puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/spec/unit/indirector/request_spec.rb

@@ -116,32 +116,32 @@ describe Puppet::Indirector::Request do
       end
 
       it "should set the protocol to the URI scheme" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).protocol).to eq("http")
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).protocol).to eq("http")
       end
 
       it "should set the server if a server is provided" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).server).to eq("host")
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).server).to eq("host")
       end
 
       it "should set the server and port if both are provided" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/an_environment", nil).port).to eq(543)
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/", nil).port).to eq(543)
       end
 
       it "should default to the masterport if the URI scheme is 'puppet'" do
         Puppet[:masterport] = "321"
-        expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/an_environment", nil).port).to eq(321)
+        expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/", nil).port).to eq(321)
       end
 
       it "should use the provided port if the URI scheme is not 'puppet'" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).port).to eq(80)
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).port).to eq(80)
       end
 
-      it "should set the request key to the unescaped key part path from the URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment/terminus/stuff with spaces", nil).key).to eq("stuff with spaces")
+      it "should set the request key to the unescaped path from the URI" do
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff with spaces", nil).key).to eq("stuff with spaces")
       end
 
       it "should set the :uri attribute to the full URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http:///an_environment/stu ff", nil).uri).to eq('http:///an_environment/stu ff')
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http:///a/path/stu ff", nil).uri).to eq('http:///a/path/stu ff')
       end
 
       it "should not parse relative URI" do

data/spec/unit/info_service_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+require 'puppet/pops'
+require 'puppet/info_service'
+require 'puppet/pops/evaluator/literal_evaluator'
+
+describe "Puppet::InfoService" do
+  context 'classes_per_environment service' do
+    include PuppetSpec::Files
+
+    let(:code_dir) do
+      dir_containing('manifests', {
+        'foo.pp' => <<-CODE,
+           class foo($foo_a, Integer $foo_b, String $foo_c = 'c default value') { }
+           class foo2($foo2_a, Integer $foo2_b, String $foo2_c = 'c default value') { }
+        CODE
+        'bar.pp' => <<-CODE,
+           class bar($bar_a, Integer $bar_b, String $bar_c = 'c default value') { }
+           class bar2($bar2_a, Integer $bar2_b, String $bar2_c = 'c default value') { }
+        CODE
+        'fee.pp' => <<-CODE,
+           class fee(Integer $fee_a = 1+1) { }
+        CODE
+        'fum.pp' => <<-CODE,
+           class fum($fum_a) { }
+        CODE
+        'nothing.pp' => <<-CODE,
+           # not much to see here, move along
+        CODE
+        'borked.pp' => <<-CODE,
+           class Borked($Herp+$Derp) {}
+        CODE
+       })
+    end
+
+    it "errors if not given a hash" do
+      expect{ Puppet::InfoService.classes_per_environment("you wassup?")}.to raise_error(ArgumentError, 'Given argument must be a Hash')
+    end
+
+    it "returns empty hash if given nothing" do
+      expect(Puppet::InfoService.classes_per_environment({})).to eq({})
+    end
+
+    it "produces classes and parameters from a given file" do
+      files = ['foo.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>[
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+               ]
+             }
+           ]} # end production env
+        })
+    end
+
+    it "produces classes and parameters from multiple files in same environment" do
+      files = ['foo.pp', 'bar.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>[
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+               ]
+             }
+           ],
+          "#{code_dir}/bar.pp"=>[
+            {:name=>"bar",
+              :params=>[
+                {:name=>"bar_a"},
+                {:name=>"bar_b", :type=>"Integer"},
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value"}
+              ]},
+            {:name=>"bar2",
+              :params=>[
+                {:name=>"bar2_a"},
+                {:name=>"bar2_b", :type=>"Integer"},
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value"}
+              ]
+            }
+          ],
+
+          } # end production env
+        }
+      )
+    end
+
+    it "produces classes and parameters from multiple files in multiple environments" do
+      files_production = ['foo.pp', 'bar.pp'].map {|f| File.join(code_dir, f) }
+      files_test = ['fee.pp', 'fum.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({
+        'production' => files_production,
+        'test'       => files_test
+      })
+
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>[
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+               ]
+             }
+           ],
+          "#{code_dir}/bar.pp"=>[
+            {:name=>"bar",
+              :params=>[
+                {:name=>"bar_a"},
+                {:name=>"bar_b", :type=>"Integer"},
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value"}
+              ]},
+            {:name=>"bar2",
+              :params=>[
+                {:name=>"bar2_a"},
+                {:name=>"bar2_b", :type=>"Integer"},
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value"}
+                ]
+              }
+            ],
+          }, # end production env
+        "test"=>{
+           "#{code_dir}/fee.pp"=>[
+             {:name=>"fee",
+               :params=>[
+                 {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
+               ]},
+           ],
+          "#{code_dir}/fum.pp"=>[
+            {:name=>"fum",
+              :params=>[
+                {:name=>"fum_a"}
+              ]},
+          ],
+         } # end test env
+        }
+      )
+    end
+
+    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
+      files_production = ['fum.pp'].map {|f| File.join(code_dir, f) }
+      files_test       = files_production
+
+      result = Puppet::InfoService.classes_per_environment({
+        'production' => files_production,
+        'test'       => files_test
+        })
+       expect(result).to eq({
+        "production"=>{ "#{code_dir}/fum.pp"=>[ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]},
+        "test"      =>{ "#{code_dir}/fum.pp"=>[ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]}
+       }
+      )
+    end
+
+    it "produces expression string if a default value is not literal" do
+      files = ['fee.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/fee.pp"=>[
+             {:name=>"fee",
+               :params=>[
+                 {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
+               ]},
+           ]} # end production env
+        })
+     end
+
+    it "produces no type entry if type is not given" do
+      files = ['fum.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/fum.pp"=>[
+             {:name=>"fum",
+               :params=>[
+                 {:name=>"fum_a" }
+               ]},
+           ]} # end production env
+        })
+    end
+
+    it "produces error entry if file is broken" do
+      files = ['borked.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+            "#{code_dir}/borked.pp"=>
+              {:error=>"Syntax error at '+' at #{code_dir}/borked.pp:1:30",
+              },
+            } # end production env
+         })
+    end
+
+    it "produces empty {} if parsed result has no classes" do
+      files = ['nothing.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+            "#{code_dir}/nothing.pp"=> []
+              },
+         })
+    end
+  end
+end

data/spec/unit/module_tool/metadata_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::ModuleTool::Metadata do
     subject { metadata }
 
     %w[ name version author summary license source project_page issues_url
-    dependencies dashed_name release_name description ].each do |prop|
+    dependencies dashed_name release_name description data_provider].each do |prop|
       describe "##{prop}" do
         it "responds to the property" do
           subject.send(prop)
@@ -224,6 +224,35 @@ describe Puppet::ModuleTool::Metadata do
         expect(subject.dependencies.size).to eq(1)
       end
     end
+
+    context 'with valid data_provider' do
+      let(:data) { {'data_provider' => 'the_name'} }
+
+      it 'validates the provider correctly' do
+        expect { subject }.not_to raise_error
+      end
+
+      it 'returns the provider' do
+        expect(subject.data_provider).to eq('the_name')
+      end
+    end
+
+    context 'with invalid data_provider' do
+      let(:data) { }
+
+      it "raises exception unless argument starts with a letter" do
+        expect { metadata.update('data_provider' => '_the_name') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
+        expect { metadata.update('data_provider' => '') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
+      end
+
+      it "raises exception if argument contains non-alphanumeric characters" do
+        expect { metadata.update('data_provider' => 'the::name') }.to raise_error(ArgumentError, /field 'data_provider' contains non-alphanumeric characters/)
+      end
+
+      it "raises exception unless argument is a string" do
+        expect { metadata.update('data_provider' => 23) }.to raise_error(ArgumentError, /field 'data_provider' must be a string/)
+      end
+    end
   end
 
   describe '#dashed_name' do
@@ -271,7 +300,7 @@ describe Puppet::ModuleTool::Metadata do
     subject { metadata.to_hash }
 
     it "contains the default set of keys" do
-      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies ].sort)
+      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies data_provider].sort)
     end
 
     describe "['license']" do

data/spec/unit/network/authconfig_spec.rb

@@ -3,80 +3,80 @@ require 'spec_helper'
 
 require 'puppet/network/authconfig'
 
-describe Puppet::Network::AuthConfig do
+describe Puppet::Network::DefaultAuthProvider do
   before :each do
     Puppet::FileSystem.stubs(:stat).returns stub('stat', :ctime => :now)
     Time.stubs(:now).returns Time.now
 
-    Puppet::Network::AuthConfig.any_instance.stubs(:exists?).returns(true)
-    # FIXME @authconfig = Puppet::Network::AuthConfig.new("dummy")
+    Puppet::Network::DefaultAuthProvider.any_instance.stubs(:exists?).returns(true)
+    # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do
     it "inserts default ACLs after setting initial rights" do
-      Puppet::Network::AuthConfig.any_instance.expects(:insert_default_acl)
-      Puppet::Network::AuthConfig.new
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.new
     end
   end
 
   describe "when defining an acl with mk_acl" do
     before :each do
-      Puppet::Network::AuthConfig.any_instance.stubs(:insert_default_acl)
-      @authconfig = Puppet::Network::AuthConfig.new
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      @authprovider = Puppet::Network::DefaultAuthProvider.new
     end
 
     it "should create a new right for each default acl" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/']).to be
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/']).to be
     end
 
     it "allows everyone for each default right" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/']).to be_globalallow
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/']).to be_globalallow
     end
 
     it "accepts an argument to restrict the method" do
-      @authconfig.mk_acl(:acl => '/', :method => :find)
-      expect(@authconfig.rights['/'].methods).to eq([:find])
+      @authprovider.mk_acl(:acl => '/', :method => :find)
+      expect(@authprovider.rights['/'].methods).to eq([:find])
     end
 
     it "creates rights with authentication set to true by default" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/'].authentication).to be_truthy
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/'].authentication).to be_truthy
     end
 
     it "accepts an argument to set the authentication requirement" do
-      @authconfig.mk_acl(:acl => '/', :authenticated => :any)
-      expect(@authconfig.rights['/'].authentication).to be_falsey
+      @authprovider.mk_acl(:acl => '/', :authenticated => :any)
+      expect(@authprovider.rights['/'].authentication).to be_falsey
     end
   end
 
   describe "when adding default ACLs" do
     before :each do
-      Puppet::Network::AuthConfig.any_instance.stubs(:insert_default_acl)
-      @authconfig = Puppet::Network::AuthConfig.new
-      Puppet::Network::AuthConfig.any_instance.unstub(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      @authprovider = Puppet::Network::DefaultAuthProvider.new
+      Puppet::Network::DefaultAuthProvider.any_instance.unstub(:insert_default_acl)
     end
 
-    Puppet::Network::AuthConfig::default_acl.each do |acl|
+    Puppet::Network::DefaultAuthProvider::default_acl.each do |acl|
       it "should create a default right for #{acl[:acl]}" do
-        @authconfig.stubs(:mk_acl)
-        @authconfig.expects(:mk_acl).with(acl)
-        @authconfig.insert_default_acl
+        @authprovider.stubs(:mk_acl)
+        @authprovider.expects(:mk_acl).with(acl)
+        @authprovider.insert_default_acl
       end
     end
 
     it "should log at info loglevel" do
       Puppet.expects(:info).at_least_once
-      @authconfig.insert_default_acl
+      @authprovider.insert_default_acl
     end
 
     it "creates an empty catch-all rule for '/' for any authentication request state" do
-      @authconfig.stubs(:mk_acl)
+      @authprovider.stubs(:mk_acl)
 
-      @authconfig.insert_default_acl
-      expect(@authconfig.rights['/']).to be_empty
-      expect(@authconfig.rights['/'].authentication).to be_falsey
+      @authprovider.insert_default_acl
+      expect(@authprovider.rights['/']).to be_empty
+      expect(@authprovider.rights['/'].authentication).to be_falsey
     end
 
     it '(CVE-2013-2275) allows report submission only for the node matching the certname by default' do
@@ -86,9 +86,9 @@ describe Puppet::Network::AuthConfig do
         :allow => '$1',
         :authenticated => true
       }
-      @authconfig.stubs(:mk_acl)
-      @authconfig.expects(:mk_acl).with(acl)
-      @authconfig.insert_default_acl
+      @authprovider.stubs(:mk_acl)
+      @authprovider.expects(:mk_acl).with(acl)
+      @authprovider.insert_default_acl
     end
   end
 
@@ -107,3 +107,33 @@ describe Puppet::Network::AuthConfig do
     end
   end
 end
+
+describe Puppet::Network::AuthConfig do
+  after :each do
+    Puppet::Network::AuthConfig.authprovider_class = nil
+  end
+
+  class TestAuthProvider
+    def initialize(rights=nil); end
+    def check_authorization(method, path, params); end
+  end
+
+  it "instantiates authprovider_class with rights" do
+    Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
+    rights = Puppet::Network::Rights.new
+    TestAuthProvider.expects(:new).with(rights)
+    described_class.new(rights)
+  end
+
+  it "delegates authorization check to authprovider_class" do
+    Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
+    TestAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    described_class.new.check_authorization(:save, '/path/to/resource', {})
+  end
+
+  it "uses DefaultAuthProvider by default" do
+    Puppet::Network::AuthConfig.authprovider_class = nil
+    Puppet::Network::DefaultAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    described_class.new.check_authorization(:save, '/path/to/resource', {})
+  end
+end