summaryrefslogtreecommitdiff
path: root/spec/unit/provider_spec.rb
blob: 88023ed1ea1299be02cb433339b89e78442e750f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
#
# Author:: Adam Jacob (<adam@opscode.com>)
# Copyright:: Copyright 2008-2016, Opscode, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

require "spec_helper"


class NoWhyrunDemonstrator < Chef::Provider
  attr_reader :system_state_altered
  def whyrun_supported?
    false
  end
  def load_current_resource

  end
  def action_foo
    @system_state_altered = true
  end
end

class ConvergeActionDemonstrator < Chef::Provider
  attr_reader :system_state_altered

  def whyrun_supported?
    true
  end

  def load_current_resource
  end

  def action_foo
    converge_by("running a state changing action") do
      @system_state_altered = true
    end
  end
end

class CheckResourceSemanticsDemonstrator < ConvergeActionDemonstrator
  def check_resource_semantics!
    raise Chef::Exceptions::InvalidResourceSpecification.new("check_resource_semantics!")
  end
end


describe Chef::Provider do
  before(:each) do
    @cookbook_collection = Chef::CookbookCollection.new([])
    @node = Chef::Node.new
    @node.name "latte"
    @events = Chef::EventDispatch::Dispatcher.new
    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
    @resource = Chef::Resource.new("funk", @run_context)
    @resource.cookbook_name = "a_delicious_pie"
    @provider = Chef::Provider.new(@resource, @run_context)
  end

  it "should mixin shell_out" do
    expect(@provider.respond_to?(:shell_out)).to be true
  end

  it "should mixin shell_out!" do
    expect(@provider.respond_to?(:shell_out!)).to be true
  end

  it "should mixin shell_out_with_systems_locale" do
    expect(@provider.respond_to?(:shell_out_with_systems_locale)).to be true
  end

  it "should store the resource passed to new as new_resource" do
    expect(@provider.new_resource).to eql(@resource)
  end

  it "should store the node passed to new as node" do
    expect(@provider.node).to eql(@node)
  end

  it "should have nil for current_resource by default" do
    expect(@provider.current_resource).to eql(nil)
  end

  it "should not support whyrun by default" do
    expect(@provider.send(:whyrun_supported?)).to eql(false)
  end

  it "should do nothing for check_resource_semantics! by default" do
    expect { @provider.check_resource_semantics! }.not_to raise_error
  end

  it "should return true for action_nothing" do
    expect(@provider.action_nothing).to eql(true)
  end

  it "evals embedded recipes with a pristine resource collection" do
    @provider.run_context.instance_variable_set(:@resource_collection, "doesn't matter what this is")
    temporary_collection = nil
    snitch = Proc.new {temporary_collection = @run_context.resource_collection}
    @provider.send(:recipe_eval, &snitch)
    expect(temporary_collection).to be_an_instance_of(Chef::ResourceCollection)
    expect(@provider.run_context.instance_variable_get(:@resource_collection)).to eq("doesn't matter what this is")
  end

  it "does not re-load recipes when creating the temporary run context" do
    expect_any_instance_of(Chef::RunContext).not_to receive(:load)
    snitch = Proc.new {temporary_collection = @run_context.resource_collection}
    @provider.send(:recipe_eval, &snitch)
  end

  context "when no converge actions are queued" do
    before do
      allow(@provider).to receive(:whyrun_supported?).and_return(true)
      allow(@provider).to receive(:load_current_resource)
    end

    it "does not mark the new resource as updated" do
      expect(@resource).not_to be_updated
      expect(@resource).not_to be_updated_by_last_action
    end
  end

  context "when converge actions have been added to the queue" do
    describe "and provider supports whyrun mode" do
      before do
        @provider = ConvergeActionDemonstrator.new(@resource, @run_context)
      end

      it "should tell us that it does support whyrun" do
        expect(@provider).to be_whyrun_supported
      end

      it "queues up converge actions" do
        @provider.action_foo
        expect(@provider.send(:converge_actions).actions.size).to eq(1)
      end

      it "executes pending converge actions to converge the system" do
        @provider.run_action(:foo)
        expect(@provider.instance_variable_get(:@system_state_altered)).to be_truthy
      end

      it "marks the resource as updated" do
        @provider.run_action(:foo)
        expect(@resource).to be_updated
        expect(@resource).to be_updated_by_last_action
      end
    end

    describe "and provider does not support whyrun mode" do
      before do
        Chef::Config[:why_run] = true
        @provider = NoWhyrunDemonstrator.new(@resource, @run_context)
      end

      after do
        Chef::Config[:why_run] = false
      end

      it "should tell us that it doesn't support whyrun" do
        expect(@provider).not_to be_whyrun_supported
      end

      it "should automatically generate a converge_by block on the provider's behalf" do
        @provider.run_action(:foo)
        expect(@provider.send(:converge_actions).actions.size).to eq(0)
        expect(@provider.system_state_altered).to be_falsey
      end

      it "should automatically execute the generated converge_by block" do
        @provider.run_action(:foo)
        expect(@provider.system_state_altered).to be_falsey
        expect(@resource).not_to be_updated
        expect(@resource).not_to be_updated_by_last_action
      end
    end

    describe "and the resource is invalid" do
      let(:provider) { CheckResourceSemanticsDemonstrator.new(@resource, @run_context) }

      it "fails with InvalidResourceSpecification when run" do
        expect { provider.run_action(:foo) }.to raise_error(Chef::Exceptions::InvalidResourceSpecification)
      end

    end
  end

end