puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/indirector/json_spec.rb

@@ -1,200 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet/indirector/indirector_testing/json'
-
-describe Puppet::Indirector::JSON do
-  include PuppetSpec::Files
-
-  subject { Puppet::IndirectorTesting::JSON.new }
-  let :model       do Puppet::IndirectorTesting end
-  let :indirection do model.indirection end
-
-  context "#path" do
-    before :each do
-      Puppet[:server_datadir] = '/sample/datadir/server'
-      Puppet[:client_datadir] = '/sample/datadir/client'
-    end
-
-    it "uses the :server_datadir setting if this is the server" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.json')
-      expect(subject.path('testing')).to eq(expected)
-    end
-
-    it "uses the :client_datadir setting if this is not the server" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(false)
-      expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.json')
-      expect(subject.path('testing')).to eq(expected)
-    end
-
-    it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-json')
-      expect(subject.path('testing', '.not-json')).to eq(expected)
-    end
-
-    ['../foo', '..\\foo', './../foo', '.\\..\\foo',
-     '/foo', '//foo', '\\foo', '\\\\goo',
-     "test\0/../bar", "test\0\\..\\bar",
-     "..\\/bar", "/tmp/bar", "/tmp\\bar", "tmp\\bar",
-     " / bar", " /../ bar", " \\..\\ bar",
-     "c:\\foo", "c:/foo", "\\\\?\\UNC\\bar", "\\\\foo\\bar",
-     "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
-     "//?/c:/foo",
-    ].each do |input|
-      it "should resist directory traversal attacks (#{input.inspect})" do
-        expect { subject.path(input) }.to raise_error ArgumentError, 'invalid key'
-      end
-    end
-  end
-
-  context "handling requests" do
-    before :each do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      Puppet[:server_datadir] = tmpdir('jsondir')
-      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
-    end
-
-    let :file do subject.path(request.key) end
-
-    def with_content(text)
-      FileUtils.mkdir_p(File.dirname(file))
-      File.binwrite(file, text)
-      yield if block_given?
-    end
-
-    it "data saves and then loads again correctly" do
-      subject.save(indirection.request(:save, 'example', model.new('banana')))
-      expect(subject.find(indirection.request(:find, 'example', nil)).value).to eq('banana')
-    end
-
-    context "#find" do
-      let :request do indirection.request(:find, 'example', nil) end
-
-      it "returns nil if the file doesn't exist" do
-        expect(subject.find(request)).to be_nil
-      end
-
-      it "raises a descriptive error when the file can't be read" do
-        with_content(model.new('foo').to_json) do
-          # I don't like this, but there isn't a credible alternative that
-          # also works on Windows, so a stub it is. At least the expectation
-          # will fail if the implementation changes. Sorry to the next dev.
-          expect(Puppet::FileSystem).to receive(:read).with(file, anything).and_raise(Errno::EPERM)
-          expect { subject.find(request) }.
-            to raise_error Puppet::Error, /Could not read JSON/
-        end
-      end
-
-      it "raises a descriptive error when the file content is invalid" do
-        with_content("this is totally invalid JSON") do
-          expect { subject.find(request) }.
-            to raise_error Puppet::Error, /Could not parse JSON data/
-        end
-      end
-
-      it "raises if the content contains binary" do
-        binary = "\xC0\xFF".force_encoding(Encoding::BINARY)
-
-        with_content(binary) do
-          expect {
-            subject.find(request)
-          }.to raise_error Puppet::Error, /Could not parse JSON data/
-        end
-      end
-
-      it "should return an instance of the indirected object when valid" do
-        with_content(model.new(1).to_json) do
-          instance = subject.find(request)
-          expect(instance).to be_an_instance_of model
-          expect(instance.value).to eq(1)
-        end
-      end
-    end
-
-    context "#save" do
-      let :instance do model.new(4) end
-      let :request  do indirection.request(:find, 'example', instance) end
-
-      it "should save the instance of the request as JSON to disk" do
-        subject.save(request)
-        content = File.read(file)
-        expect(content).to match(/"value"\s*:\s*4/)
-      end
-
-      it "should create the indirection directory if required" do
-        target = File.join(Puppet[:server_datadir], 'indirector_testing')
-        Dir.rmdir(target)
-
-        subject.save(request)
-
-        expect(File).to be_directory(target)
-      end
-    end
-
-    context "#destroy" do
-      let :request do indirection.request(:find, 'example', nil) end
-
-      it "removes an existing file" do
-        with_content('hello') do
-          subject.destroy(request)
-        end
-        expect(Puppet::FileSystem.exist?(file)).to be_falsey
-      end
-
-      it "silently succeeds when files don't exist" do
-        Puppet::FileSystem.unlink(file) rescue nil
-        expect(subject.destroy(request)).to be_truthy
-      end
-
-      it "raises an informative error for other failures" do
-        allow(Puppet::FileSystem).to receive(:unlink).with(file).and_raise(Errno::EPERM, 'fake permission problem')
-        with_content('hello') do
-          expect { subject.destroy(request) }.to raise_error(Puppet::Error)
-        end
-      end
-    end
-  end
-
-  context "#search" do
-    before :each do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      Puppet[:server_datadir] = tmpdir('jsondir')
-      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
-    end
-
-    def request(glob)
-      indirection.request(:search, glob, nil)
-    end
-
-    def create_file(name, value = 12)
-      File.open(subject.path(name, ''), 'wb') do |f|
-        f.puts Puppet::IndirectorTesting.new(value).to_json
-      end
-    end
-
-    it "returns an empty array when nothing matches the key as a glob" do
-      expect(subject.search(request('*'))).to eq([])
-    end
-
-    it "returns an array with one item if one item matches" do
-      create_file('foo.json', 'foo')
-      create_file('bar.json', 'bar')
-      expect(subject.search(request('f*')).map(&:value)).to eq(['foo'])
-    end
-
-    it "returns an array of items when more than one item matches" do
-      create_file('foo.json', 'foo')
-      create_file('bar.json', 'bar')
-      create_file('baz.json', 'baz')
-      expect(subject.search(request('b*')).map(&:value)).to match_array(['bar', 'baz'])
-    end
-
-    it "only items with the .json extension" do
-      create_file('foo.json', 'foo-json')
-      create_file('foo.pson', 'foo-pson')
-      create_file('foo.json~', 'foo-backup')
-      expect(subject.search(request('f*')).map(&:value)).to eq(['foo-json'])
-    end
-  end
-end

data/spec/unit/indirector/memory_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/memory'
-
-require 'shared_behaviours/memory_terminus'
-
-describe Puppet::Indirector::Memory do
-  it_should_behave_like "A Memory Terminus"
-
-  before do
-    allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
-    @model = double('model')
-    @indirection = double('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
-    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(@indirection)
-
-    module Testing; end
-    @memory_class = class Testing::MyMemory < Puppet::Indirector::Memory
-      self
-    end
-
-    @searcher = @memory_class.new
-    @name = "me"
-    @instance = double('instance', :name => @name)
-
-    @request = double('request', :key => @name, :instance => @instance)
-  end
-end

data/spec/unit/indirector/msgpack_spec.rb

@@ -1,199 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet/indirector/indirector_testing/msgpack'
-
-describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
-  include PuppetSpec::Files
-
-  subject { Puppet::IndirectorTesting::Msgpack.new }
-  let :model       do Puppet::IndirectorTesting end
-  let :indirection do model.indirection end
-
-  context "#path" do
-    before :each do
-      Puppet[:server_datadir] = '/sample/datadir/server'
-      Puppet[:client_datadir] = '/sample/datadir/client'
-    end
-
-    it "uses the :server_datadir setting if this is the server" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.msgpack')
-      expect(subject.path('testing')).to eq(expected)
-    end
-
-    it "uses the :client_datadir setting if this is not the server" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(false)
-      expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.msgpack')
-      expect(subject.path('testing')).to eq(expected)
-    end
-
-    it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-msgpack')
-      expect(subject.path('testing', '.not-msgpack')).to eq(expected)
-    end
-
-    ['../foo', '..\\foo', './../foo', '.\\..\\foo',
-     '/foo', '//foo', '\\foo', '\\\\goo',
-     "test\0/../bar", "test\0\\..\\bar",
-     "..\\/bar", "/tmp/bar", "/tmp\\bar", "tmp\\bar",
-     " / bar", " /../ bar", " \\..\\ bar",
-     "c:\\foo", "c:/foo", "\\\\?\\UNC\\bar", "\\\\foo\\bar",
-     "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
-     "//?/c:/foo",
-    ].each do |input|
-      it "should resist directory traversal attacks (#{input.inspect})" do
-        expect { subject.path(input) }.to raise_error ArgumentError, 'invalid key'
-      end
-    end
-  end
-
-  context "handling requests" do
-    before :each do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      Puppet[:server_datadir] = tmpdir('msgpackdir')
-      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
-    end
-
-    let :file do subject.path(request.key) end
-
-    def with_content(text)
-      FileUtils.mkdir_p(File.dirname(file))
-      File.open(file, 'w') {|f| f.write text }
-      yield if block_given?
-    end
-
-    it "data saves and then loads again correctly" do
-      subject.save(indirection.request(:save, 'example', model.new('banana')))
-      expect(subject.find(indirection.request(:find, 'example', nil)).value).to eq('banana')
-    end
-
-    context "#find" do
-      let :request do indirection.request(:find, 'example', nil) end
-
-      it "returns nil if the file doesn't exist" do
-        expect(subject.find(request)).to be_nil
-      end
-
-      it "can load a UTF-8 file from disk" do
-        rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
-
-        with_content(model.new(rune_utf8).to_msgpack) do
-          instance = subject.find(request)
-          expect(instance).to be_an_instance_of model
-          expect(instance.value).to eq(rune_utf8)
-        end
-      end
-
-      it "raises a descriptive error when the file can't be read" do
-        with_content(model.new('foo').to_msgpack) do
-          # I don't like this, but there isn't a credible alternative that
-          # also works on Windows, so a stub it is. At least the expectation
-          # will fail if the implementation changes. Sorry to the next dev.
-          expect(Puppet::FileSystem).to receive(:read).with(file, {:encoding => 'utf-8'}).and_raise(Errno::EPERM)
-          expect { subject.find(request) }.
-            to raise_error Puppet::Error, /Could not read MessagePack/
-        end
-      end
-
-      it "raises a descriptive error when the file content is invalid" do
-        with_content("this is totally invalid MessagePack") do
-          expect { subject.find(request) }.
-            to raise_error Puppet::Error, /Could not parse MessagePack data/
-        end
-      end
-
-      it "should return an instance of the indirected object when valid" do
-        with_content(model.new(1).to_msgpack) do
-          instance = subject.find(request)
-          expect(instance).to be_an_instance_of model
-          expect(instance.value).to eq(1)
-        end
-      end
-    end
-
-    context "#save" do
-      let :instance do model.new(4) end
-      let :request  do indirection.request(:find, 'example', instance) end
-
-      it "should save the instance of the request as MessagePack to disk" do
-        subject.save(request)
-        content = File.read(file)
-        expect(MessagePack.unpack(content)['value']).to eq(4)
-      end
-
-      it "should create the indirection directory if required" do
-        target = File.join(Puppet[:server_datadir], 'indirector_testing')
-        Dir.rmdir(target)
-
-        subject.save(request)
-
-        expect(File).to be_directory(target)
-      end
-    end
-
-    context "#destroy" do
-      let :request do indirection.request(:find, 'example', nil) end
-
-      it "removes an existing file" do
-        with_content('hello') do
-          subject.destroy(request)
-        end
-        expect(Puppet::FileSystem.exist?(file)).to be_falsey
-      end
-
-      it "silently succeeds when files don't exist" do
-        Puppet::FileSystem.unlink(file) rescue nil
-        expect(subject.destroy(request)).to be_truthy
-      end
-
-      it "raises an informative error for other failures" do
-        allow(Puppet::FileSystem).to receive(:unlink).with(file).and_raise(Errno::EPERM, 'fake permission problem')
-        with_content('hello') do
-          expect { subject.destroy(request) }.to raise_error(Puppet::Error)
-        end
-      end
-    end
-  end
-
-  context "#search" do
-    before :each do
-      allow(Puppet.run_mode).to receive(:server?).and_return(true)
-      Puppet[:server_datadir] = tmpdir('msgpackdir')
-      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
-    end
-
-    def request(glob)
-      indirection.request(:search, glob, nil)
-    end
-
-    def create_file(name, value = 12)
-      File.open(subject.path(name, ''), 'w') do |f|
-        f.write Puppet::IndirectorTesting.new(value).to_msgpack
-      end
-    end
-
-    it "returns an empty array when nothing matches the key as a glob" do
-      expect(subject.search(request('*'))).to eq([])
-    end
-
-    it "returns an array with one item if one item matches" do
-      create_file('foo.msgpack', 'foo')
-      create_file('bar.msgpack', 'bar')
-      expect(subject.search(request('f*')).map(&:value)).to eq(['foo'])
-    end
-
-    it "returns an array of items when more than one item matches" do
-      create_file('foo.msgpack', 'foo')
-      create_file('bar.msgpack', 'bar')
-      create_file('baz.msgpack', 'baz')
-      expect(subject.search(request('b*')).map(&:value)).to match_array(['bar', 'baz'])
-    end
-
-    it "only items with the .msgpack extension" do
-      create_file('foo.msgpack', 'foo-msgpack')
-      create_file('foo.msgpack~', 'foo-backup')
-      expect(subject.search(request('f*')).map(&:value)).to eq(['foo-msgpack'])
-    end
-  end
-end

data/spec/unit/indirector/node/exec_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/node/exec'
-require 'puppet/indirector/request'
-
-describe Puppet::Node::Exec do
-  let(:indirection) { mock 'indirection' }
-  let(:searcher) { Puppet::Node::Exec.new }
-
-  before do
-    Puppet.settings[:external_nodes] = File.expand_path("/echo")
-  end
-
-  describe "when constructing the command to run" do
-    it "should use the external_node script as the command" do
-      Puppet[:external_nodes] = "/bin/echo"
-      expect(searcher.command).to eq(%w{/bin/echo})
-    end
-
-    it "should throw an exception if no external node command is set" do
-      Puppet[:external_nodes] = "none"
-      expect { searcher.find(double('request', :key => "foo")) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "when handling the results of the command" do
-    let(:testing_env) { Puppet::Node::Environment.create(:testing, []) }
-    let(:other_env) { Puppet::Node::Environment.create(:other, []) }
-    let(:request) { Puppet::Indirector::Request.new(:node, :find, name, environment: testing_env) }
-    let(:name) { 'yay' }
-    let(:facts) { Puppet::Node::Facts.new(name, {}) }
-
-    before do
-      allow(Puppet::Node::Facts.indirection).to receive(:find).and_return(facts)
-
-      @result = {}
-      # Use a local variable so the reference is usable in the execute definition.
-      result = @result
-      searcher.meta_def(:execute) do |command, arguments|
-        return YAML.dump(result)
-      end
-    end
-
-    around do |example|
-      envs = Puppet::Environments::Static.new(testing_env, other_env)
-
-      Puppet.override(:environments => envs) do
-        example.run
-      end
-    end
-
-    it "should translate the YAML into a Node instance" do
-      @result = {}
-      node = searcher.find(request)
-      expect(node.name).to eq(name)
-      expect(node.parameters).to include('environment')
-      expect(node.facts).to eq(facts)
-      expect(node.environment.name).to eq(:'*root*') # request env is ignored
-    end
-
-    it "should set the resulting parameters as the node parameters" do
-      @result[:parameters] = {"a" => "b", "c" => "d"}
-      node = searcher.find(request)
-      expect(node.parameters).to eq({"a" => "b", "c" => "d", "environment" => "*root*"})
-    end
-
-    it "accepts symbolic parameter names" do
-      @result[:parameters] = {:name => "value"}
-      node = searcher.find(request)
-      expect(node.parameters).to include({:name => "value"})
-    end
-
-    it "raises when deserializing unacceptable objects" do
-      @result[:parameters] = {'name' => Object.new }
-
-      expect {
-        searcher.find(request)
-      }.to raise_error(Puppet::Error,
-                       /Could not load external node results for yay: \(<unknown>\): Tried to load unspecified class: Object/)
-    end
-
-    it "should set the resulting classes as the node classes" do
-      @result[:classes] = %w{one two}
-      node = searcher.find(request)
-      expect(node.classes).to eq([ 'one', 'two' ])
-    end
-
-    it "should merge facts from the request if supplied" do
-      facts = Puppet::Node::Facts.new('test', 'foo' => 'bar')
-      request.options[:facts] = facts
-      node = searcher.find(request)
-      expect(node.facts).to eq(facts)
-    end
-
-    it "should set the node's environment if one is provided" do
-      @result[:environment] = "testing"
-      node = searcher.find(request)
-      expect(node.environment.name).to eq(:testing)
-    end
-
-    it "should set the node's environment based on the request if not otherwise provided" do
-      request.environment = "other"
-      node = searcher.find(request)
-      expect(node.environment.name).to eq(:other)
-    end
-  end
-end

data/spec/unit/indirector/node/json_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'puppet/node'
-require 'puppet/indirector/node/json'
-
-describe Puppet::Node::Json do
-  describe '#save' do
-    subject(:indirection) { described_class.indirection }
-
-    let(:env) { Puppet::Node::Environment.create(:testing, []) }
-    let(:node) { Puppet::Node.new('node_name', :environment => env) }
-    let(:file) { File.join(Puppet[:client_datadir], "node", "node_name.json") }
-
-    before do
-      indirection.terminus_class = :json
-    end
-
-    it 'saves the instance of the node as JSON to disk' do
-      indirection.save(node)
-      json = Puppet::FileSystem.read(file, :encoding => 'bom|utf-8')
-      content = Puppet::Util::Json.load(json)
-      expect(content["name"]).to eq('node_name')
-    end
-
-    context 'when node cannot be saved' do
-      it 'raises Errno::EISDIR' do
-        FileUtils.mkdir_p(file)
-        expect {
-          indirection.save(node)
-         }.to raise_error(Errno::EISDIR, /node_name.json/)
-      end
-    end
-  end
-end

data/spec/unit/indirector/node/memory_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/node/memory'
-require 'shared_behaviours/memory_terminus'
-
-describe Puppet::Node::Memory do
-  before do
-    @name = "me"
-    @searcher = Puppet::Node::Memory.new
-    @instance = double('instance', :name => @name)
-
-    @request = double('request', :key => @name, :instance => @instance)
-  end
-
-  it_should_behave_like "A Memory Terminus"
-end

data/spec/unit/indirector/node/msgpack_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/node'
-require 'puppet/indirector/node/msgpack'
-
-describe Puppet::Node::Msgpack, :if => Puppet.features.msgpack? do
-  it "should be a subclass of the Msgpack terminus" do
-    expect(Puppet::Node::Msgpack.superclass).to equal(Puppet::Indirector::Msgpack)
-  end
-
-  it "should have documentation" do
-    expect(Puppet::Node::Msgpack.doc).not_to be_nil
-  end
-
-  it "should be registered with the configuration store indirection" do
-    indirection = Puppet::Indirector::Indirection.instance(:node)
-    expect(Puppet::Node::Msgpack.indirection).to equal(indirection)
-  end
-
-  it "should have its name set to :msgpack" do
-    expect(Puppet::Node::Msgpack.name).to eq(:msgpack)
-  end
-end

data/spec/unit/indirector/node/plain_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/node/plain'
-
-describe Puppet::Node::Plain do
-  let(:nodename) { "mynode" }
-  let(:indirection_fact_values) { {:afact => "a value"} }
-  let(:indirection_facts) { Puppet::Node::Facts.new(nodename, indirection_fact_values) }
-  let(:request_fact_values) { {:foo => "bar" } }
-  let(:request_facts) { Puppet::Node::Facts.new(nodename, request_fact_values)}
-  let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
-  let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
-  let(:node_indirection) { Puppet::Node::Plain.new }
-
-  it "should merge facts from the request if supplied" do
-    expect(Puppet::Node::Facts.indirection).not_to receive(:find)
-    request.options[:facts] = request_facts
-    node = node_indirection.find(request)
-    expect(node.parameters).to include(request_fact_values)
-    expect(node.facts).to eq(request_facts)
-  end
-
-  it "should find facts if none are supplied" do
-    expect(Puppet::Node::Facts.indirection).to receive(:find).with(nodename, {:environment => environment}).and_return(indirection_facts)
-    request.options.delete(:facts)
-    node = node_indirection.find(request)
-    expect(node.parameters).to include(indirection_fact_values)
-    expect(node.facts).to eq(indirection_facts)
-  end
-
-  it "should set the node environment from the request" do
-    expect(node_indirection.find(request).environment).to eq(environment)
-  end
-end