puppet 5.3.4 → 6.29.0

data/spec/unit/indirector/yaml_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/yaml'
@@ -6,70 +5,77 @@ require 'puppet/indirector/yaml'
 describe Puppet::Indirector::Yaml do
   include PuppetSpec::Files
 
-  class TestSubject
-    attr_accessor :name
-  end
+  before(:all) do
+    class Puppet::YamlTestModel
+      extend Puppet::Indirector
+      indirects :yaml_test_model
+      attr_reader :name
 
-  before :all do
-    @indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
-    Puppet::Indirector::Indirection.expects(:instance).with(:my_yaml).returns(@indirection)
-    module MyYaml; end
-    @store_class = class MyYaml::MyType < Puppet::Indirector::Yaml
-      self
+      def initialize(name)
+        @name = name
+      end
     end
-  end
 
-  before :each do
-    @store = @store_class.new
-
-    @subject = TestSubject.new
-    @subject.name = :me
+    class Puppet::YamlTestModel::Yaml < Puppet::Indirector::Yaml; end
 
-    @dir = tmpdir("yaml_indirector")
-    Puppet[:clientyamldir] = @dir
-    Puppet.run_mode.stubs(:master?).returns false
+    Puppet::YamlTestModel.indirection.terminus_class = :yaml
+  end
 
-    @request = stub 'request', :key => :me, :instance => @subject
+  after(:all) do
+    Puppet::YamlTestModel.indirection.delete
+    Puppet.send(:remove_const, :YamlTestModel)
   end
 
+  let(:model) { Puppet::YamlTestModel }
+  let(:subject) { model.new(:me) }
+  let(:indirection) { model.indirection }
+  let(:terminus) { indirection.terminus(:yaml) }
+
+  let(:dir) { tmpdir("yaml_indirector") }
+  let(:indirection_dir) { File.join(dir, indirection.name.to_s) }
   let(:serverdir) { File.expand_path("/server/yaml/dir") }
   let(:clientdir) { File.expand_path("/client/yaml/dir") }
 
+  before :each do
+    Puppet[:clientyamldir] = dir
+    allow(Puppet.run_mode).to receive(:server?).and_return(false)
+  end
+
   describe "when choosing file location" do
-    it "should use the server_datadir if the run_mode is master" do
-      Puppet.run_mode.stubs(:master?).returns true
+    it "should use the server_datadir if the run_mode is server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
-      expect(@store.path(:me)).to match(/^#{serverdir}/)
+      expect(terminus.path(:me)).to match(/^#{serverdir}/)
     end
 
-    it "should use the client yamldir if the run_mode is not master" do
-      Puppet.run_mode.stubs(:master?).returns false
+    it "should use the client yamldir if the run_mode is not server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       Puppet[:clientyamldir] = clientdir
-      expect(@store.path(:me)).to match(/^#{clientdir}/)
+      expect(terminus.path(:me)).to match(/^#{clientdir}/)
     end
 
     it "should use the extension if one is specified" do
-      Puppet.run_mode.stubs(:master?).returns true
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
-      expect(@store.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
+      expect(terminus.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
     end
 
     it "should assume an extension of .yaml if none is specified" do
-      Puppet.run_mode.stubs(:master?).returns true
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
-      expect(@store.path(:me)).to match(%r{\.yaml$})
+      expect(terminus.path(:me)).to match(%r{\.yaml$})
     end
 
     it "should store all files in a single file root set in the Puppet defaults" do
-      expect(@store.path(:me)).to match(%r{^#{@dir}})
+      expect(terminus.path(:me)).to match(%r{^#{dir}})
     end
 
     it "should use the terminus name for choosing the subdirectory" do
-      expect(@store.path(:me)).to match(%r{^#{@dir}/my_yaml})
+      expect(terminus.path(:me)).to match(%r{^#{dir}/yaml_test_model})
     end
 
     it "should use the object's name to determine the file name" do
-      expect(@store.path(:me)).to match(%r{me.yaml$})
+      expect(terminus.path(:me)).to match(%r{me.yaml$})
     end
 
     ['../foo', '..\\foo', './../foo', '.\\..\\foo',
@@ -82,84 +88,100 @@ describe Puppet::Indirector::Yaml do
      "//?/c:/foo",
     ].each do |input|
       it "should resist directory traversal attacks (#{input.inspect})" do
-        expect { @store.path(input) }.to raise_error(ArgumentError)
+        expect { terminus.path(input) }.to raise_error(ArgumentError)
       end
     end
   end
 
   describe "when storing objects as YAML" do
     it "should only store objects that respond to :name" do
-      @request.stubs(:instance).returns Object.new
-      expect { @store.save(@request) }.to raise_error(ArgumentError)
+      request = indirection.request(:save, "testing", Object.new)
+      expect { terminus.save(request) }.to raise_error(ArgumentError)
     end
   end
 
   describe "when retrieving YAML" do
     it "should read YAML in from disk and convert it to Ruby objects" do
-      @store.save(Puppet::Indirector::Request.new(:my_yaml, :save, "testing", @subject))
-
-      expect(@store.find(Puppet::Indirector::Request.new(:my_yaml, :find, "testing", nil)).name).to eq(:me)
+      terminus.save(indirection.request(:save, "testing", subject))
+      yaml = terminus.find(indirection.request(:find, "testing", nil))
+      expect(yaml.name).to eq(:me)
     end
 
     it "should fail coherently when the stored YAML is invalid" do
-      saved_structure = Struct.new(:name).new("testing")
-
-      @store.save(Puppet::Indirector::Request.new(:my_yaml, :save, "testing", saved_structure))
-      File.open(@store.path(saved_structure.name), "w") do |file|
+      terminus.save(indirection.request(:save, "testing", subject))
+      # overwrite file
+      File.open(terminus.path('testing'), "w") do |file|
         file.puts "{ invalid"
       end
 
       expect {
-        @store.find(Puppet::Indirector::Request.new(:my_yaml, :find, "testing", nil))
+        terminus.find(indirection.request(:find, "testing", nil))
       }.to raise_error(Puppet::Error, /Could not parse YAML data/)
     end
   end
 
   describe "when searching" do
+    before :each do
+      Puppet[:clientyamldir] = dir
+    end
+
+    def dir_containing_instances(instances)
+      Dir.mkdir(indirection_dir)
+      instances.each do |hash|
+        File.open(File.join(indirection_dir, "#{hash['name']}.yaml"), 'wb') do |f|
+          f.write(YAML.dump(hash))
+        end
+      end
+    end
+
     it "should return an array of fact instances with one instance for each file when globbing *" do
-      @request = stub 'request', :key => "*", :instance => @subject
-      @one = mock 'one'
-      @two = mock 'two'
-      @store.expects(:path).with(@request.key,'').returns :glob
-      Dir.expects(:glob).with(:glob).returns(%w{one.yaml two.yaml})
-      YAML.expects(:load_file).with("one.yaml").returns @one;
-      YAML.expects(:load_file).with("two.yaml").returns @two;
-      expect(@store.search(@request)).to eq([@one, @two])
+      one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
+      two = { 'name' => 'two', 'values' => { 'foo' => 'baz' } }
+      dir_containing_instances([one, two])
+
+      request = indirection.request(:search, "*", nil)
+      expect(terminus.search(request)).to contain_exactly(one, two)
     end
 
     it "should return an array containing a single instance of fact when globbing 'one*'" do
-      @request = stub 'request', :key => "one*", :instance => @subject
-      @one = mock 'one'
-      @store.expects(:path).with(@request.key,'').returns :glob
-      Dir.expects(:glob).with(:glob).returns(%w{one.yaml})
-      YAML.expects(:load_file).with("one.yaml").returns @one;
-      expect(@store.search(@request)).to eq([@one])
+      one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
+      two = { 'name' => 'two', 'values' => { 'foo' => 'baz' } }
+      dir_containing_instances([one, two])
+
+      request = indirection.request(:search, "one*", nil)
+      expect(terminus.search(request)).to eq([one])
     end
 
     it "should return an empty array when the glob doesn't match anything" do
-      @request = stub 'request', :key => "f*ilglobcanfail*", :instance => @subject
-      @store.expects(:path).with(@request.key,'').returns :glob
-      Dir.expects(:glob).with(:glob).returns []
-      expect(@store.search(@request)).to eq([])
+      one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
+      dir_containing_instances([one])
+
+      request = indirection.request(:search, "f*ilglobcanfail*", nil)
+      expect(terminus.search(request)).to eq([])
     end
 
     describe "when destroying" do
-      let(:path) do
-        File.join(@dir, @store.class.indirection_name.to_s, @request.key.to_s + ".yaml")
+      let(:path) { File.join(indirection_dir, "one.yaml") }
+
+      before :each do
+        Puppet[:clientyamldir] = dir
+
+        one = { 'name' => 'one', 'values' => { 'foo' => 'bar' } }
+        dir_containing_instances([one])
       end
 
       it "should unlink the right yaml file if it exists" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
-        Puppet::FileSystem.expects(:unlink).with(path)
+        request = indirection.request(:destroy, "one", nil)
+        terminus.destroy(request)
 
-        @store.destroy(@request)
+        expect(Puppet::FileSystem).to_not exist(path)
       end
 
       it "should not unlink the yaml file if it does not exists" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns false
-        Puppet::FileSystem.expects(:unlink).with(path).never
+        request = indirection.request(:destroy, "doesntexist", nil)
+        terminus.destroy(request)
 
-        @store.destroy(@request)
+        expect(Puppet::FileSystem).to exist(path)
       end
     end
   end

data/spec/unit/indirector_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/defaults'
@@ -113,9 +112,8 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 
   it "should pass any provided options to the indirection during initialization" do
-    klass = mock 'terminus class'
-    Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
-    @indirection = @thingie.indirects :first, :some => :options
+    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:doc => 'some docs', :indirected_class => 'Thingie'})
+    @indirection = @thingie.indirects :first, :doc => 'some docs'
   end
 
   it "should extend the class to handle serialization" do

data/spec/unit/info_service_spec.rb

@@ -20,7 +20,7 @@ describe "Puppet::InfoService" do
     context 'tasks_per_environment method' do
       it "returns task data for the tasks in an environment" do
         Puppet.override(:environments => env_loader) do
-          mod = PuppetSpec::Modules.create(mod_name, modpath, {:environment => env, :tasks => [['thingtask']]})
+          PuppetSpec::Modules.create(mod_name, modpath, {:environment => env, :tasks => [['thingtask']]})
           expect(Puppet::InfoService.tasks_per_environment(env_name)).to eq([{:name => task_name, :module => {:name => mod_name}}])
         end
       end
@@ -31,19 +31,24 @@ describe "Puppet::InfoService" do
     end
 
     context 'task_data method' do
-      before do
-        Puppet.override(:environments => env_loader) do
-          @mod = PuppetSpec::Modules.create(mod_name, modpath, {:environment => env, :tasks => [['thingtask', 'thingtask.json']]})
-          @result = Puppet::InfoService.task_data(env_name, mod_name, task_name)
+      context 'For a valid simple module' do
+        before do
+          Puppet.override(:environments => env_loader) do
+            @mod = PuppetSpec::Modules.create(mod_name, modpath,
+                                              {:environment => env,
+                                               :tasks => [['thingtask',
+                                                           {:name => 'thingtask.json',
+                                                            :content => '{}'}]]})
+            @result = Puppet::InfoService.task_data(env_name, mod_name, task_name)
+          end
         end
-      end
-      describe 'in the happy case' do
+
         it 'returns the right set of keys' do
-          expect(@result.keys.sort).to eq([:files, :metadata_file])
+          expect(@result.keys.sort).to eq([:files, :metadata])
         end
+
         it 'specifies the metadata_file correctly' do
-          task = @mod.tasks[0]
-          expect(@result[:metadata_file]).to eq(task.metadata_file)
+          expect(@result[:metadata]).to eq({})
         end
 
         it 'specifies the other files correctly' do
@@ -52,6 +57,136 @@ describe "Puppet::InfoService" do
         end
       end
 
+      context 'For a module with multiple implemenations and files' do
+        let(:other_mod_name) { "shell_helpers" }
+        let(:metadata) {
+          { "implementations" => [
+            {"name" => "thingtask.rb", "requirements" => ["puppet_agent"],
+             "files" => ["#{mod_name}/lib/puppet/providers/"]},
+            {"name" => "thingtask.sh", "requirements" => ["shell"] } ],
+            "files" => [
+             "#{mod_name}/files/my_data.json",
+             "#{other_mod_name}/files/scripts/helper.sh",
+             "#{mod_name}/files/data/files/data.rb"] } }
+        let(:expected_files) { [ {'name' => 'thingtask.rb',
+                                  'path' => "#{modpath}/#{mod_name}/tasks/thingtask.rb"},
+        { 'name' => 'thingtask.sh',
+          'path' => "#{modpath}/#{mod_name}/tasks/thingtask.sh"},
+        { 'name' => "#{mod_name}/lib/puppet/providers/prov.rb",
+          'path' => "#{modpath}/#{mod_name}/lib/puppet/providers/prov.rb"},
+        { 'name' => "#{mod_name}/files/data/files/data.rb",
+          'path' => "#{modpath}/#{mod_name}/files/data/files/data.rb"},
+        { 'name' => "#{mod_name}/files/my_data.json",
+          'path' => "#{modpath}/#{mod_name}/files/my_data.json"},
+        { 'name' => "#{other_mod_name}/files/scripts/helper.sh",
+          'path' => "#{modpath}/#{other_mod_name}/files/scripts/helper.sh" }
+        ].sort_by {|f| f['name']} }
+
+        before do
+          Puppet.override(:environments => env_loader) do
+            @mod = PuppetSpec::Modules.create(mod_name, modpath,
+                                              {:environment => env,
+                                               :tasks => [['thingtask.rb',
+                                                           'thingtask.sh',
+                                                           {:name => 'thingtask.json',
+                                                            :content => metadata.to_json}]],
+                                               :files => {
+                                                 "files/data/files/data.rb" => "a file of data",
+                                                 "files/my_data.json" => "{}",
+                                                 "lib/puppet/providers/prov.rb" => "provider_content"} })
+            @other_mod = PuppetSpec::Modules.create(other_mod_name, modpath, { :environment => env,
+                                                                               :files =>{
+              "files/scripts/helper.sh" => "helper content" } } )
+            @result = Puppet::InfoService.task_data(env_name, mod_name, task_name)
+          end
+        end
+
+        it 'returns the right set of keys' do
+          expect(@result.keys.sort).to eq([:files, :metadata])
+        end
+
+        it 'specifies the metadata_file correctly' do
+          expect(@result[:metadata]).to eq(metadata)
+        end
+
+        it 'specifies the other file names correctly' do
+          expect(@result[:files].sort_by{|f| f['name']}).to eq(expected_files)
+        end
+      end
+
+      context 'For a task with files that do not exist' do
+        let(:metadata) {
+          { "files" => [
+            "#{mod_name}/files/random_data",
+            "shell_helpers/files/scripts/helper.sh"] } }
+
+        before do
+          Puppet.override(:environments => env_loader) do
+            @mod = PuppetSpec::Modules.create(mod_name, modpath,
+                                              {:environment => env,
+                                               :tasks => [['thingtask.rb',
+                                                           {:name => 'thingtask.json',
+                                                            :content => metadata.to_json}]]})
+            @result = Puppet::InfoService.task_data(env_name, mod_name, task_name)
+          end
+        end
+
+        it 'errors when the file is not found' do
+          expect(@result[:error][:kind]).to eq('puppet.tasks/invalid-file')
+        end
+      end
+
+      context 'For a task with bad metadata' do
+        let(:metadata) {
+          { "implementations" => [
+            {"name" => "thingtask.rb", "requirements" => ["puppet_agent"] },
+            {"name" => "thingtask.sh", "requirements" => ["shell"] } ] } }
+
+        before do
+          Puppet.override(:environments => env_loader) do
+            @mod = PuppetSpec::Modules.create(mod_name, modpath,
+                                              {:environment => env,
+                                               :tasks => [['thingtask.sh',
+                                                           {:name => 'thingtask.json',
+                                                            :content => metadata.to_json}]]})
+            @result = Puppet::InfoService.task_data(env_name, mod_name, task_name)
+          end
+        end
+
+        it 'returns the right set of keys' do
+          expect(@result.keys.sort).to eq([:error, :files, :metadata])
+        end
+
+        it 'returns the expected error' do
+          expect(@result[:error][:kind]).to eq('puppet.tasks/missing-implementation')
+        end
+      end
+
+      context 'For a task with required directories with no trailing slash' do
+        let(:metadata) { { "files" => [ "#{mod_name}/files" ] } }
+
+        before do
+          Puppet.override(:environments => env_loader) do
+            @mod = PuppetSpec::Modules.create(mod_name, modpath,
+                                              {:environment => env,
+                                               :tasks => [['thingtask.sh',
+                                                           {:name => 'thingtask.json',
+                                                            :content => metadata.to_json}]],
+                                               :files => {
+                                                 "files/helper.rb" => "help"}})
+            @result = Puppet::InfoService.task_data(env_name, mod_name, task_name)
+          end
+        end
+
+        it 'returns the right set of keys' do
+          expect(@result.keys.sort).to eq([:error, :files, :metadata])
+        end
+
+        it 'returns the expected error' do
+          expect(@result[:error][:kind]).to eq('puppet.tasks/invalid-metadata')
+        end
+      end
+
       it "should raise EnvironmentNotFound if given a nonexistent environment" do
         expect{ Puppet::InfoService.task_data('utopia', mod_name, task_name) }.to raise_error(Puppet::Environments::EnvironmentNotFound)
       end
@@ -65,12 +200,61 @@ describe "Puppet::InfoService" do
 
       it "should raise TaskNotFound if the task does not exist" do
         Puppet.override(:environments => env_loader) do
+          PuppetSpec::Modules.create(mod_name, modpath)
           expect { Puppet::InfoService.task_data(env_name, mod_name, 'testing1::notatask') }
             .to raise_error(Puppet::Module::Task::TaskNotFound)
         end
       end
     end
   end
+  
+  context 'plan information service' do
+    let(:mod_name) { 'test1' }
+    let(:plan_name) { "#{mod_name}::thingplan" }
+    let(:modpath) { tmpdir('modpath') }
+    let(:env_name) { 'testing' }
+    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [modpath]) }
+    let(:env_loader) { Puppet::Environments::Static.new(env) }
+
+    context 'plans_per_environment method' do
+      it "returns plan data for the plans in an environment" do
+        Puppet.override(:environments => env_loader) do
+          PuppetSpec::Modules.create(mod_name, modpath, {:environment => env, :plans => ['thingplan.pp']})
+          expect(Puppet::InfoService.plans_per_environment(env_name)).to eq([{:name => plan_name, :module => {:name => mod_name}}])
+        end
+      end
+
+      it "should throw EnvironmentNotFound if given a nonexistent environment" do
+        expect{ Puppet::InfoService.plans_per_environment('utopia') }.to raise_error(Puppet::Environments::EnvironmentNotFound)
+      end
+    end
+
+    context 'plan_data method' do
+      context 'For a valid simple module' do
+        before do
+          Puppet.override(:environments => env_loader) do
+            @mod = PuppetSpec::Modules.create(mod_name, modpath,
+                                              {:environment => env,
+                                               :plans => ['thingplan.pp']})
+            @result = Puppet::InfoService.plan_data(env_name, mod_name, plan_name)
+          end
+        end
+
+        it 'returns the right set of keys' do
+          expect(@result.keys.sort).to eq([:files, :metadata])
+        end
+
+        it 'specifies the metadata_file correctly' do
+          expect(@result[:metadata]).to eq({})
+        end
+
+        it 'specifies the other files correctly' do
+          plan = @mod.plans[0]
+          expect(@result[:files]).to eq(plan.files)
+        end
+      end
+    end
+  end
 
   context 'classes_per_environment service' do
     let(:code_dir) do
@@ -248,7 +432,7 @@ describe "Puppet::InfoService" do
     it "avoids parsing file more than once when environments have same feature flag set" do
       # in this version of puppet, all environments are equal in this respect
       result = Puppet::Pops::Parser::EvaluatingParser.new.parse_file("#{code_dir}/fum.pp")
-      Puppet::Pops::Parser::EvaluatingParser.any_instance.expects(:parse_file).with("#{code_dir}/fum.pp").returns(result).once
+      expect_any_instance_of(Puppet::Pops::Parser::EvaluatingParser).to receive(:parse_file).with("#{code_dir}/fum.pp").once.and_return(result)
       files_production = ['fum.pp'].map {|f| File.join(code_dir, f) }
       files_test       = files_production
 

data/spec/unit/interface/action_builder_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/interface'
 require 'puppet/network/format_handler'

data/spec/unit/interface/action_manager_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/interface'
@@ -232,7 +231,7 @@ describe Puppet::Interface::ActionManager do
           when_invoked do |options| true end
           default
         }
-      }.to raise_error /cannot both be default/
+      }.to raise_error(/cannot both be default/)
     end
   end
 

data/spec/unit/interface/action_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/interface'
 
@@ -138,7 +137,7 @@ describe Puppet::Interface::Action do
       end
 
       it "should call #validate_and_clean on the action when invoked" do
-        face.get_action(:bar).expects(:validate_and_clean).with({}).returns({})
+        expect(face.get_action(:bar)).to receive(:validate_and_clean).with({}).and_return({})
         face.bar 1, :two, 'three'
       end
     end
@@ -246,7 +245,7 @@ describe Puppet::Interface::Action do
         face = Puppet::Interface.new(:with_options, '0.0.1') do
           action(:foo) do
             when_invoked do |options| true end
-            self.instance_eval &block
+            self.instance_eval(&block)
           end
         end
         face.get_action(:foo)
@@ -397,7 +396,7 @@ describe Puppet::Interface::Action do
 
       it "should not invoke a decorator if the options are empty" do
         face.option("--foo FOO") { before_action { |_,_,_| report :before_action } }
-        face.expects(:report).never
+        expect(face).not_to receive(:report)
         face.bar
       end
 
@@ -538,15 +537,6 @@ describe Puppet::Interface::Action do
     end
   end
 
-  context "#when_rendering" do
-    it "should fail if no type is given when_rendering"
-    it "should accept a when_rendering block"
-    it "should accept multiple when_rendering blocks"
-    it "should fail if when_rendering gets a non-symbol identifier"
-    it "should fail if a second block is given for the same type"
-    it "should return the block if asked"
-  end
-
   context "#validate_and_clean" do
     subject do
       Puppet::Interface.new(:validate_args, '1.0.0') do
@@ -644,4 +634,37 @@ describe Puppet::Interface::Action do
       expect(subject.get_default_action).to eq(action)
     end
   end
+
+  context "when deprecating a face action" do
+    let :face do
+      Puppet::Interface.new(:foo, '1.0.0') do
+        action :bar do
+          option "--bar"
+          when_invoked do |options| options end
+        end
+      end
+    end
+
+    let :action do face.get_action :bar end
+
+    describe "#deprecate" do
+      it "should set the deprecated value to true" do
+        expect(action).not_to be_deprecated
+        action.deprecate
+        expect(action).to be_deprecated
+      end
+    end
+
+    describe "#deprecated?" do
+      it "should return a nil (falsey) value by default" do
+        expect(action.deprecated?).to be_falsey
+      end
+
+      it "should return true if the action has been deprecated" do
+        expect(action).not_to be_deprecated
+        action.deprecate
+        expect(action).to be_deprecated
+      end
+    end
+  end
 end

data/spec/unit/interface/documentation_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/interface'