puppet 5.1.0-universal-darwin → 5.2.0-universal-darwin

data/spec/unit/indirector/request_spec.rb

@@ -517,4 +517,45 @@ describe Puppet::Indirector::Request do
       expect(request(:node => 'example.com', :ip => '127.0.0.1')).to be_remote
     end
   end
+
+  describe "failover" do
+    it "should use the provided failover host and port" do
+      Puppet.override(:server => 'myhost', :serverport => 666) do
+        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
+        req.do_request() do |request|
+          expect(request.server).to eq('myhost')
+          expect(request.port).to eq(666)
+        end
+      end
+    end
+
+    it "should not use raw settings when failover fails" do
+      Puppet.override(:server => nil, :serverport => nil) do
+        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
+        req.do_request() do |request|
+          expect(request.server).to be_nil
+          expect(request.port).to be_nil
+          expect(Puppet.settings[:server]).not_to be_nil
+          expect(Puppet.settings[:masterport]).not_to be_nil
+        end
+      end
+    end
+
+    it "should use server_list when set and failover has not occured" do
+      Puppet.settings[:server_list] = [['myhost',666]]
+      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
+      req.do_request() do |request|
+        expect(request.server).to eq('myhost')
+        expect(request.port).to eq(666)
+      end
+    end
+
+    it "should use server when server_list is not set" do
+      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
+      req.do_request() do |request|
+        expect(request.server).to eq(Puppet.settings[:server])
+        expect(request.port).to eq(Puppet.settings[:masterport])
+      end
+    end
+  end
 end

data/spec/unit/info_service_spec.rb

@@ -1,14 +1,78 @@
 require 'spec_helper'
 require 'puppet_spec/files'
+require 'puppet_spec/modules'
 
 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
+  include PuppetSpec::Files
+
+  context 'task information service' do
+    let(:mod_name) { 'test1' }
+    let(:task_name) { "#{mod_name}::thingtask" }
+    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 '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']]})
+          expect(Puppet::InfoService.tasks_per_environment(env_name)).to eq([{:name => task_name, :module => {:name => mod_name}}])
+        end
+      end
+
+      it "should throw EnvironmentNotFound if given a nonexistent environment" do
+        expect{ Puppet::InfoService.tasks_per_environment('utopia') }.to raise_error(Puppet::Environments::EnvironmentNotFound)
+      end
+    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)
+        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])
+        end
+        it 'specifies the metadata_file correctly' do
+          task = @mod.tasks[0]
+          expect(@result[:metadata_file]).to eq(task.metadata_file)
+        end
+
+        it 'specifies the other files correctly' do
+          task = @mod.tasks[0]
+          expect(@result[:files]).to eq(task.files)
+        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
+
+      it "should raise MissingModule if the module does not exist" do
+        Puppet.override(:environments => env_loader) do
+          expect { Puppet::InfoService.task_data(env_name, 'notamodule', 'notamodule::thingtask') }
+            .to raise_error(Puppet::Module::MissingModule)
+        end
+      end
+
+      it "should raise TaskNotFound if the task does not exist" do
+        Puppet.override(:environments => env_loader) do
+          expect { Puppet::InfoService.task_data(env_name, mod_name, 'testing1::notatask') }
+            .to raise_error(Puppet::Module::Task::TaskNotFound)
+        end
+      end
+    end
+  end
+
+  context 'classes_per_environment service' do
     let(:code_dir) do
       dir_containing('manifests', {
         'foo.pp' => <<-CODE,

data/spec/unit/module_spec.rb

@@ -222,7 +222,9 @@ describe Puppet::Module do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
       ['test_gte_req', 'test_specific_req', 'foobar'].each do |mod_name|
-        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
+        mod_dir = "#{@modpath}/#{mod_name}"
+        metadata_file = "#{mod_dir}/metadata.json"
+        tasks_dir = "#{mod_dir}/tasks"
         Puppet::FileSystem.stubs(:exist?).with(metadata_file).returns true
       end
       mod = PuppetSpec::Modules.create(
@@ -553,6 +555,84 @@ describe Puppet::Module do
   it "should return the path to the plugin directory" do
     expect(mod.plugin_directory).to eq(File.join(path, "lib"))
   end
+
+  it "should return the path to the tasks directory" do
+    expect(mod.tasks_directory).to eq(File.join(path, "tasks"))
+  end
+
+  describe "when finding tasks" do
+    before do
+      Puppet::FileSystem.unstub(:exist?)
+      @modpath = tmpdir('modpath')
+      Puppet.settings[:modulepath] = @modpath
+    end
+
+    it "should have an empty array for the tasks when the tasks directory does not exist" do
+      mod = PuppetSpec::Modules.create('tasks_test_nodir', @modpath, :environment => env)
+      expect(mod.tasks).to eq([])
+    end
+
+    it "should have an empty array for the tasks when the tasks directory does exist and is empty" do
+      mod = PuppetSpec::Modules.create('tasks_test_empty', @modpath, {:environment => env,
+                                                                      :tasks => []})
+      expect(mod.tasks).to eq([])
+    end
+
+    it "should list the expected tasks when the required files exist" do
+      fake_tasks = [['task1'], ['task2.sh', 'task2.json']]
+      mod = PuppetSpec::Modules.create('tasks_smoke', @modpath, {:environment => env,
+                                                                 :tasks => fake_tasks})
+
+      expect(mod.tasks.count).to eq(2)
+      expect(mod.tasks.map{|t| t.name}.sort).to eq(['tasks_smoke::task1', 'tasks_smoke::task2'])
+      expect(mod.tasks.map{|t| t.class}).to eq([Puppet::Module::Task] * 2)
+    end
+
+    it "should be able to find individual task files when they exist" do
+      task_exe = 'stateskatetask.stk'
+      mod = PuppetSpec::Modules.create('task_file_smoke', @modpath, {:environment => env,
+                                                                     :tasks => [[task_exe]]})
+
+      expect(mod.task_file(task_exe)).to eq("#{mod.path}/tasks/#{task_exe}")
+    end
+
+    it "should return nil when asked for an individual task file if it does not exist" do
+      mod = PuppetSpec::Modules.create('task_file_neg', @modpath, {:environment => env,
+                                                                   :tasks => []})
+      expect(mod.task_file('nosuchtask')).to be_nil
+    end
+
+    describe "does the task finding" do
+      before :each do
+        Puppet::FileSystem.unstub(:exist?)
+        Puppet::Module::Task.unstub(:tasks_in_module)
+      end
+
+      let(:mod_name) { 'tasks_test_lazy' }
+      let(:mod_tasks_dir) { File.join(@modpath, mod_name, 'tasks') }
+
+      it "after the module is initialized" do
+        Puppet::FileSystem.expects(:exist?).with(mod_tasks_dir).never
+        Puppet::Module::Task.expects(:tasks_in_module).never
+        Puppet::Module.new(mod_name, @modpath, env)
+      end
+
+      it "when the tasks method is called" do
+        Puppet::Module::Task.expects(:tasks_in_module)
+        mod = PuppetSpec::Modules.create(mod_name, @modpath, {:environment => env,
+                                                              :tasks => [['itascanstaccatotask']]})
+        mod.tasks
+      end
+
+      it "only once for the lifetime of the module object" do
+        Dir.expects(:glob).with("#{mod_tasks_dir}/*").once.returns ['allalaskataskattacktactics']
+        mod = PuppetSpec::Modules.create(mod_name, @modpath, {:environment => env,
+                                                              :tasks => []})
+        mod.tasks
+        mod.tasks
+      end
+    end
+  end
 end
 
 describe Puppet::Module, "when finding matching manifests" do

data/spec/unit/parser/ast/leaf_spec.rb

@@ -60,13 +60,12 @@ describe Puppet::Parser::AST::Regex do
     end
   end
 
-  it "should return the regex source with to_s" do
+  it 'should return the PRegexpType#regexp_to_s_with_delimiters with to_s' do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)
 
-    val = Puppet::Parser::AST::Regex.new :value => "/ab/"
-
-    regex.expects(:source)
+    val = Puppet::Parser::AST::Regex.new :value => '/ab/'
+    Puppet::Pops::Types::PRegexpType.expects(:regexp_to_s_with_delimiters)
 
     val.to_s
   end

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -539,6 +539,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(type_expr)).to eql(tf.callable([String], Integer))
     end
 
+    # Variant Type
+    it 'does not allow Variant declarations with non-type arguments' do
+      type_expr = fqr('Variant').access_at(fqr('Integer'), 'not a type')
+      expect { evaluate(type_expr) }.to raise_error(/Cannot use String where Any-Type is expected/)
+    end
   end
 
   matcher :be_the_type do |type|

data/spec/unit/pops/factory_spec.rb

@@ -45,7 +45,11 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "Multiple expressions should produce a block expression" do
-      model = block_or_expression([literal(1) + literal(2), literal(2) + literal(3)]).model
+      braces = mock 'braces'
+      braces.stubs(:offset).returns(0)
+      braces.stubs(:length).returns(0)
+
+      model = block_or_expression([literal(1) + literal(2), literal(2) + literal(3)], braces, braces).model
       expect(model.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
       expect(model.statements.size).to eq(2)
     end

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

@@ -30,6 +30,144 @@ describe Puppet::Pops::Parser::Parser do
     expect(model.body.length).to eq(0)
   end
 
+  it "should give single resource expressions the correct offset inside an if/else statement" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string(<<-EOF).model
+class firewall {
+  if(true) {
+    service { 'if service':
+      ensure    => stopped
+    }
+  } else {
+    service { 'else service':
+      ensure    => running
+    }
+  }
+}
+    EOF
+
+    then_service = model.body.body.statements[0].then_expr
+    expect(then_service.class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(then_service.offset).to eq(34)
+
+    else_service = model.body.body.statements[0].else_expr
+    expect(else_service.class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(else_service.offset).to eq(106)
+  end
+
+  it "should give block expressions and their contained resources the correct offset inside an if/else statement" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string(<<-EOF).model
+class firewall {
+  if(true) {
+    service { 'if service 1':
+      ensure    => running
+    }
+
+    service { 'if service 2':
+      ensure    => stopped
+    }
+  } else {
+    service { 'else service 1':
+      ensure    => running
+    }
+
+    service { 'else service 2':
+      ensure    => stopped
+    }
+  }
+}
+    EOF
+
+    if_expr = model.body.body.statements[0]
+    block_expr = model.body.body.statements[0].then_expr
+    expect(if_expr.class).to eq(Puppet::Pops::Model::IfExpression)
+    expect(if_expr.offset).to eq(19)
+    expect(block_expr.class).to eq(Puppet::Pops::Model::BlockExpression)
+    expect(block_expr.offset).to eq(28)
+    expect(block_expr.statements[0].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[0].offset).to eq(34)
+    expect(block_expr.statements[1].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[1].offset).to eq(98)
+
+    block_expr = model.body.body.statements[0].else_expr
+    expect(block_expr.class).to eq(Puppet::Pops::Model::BlockExpression)
+    expect(block_expr.offset).to eq(166)
+    expect(block_expr.statements[0].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[0].offset).to eq(172)
+    expect(block_expr.statements[1].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[1].offset).to eq(238)
+  end
+
+  it "should give single resource expressions the correct offset inside an unless/else statement" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string(<<-EOF).model
+class firewall {
+  unless(true) {
+    service { 'if service':
+      ensure    => stopped
+    }
+  } else {
+    service { 'else service':
+      ensure    => running
+    }
+  }
+}
+    EOF
+
+    then_service = model.body.body.statements[0].then_expr
+    expect(then_service.class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(then_service.offset).to eq(38)
+
+    else_service = model.body.body.statements[0].else_expr
+    expect(else_service.class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(else_service.offset).to eq(110)
+  end
+
+  it "should give block expressions and their contained resources the correct offset inside an unless/else statement" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string(<<-EOF).model
+class firewall {
+  unless(true) {
+    service { 'if service 1':
+      ensure    => running
+    }
+
+    service { 'if service 2':
+      ensure    => stopped
+    }
+  } else {
+    service { 'else service 1':
+      ensure    => running
+    }
+
+    service { 'else service 2':
+      ensure    => stopped
+    }
+  }
+}
+    EOF
+
+    if_expr = model.body.body.statements[0]
+    block_expr = model.body.body.statements[0].then_expr
+    expect(if_expr.class).to eq(Puppet::Pops::Model::UnlessExpression)
+    expect(if_expr.offset).to eq(19)
+    expect(block_expr.class).to eq(Puppet::Pops::Model::BlockExpression)
+    expect(block_expr.offset).to eq(32)
+    expect(block_expr.statements[0].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[0].offset).to eq(38)
+    expect(block_expr.statements[1].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[1].offset).to eq(102)
+
+    block_expr = model.body.body.statements[0].else_expr
+    expect(block_expr.class).to eq(Puppet::Pops::Model::BlockExpression)
+    expect(block_expr.offset).to eq(170)
+    expect(block_expr.statements[0].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[0].offset).to eq(176)
+    expect(block_expr.statements[1].class).to eq(Puppet::Pops::Model::ResourceExpression)
+    expect(block_expr.statements[1].offset).to eq(242)
+  end
+
   it "multi byte characters in a comment are counted as individual bytes" do
     parser = Puppet::Pops::Parser::Parser.new()
     model = parser.parse_string("# \u{0400}comment\n").model

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -465,7 +465,7 @@ module Serialization
     end
 
     context 'and symbol_as_string is set to true' do
-      let(:to_converter) { ToDataConverter.new(:symbol_as_string => true) }
+      let(:to_converter) { ToDataConverter.new(:rich_data => false, :symbol_as_string => true) }
 
       it 'A Hash with Symbol keys is silently converted to hash with String keys' do
         val = { :one => 'one', :two => 'two' }
@@ -477,6 +477,71 @@ module Serialization
         end
         expect(warnings).to be_empty
       end
+
+      it 'A Hash with Symbol values is silently converted to hash with String values' do
+        val = { 'one' => :one, 'two' => :two  }
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Hash)
+          expect(val2).to eql({ 'one' => 'one', 'two' => 'two' })
+        end
+        expect(warnings).to be_empty
+      end
+
+      it 'A Hash with default values will have the values converted to string with a warning' do
+        val = { 'key' => :default  }
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Hash)
+          expect(val2).to eql({ 'key' => 'default' })
+        end
+        expect(warnings).to eql(["['key'] contains the special value default. It will be converted to the String 'default'"])
+      end
+    end
+  end
+
+  context 'with rich_data is set to true' do
+    let(:to_converter) { ToDataConverter.new(:message_prefix => 'Test Hash', :rich_data => true) }
+    let(:logs) { [] }
+    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+    context 'and symbol_as_string is set to true' do
+      let(:to_converter) { ToDataConverter.new(:rich_data => true, :symbol_as_string => true) }
+
+      it 'A Hash with Symbol keys is silently converted to hash with String keys' do
+        val = { :one => 'one', :two => 'two' }
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Hash)
+          expect(val2).to eql({ 'one' => 'one', 'two' => 'two' })
+        end
+        expect(warnings).to be_empty
+      end
+
+      it 'A Hash with Symbol values is silently converted to hash with String values' do
+        val = { 'one' => :one, 'two' => :two  }
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Hash)
+          expect(val2).to eql({ 'one' => 'one', 'two' => 'two' })
+        end
+        expect(warnings).to be_empty
+      end
+
+      it 'A Hash with default values will not loose type information' do
+        val = { 'key' => :default  }
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Hash)
+          expect(val2).to eql({ 'key' => :default })
+        end
+        expect(warnings).to be_empty
+      end
     end
   end
 
@@ -489,6 +554,14 @@ module Serialization
       expect { write(val) }.to raise_error(/Endless recursion detected when attempting to serialize value of class Hash/)
     end
   end
+
+  context 'will fail when' do
+    it 'the value of a type description is something other than a String or a Hash' do
+      expect do
+        from_converter.convert({ '__pcore_type__' => { '__pcore_type__' => 'Pcore::TimestampType', '__pcore_value__' => 12345 }})
+      end.to raise_error(/Cannot create a Pcore::TimestampType from a (Fixnum|Integer)/)
+    end
+  end
 end
 end
 end