puppet 4.0.0.rc1 → 4.0.0

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -63,7 +63,7 @@ describe 'function for dynamically creating resources' do
     it 'should fail to add non-existing type' do
       expect do
         @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
-      end.to raise_error(ArgumentError, /Invalid resource type create-resource-foo/)
+      end.to raise_error(/Invalid resource type create-resource-foo/)
     end
 
     it 'should be able to add edges' do

data/spec/unit/pops/binder/injector_spec.rb

@@ -607,24 +607,6 @@ describe 'Injector' do
         expect { injector.lookup(scope, 'broken_family2')}.to raise_error(/:uniq/)
       end
 
-      it "a higher priority contribution is selected when resolution is :priority" do
-        hash_of_duck = type_factory.hash_of(duck_type)
-        multibind_id = "ducks"
-
-        bindings.multibind(multibind_id).type(hash_of_duck).name('donalds_nephews')
-
-        mb1 = bindings.bind.in_multibind(multibind_id)
-        pending 'priority based on layers not added, and priority on category removed'
-        mb1.type(duck_type).name('nephew').to(InjectorSpecModule::NamedDuck, 'Huey')
-
-        mb2 = bindings.bind.in_multibind(multibind_id)
-        mb2.type(duck_type).name('nephew').to(InjectorSpecModule::NamedDuck, 'Dewey')
-
-        binder.define_layers(layered_bindings)
-
-        expect(injector(binder).lookup(scope, hash_of_duck, "donalds_nephews")['nephew'].name).to eq('Huey')
-      end
-
       it "a higher priority contribution wins when resolution is :merge" do
         # THIS TEST MAY DEPEND ON HASH ORDER SINCE PRIORITY BASED ON CATEGORY IS REMOVED
         hash_of_data = type_factory.hash_of_data()

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -118,10 +118,8 @@ describe 'Lexer2' do
   end
 
   [ '_x::y', 'x::_y'].each do |string|
-    it "should consider the bare word '#{string}' to be a bad NAME" do
-      expect {
-        tokens_scanned_from(string)
-      }.to raise_error(/Illegal fully qualified name/)
+    it "should consider the bare word '#{string}' to be a WORD" do
+      expect(tokens_scanned_from(string)).to match_tokens2(:WORD)
     end
   end
 
@@ -209,21 +207,33 @@ describe 'Lexer2' do
     end
   end
 
-  { '"a$x b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                   [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
+  { '"a$x b"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                      [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
 
-    '"a$x.b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                   [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
+    '"a$x.b"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                      [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
 
-    '"$x.b"'   => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
-                   [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
+    '"$x.b"'      => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
+                      [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
 
-    '"a$x"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                   [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
+    '"a$x"'       => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
+
+    '"a${x}"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>5, :length=>1 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>7, :length=>1 }]],
+
+    '"a${_x}"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>8, :length=>1 }]],
+
+    '"a${y::_x}"' => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, 'y::_x',  {:line => 1, :pos=>5, :length=>5 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>11, :length=>1 }]],
   }.each do |source, expected|
     it "should lex an interpolated variable 'x' from #{source}" do
       expect(tokens_scanned_from(source)).to match_tokens2(*expected)

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -114,4 +114,25 @@ describe "egrammar parsing heredoc" do
     ].join("\n"))
   end
 
+  it 'parses multiple heredocs on the same line' do
+    src = <<-CODE
+    notice({ @(foo) => @(bar) })
+    hello
+    -foo
+    world
+    -bar
+    notice '!'
+    CODE
+    expect(dump(parse(src))).to eq([
+      '(block',
+      '  (invoke notice ({} ((@()',
+      '    (sublocated \'    hello\')',
+      '  ) (@()',
+      '    (sublocated \'    world\')',
+      '  ))))',
+      '  (invoke notice \'!\')',
+      ')'
+    ].join("\n"))
+  end
+
 end

data/spec/unit/pops/validator/validator_spec.rb

@@ -19,9 +19,8 @@ describe "validating 4x" do
   end
 
   it 'should raise error for illegal names' do
-    pending "validation was too strict, now too relaxed - validation missing"
-    expect(validate(fqn('Aaa'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
-    expect(validate(fqn('AAA'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
+    expect(validate(parse('class aaa::_bbb {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
+    expect(validate(parse('class Aaa {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end
 
   it 'should raise error for illegal variable names' do

data/spec/unit/provider/macauthorization_spec.rb

@@ -6,7 +6,7 @@
 require 'spec_helper'
 
 require 'puppet'
-require 'facter/util/plist'
+require 'plist'
 
 provider_class = Puppet::Type.type(:macauthorization).provider(:macauthorization)
 

data/spec/unit/provider/package/gem_spec.rb

@@ -3,184 +3,246 @@ require 'spec_helper'
 
 provider_class = Puppet::Type.type(:package).provider(:gem)
 
-describe provider_class do
-  let(:resource) do
-    Puppet::Type.type(:package).new(
-      :name     => 'myresource',
-      :ensure   => :installed
-    )
-  end
-
-  let(:provider) do
-    provider = provider_class.new
-    provider.resource = resource
-    provider
-  end
-
-  before :each do
-    resource.provider = provider
-  end
-
-  describe "when installing" do
-    it "should use the path to the gem" do
-      provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
-      provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
-      provider.install
+context 'installing myresource' do
+  describe provider_class do
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name     => 'myresource',
+        :ensure   => :installed
+      )
     end
 
-    it "should specify that the gem is being installed" do
-      provider.expects(:execute).with { |args| args[1] == "install" }.returns ""
-      provider.install
+    let(:provider) do
+      provider = provider_class.new
+      provider.resource = resource
+      provider
     end
 
-    it "should specify that documentation should not be included" do
-      provider.expects(:execute).with { |args| args[2] == "--no-rdoc" }.returns ""
-      provider.install
+    before :each do
+      resource.provider = provider
     end
 
-    it "should specify that RI should not be included" do
-      provider.expects(:execute).with { |args| args[3] == "--no-ri" }.returns ""
-      provider.install
-    end
+    describe "when installing" do
+      it "should use the path to the gem" do
+        provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
+        provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
+        provider.install
+      end
 
-    it "should specify the package name" do
-      provider.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
-      provider.install
-    end
+      it "should specify that the gem is being installed" do
+        provider.expects(:execute).with { |args| args[1] == "install" }.returns ""
+        provider.install
+      end
 
-    it "should not append install_options by default" do
-      provider.expects(:execute).with { |args| args.length == 5 }.returns ""
-      provider.install
-    end
+      it "should specify that documentation should not be included" do
+        provider.expects(:execute).with { |args| args[2] == "--no-rdoc" }.returns ""
+        provider.install
+      end
 
-    it "should allow setting an install_options parameter" do
-      resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      provider.expects(:execute).with { |args| args[5] == '--force' && args[6] == '--bindir=/usr/bin' }.returns ''
-      provider.install
-    end
+      it "should specify that RI should not be included" do
+        provider.expects(:execute).with { |args| args[3] == "--no-ri" }.returns ""
+        provider.install
+      end
 
-    describe "when a source is specified" do
-      describe "as a normal file" do
-        it "should use the file name instead of the gem name" do
-          resource[:source] = "/my/file"
-          provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
-          provider.install
-        end
+      it "should specify the package name" do
+        provider.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
+        provider.install
       end
-      describe "as a file url" do
-        it "should use the file name instead of the gem name" do
-          resource[:source] = "file:///my/file"
-          provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
-          provider.install
-        end
+
+      it "should not append install_options by default" do
+        provider.expects(:execute).with { |args| args.length == 5 }.returns ""
+        provider.install
       end
-      describe "as a puppet url" do
-        it "should fail" do
-          resource[:source] = "puppet://my/file"
-          expect { provider.install }.to raise_error(Puppet::Error)
-        end
+
+      it "should allow setting an install_options parameter" do
+        resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
+        provider.expects(:execute).with { |args| args[5] == '--force' && args[6] == '--bindir=/usr/bin' }.returns ''
+        provider.install
       end
-      describe "as a non-file and non-puppet url" do
-        it "should treat the source as a gem repository" do
-          resource[:source] = "http://host/my/file"
-          provider.expects(:execute).with { |args| args[2..4] == ["--source", "http://host/my/file", "myresource"] }.returns ""
-          provider.install
+
+      describe "when a source is specified" do
+        describe "as a normal file" do
+          it "should use the file name instead of the gem name" do
+            resource[:source] = "/my/file"
+            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
+            provider.install
+          end
         end
-      end
-      describe "with an invalid uri" do
-        it "should fail" do
-          URI.expects(:parse).raises(ArgumentError)
-          resource[:source] = "http:::::uppet:/:/my/file"
-          expect { provider.install }.to raise_error(Puppet::Error)
+        describe "as a file url" do
+          it "should use the file name instead of the gem name" do
+            resource[:source] = "file:///my/file"
+            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
+            provider.install
+          end
+        end
+        describe "as a puppet url" do
+          it "should fail" do
+            resource[:source] = "puppet://my/file"
+            expect { provider.install }.to raise_error(Puppet::Error)
+          end
+        end
+        describe "as a non-file and non-puppet url" do
+          it "should treat the source as a gem repository" do
+            resource[:source] = "http://host/my/file"
+            provider.expects(:execute).with { |args| args[2..4] == ["--source", "http://host/my/file", "myresource"] }.returns ""
+            provider.install
+          end
+        end
+        describe "with an invalid uri" do
+          it "should fail" do
+            URI.expects(:parse).raises(ArgumentError)
+            resource[:source] = "http:::::uppet:/:/my/file"
+            expect { provider.install }.to raise_error(Puppet::Error)
+          end
         end
       end
     end
-  end
 
-  describe "#latest" do
-    it "should return a single value for 'latest'" do
-      #gemlist is used for retrieving both local and remote version numbers, and there are cases
-      # (particularly local) where it makes sense for it to return an array.  That doesn't make
-      # sense for '#latest', though.
-      provider.class.expects(:gemlist).with({ :justme => 'myresource'}).returns({
+    describe "#latest" do
+      it "should return a single value for 'latest'" do
+        #gemlist is used for retrieving both local and remote version numbers, and there are cases
+        # (particularly local) where it makes sense for it to return an array.  That doesn't make
+        # sense for '#latest', though.
+        provider.class.expects(:gemlist).with({ :justme => 'myresource'}).returns({
           :name     => 'myresource',
           :ensure   => ["3.0"],
           :provider => :gem,
-          })
-      expect(provider.latest).to eq("3.0")
-    end
+        })
+        expect(provider.latest).to eq("3.0")
+      end
 
-    it "should list from the specified source repository" do
-      resource[:source] = "http://foo.bar.baz/gems"
-      provider.class.expects(:gemlist).
-        with({:justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
-        returns({
-          :name     => 'myresource',
-          :ensure   => ["3.0"],
-          :provider => :gem,
+      it "should list from the specified source repository" do
+        resource[:source] = "http://foo.bar.baz/gems"
+        provider.class.expects(:gemlist).
+          with({:justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
+          returns({
+            :name     => 'myresource',
+            :ensure   => ["3.0"],
+            :provider => :gem,
           })
-      expect(provider.latest).to eq("3.0")
+          expect(provider.latest).to eq("3.0")
+      end
     end
-  end
 
-  describe "#instances" do
-    before do
-      provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
-    end
+    describe "#instances" do
+      before do
+        provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
+      end
 
-    it "should return an empty array when no gems installed" do
-      provider_class.expects(:execute).with(%w{/my/gem list --local}).returns("\n")
-      expect(provider_class.instances).to eq([])
-    end
+      it "should return an empty array when no gems installed" do
+        provider_class.expects(:execute).with(%w{/my/gem list --local}).returns("\n")
+        expect(provider_class.instances).to eq([])
+      end
 
-    it "should return ensure values as an array of installed versions" do
-      provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
+      it "should return ensure values as an array of installed versions" do
+        provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
-      HEREDOC
+        HEREDOC
 
-      expect(provider_class.instances.map {|p| p.properties}).to eq([
-        {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
-        {:ensure => ["0.8.7", "0.6.9"], :provider => :gem, :name => 'vagrant'}
-      ])
-    end
+        expect(provider_class.instances.map {|p| p.properties}).to eq([
+          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
+          {:ensure => ["0.8.7", "0.6.9"], :provider => :gem, :name => 'vagrant'}
+        ])
+      end
 
-    it "should ignore platform specifications" do
-      provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
+      it "should ignore platform specifications" do
+        provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
         systemu (1.2.0)
         nokogiri (1.6.1 ruby java x86-mingw32 x86-mswin32-60, 1.4.4.1 x86-mswin32)
-      HEREDOC
+        HEREDOC
+
+        expect(provider_class.instances.map {|p| p.properties}).to eq([
+          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
+          {:ensure => ["1.6.1", "1.4.4.1"], :provider => :gem, :name => 'nokogiri'}
+        ])
+      end
 
-      expect(provider_class.instances.map {|p| p.properties}).to eq([
-        {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
-        {:ensure => ["1.6.1", "1.4.4.1"], :provider => :gem, :name => 'nokogiri'}
-      ])
+      it "should not fail when an unmatched line is returned" do
+        provider_class.expects(:execute).with(%w{/my/gem list --local}).
+          returns(File.read(my_fixture('line-with-1.8.5-warning')))
+
+        expect(provider_class.instances.map {|p| p.properties}).
+          to eq([{:provider=>:gem, :ensure=>["0.3.2"], :name=>"columnize"},
+                 {:provider=>:gem, :ensure=>["1.1.3"], :name=>"diff-lcs"},
+                 {:provider=>:gem, :ensure=>["0.0.1"], :name=>"metaclass"},
+                 {:provider=>:gem, :ensure=>["0.10.5"], :name=>"mocha"},
+                 {:provider=>:gem, :ensure=>["0.8.7"], :name=>"rake"},
+                 {:provider=>:gem, :ensure=>["2.9.0"], :name=>"rspec-core"},
+                 {:provider=>:gem, :ensure=>["2.9.1"], :name=>"rspec-expectations"},
+                 {:provider=>:gem, :ensure=>["2.9.0"], :name=>"rspec-mocks"},
+                 {:provider=>:gem, :ensure=>["0.9.0"], :name=>"rubygems-bundler"},
+                 {:provider=>:gem, :ensure=>["1.11.3.3"], :name=>"rvm"}])
+      end
     end
 
-    it "should not fail when an unmatched line is returned" do
-      provider_class.expects(:execute).with(%w{/my/gem list --local}).
-        returns(File.read(my_fixture('line-with-1.8.5-warning')))
-
-      expect(provider_class.instances.map {|p| p.properties}).
-        to eq([{:provider=>:gem, :ensure=>["0.3.2"], :name=>"columnize"},
-                   {:provider=>:gem, :ensure=>["1.1.3"], :name=>"diff-lcs"},
-                   {:provider=>:gem, :ensure=>["0.0.1"], :name=>"metaclass"},
-                   {:provider=>:gem, :ensure=>["0.10.5"], :name=>"mocha"},
-                   {:provider=>:gem, :ensure=>["0.8.7"], :name=>"rake"},
-                   {:provider=>:gem, :ensure=>["2.9.0"], :name=>"rspec-core"},
-                   {:provider=>:gem, :ensure=>["2.9.1"], :name=>"rspec-expectations"},
-                   {:provider=>:gem, :ensure=>["2.9.0"], :name=>"rspec-mocks"},
-                   {:provider=>:gem, :ensure=>["0.9.0"], :name=>"rubygems-bundler"},
-                   {:provider=>:gem, :ensure=>["1.11.3.3"], :name=>"rvm"}])
+    describe "listing gems" do
+      describe "searching for a single package" do
+        it "searches for an exact match" do
+          provider_class.expects(:execute).with(includes('^bundler$')).returns(File.read(my_fixture('gem-list-single-package')))
+          expected = {:name => 'bundler', :ensure => %w[1.6.2], :provider => :gem}
+          expect(provider_class.gemlist({:justme => 'bundler'})).to eq(expected)
+        end
+      end
     end
   end
+end
+
+context 'uninstalling myresource' do
+  describe provider_class do
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name     => 'myresource',
+        :ensure   => :absent
+      )
+    end
+
+    let(:provider) do
+      provider = provider_class.new
+      provider.resource = resource
+      provider
+    end
+
+    before :each do
+      resource.provider = provider
+    end
+
+    describe "when uninstalling" do
+      it "should use the path to the gem" do
+        provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
+        provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
+        provider.uninstall
+      end
+
+      it "should specify that the gem is being uninstalled" do
+        provider.expects(:execute).with { |args| args[1] == "uninstall" }.returns ""
+        provider.uninstall
+      end
+
+      it "should specify that the relevant executables should be removed without confirmation" do
+        provider.expects(:execute).with { |args| args[2] == "--executables" }.returns ""
+        provider.uninstall
+      end
+
+      it "should specify that all the matching versions should be removed" do
+        provider.expects(:execute).with { |args| args[3] == "--all" }.returns ""
+        provider.uninstall
+      end
+
+      it "should specify the package name" do
+        provider.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
+        provider.uninstall
+      end
+
+      it "should not append uninstall_options by default" do
+        provider.expects(:execute).with { |args| args.length == 5 }.returns ""
+        provider.uninstall
+      end
 
-  describe "listing gems" do
-    describe "searching for a single package" do
-      it "searches for an exact match" do
-        provider_class.expects(:execute).with(includes('^bundler$')).returns(File.read(my_fixture('gem-list-single-package')))
-        expected = {:name => 'bundler', :ensure => %w[1.6.2], :provider => :gem}
-        expect(provider_class.gemlist({:justme => 'bundler'})).to eq(expected)
+      it "should allow setting an uninstall_options parameter" do
+        resource[:uninstall_options] = [ '--ignore-dependencies', {'--version' => '0.1.1' } ]
+        provider.expects(:execute).with { |args| args[5] == '--ignore-dependencies' && args[6] == '--version=0.1.1' }.returns ''
+        provider.uninstall
       end
     end
   end