puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/unit/resource/catalog_spec.rb

@@ -836,10 +836,6 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
 end
 
 describe Puppet::Resource::Catalog, "when converting from pson" do
-  def pson_result_should
-    Puppet::Resource::Catalog.expects(:new).with { |hash| yield hash }
-  end
-
   before do
     @data = {
       'name' => "myhost"
@@ -849,125 +845,45 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
       'data' => @data,
       'metadata' => {}
     }
-
-    @catalog = Puppet::Resource::Catalog.new("myhost")
-    Puppet::Resource::Catalog.stubs(:new).returns @catalog
-  end
-
-  it "should be extended with the PSON utility module" do
-    Puppet::Resource::Catalog.singleton_class.ancestors.should be_include(Puppet::Util::Pson)
   end
 
   it "should create it with the provided name" do
-    Puppet::Resource::Catalog.expects(:new).with('myhost').returns @catalog
-    PSON.parse @pson.to_pson
-  end
-
-  it "should set the provided version on the catalog if one is set" do
     @data['version'] = 50
-    PSON.parse @pson.to_pson
-    @catalog.version.should == @data['version']
-  end
-
-  it "should set any provided tags on the catalog" do
     @data['tags'] = %w{one two}
-    PSON.parse @pson.to_pson
-    @catalog.should be_tagged("one")
-    @catalog.should be_tagged("two")
-  end
-
-  it "should set any provided classes on the catalog" do
     @data['classes'] = %w{one two}
-    PSON.parse @pson.to_pson
-    @catalog.classes.should == @data['classes']
-  end
+    @data['edges'] = [Puppet::Relationship.new("File[/foo]", "File[/bar]",
+                                               :event => "one",
+                                               :callback => "refresh").to_data_hash]
+    @data['resources'] = [Puppet::Resource.new(:file, "/foo").to_data_hash,
+                          Puppet::Resource.new(:file, "/bar").to_data_hash]
 
-  it 'should convert the resources list into resources and add each of them' do
-    @data['resources'] = [Puppet::Resource.new(:file, "/foo"), Puppet::Resource.new(:file, "/bar")]
 
     catalog = PSON.parse @pson.to_pson
 
-    catalog.resources.collect(&:ref) == ["File[/foo]", "File[/bar]"]
-  end
-
-  it 'should convert resources even if they do not include "type" information' do
-    @data['resources'] = [Puppet::Resource.new(:file, "/foo")]
-
-    @data['resources'][0].expects(:to_pson).returns '{"title":"/foo","tags":["file"],"type":"File"}'
-
-    @catalog.expects(:add_resource).with { |res| res.type == "File" }
-
-    PSON.parse @pson.to_pson
-  end
-
-  it 'should convert the edges list into edges and add each of them' do
-    one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
-    two = Puppet::Relationship.new("tsource", "ttarget", :event => "two", :callback => "refresh")
-
-    @data['edges'] = [one, two]
+    expect(catalog.name).to eq('myhost')
+    expect(catalog.version).to eq(@data['version'])
+    expect(catalog).to be_tagged("one")
+    expect(catalog).to be_tagged("two")
 
-    @catalog.stubs(:resource).returns("eh")
+    expect(catalog.classes).to eq(@data['classes'])
+    expect(catalog.resources.collect(&:ref)).to eq(["File[/foo]", "File[/bar]"])
 
-    @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
-    @catalog.expects(:add_edge).with { |edge| edge.event == "two" }
-
-    PSON.parse @pson.to_pson
-  end
-
-  it "should be able to convert relationships that do not include 'type' information" do
-    one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
-    one.expects(:to_pson).returns "{\"event\":\"one\",\"callback\":\"refresh\",\"source\":\"osource\",\"target\":\"otarget\"}"
-
-    @data['edges'] = [one]
-
-    @catalog.stubs(:resource).returns("eh")
-
-    @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
-
-    PSON.parse @pson.to_pson
-  end
-
-  it "should set the source and target for each edge to the actual resource" do
-    edge = Puppet::Relationship.new("source", "target")
-
-    @data['edges'] = [edge]
-
-    @catalog.expects(:resource).with("source").returns("source_resource")
-    @catalog.expects(:resource).with("target").returns("target_resource")
-
-    @catalog.expects(:add_edge).with { |edge| edge.source == "source_resource" and edge.target == "target_resource" }
-
-    PSON.parse @pson.to_pson
+    expect(catalog.edges.collect(&:event)).to eq(["one"])
+    expect(catalog.edges[0].source).to eq(catalog.resource(:file, "/foo"))
+    expect(catalog.edges[0].target).to eq(catalog.resource(:file, "/bar"))
   end
 
   it "should fail if the source resource cannot be found" do
-    edge = Puppet::Relationship.new("source", "target")
-
-    @data['edges'] = [edge]
+    @data['edges'] = [Puppet::Relationship.new("File[/missing]", "File[/bar]").to_data_hash]
+    @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]
 
-    @catalog.expects(:resource).with("source").returns(nil)
-    @catalog.stubs(:resource).with("target").returns("target_resource")
-
-    lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
+    expect { PSON.parse @pson.to_pson }.to raise_error(ArgumentError, /Could not find relationship source/)
   end
 
   it "should fail if the target resource cannot be found" do
-    edge = Puppet::Relationship.new("source", "target")
-
-    @data['edges'] = [edge]
+    @data['edges'] = [Puppet::Relationship.new("File[/bar]", "File[/missing]").to_data_hash]
+    @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]
 
-    @catalog.stubs(:resource).with("source").returns("source_resource")
-    @catalog.expects(:resource).with("target").returns(nil)
-
-    lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
-  end
-
-  describe "#title_key_for_ref" do
-    it "should parse a resource ref string into a pair" do
-      @catalog.title_key_for_ref("Title[name]").should == ["Title", "name"]
-    end
-    it "should parse a resource ref string into a pair, even if there's a newline inside the name" do
-      @catalog.title_key_for_ref("Title[na\nme]").should == ["Title", "na\nme"]
-    end
+    expect { PSON.parse @pson.to_pson }.to raise_error(ArgumentError, /Could not find relationship target/)
   end
 end

data/spec/unit/resource/type_collection_spec.rb

@@ -400,18 +400,19 @@ describe Puppet::Resource::TypeCollection do
       @code.version.should == time.to_i
     end
 
-    it "should use the output of the environment's config_version setting if one is provided" do
-      @code.environment.stubs(:[]).with(:config_version).returns("/my/foo")
+    context "when config_version script is specified" do
+      let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
 
-      Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
-      @code.version.should == "output"
-    end
+      it "should use the output of the environment's config_version setting if one is provided" do
+        Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
+        @code.version.should == "output"
+      end
 
-    it "should raise a puppet parser error if executing config_version fails" do
-      @code.environment.stubs(:[]).with(:config_version).returns("test")
-      Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
+      it "should raise a puppet parser error if executing config_version fails" do
+        Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
-      lambda { @code.version }.should raise_error(Puppet::ParseError)
+        lambda { @code.version }.should raise_error(Puppet::ParseError)
+      end
     end
   end
 end

data/spec/unit/settings/config_file_spec.rb

@@ -5,12 +5,6 @@ require 'puppet/settings/config_file'
 describe Puppet::Settings::ConfigFile do
   NOTHING = {}
 
-  def section_containing(data)
-    meta = data[:meta] || {}
-    values = data.reject { |key, _| key == :meta }
-    values.merge({ :_meta => Hash[values.keys.collect { |key| [key, meta[key] || {}] }] })
-  end
-
   def the_parse_of(*lines)
     config.parse_file(filename, lines.join("\n"))
   end
@@ -130,6 +124,35 @@ badline
         "Illegal section 'global_defaults' in config file #{filename} at line 2"
   end
 
+  it "issues a single deprecation warning when any section other than main, master, agent or user is parsed" do
+    text = "[legacy]
+    one = 'e'
+    two = 'f'
+    [also_deprecated]
+    one = 'g'
+    "
+
+    config.parse_file(filename, text)
+
+    expect(@logs.map(&:message).grep(/Sections other than/)).to have_exactly(1).item
+  end
+
+  it "does not issue a deprecation warning for main, master, agent or user sections" do
+    text = "[main]
+    one = 'a'
+    [master]
+    one = 'b'
+    [agent]
+    one = 'c'
+    [user]
+    one = 'd'
+    "
+
+    Puppet.expects(:deprecation_warning).never
+
+    config.parse_file(filename, text)
+  end
+
   it "transforms values with the given function" do
     config = Puppet::Settings::ConfigFile.new(Proc.new { |value| value + " changed" })
 

data/spec/unit/settings/environment_conf_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'puppet/settings/environment_conf.rb'
+
+describe Puppet::Settings::EnvironmentConf do
+
+  context "with config" do
+    let(:config) { stub(:config) }
+    let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
+
+    it "reads a modulepath from config and does not include global_module_path" do
+      config.expects(:setting).with(:modulepath).returns(
+        mock('setting', :value => '/some/modulepath')
+      )
+      expect(envconf.modulepath).to eq(File.expand_path('/some/modulepath'))
+    end
+
+    it "reads a manifest from config" do
+      config.expects(:setting).with(:manifest).returns(
+        mock('setting', :value => '/some/manifest')
+      )
+      expect(envconf.manifest).to eq(File.expand_path('/some/manifest'))
+    end
+
+    it "reads a config_version from config" do
+      config.expects(:setting).with(:config_version).returns(
+        mock('setting', :value => '/some/version.sh')
+      )
+      expect(envconf.config_version).to eq(File.expand_path('/some/version.sh'))
+    end
+
+  end
+
+  context "without config" do
+    let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", nil, ["/global/modulepath"]) }
+
+    it "returns a default modulepath when config has none, with global_module_path" do
+      expect(envconf.modulepath).to eq(
+        [File.expand_path('/some/direnv/modules'),
+        File.expand_path('/global/modulepath')].join(File::PATH_SEPARATOR)
+      )
+    end
+
+    it "returns a default manifest when config has none" do
+      expect(envconf.manifest).to eq(File.expand_path('/some/direnv/manifests'))
+    end
+
+    it "returns nothing for config_version when config has none" do
+      expect(envconf.config_version).to be_nil
+    end
+  end
+end

data/spec/unit/settings_spec.rb

@@ -755,7 +755,7 @@ describe Puppet::Settings do
 
       Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
 
-      File.expects(:read).with(myfile).returns "[main]"
+      Puppet::FileSystem.expects(:read).with(myfile).returns "[main]"
 
       @settings.send(:parse_config_files)
     end
@@ -1002,22 +1002,107 @@ describe Puppet::Settings do
       @settings[:myarg].should == ""
     end
 
-    describe "and when reading a non-positive filetimeout value from the config file" do
-      before do
-        @settings.define_settings :foo, :filetimeout => { :default => 5, :desc => "eh" }
+    describe "deprecations" do
+      context "in puppet.conf" do
+
+        def assert_puppet_conf_deprecation(setting, matches)
+          Puppet.expects(:deprecation_warning).with(regexp_matches(matches), anything)
+
+          val = "/you/can/set/this/but/will/get/warning"
+          text = "[main]
+          #{setting}=#{val}
+          "
+          Puppet.settings.parse_config(text)
+        end
+
+        it "warns when manifest is set" do
+          assert_puppet_conf_deprecation('manifest', /manifest.*puppet.conf/)
+        end
+
+        it "warns when modulepath is set" do
+          assert_puppet_conf_deprecation('modulepath', /modulepath.*puppet.conf/)
+        end
+
+        it "warns when config_version is set" do
+          assert_puppet_conf_deprecation('config_version', /config_version.*puppet.conf/)
+        end
+
+        it "warns when manifestdir is set" do
+          assert_puppet_conf_deprecation('manifestdir', /Setting manifestdir.*is.*deprecated/)
+        end
+
+        it "warns when templatedir is set" do
+          assert_puppet_conf_deprecation('templatedir', /Setting templatedir.*is.*deprecated/)
+        end
+      end
+
+      context "on the command line" do
+        def assert_command_line_deprecation(setting, message)
+          Puppet.expects(:deprecation_warning).with(message, anything)
+
+          args = ["--#{setting}", "/some/value"]
+          Puppet.settings.send(:parse_global_options, args)
+        end
+
+        def assert_command_line_not_deprecated(setting)
+          Puppet.expects(:deprecation_warning).never
+
+          args = ["--#{setting}", "/some/value"]
+          Puppet.settings.send(:parse_global_options, args)
+        end
+
+        it "does not warn when manifest is set on command line" do
+          assert_command_line_not_deprecated('manifest')
+        end
+
+        it "does not warn when modulepath is set on command line" do
+          assert_command_line_not_deprecated('modulepath')
+        end
+
+        it "does not warn when config_version is set on command line" do
+          assert_command_line_not_deprecated('config_version')
+        end
+
+        it "warns when manifestdir is set on command line" do
+          assert_command_line_deprecation('manifestdir', "Setting manifestdir is deprecated. See http://links.puppetlabs.com/env-settings-deprecations")
+        end
+
+        it "warns when templatedir is set on command line" do
+          assert_command_line_deprecation('templatedir', "Setting templatedir is deprecated. See http://links.puppetlabs.com/env-settings-deprecations")
+        end
+      end
+
+      context "as settings in the code base" do
+        def assert_accessing_setting_is_deprecated(setting)
+          Puppet.expects(:deprecation_warning).with("Accessing '#{setting}' as a setting is deprecated. See http://links.puppetlabs.com/env-settings-deprecations")
+          Puppet.expects(:deprecation_warning).with("Modifying '#{setting}' as a setting is deprecated. See http://links.puppetlabs.com/env-settings-deprecations")
+          Puppet[setting.intern] = apath = File.expand_path('foo')
+          expect(Puppet[setting.intern]).to eq(apath)
+        end
+
+        it "warns when attempt to access a 'manifest' setting" do
+          assert_accessing_setting_is_deprecated('manifest')
+        end
+
+        it "warns when attempt to access a 'modulepath' setting" do
+          assert_accessing_setting_is_deprecated('modulepath')
+        end
+        it "warns when attempt to access a 'config_version' setting" do
+          assert_accessing_setting_is_deprecated('config_version')
+        end
+
+        it "warns when attempt to access a 'manifestdir' setting" do
+          assert_accessing_setting_is_deprecated('manifestdir')
+        end
+
+        it "warns when attempt to access a 'templatedir' setting" do
+          assert_accessing_setting_is_deprecated('templatedir')
+        end
 
-        somefile = "/some/file"
-        text = "[main]
-        filetimeout = -1
-        "
-        File.expects(:read).with(somefile).returns(text)
-        File.expects(:expand_path).with(somefile).returns somefile
-        @settings[:config] = somefile
       end
     end
   end
 
-
   describe "when there are multiple config files" do
     let(:main_config_text) { "[main]\none = main\ntwo = main2" }
     let(:user_config_text) { "[main]\none = user\n" }

data/spec/unit/ssl/certificate_authority_spec.rb

@@ -978,6 +978,7 @@ end
 
 require 'puppet/indirector/memory'
 
+module CertificateAuthorityGenerateSpecs
 describe "CertificateAuthority.generate" do
 
   def expect_to_increment_serial_file
@@ -1103,3 +1104,4 @@ describe "CertificateAuthority.generate" do
     end
   end
 end
+end

data/spec/unit/type/augeas_spec.rb

@@ -34,7 +34,7 @@ describe augeas do
     end
 
     properties = [:returns]
-    params = [:name, :context, :onlyif, :changes, :root, :load_path, :type_check]
+    params = [:name, :context, :onlyif, :changes, :root, :load_path, :type_check, :show_diff]
 
     properties.each do |property|
       it "should have a #{property} property" do

data/spec/unit/type/cron_spec.rb

@@ -3,13 +3,17 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows? do
-  before :all do
+  let(:simple_provider) do
     @provider_class = described_class.provide(:simple) { mk_resource_methods }
     @provider_class.stubs(:suitable?).returns true
+    @provider_class
+  end
+
+  before :each do
     described_class.stubs(:defaultprovider).returns @provider_class
   end
 
-  after :all do
+  after :each do
     described_class.unprovide(:simple)
   end
 
@@ -526,11 +530,6 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
     end
   end
 
-  it "should require a command when adding an entry" do
-    entry = described_class.new(:name => "test_entry", :ensure => :present)
-    expect { entry.value(:command) }.to raise_error(Puppet::Error, /No command/)
-  end
-
   it "should not require a command when removing an entry" do
     entry = described_class.new(:name => "test_entry", :ensure => :absent)
     entry.value(:command).should == nil