puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/provider/cisco_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/provider/cisco'
-
-describe Puppet::Provider::Cisco do
-  it "should implement a device class method" do
-    expect(Puppet::Provider::Cisco).to respond_to(:device)
-  end
-
-  it "should create a cisco device instance" do
-    expect(Puppet::Util::NetworkDevice::Cisco::Device).to receive(:new).and_return(:device)
-    expect(Puppet::Provider::Cisco.device(:url)).to eq(:device)
-  end
-end

data/spec/unit/provider/cron/crontab_spec.rb

@@ -1,206 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:cron).provider(:crontab) do
-  subject do
-    provider = Puppet::Type.type(:cron).provider(:crontab)
-    provider.initvars
-    provider
-  end
-
-  def compare_crontab_text(have, want)
-    # We should have four header lines, and then the text...
-    expect(have.lines.to_a[0..3]).to(be_all {|x| x =~ /^# / })
-    expect(have.lines.to_a[4..-1].join('')).to eq(want)
-  end
-
-  context "with the simple samples" do
-    FIELDS = {
-      :crontab => %w{command minute hour month monthday weekday}.collect { |o| o.intern },
-      :environment => [:line],
-      :blank => [:line],
-      :comment => [:line],
-    }
-
-    def compare_crontab_record(have, want)
-      want.each do |param, value|
-        expect(have).to be_key param
-        expect(have[param]).to eq(value)
-      end
-
-      (FIELDS[have[:record_type]] - want.keys).each do |name|
-        expect(have[name]).to eq(:absent)
-      end
-    end
-
-    ########################################################################
-    # Simple input fixtures for testing.
-    samples = YAML.load(File.read(my_fixture('single_line.yaml')))
-
-    samples.each do |name, data|
-      it "should parse crontab line #{name} correctly" do
-        compare_crontab_record subject.parse_line(data[:text]), data[:record]
-      end
-
-      it "should reconstruct the crontab line #{name} from the record" do
-        expect(subject.to_line(data[:record])).to eq(data[:text])
-      end
-    end
-
-    records = []
-    text    = ""
-
-    # Sorting is from the original, and avoids :empty being the last line,
-    # since the provider will ignore that and cause this to fail.
-    samples.sort_by {|x| x.first.to_s }.each do |name, data|
-      records << data[:record]
-      text    << data[:text] + "\n"
-    end
-
-    it "should parse all sample records at once" do
-      subject.parse(text).zip(records).each do |round|
-        compare_crontab_record(*round)
-      end
-    end
-
-    it "should reconstitute the file from the records" do
-      compare_crontab_text subject.to_file(records), text
-    end
-
-    context "multi-line crontabs" do
-      tests = { :simple    => [:spaces_in_command_with_times],
-        :with_name => [:name, :spaces_in_command_with_times],
-        :with_env  => [:environment, :spaces_in_command_with_times],
-        :with_multiple_envs => [:environment, :lowercase_environment, :spaces_in_command_with_times],
-        :with_name_and_env => [:name_with_spaces, :another_env, :spaces_in_command_with_times],
-        :with_name_and_multiple_envs => [:long_name, :another_env, :fourth_env, :spaces_in_command_with_times]
-      }
-
-      all_records = []
-      all_text    = ''
-
-      tests.each do |name, content|
-        data    = content.map {|x| samples[x] or raise "missing sample data #{x}" }
-        text    = data.map {|x| x[:text] }.join("\n") + "\n"
-        records = data.map {|x| x[:record] }
-
-        # Capture the whole thing for later, too...
-        all_records += records
-        all_text    += text
-
-        context name.to_s.gsub('_', ' ') do
-          it "should regenerate the text from the record" do
-            compare_crontab_text subject.to_file(records), text
-          end
-
-          it "should parse the records from the text" do
-            subject.parse(text).zip(records).each do |round|
-              compare_crontab_record(*round)
-            end
-          end
-        end
-      end
-
-      it "should parse the whole set of records from the text" do
-        subject.parse(all_text).zip(all_records).each do |round|
-          compare_crontab_record(*round)
-        end
-      end
-
-      it "should regenerate the whole text from the set of all records" do
-        compare_crontab_text subject.to_file(all_records), all_text
-      end
-    end
-  end
-
-  context "when receiving a vixie cron header from the cron interface" do
-    it "should not write that header back to disk" do
-      vixie_header = File.read(my_fixture('vixie_header.txt'))
-      vixie_records = subject.parse(vixie_header)
-      compare_crontab_text subject.to_file(vixie_records), ""
-    end
-  end
-
-  context "when adding a cronjob with the same command as an existing job" do
-    let(:record) { {:name => "existing", :user => "root", :command => "/bin/true", :record_type => :crontab} }
-    let(:resource) { Puppet::Type::Cron.new(:name => "test", :user => "root", :command => "/bin/true") }
-    let(:resources) { { "test" => resource } }
-
-    before :each do
-      allow(subject).to receive(:prefetch_all_targets).and_return([record])
-    end
-
-# this would be a more fitting test, but I haven't yet
-# figured out how to get it working
-#    it "should include both jobs in the output" do
-#      subject.prefetch(resources)
-#      class Puppet::Provider::ParsedFile
-#        def self.records
-#          @records
-#        end
-#      end
-#      subject.to_file(subject.records).should match /Puppet name: test/
-#    end
-
-    it "should not base the new resource's provider on the existing record" do
-      expect(subject).not_to receive(:new).with(record)
-      allow(subject).to receive(:new)
-      subject.prefetch(resources)
-    end
-  end
-
-  context "when prefetching an entry now managed for another user" do
-    let(:resource) do
-     s = double(:resource)
-     allow(s).to receive(:[]).with(:user).and_return('root')
-     allow(s).to receive(:[]).with(:target).and_return('root')
-     s
-    end
-
-    let(:record) { {:name => "test", :user => "nobody", :command => "/bin/true", :record_type => :crontab} }
-    let(:resources) { { "test" => resource } }
-
-    before :each do
-      allow(subject).to receive(:prefetch_all_targets).and_return([record])
-    end
-
-    it "should try and use the match method to find a more fitting record" do
-      expect(subject).to receive(:match).with(record, resources)
-      subject.prefetch(resources)
-    end
-
-    it "should not match a provider to the resource" do
-      expect(resource).not_to receive(:provider=)
-      subject.prefetch(resources)
-    end
-
-    it "should not find the resource when looking up the on-disk record" do
-      subject.prefetch(resources)
-      expect(subject.resource_for_record(record, resources)).to be_nil
-    end
-  end
-
-  context "when matching resources to existing crontab entries" do
-    let(:first_resource) { Puppet::Type::Cron.new(:name => :one, :user => 'root', :command => '/bin/true') }
-    let(:second_resource) { Puppet::Type::Cron.new(:name => :two, :user => 'nobody', :command => '/bin/false') }
-
-    let(:resources) {{:one => first_resource, :two => second_resource}}
-
-    describe "with a record with a matching name and mismatching user (#2251)" do
-      # Puppet::Resource objects have #should defined on them, so in these
-      # examples we have to use the monkey patched `must` alias for the rspec
-      # `should` method.
-
-      it "doesn't match the record to the resource" do
-        record = {:name => :one, :user => 'notroot', :record_type => :crontab}
-        expect(subject.resource_for_record(record, resources)).to be_nil
-      end
-    end
-
-    describe "with a record with a matching name and matching user" do
-      it "matches the record to the resource" do
-        record = {:name => :two, :target => 'nobody', :command => '/bin/false'}
-        expect(subject.resource_for_record(record, resources)).to eq(second_resource)
-      end
-    end
-  end
-end

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

@@ -1,355 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:cron).provider(:crontab) do
-  let :provider do
-    described_class.new(:command => '/bin/true')
-  end
-
-  let :resource do
-    Puppet::Type.type(:cron).new(
-      :minute      => %w{0 15 30 45},
-      :hour        => %w{8-18 20-22},
-      :monthday    => %w{31},
-      :month       => %w{12},
-      :weekday     => %w{7},
-      :name        => 'basic',
-      :command     => '/bin/true',
-      :target      => 'root',
-      :provider    => provider
-    )
-  end
-
-  let :resource_special do
-    Puppet::Type.type(:cron).new(
-      :special => 'reboot',
-      :name    => 'special',
-      :command => '/bin/true',
-      :target  => 'nobody'
-    )
-  end
-
-  let :resource_sparse do
-    Puppet::Type.type(:cron).new(
-      :minute => %w{42},
-      :target => 'root',
-      :name   => 'sparse'
-    )
-  end
-
-  let :record_special do
-    {
-      :record_type => :crontab,
-      :special     => 'reboot',
-      :command     => '/bin/true',
-      :on_disk     => true,
-      :target      => 'nobody'
-    }
-  end
-
-  let :record do
-    {
-      :record_type => :crontab,
-      :minute      => %w{0 15 30 45},
-      :hour        => %w{8-18 20-22},
-      :monthday    => %w{31},
-      :month       => %w{12},
-      :weekday     => %w{7},
-      :special     => :absent,
-      :command     => '/bin/true',
-      :on_disk     => true,
-      :target      => 'root'
-    }
-  end
-
-  describe "when determining the correct filetype" do
-    it "should use the suntab filetype on Solaris" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
-      expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeSuntab)
-    end
-
-    it "should use the aixtab filetype on AIX" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('AIX')
-      expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeAixtab)
-    end
-
-    it "should use the crontab filetype on other platforms" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('Not a real operating system family')
-      expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeCrontab)
-    end
-  end
-
-  # I'd use ENV.expects(:[]).with('USER') but this does not work because
-  # ENV["USER"] is evaluated at load time.
-  describe "when determining the default target" do
-    it "should use the current user #{ENV['USER']}", :if => ENV['USER'] do
-      expect(described_class.default_target).to eq(ENV['USER'])
-    end
-
-    it "should fallback to root", :unless => ENV['USER'] do
-      expect(described_class.default_target).to eq("root")
-    end
-  end
-
-  describe ".targets" do
-    let(:tabs) { [ described_class.default_target ] + %w{foo bar} }
-
-    before do
-      expect(File).to receive(:readable?).and_return(true)
-      allow(File).to receive(:file?).and_return(true)
-      allow(File).to receive(:writable?).and_return(true)
-    end
-
-    it "should add all crontabs as targets" do
-      dir_expectation = receive(:foreach)
-      tabs.each do |tab|
-        dir_expectation = dir_expectation.and_yield(tab)
-      end
-      expect(Dir).to dir_expectation
-      expect(described_class.targets).to eq(tabs)
-    end
-  end
-
-  describe "when parsing a record" do
-    it "should parse a comment" do
-      expect(described_class.parse_line("# This is a test")).to eq({
-        :record_type => :comment,
-        :line        => "# This is a test",
-      })
-    end
-
-    it "should get the resource name of a PUPPET NAME comment" do
-      expect(described_class.parse_line('# Puppet Name: My Fancy Cronjob')).to eq({
-        :record_type => :comment,
-        :name        => 'My Fancy Cronjob',
-        :line        => '# Puppet Name: My Fancy Cronjob',
-      })
-    end
-
-    it "should ignore blank lines" do
-      expect(described_class.parse_line('')).to eq({:record_type => :blank, :line => ''})
-      expect(described_class.parse_line(' ')).to eq({:record_type => :blank, :line => ' '})
-      expect(described_class.parse_line("\t")).to eq({:record_type => :blank, :line => "\t"})
-      expect(described_class.parse_line("  \t ")).to eq({:record_type => :blank, :line => "  \t "})
-    end
-
-    it "should extract environment assignments" do
-      # man 5 crontab: MAILTO="" with no value can be used to surpress sending
-      # mails at all
-      expect(described_class.parse_line('MAILTO=""')).to eq({:record_type => :environment, :line => 'MAILTO=""'})
-      expect(described_class.parse_line('FOO=BAR')).to eq({:record_type => :environment, :line => 'FOO=BAR'})
-      expect(described_class.parse_line('FOO_BAR=BAR')).to eq({:record_type => :environment, :line => 'FOO_BAR=BAR'})
-      expect(described_class.parse_line('SPACE = BAR')).to eq({:record_type => :environment, :line => 'SPACE = BAR'})
-    end
-
-    it "should extract a cron entry" do
-      expect(described_class.parse_line('* * * * * /bin/true')).to eq({
-        :record_type => :crontab,
-        :hour        => :absent,
-        :minute      => :absent,
-        :month       => :absent,
-        :weekday     => :absent,
-        :monthday    => :absent,
-        :special     => :absent,
-        :command     => '/bin/true'
-      })
-      expect(described_class.parse_line('0,15,30,45 8-18,20-22 31 12 7 /bin/true')).to eq({
-        :record_type => :crontab,
-        :minute      => %w{0 15 30 45},
-        :hour        => %w{8-18 20-22},
-        :monthday    => %w{31},
-        :month       => %w{12},
-        :weekday     => %w{7},
-        :special     => :absent,
-        :command     => '/bin/true'
-      })
-      # A percent sign will cause the rest of the string to be passed as
-      # standard input and will also act as a newline character. Not sure
-      # if puppet should convert % to a \n as the command property so the
-      # test covers the current behaviour: Do not do any conversions
-      expect(described_class.parse_line('0 22 * * 1-5   mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%')).to eq({
-        :record_type => :crontab,
-        :minute      => %w{0},
-        :hour        => %w{22},
-        :monthday    => :absent,
-        :month       => :absent,
-        :weekday     => %w{1-5},
-        :special     => :absent,
-        :command     => 'mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%'
-      })
-    end
-
-    describe "it should support special strings" do
-      ['reboot','yearly','anually','monthly', 'weekly', 'daily', 'midnight', 'hourly'].each do |special|
-        it "should support @#{special}" do
-          expect(described_class.parse_line("@#{special} /bin/true")).to eq({
-            :record_type => :crontab,
-            :hour        => :absent,
-            :minute      => :absent,
-            :month       => :absent,
-            :weekday     => :absent,
-            :monthday    => :absent,
-            :special     => special,
-            :command     => '/bin/true'
-          })
-        end
-      end
-    end
-  end
-
-  describe ".instances" do
-    before :each do
-      allow(described_class).to receive(:default_target).and_return('foobar')
-    end
-
-    describe "on linux" do
-      before do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('Linux')
-        allow(Facter).to receive(:value).with(:operatingsystem)
-      end
-
-      it "should contain no resources for a user who has no crontab" do
-        allow(Puppet::Util).to receive(:uid).and_return(10)
-
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with('crontab -u foobar -l', { failonfail: true, combine: true })
-          .and_return("")
-        expect(described_class.instances.select { |resource|
-          resource.get('target') == 'foobar'
-        }).to be_empty
-      end
-
-      it "should contain no resources for a user who is absent" do
-        allow(Puppet::Util).to receive(:uid).and_return(nil)
-
-        expect(described_class.instances.select { |resource|
-          resource.get('target') == 'foobar'
-        }).to be_empty
-      end
-
-      it "should be able to create records from not-managed records" do
-        allow(described_class).to receive(:target_object).and_return(File.new(my_fixture('simple')))
-        parameters = described_class.instances.map do |p|
-          h = {:name => p.get(:name)}
-          Puppet::Type.type(:cron).validproperties.each do |property|
-            h[property] = p.get(property)
-          end
-          h
-        end
-
-        expect(parameters[0][:name]).to match(%r{unmanaged:\$HOME/bin/daily.job_>>_\$HOME/tmp/out_2>&1-\d+})
-        expect(parameters[0][:minute]).to eq(['5'])
-        expect(parameters[0][:hour]).to eq(['0'])
-        expect(parameters[0][:weekday]).to eq(:absent)
-        expect(parameters[0][:month]).to eq(:absent)
-        expect(parameters[0][:monthday]).to eq(:absent)
-        expect(parameters[0][:special]).to eq(:absent)
-        expect(parameters[0][:command]).to match(%r{\$HOME/bin/daily.job >> \$HOME/tmp/out 2>&1})
-        expect(parameters[0][:ensure]).to eq(:present)
-        expect(parameters[0][:environment]).to eq(:absent)
-        expect(parameters[0][:user]).to eq(:absent)
-
-        expect(parameters[1][:name]).to match(%r{unmanaged:\$HOME/bin/monthly-\d+})
-        expect(parameters[1][:minute]).to eq(['15'])
-        expect(parameters[1][:hour]).to eq(['14'])
-        expect(parameters[1][:weekday]).to eq(:absent)
-        expect(parameters[1][:month]).to eq(:absent)
-        expect(parameters[1][:monthday]).to eq(['1'])
-        expect(parameters[1][:special]).to eq(:absent)
-        expect(parameters[1][:command]).to match(%r{\$HOME/bin/monthly})
-        expect(parameters[1][:ensure]).to eq(:present)
-        expect(parameters[1][:environment]).to eq(:absent)
-        expect(parameters[1][:user]).to eq(:absent)
-        expect(parameters[1][:target]).to eq('foobar')
-      end
-
-      it "should be able to parse puppet managed cronjobs" do
-        allow(described_class).to receive(:target_object).and_return(File.new(my_fixture('managed')))
-        expect(described_class.instances.map do |p|
-          h = {:name => p.get(:name)}
-          Puppet::Type.type(:cron).validproperties.each do |property|
-            h[property] = p.get(property)
-          end
-          h
-        end).to eq([
-          {
-            :name        => 'real_job',
-            :minute      => :absent,
-            :hour        => :absent,
-            :weekday     => :absent,
-            :month       => :absent,
-            :monthday    => :absent,
-            :special     => :absent,
-            :command     => '/bin/true',
-            :ensure      => :present,
-            :environment => :absent,
-            :user        => :absent,
-            :target      => 'foobar'
-          },
-          {
-            :name        => 'complex_job',
-            :minute      => :absent,
-            :hour        => :absent,
-            :weekday     => :absent,
-            :month       => :absent,
-            :monthday    => :absent,
-            :special     => 'reboot',
-            :command     => '/bin/true >> /dev/null 2>&1',
-            :ensure      => :present,
-            :environment => [
-              'MAILTO=foo@example.com',
-              'SHELL=/bin/sh'
-            ],
-            :user        => :absent,
-            :target      => 'foobar'
-          }
-        ])
-      end
-    end
-  end
-
-  describe ".match" do
-    describe "normal records" do
-      it "should match when all fields are the same" do
-        expect(described_class.match(record,{resource[:name] => resource})).to eq(resource)
-      end
-
-      {
-        :minute      => %w{0 15 31 45},
-        :hour        => %w{8-18},
-        :monthday    => %w{30 31},
-        :month       => %w{12 23},
-        :weekday     => %w{4},
-        :command     => '/bin/false',
-        :target      => 'nobody'
-      }.each_pair do |field, new_value|
-        it "should not match a record when #{field} does not match" do
-          record[field] = new_value
-          expect(described_class.match(record,{resource[:name] => resource})).to be_falsey
-        end
-      end
-    end
-
-    describe "special records" do
-      it "should match when all fields are the same" do
-        expect(described_class.match(record_special,{resource_special[:name] => resource_special})).to eq(resource_special)
-      end
-
-      {
-        :special => 'monthly',
-        :command => '/bin/false',
-        :target  => 'root'
-      }.each_pair do |field, new_value|
-        it "should not match a record when #{field} does not match" do
-          record_special[field] = new_value
-          expect(described_class.match(record_special,{resource_special[:name] => resource_special})).to be_falsey
-        end
-      end
-    end
-
-    describe "with a resource without a command" do
-      it "should not raise an error" do
-        expect { described_class.match(record,{resource_sparse[:name] => resource_sparse}) }.to_not raise_error
-      end
-    end
-  end
-end