puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/provider/host/parsed_spec.rb

@@ -1,219 +0,0 @@
-require 'spec_helper'
-
-require 'shared_behaviours/all_parsedfile_providers'
-require 'puppet_spec/files'
-
-describe Puppet::Type.type(:host).provider(:parsed) do
-  include PuppetSpec::Files
-
-  before do
-    @host_class = Puppet::Type.type(:host)
-    @provider = @host_class.provider(:parsed)
-    @hostfile = tmpfile('hosts')
-    allow_any_instance_of(@provider).to receive(:target).and_return(@hostfile)
-  end
-
-  after :each do
-    @provider.initvars
-  end
-
-  def mkhost(args)
-    hostresource = Puppet::Type::Host.new(:name => args[:name])
-    allow(hostresource).to receive(:should).with(:target).and_return(@hostfile)
-
-    # Using setters of provider to build our testobject
-    # Note: We already proved, that in case of host_aliases
-    # the provider setter "host_aliases=(value)" will be
-    # called with the joined array, so we just simulate that
-    host = @provider.new(hostresource)
-    args.each do |property,value|
-      value = value.join(" ") if property == :host_aliases and value.is_a?(Array)
-      host.send("#{property}=", value)
-    end
-    host
-  end
-
-  def genhost(host)
-    allow(@provider).to receive(:filetype).and_return(Puppet::Util::FileType::FileTypeRam)
-    allow(File).to receive(:chown)
-    allow(File).to receive(:chmod)
-    allow(Puppet::Util::SUIDManager).to receive(:asuser).and_yield
-    host.flush
-    @provider.target_object(@hostfile).read
-  end
-
-  describe "when parsing on incomplete line" do
-    it "should work for only ip" do
-      expect(@provider.parse_line("127.0.0.1")[:line]).to eq("127.0.0.1")
-    end
-
-    it "should work for only hostname" do
-      expect(@provider.parse_line("www.example.com")[:line]).to eq("www.example.com")
-    end
-
-    it "should work for ip and space" do
-      expect(@provider.parse_line("127.0.0.1 ")[:line]).to eq("127.0.0.1 ")
-    end
-
-    it "should work for hostname and space" do
-      expect(@provider.parse_line("www.example.com ")[:line]).to eq("www.example.com ")
-    end
-
-    it "should work for hostname and host_aliases" do
-      expect(@provider.parse_line("www.example.com  www xyz")[:line]).to eq("www.example.com  www xyz")
-    end
-
-    it "should work for ip and comment" do
-      expect(@provider.parse_line("127.0.0.1  #www xyz")[:line]).to eq("127.0.0.1  #www xyz")
-    end
-
-    it "should work for hostname and comment" do
-      expect(@provider.parse_line("xyz  #www test123")[:line]).to eq("xyz  #www test123")
-    end
-
-    it "should work for crazy incomplete lines" do
-      expect(@provider.parse_line("%th1s is a\t cr$zy    !incompl1t line")[:line]).to eq("%th1s is a\t cr$zy    !incompl1t line")
-    end
-  end
-
-  describe "when parsing a line with ip and hostname" do
-    it "should parse an ipv4 from the first field" do
-      expect(@provider.parse_line("127.0.0.1    localhost")[:ip]).to eq("127.0.0.1")
-    end
-
-    it "should parse an ipv6 from the first field" do
-      expect(@provider.parse_line("::1     localhost")[:ip]).to eq("::1")
-    end
-
-    it "should parse the name from the second field" do
-      expect(@provider.parse_line("::1     localhost")[:name]).to eq("localhost")
-    end
-
-    it "should set an empty comment" do
-      expect(@provider.parse_line("::1     localhost")[:comment]).to eq("")
-    end
-
-    it "should set host_aliases to :absent" do
-      expect(@provider.parse_line("::1     localhost")[:host_aliases]).to eq(:absent)
-    end
-  end
-
-  describe "when parsing a line with ip, hostname and comment" do
-    before do
-      @testline = "127.0.0.1   localhost # A comment with a #-char"
-    end
-
-    it "should parse the ip from the first field" do
-      expect(@provider.parse_line(@testline)[:ip]).to eq("127.0.0.1")
-    end
-
-    it "should parse the hostname from the second field" do
-      expect(@provider.parse_line(@testline)[:name]).to eq("localhost")
-    end
-
-    it "should parse the comment after the first '#' character" do
-      expect(@provider.parse_line(@testline)[:comment]).to eq('A comment with a #-char')
-    end
-  end
-
-  describe "when parsing a line with ip, hostname and aliases" do
-    it "should parse alias from the third field" do
-      expect(@provider.parse_line("127.0.0.1   localhost   localhost.localdomain")[:host_aliases]).to eq("localhost.localdomain")
-    end
-
-    it "should parse multiple aliases" do
-      expect(@provider.parse_line("127.0.0.1 host alias1 alias2")[:host_aliases]).to eq('alias1 alias2')
-      expect(@provider.parse_line("127.0.0.1 host alias1\talias2")[:host_aliases]).to eq('alias1 alias2')
-      expect(@provider.parse_line("127.0.0.1 host alias1\talias2   alias3")[:host_aliases]).to eq('alias1 alias2 alias3')
-    end
-  end
-
-  describe "when parsing a line with ip, hostname, aliases and comment" do
-    before do
-      # Just playing with a few different delimiters
-      @testline = "127.0.0.1\t   host  alias1\talias2   alias3   #   A comment with a #-char"
-    end
-
-    it "should parse the ip from the first field" do
-      expect(@provider.parse_line(@testline)[:ip]).to eq("127.0.0.1")
-    end
-
-    it "should parse the hostname from the second field" do
-      expect(@provider.parse_line(@testline)[:name]).to eq("host")
-    end
-
-    it "should parse all host_aliases from the third field" do
-      expect(@provider.parse_line(@testline)[:host_aliases]).to eq('alias1 alias2 alias3')
-    end
-
-    it "should parse the comment after the first '#' character" do
-      expect(@provider.parse_line(@testline)[:comment]).to eq('A comment with a #-char')
-    end
-  end
-
-  describe "when operating on /etc/hosts like files" do
-    it_should_behave_like "all parsedfile providers",
-      described_class, my_fixtures('valid*')
-
-    it "should be able to generate a simple hostfile entry" do
-      host = mkhost(
-        :name   => 'localhost',
-        :ip     => '127.0.0.1',
-        :ensure => :present
-      )
-      expect(genhost(host)).to eq("127.0.0.1\tlocalhost\n")
-    end
-
-    it "should be able to generate an entry with one alias" do
-      host = mkhost(
-        :name   => 'localhost.localdomain',
-        :ip     => '127.0.0.1',
-        :host_aliases => 'localhost',
-        :ensure => :present
-      )
-      expect(genhost(host)).to eq("127.0.0.1\tlocalhost.localdomain\tlocalhost\n")
-    end
-
-    it "should be able to generate an entry with more than one alias" do
-      host = mkhost(
-        :name       => 'host',
-        :ip         => '192.0.0.1',
-        :host_aliases => [ 'a1','a2','a3','a4' ],
-        :ensure     => :present
-      )
-      expect(genhost(host)).to eq("192.0.0.1\thost\ta1 a2 a3 a4\n")
-    end
-
-    it "should be able to generate a simple hostfile entry with comments" do
-      host = mkhost(
-        :name    => 'localhost',
-        :ip      => '127.0.0.1',
-        :comment => 'Bazinga!',
-        :ensure  => :present
-      )
-      expect(genhost(host)).to eq("127.0.0.1\tlocalhost\t# Bazinga!\n")
-    end
-
-    it "should be able to generate an entry with one alias and a comment" do
-      host = mkhost(
-        :name   => 'localhost.localdomain',
-        :ip     => '127.0.0.1',
-        :host_aliases => 'localhost',
-        :comment => 'Bazinga!',
-        :ensure => :present
-      )
-      expect(genhost(host)).to eq("127.0.0.1\tlocalhost.localdomain\tlocalhost\t# Bazinga!\n")
-    end
-
-    it "should be able to generate an entry with more than one alias and a comment" do
-      host = mkhost(
-        :name         => 'host',
-        :ip           => '192.0.0.1',
-        :host_aliases => [ 'a1','a2','a3','a4' ],
-        :comment      => 'Bazinga!',
-        :ensure       => :present
-      )
-      expect(genhost(host)).to eq("192.0.0.1\thost\ta1 a2 a3 a4\t# Bazinga!\n")
-    end
-  end
-end

data/spec/unit/provider/interface/cisco_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/provider/interface/cisco'
-
-describe Puppet::Type.type(:interface).provider(:cisco) do
-  before do
-    @device = double('device')
-    @resource = double("resource", :name => "Fa0/1")
-    @provider = described_class.new(@device, @resource)
-  end
-
-  it "should have a parent of Puppet::Provider::Cisco" do
-    expect(described_class).to be < Puppet::Provider::Cisco
-  end
-
-  it "should have an instances method" do
-    expect(described_class).to respond_to(:instances)
-  end
-
-  describe "when looking up instances at prefetch" do
-    before do
-      allow(@device).to receive(:command).and_yield(@device)
-    end
-
-    it "should delegate to the device interface fetcher" do
-      expect(@device).to receive(:interface)
-      described_class.lookup(@device, "Fa0/1")
-    end
-
-    it "should return the given interface data" do
-      expect(@device).to receive(:interface).and_return({:description => "thisone", :mode => :access})
-      expect(described_class.lookup(@device, "Fa0")).to eq({:description => "thisone", :mode => :access })
-    end
-  end
-
-  describe "when an instance is being flushed" do
-    it "should call the device interface update method with current and past properties" do
-      @instance = described_class.new(@device, :ensure => :present, :name => "Fa0/1", :description => "myinterface")
-      @instance.description = "newdesc"
-      @instance.resource = @resource
-      allow(@resource).to receive(:[]).with(:name).and_return("Fa0/1")
-      device = double('device')
-      allow(@instance).to receive(:device).and_return(device)
-      expect(device).to receive(:command).and_yield(device)
-      interface = double('interface')
-      expect(device).to receive(:new_interface).with("Fa0/1").and_return(interface)
-      expect(interface).to receive(:update).with( {:ensure => :present, :name => "Fa0/1", :description => "myinterface"},
-                                                  {:ensure => :present, :name => "Fa0/1", :description => "newdesc"})
-
-      @instance.flush
-    end
-  end
-end

data/spec/unit/provider/macauthorization_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-require 'puppet'
-
-RSpec::Matchers.define_negated_matcher :neq, :eq
-
-module Puppet::Util::Plist
-end
-
-describe Puppet::Type.type(:macauthorization).provider(:macauthorization) do
-  before :each do
-    # Create a mock resource
-    @resource = double('resource')
-
-    @authname = "foo.spam.eggs.puppettest"
-    @authplist = {}
-
-    @rules = {@authname => @authplist}
-
-    authdb = {}
-    authdb["rules"] = { "foorule" => "foo" }
-    authdb["rights"] = { "fooright" => "foo" }
-
-    # Stub out Plist::parse_xml
-    allow(Puppet::Util::Plist).to receive(:parse_plist).and_return(authdb)
-    allow(Puppet::Util::Plist).to receive(:write_plist_file)
-
-    # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
-
-    # But set name, ensure
-    allow(@resource).to receive(:[]).with(:name).and_return(@authname)
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:present)
-    allow(@resource).to receive(:ref).and_return("MacAuthorization[#{@authname}]")
-
-    @provider = described_class.new(@resource)
-  end
-
-  it "should have a create method" do
-    expect(@provider).to respond_to(:create)
-  end
-
-  it "should have a destroy method" do
-    expect(@provider).to respond_to(:destroy)
-  end
-
-  it "should have an exists? method" do
-    expect(@provider).to respond_to(:exists?)
-  end
-
-  it "should have a flush method" do
-    expect(@provider).to respond_to(:flush)
-  end
-
-  properties = [  :allow_root, :authenticate_user, :auth_class, :comment,
-            :group, :k_of_n, :mechanisms, :rule, :session_owner,
-            :shared, :timeout, :tries, :auth_type ]
-
-  properties.each do |prop|
-    it "should have a #{prop.to_s} method" do
-      expect(@provider).to respond_to(prop.to_s)
-    end
-
-    it "should have a #{prop.to_s}= method" do
-      expect(@provider).to respond_to(prop.to_s + "=")
-    end
-  end
-
-  describe "when destroying a right" do
-    before :each do
-      allow(@resource).to receive(:[]).with(:auth_type).and_return(:right)
-    end
-
-    it "should call the internal method destroy_right" do
-      expect(@provider).to receive(:destroy_right)
-      @provider.destroy
-    end
-    it "should call the external command 'security authorizationdb remove @authname" do
-      expect(@provider).to receive(:security).with("authorizationdb", :remove, @authname)
-      @provider.destroy
-    end
-  end
-
-  describe "when destroying a rule" do
-    before :each do
-      allow(@resource).to receive(:[]).with(:auth_type).and_return(:rule)
-    end
-
-    it "should call the internal method destroy_rule" do
-      expect(@provider).to receive(:destroy_rule)
-      @provider.destroy
-    end
-  end
-
-  describe "when flushing a right" do
-    before :each do
-      allow(@resource).to receive(:[]).with(:auth_type).and_return(:right)
-    end
-
-    it "should call the internal method flush_right" do
-      expect(@provider).to receive(:flush_right)
-      @provider.flush
-    end
-
-    it "should call the internal method set_right" do
-      expect(@provider).to receive(:execute).with(include("read").and(include(@authname)), hash_including(combine: false)).once
-      expect(@provider).to receive(:set_right)
-      @provider.flush
-    end
-
-    it "should read and write to the auth database with the right arguments" do
-      expect(@provider).to receive(:execute).with(include("read").and(include(@authname)), hash_including(combine: false)).once
-      expect(@provider).to receive(:execute).with(include("write").and(include(@authname)), hash_including(combine: false, stdinfile: neq(nil))).once
-
-      @provider.flush
-    end
-
-  end
-
-  describe "when flushing a rule" do
-    before :each do
-      allow(@resource).to receive(:[]).with(:auth_type).and_return(:rule)
-    end
-
-    it "should call the internal method flush_rule" do
-      expect(@provider).to receive(:flush_rule)
-      @provider.flush
-    end
-
-    it "should call the internal method set_rule" do
-      expect(@provider).to receive(:set_rule)
-      @provider.flush
-    end
-  end
-end

data/spec/unit/provider/mcx/mcxcontent_spec.rb

@@ -1,190 +0,0 @@
-require 'spec_helper'
-
-provider_class = Puppet::Type.type(:mcx).provider(:mcxcontent)
-
-# describe creates a new ExampleGroup object.
-describe provider_class do
-  # :each executes before each test.
-  # :all executes once for the test group and before :each.
-  before :each do
-    # Create a mock resource
-    @resource = double('resource')
-
-    @provider = provider_class.new
-    @attached_to = "/Users/foobar"
-    @ds_path = "/Local/Default/Users/foobar"
-
-    # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
-
-    # But set name, ensure and enable
-    allow(@resource).to receive(:[]).with(:name).and_return(@attached_to)
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:present)
-    allow(@resource).to receive(:ref).and_return("Mcx[#{@attached_to}]")
-
-    # stub out the provider methods that actually touch the filesystem
-    # or execute commands
-    allow(@provider.class).to receive(:execute).and_return('')
-    allow(@provider).to receive(:execute).and_return('')
-    allow(@provider).to receive(:resource).and_return(@resource)
-  end
-
-  it "should have a create method." do
-    expect(@provider).to respond_to(:create)
-  end
-
-  it "should have a destroy method." do
-    expect(@provider).to respond_to(:destroy)
-  end
-
-  it "should have an exists? method." do
-    expect(@provider).to respond_to(:exists?)
-  end
-
-  it "should have a content method." do
-    expect(@provider).to respond_to(:content)
-  end
-
-  it "should have a content= method." do
-    expect(@provider).to respond_to(:content=)
-  end
-
-  describe "when managing the resource" do
-    it "should execute external command dscl from :create" do
-      allow(@provider).to receive(:has_mcx?).and_return(false)
-      expect(@provider.class).to receive(:dscl).and_return('').once
-      @provider.create
-    end
-
-    it "deletes existing mcx prior to import from :create" do
-      allow(@provider).to receive(:has_mcx?).and_return(true)
-      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxdelete', @ds_path, any_args()).once
-      expect(@provider.class).to receive(:dscl).with('localhost', '-mcximport', @ds_path, any_args()).once
-      @provider.create
-    end
-
-    it "should execute external command dscl from :destroy" do
-      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxdelete', @ds_path).and_return('').once
-      @provider.destroy
-    end
-
-    it "should execute external command dscl from :exists?" do
-      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxexport', @ds_path).and_return('').once
-      @provider.exists?
-    end
-
-    it "should execute external command dscl from :content" do
-      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxexport', @ds_path).and_return('')
-      @provider.content
-    end
-
-    it "should execute external command dscl from :content=" do
-      allow(@provider).to receive(:has_mcx?).and_return(false)
-      expect(@provider.class).to receive(:dscl).and_return('').once
-      @provider.content=''
-    end
-
-    it "deletes existing mcx prior to import from :content=" do
-      allow(@provider).to receive(:has_mcx?).and_return(true)
-      expect(@provider.class).to receive(:dscl).with('localhost', '-mcxdelete', @ds_path, any_args()).once
-      expect(@provider.class).to receive(:dscl).with('localhost', '-mcximport', @ds_path, any_args()).once
-      @provider.content=''
-    end
-  end
-
-  describe "when creating and parsing the name for ds_type" do
-    before :each do
-      allow(@provider.class).to receive(:dscl).and_return('')
-      allow(@resource).to receive(:[]).with(:name).and_return("/Foo/bar")
-    end
-
-    it "should not accept /Foo/bar" do
-      expect { @provider.create }.to raise_error(MCXContentProviderException)
-    end
-
-    it "should accept /Foo/bar with ds_type => user" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("user")
-      expect { @provider.create }.to_not raise_error
-    end
-
-    it "should accept /Foo/bar with ds_type => group" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("group")
-      expect { @provider.create }.to_not raise_error
-    end
-
-    it "should accept /Foo/bar with ds_type => computer" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("computer")
-      expect { @provider.create }.to_not raise_error
-    end
-
-    it "should accept :name => /Foo/bar with ds_type => computerlist" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("computerlist")
-      expect { @provider.create }.to_not raise_error
-    end
-  end
-
-  describe "when creating and :name => foobar" do
-    before :each do
-      allow(@provider.class).to receive(:dscl).and_return('')
-      allow(@resource).to receive(:[]).with(:name).and_return("foobar")
-    end
-
-    it "should not accept unspecified :ds_type and :ds_name" do
-      expect { @provider.create }.to raise_error(MCXContentProviderException)
-    end
-
-    it "should not accept unspecified :ds_type" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("user")
-      expect { @provider.create }.to raise_error(MCXContentProviderException)
-    end
-
-    it "should not accept unspecified :ds_name" do
-      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
-      expect { @provider.create }.to raise_error(MCXContentProviderException)
-    end
-
-    it "should accept :ds_type => user, ds_name => foo" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("user")
-      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
-      expect { @provider.create }.to_not raise_error
-    end
-
-    it "should accept :ds_type => group, ds_name => foo" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("group")
-      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
-      expect { @provider.create }.to_not raise_error
-    end
-
-    it "should accept :ds_type => computer, ds_name => foo" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("computer")
-      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
-      expect { @provider.create }.to_not raise_error
-    end
-
-    it "should accept :ds_type => computerlist, ds_name => foo" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("computerlist")
-      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
-      expect { @provider.create }.to_not raise_error
-    end
-
-    it "should not accept :ds_type => bogustype, ds_name => foo" do
-      allow(@resource).to receive(:[]).with(:ds_type).and_return("bogustype")
-      allow(@resource).to receive(:[]).with(:ds_name).and_return("foo")
-      expect { @provider.create }.to raise_error(MCXContentProviderException)
-    end
-  end
-
-  describe "when gathering existing instances" do
-    it "should define an instances class method." do
-      expect(@provider.class).to respond_to(:instances)
-    end
-
-    it "should call external command dscl -list /Local/Default/<ds_type> on each known ds_type" do
-      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/Users").and_return('')
-      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/Groups").and_return('')
-      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/Computers").and_return('')
-      expect(@provider.class).to receive(:dscl).with('localhost', '-list', "/Local/Default/ComputerLists").and_return('')
-      @provider.class.instances
-    end
-  end
-end