puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

data/spec/unit/application/filebucket_spec.rb

@@ -93,7 +93,8 @@ describe Puppet::Application::Filebucket do
       end
 
       it "should create a client with the default bucket if none passed" do
-        Puppet[:bucketdir] = path
+        Puppet[:clientbucketdir] = path
+        Puppet[:bucketdir] = path + "2"
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Path] == path }
 
@@ -111,17 +112,30 @@ describe Puppet::Application::Filebucket do
     end
 
     describe "with remote bucket" do
-
       it "should create a remote Client to the configured server" do
         Puppet[:server] = "puppet.reductivelabs.com"
-
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Server] == "puppet.reductivelabs.com" }
+        @filebucket.setup
+      end
 
+      it "should default to the first server_list entry if set" do
+        Puppet[:server_list] = "foo,bar,baz"
+        Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Server] == "foo" }
         @filebucket.setup
       end
 
-    end
+      it "should fall back to server if server_list is empty" do
+        Puppet[:server_list] = ""
+        Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Server] == "puppet" }
+        @filebucket.setup
+      end
 
+      it "should take both the server and port specified in server_list" do
+        Puppet[:server_list] = "foo:632,bar:6215,baz:351"
+        Puppet::FileBucket::Dipper.expects(:new).with({ :Server => "foo", :Port => "632" })
+        @filebucket.setup
+      end
+    end
   end
 
   describe "when running" do

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -4,13 +4,10 @@ require 'puppet/configurer'
 require 'puppet/configurer/plugin_handler'
 
 describe Puppet::Configurer::PluginHandler do
-  let(:factory)       { Puppet::Configurer::DownloaderFactory.new }
-  let(:pluginhandler) { Puppet::Configurer::PluginHandler.new(factory) }
+  let(:pluginhandler) { Puppet::Configurer::PluginHandler.new() }
   let(:environment)   { Puppet::Node::Environment.create(:myenv, []) }
 
-
   context "server agent version is 5.3.4" do
-
     before :each do
       # PluginHandler#load_plugin has an extra-strong rescue clause
       # this mock is to make sure that we don't silently ignore errors
@@ -20,32 +17,19 @@ describe Puppet::Configurer::PluginHandler do
     end
 
     it "downloads plugins, facts, and locales" do
-      plugin_downloader = stub('plugin-downloader', :evaluate => [])
-      facts_downloader = stub('facts-downloader', :evaluate => [])
-      locales_downloader = stub('locales-downloader', :evaluate => [])
-
-      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
-      factory.expects(:create_locales_downloader).returns(locales_downloader)
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       pluginhandler.download_plugins(environment)
     end
 
     it "returns downloaded plugin, fact, and locale filenames" do
-      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
-      facts_downloader = stub('facts-downloader', :evaluate => %w[/b])
-      locales_downloader = stub('locales-downloader', :evaluate => %w[/c])
-
-      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
-      factory.expects(:create_locales_downloader).returns(locales_downloader)
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
 
       expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b /c])
     end
   end
 
   context "server agent version is 5.3.3" do
-
     before :each do
       # PluginHandler#load_plugin has an extra-strong rescue clause
       # this mock is to make sure that we don't silently ignore errors
@@ -55,12 +39,7 @@ describe Puppet::Configurer::PluginHandler do
     end
 
     it "returns downloaded plugin, fact, but not locale filenames" do
-      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
-      facts_downloader = stub('facts-downloader', :evaluate => %w[/b])
-
-      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
-      factory.expects(:create_locales_downloader).never
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
     end
@@ -77,15 +56,9 @@ describe Puppet::Configurer::PluginHandler do
     end
 
     it "returns downloaded plugin, fact, but not locale filenames" do
-      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
-      facts_downloader = stub('facts-downloader', :evaluate => %w[/b])
-
-      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
-      factory.expects(:create_locales_downloader).never
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
     end
-
   end
 end

data/spec/unit/configurer_spec.rb

@@ -200,7 +200,7 @@ describe Puppet::Configurer do
     end
 
     it "should create report with passed transaction_uuid and job_id" do
-      @agent = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, "test_tuuid", "test_jid")
+      @agent = Puppet::Configurer.new("test_tuuid", "test_jid")
       @agent.stubs(:init_storage)
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
@@ -399,7 +399,7 @@ describe Puppet::Configurer do
 
     it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
       Puppet::Resource::Catalog.indirection.expects(:find).with(anything,
-        has_entries(:checksum_type => 'md5.sha256'))
+        has_entries(:checksum_type => 'md5.sha256.sha384.sha512.sha224'))
       @agent.run
     end
 
@@ -444,7 +444,7 @@ describe Puppet::Configurer do
   describe "when initialized with a transaction_uuid" do
     it "stores it" do
       SecureRandom.expects(:uuid).never
-      configurer = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, 'foo')
+      configurer = Puppet::Configurer.new('foo')
       expect(configurer.instance_variable_get(:@transaction_uuid) == 'foo')
     end
   end

data/spec/unit/datatypes_spec.rb

@@ -0,0 +1,304 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'puppet_spec/files'
+require 'puppet/pops'
+
+module PuppetSpec::DataTypes
+describe "Puppet::DataTypes" do
+  include PuppetSpec::Compiler
+  include PuppetSpec::Files
+
+  let(:modules) { { 'mytest' => mytest } }
+  let(:datatypes) { {} }
+  let(:environments_dir) { Puppet[:environmentpath] }
+
+  let(:mytest) {{
+    'lib' => {
+      'puppet' => {
+        'datatypes' => mytest_datatypes,
+        'functions' => mytest_functions },
+      'puppetx' => { 'mytest' => mytest_classes },
+    }
+  }}
+
+  let(:mytest_datatypes) { {} }
+  let(:mytest_classes) { {} }
+  let(:mytest_functions) { {
+    'mytest' => {
+      'to_data.rb' => <<-RUBY.unindent,
+        Puppet::Functions.create_function('mytest::to_data') do
+          def to_data(data)
+            Puppet::Pops::Serialization::ToDataConverter.convert(data, {
+              :rich_data => true,
+              :symbol_as_string => true,
+              :type_by_reference => true,
+              :message_prefix => 'test'
+            })
+          end
+        end
+        RUBY
+
+      'from_data.rb' => <<-RUBY.unindent,
+        Puppet::Functions.create_function('mytest::from_data') do
+          def from_data(data)
+            Puppet::Pops::Serialization::FromDataConverter.convert(data)
+          end
+        end
+        RUBY
+
+      'serialize.rb' => <<-RUBY.unindent,
+        Puppet::Functions.create_function('mytest::serialize') do
+          def serialize(data)
+            buffer = ''
+            serializer = Puppet::Pops::Serialization::Serializer.new(
+              Puppet::Pops::Serialization::JSON::Writer.new(buffer))
+            serializer.write(data)
+            serializer.finish
+            buffer
+          end
+        end
+        RUBY
+
+      'deserialize.rb' => <<-RUBY.unindent,
+        Puppet::Functions.create_function('mytest::deserialize') do
+          def deserialize(data)
+            deserializer = Puppet::Pops::Serialization::Deserializer.new(
+              Puppet::Pops::Serialization::JSON::Reader.new(data), Puppet::Pops::Loaders.find_loader(nil))
+            deserializer.read
+          end
+        end
+        RUBY
+      }
+  } }
+
+  let(:testing_env_dir) do
+    dir_contained_in(environments_dir, testing_env)
+    env_dir = File.join(environments_dir, 'testing')
+    PuppetSpec::Files.record_tmp(env_dir)
+    env_dir
+  end
+
+  let(:modules_dir) { File.join(testing_env_dir, 'modules') }
+  let(:env) { Puppet::Node::Environment.create(:testing, [modules_dir]) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+
+  let(:testing_env) do
+    {
+      'testing' => {
+        'lib' => { 'puppet' => { 'datatypes' => datatypes } },
+        'modules' => modules,
+      }
+    }
+  end
+
+  before(:each) do
+    Puppet[:environment] = 'testing'
+  end
+
+  context 'when creating type with derived attributes using implementation' do
+    let(:datatypes) {
+      {
+        'mytype.rb' => <<-RUBY.unindent,
+          Puppet::DataTypes.create_type('Mytype') do
+            interface <<-PUPPET
+              attributes => {
+                name => { type => String },
+                year_of_birth => { type => Integer },
+                age => { type => Integer, kind => derived },
+              }
+              PUPPET
+
+            implementation do
+              def age
+                DateTime.now.year - @year_of_birth
+              end
+            end
+          end
+          RUBY
+      }
+    }
+
+    it 'loads and returns value of attribute' do
+      expect(eval_and_collect_notices('notice(Mytype("Bob", 1984).age)', node)).to eql(["#{DateTime.now.year - 1984}"])
+    end
+
+    it 'can convert value to and from data' do
+      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['false', 'true', 'true', "#{DateTime.now.year - 1984}"])
+        $m = Mytype("Bob", 1984)
+        $d = $m.mytest::to_data
+        notice($m == $d)
+        notice($d =~ Data)
+        $m2 = $d.mytest::from_data
+        notice($m == $m2)
+        notice($m2.age)
+      PUPPET
+    end
+  end
+
+  context 'when creating type for an already implemented class' do
+    let(:datatypes) {
+      {
+        'mytest.rb' => <<-RUBY.unindent,
+          Puppet::DataTypes.create_type('Mytest') do
+            interface <<-PUPPET
+              attributes => {
+                name => { type => String },
+                year_of_birth => { type => Integer },
+                age => { type => Integer, kind => derived },
+              },
+              functions => {
+                '[]' => Callable[[String[1]], Variant[String, Integer]]
+              }
+              PUPPET
+
+            implementation_class PuppetSpec::DataTypes::MyTest
+          end
+      RUBY
+      }
+    }
+
+    before(:each) do
+      class ::PuppetSpec::DataTypes::MyTest
+        attr_reader :name, :year_of_birth
+
+        def initialize(name, year_of_birth)
+          @name = name
+          @year_of_birth = year_of_birth
+        end
+
+        def age
+          DateTime.now.year - @year_of_birth
+        end
+
+        def [](key)
+          case key
+          when 'name'
+            @name
+          when 'year_of_birth'
+            @year_of_birth
+          when 'age'
+            age
+          else
+            nil
+          end
+        end
+
+        def ==(o)
+          self.class == o.class && @name == o.name && @year_of_birth == o.year_of_birth
+        end
+      end
+    end
+
+    after(:each) do
+      ::PuppetSpec::DataTypes.send(:remove_const, :MyTest)
+    end
+
+    it 'loads and returns value of attribute' do
+      expect(eval_and_collect_notices('notice(Mytest("Bob", 1984).age)', node)).to eql(["#{DateTime.now.year - 1984}"])
+    end
+
+    it 'can convert value to and from data' do
+      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['true', 'true', "#{DateTime.now.year - 1984}"])
+        $m = Mytest("Bob", 1984)
+        $d = $m.mytest::to_data
+        notice($d =~ Data)
+        $m2 = $d.mytest::from_data
+        notice($m == $m2)
+        notice($m2.age)
+        PUPPET
+    end
+
+    it 'can access using implemented [] method' do
+      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['Bob', "#{DateTime.now.year - 1984}"])
+        $m = Mytest("Bob", 1984)
+        notice($m['name'])
+        notice($m['age'])
+      PUPPET
+    end
+
+    it 'can serialize and deserialize data' do
+      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['true', 'true', "#{DateTime.now.year - 1984}"])
+        $m = Mytest("Bob", 1984)
+        $d = $m.mytest::serialize
+        notice($d =~ String)
+        $m2 = $d.mytest::deserialize
+        notice($m == $m2)
+        notice($m2.age)
+        PUPPET
+    end
+  end
+
+  context 'with data type and class defined in a module' do
+    let(:mytest_classes) {
+      {
+        'position.rb' => <<-RUBY
+            module PuppetX; module Mytest; class Position
+              attr_reader :x, :y
+  
+              def initialize(x, y)
+                @x = x
+                @y = y
+              end
+            end; end; end
+      RUBY
+      }
+    }
+
+    after(:each) do
+      ::PuppetX.send(:remove_const, :Mytest)
+    end
+
+    context 'in module namespace' do
+      let(:mytest_datatypes) {
+        {
+          'mytest' => { 'position.rb' => <<-RUBY
+            Puppet::DataTypes.create_type('Mytest::Position') do
+              interface <<-PUPPET
+                attributes => {
+                  x => Integer,
+                  y => Integer
+                }
+                PUPPET
+
+              load_file('puppetx/mytest/position')
+  
+              implementation_class PuppetX::Mytest::Position
+            end
+            RUBY
+          }
+        }
+      }
+
+      it 'loads and returns value of attribute' do
+        expect(eval_and_collect_notices('notice(Mytest::Position(23, 12).x)', node)).to eql(['23'])
+      end
+    end
+
+    context 'in top namespace' do
+      let(:mytest_datatypes) {
+        {
+          'position.rb' => <<-RUBY
+            Puppet::DataTypes.create_type('Position') do
+              interface <<-PUPPET
+                attributes => {
+                  x => Integer,
+                  y => Integer
+                }
+                PUPPET
+
+              load_file('puppetx/mytest/position')
+  
+              implementation_class PuppetX::Mytest::Position
+            end
+        RUBY
+        }
+      }
+
+      it 'loads and returns value of attribute' do
+        expect(eval_and_collect_notices('notice(Position(23, 12).x)', node)).to eql(['23'])
+      end
+    end
+  end
+end
+end