puppet 5.0.0 → 6.0.0

data/spec/unit/provider/selboolean_spec.rb

@@ -1,36 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-provider_class = Puppet::Type.type(:selboolean).provider(:getsetsebool)
-
-describe provider_class do
-  before :each do
-    @resource = stub("resource", :name => "foo")
-    @resource.stubs(:[]).returns "foo"
-    @provider = provider_class.new(@resource)
-  end
-
-  it "should return :on when getsebool returns on" do
-    @provider.expects(:getsebool).with("foo").returns "foo --> on\n"
-    expect(@provider.value).to eq(:on)
-  end
-
-  it "should return :off when getsebool returns on" do
-    @provider.expects(:getsebool).with("foo").returns "foo --> off\n"
-    expect(@provider.value).to eq(:off)
-  end
-
-  it "should call execpipe when updating boolean setting" do
-    @provider.expects(:command).with(:setsebool).returns "/usr/sbin/setsebool"
-    @provider.expects(:execpipe).with("/usr/sbin/setsebool  foo off")
-    @provider.value = :off
-  end
-
-  it "should call execpipe with -P when updating persistent boolean setting" do
-    @resource.stubs(:[]).with(:persistent).returns :true
-    @provider.expects(:command).with(:setsebool).returns "/usr/sbin/setsebool"
-    @provider.expects(:execpipe).with("/usr/sbin/setsebool -P foo off")
-    @provider.value = :off
-  end
-
-end

data/spec/unit/provider/selmodule_spec.rb

@@ -1,73 +0,0 @@
-#! /usr/bin/env ruby
-
-# Note: This unit test depends on having a sample SELinux policy file
-# in the same directory as this test called selmodule-example.pp
-# with version 1.5.0.  The provided selmodule-example.pp is the first
-# 256 bytes taken from /usr/share/selinux/targeted/nagios.pp on Fedora 9
-
-require 'spec_helper'
-require 'stringio'
-
-provider_class = Puppet::Type.type(:selmodule).provider(:semodule)
-
-describe provider_class do
-  before :each do
-    @resource = stub("resource", :name => "foo")
-    @resource.stubs(:[]).returns "foo"
-    @provider = provider_class.new(@resource)
-  end
-
-  describe "exists? method" do
-    it "should find a module if it is already loaded" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nfoo\t4.4.4\nbang\t1.0.0\n")
-      expect(@provider.exists?).to eq(:true)
-    end
-
-    it "should return nil if not loaded" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nbang\t1.0.0\n")
-      expect(@provider.exists?).to be_nil
-    end
-
-    it "should return nil if no modules are loaded" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("")
-      expect(@provider.exists?).to be_nil
-    end
-  end
-
-  describe "selmodversion_file" do
-    it "should return 1.5.0 for the example policy file" do
-      @provider.expects(:selmod_name_to_filename).returns "#{File.dirname(__FILE__)}/selmodule-example.pp"
-      expect(@provider.selmodversion_file).to eq("1.5.0")
-    end
-  end
-
-  describe "syncversion" do
-    it "should return :true if loaded and file modules are in sync" do
-      @provider.expects(:selmodversion_loaded).returns "1.5.0"
-      @provider.expects(:selmodversion_file).returns "1.5.0"
-      expect(@provider.syncversion).to eq(:true)
-    end
-
-    it "should return :false if loaded and file modules are not in sync" do
-      @provider.expects(:selmodversion_loaded).returns "1.4.0"
-      @provider.expects(:selmodversion_file).returns "1.5.0"
-      expect(@provider.syncversion).to eq(:false)
-    end
-
-    it "should return before checking file version if no loaded policy" do
-      @provider.expects(:selmodversion_loaded).returns nil
-      expect(@provider.syncversion).to eq(:false)
-    end
-  end
-
-  describe "selmodversion_loaded" do
-    it "should return the version of a loaded module" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nfoo\t4.4.4\nbang\t1.0.0\n")
-      expect(@provider.selmodversion_loaded).to eq("4.4.4")
-    end
-  end
-end

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

@@ -1,277 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'shared_behaviours/all_parsedfile_providers'
-require 'puppet_spec/files'
-
-provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
-
-describe provider_class, :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-
-  before :each do
-    @keyfile = tmpfile('authorized_keys')
-    @provider_class = provider_class
-    @provider_class.initvars
-    @provider_class.any_instance.stubs(:target).returns @keyfile
-    @user = 'random_bob'
-    Puppet::Util.stubs(:uid).with(@user).returns 12345
-  end
-
-  def mkkey(args)
-    args[:target] = @keyfile
-    args[:user]   = @user
-    resource = Puppet::Type.type(:ssh_authorized_key).new(args)
-    key = @provider_class.new(resource)
-    args.each do |p,v|
-      key.send(p.to_s + "=", v)
-    end
-    key
-  end
-
-  def genkey(key)
-    @provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
-    File.stubs(:chown)
-    File.stubs(:chmod)
-    Puppet::Util::SUIDManager.stubs(:asuser).yields
-    key.flush
-    @provider_class.target_object(@keyfile).read
-  end
-
-  it_should_behave_like "all parsedfile providers", provider_class
-
-  it "should be able to generate a basic authorized_keys file" do
-
-    key = mkkey(:name    => "Just_Testing",
-                :key     => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
-                :type    => "ssh-dss",
-                :ensure  => :present,
-                :options => [:absent]
-              )
-
-    expect(genkey(key)).to eq("ssh-dss AAAAfsfddsjldjgksdflgkjsfdlgkj Just_Testing\n")
-  end
-
-  it "should be able to generate an authorized_keys file with options" do
-
-    key = mkkey(:name    => "root@localhost",
-                :key     => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
-                :type    => "ssh-rsa",
-                :ensure  => :present,
-                :options => ['from="192.168.1.1"', "no-pty", "no-X11-forwarding"]
-                )
-
-    expect(genkey(key)).to eq("from=\"192.168.1.1\",no-pty,no-X11-forwarding ssh-rsa AAAAfsfddsjldjgksdflgkjsfdlgkj root@localhost\n")
-  end
-
-  it "should parse comments" do
-    result = [{ :record_type => :comment, :line => "# hello" }]
-    expect(@provider_class.parse("# hello\n")).to eq(result)
-  end
-
-  it "should parse comments with leading whitespace" do
-    result = [{ :record_type => :comment, :line => "  # hello" }]
-    expect(@provider_class.parse("  # hello\n")).to eq(result)
-  end
-
-  it "should skip over lines with only whitespace" do
-    result = [{ :record_type => :comment, :line => "#before" },
-              { :record_type => :blank,   :line => "  " },
-              { :record_type => :comment, :line => "#after" }]
-    expect(@provider_class.parse("#before\n  \n#after\n")).to eq(result)
-  end
-
-  it "should skip over completely empty lines" do
-    result = [{ :record_type => :comment, :line => "#before"},
-              { :record_type => :blank,   :line => ""},
-              { :record_type => :comment, :line => "#after"}]
-    expect(@provider_class.parse("#before\n\n#after\n")).to eq(result)
-  end
-
-  it "should be able to parse name if it includes whitespace" do
-    expect(@provider_class.parse_line('ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQC7pHZ1XRj3tXbFpPFhMGU1bVwz7jr13zt/wuE+pVIJA8GlmHYuYtIxHPfDHlkixdwLachCpSQUL9NbYkkRFRn9m6PZ7125ohE4E4m96QS6SGSQowTiRn4Lzd9LV38g93EMHjPmEkdSq7MY4uJEd6DUYsLvaDYdIgBiLBIWPA3OrQ== fancy user')[:name]).to eq('fancy user')
-    expect(@provider_class.parse_line('from="host1.reductlivelabs.com,host.reductivelabs.com",command="/usr/local/bin/run",ssh-pty ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQC7pHZ1XRj3tXbFpPFhMGU1bVwz7jr13zt/wuE+pVIJA8GlmHYuYtIxHPfDHlkixdwLachCpSQUL9NbYkkRFRn9m6PZ7125ohE4E4m96QS6SGSQowTiRn4Lzd9LV38g93EMHjPmEkdSq7MY4uJEd6DUYsLvaDYdIgBiLBIWPA3OrQ== fancy user')[:name]).to eq('fancy user')
-    expect(@provider_class.parse_line('ssh-rsa               AAAAB3NzaC1yc2EAAAADAQABAAAAgQC7pHZ1XRj3tXbFpPFhMGU1bVwz7jr13zt/wuE+pVIJA8GlmHYuYtIxHPfDHlkixdwLachCpSQUL9NbYkkRFRn9m6PZ7125ohE4E4m96QS6SGSQowTiRn4Lzd9LV38g93EMHjPmEkdSq7MY4uJEd6DUYsLvaDYdIgBiLBIWPA3OrQ==       whitespace fan')[:name]).to eq('whitespace fan')
-  end
-
-  it "should be able to parse options containing commas via its parse_options method" do
-    options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
-    optionstr = options.join(", ")
-
-    expect(@provider_class.parse_options(optionstr)).to eq(options)
-  end
-
-  it "should parse quoted options" do
-    line = 'command="/usr/local/bin/mybin \"$SSH_ORIGINAL_COMMAND\"" ssh-rsa xxx mykey'
-
-    expect(@provider_class.parse(line)[0][:options][0]).to eq('command="/usr/local/bin/mybin \"$SSH_ORIGINAL_COMMAND\""')
-  end
-
-  it "should use '' as name for entries that lack a comment" do
-    line = "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAut8aOSxenjOqF527dlsdHWV4MNoAsX14l9M297+SQXaQ5Z3BedIxZaoQthkDALlV/25A1COELrg9J2MqJNQc8Xe9XQOIkBQWWinUlD/BXwoOTWEy8C8zSZPHZ3getMMNhGTBO+q/O+qiJx3y5cA4MTbw2zSxukfWC87qWwcZ64UUlegIM056vPsdZWFclS9hsROVEa57YUMrehQ1EGxT4Z5j6zIopufGFiAPjZigq/vqgcAqhAKP6yu4/gwO6S9tatBeEjZ8fafvj1pmvvIplZeMr96gHE7xS3pEEQqnB3nd4RY7AF6j9kFixnsytAUO7STPh/M3pLiVQBN89TvWPQ=="
-
-    expect(@provider_class.parse(line)[0][:name]).to eq("")
-  end
-
-  {
-    # ssh-keygen -t dsa -b 1024
-    'ssh-dss' => 'AAAAB3NzaC1kc3MAAACBANGTefWMXS780qLMMgysq3GNMKzg55LXZODif6Tqv1vtTh4Wuk3J5X5u644jTyNdAIn1RiBI9MnwnZMZ6nXKvucMcMQWMibYS9W2MhkRj3oqsLWMMsdGXJL18SWM5A6oC3oIRC4JHJZtkm0OctR2trKxmX+MGhdCd+Xpsh9CNK8XAAAAFQD4olFiwv+QQUFdaZbWUy1CLEG9xQAAAIByCkXKgoriZF8bQ0OX1sKuR69M/6n5ngmQGVBKB7BQkpUjbK/OggB6iJgst5utKkDcaqYRnrTYG9q3jJ/flv7yYePuoSreS0nCMMx9gpEYuq+7Sljg9IecmN/IHrNd9qdYoASy5iuROQMvEZM7KFHA8vBv0tWdBOsp4hZKyiL1DAAAAIEAjkZlOps9L+cD/MTzxDj7toYYypdLOvjlcPBaglkPZoFZ0MAKTI0zXlVX1cWAnkd0Yfo4EpP+6XAjlZkod+QXKXM4Tb4PnR34ASMeU6sEjM61Na24S7JD3gpPKataFU/oH3hzXsBdK2ttKYmoqvf61h32IA/3Z5PjCCD9pPLPpAY',
-    # ssh-keygen -t rsa -b 2048
-    'ssh-rsa' => 'AAAAB3NzaC1yc2EAAAADAQABAAABAQDYtEaWa1mlxaAh9vtiz6RCVKDiJHDY15nsqqWU7F7A1+U1498+sWDyRDkZ8vXWQpzyOMBzBSHIxhsprlKhkjomy8BuJP+bHDBIKx4zgSFDrklrPIf467Iuug8J0qqDLxO4rOOjeAiLEyC0t2ZGnsTEea+rmat0bJ2cv3g5L4gH/OFz2pI4ZLp1HGN83ipl5UH8CjXQKwo3Db1E3WJCqKgszVX0Z4/qjnBRxFMoqky/1mGb/mX1eoT9JyQ8OhU9uENZOShkksSpgUqjlrjpj0Yd14hBlnE3M18pE4ivxjzectA/XRKNZaxOL1YREtU8sXusAwmlEY4aJ64aR0JrXfgx',
-    # ssh-keygen -t ecdsa -b 256
-    'ecdsa-sha2-nistp256' => 'AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBBO5PfBf0c2jAuqD+Lj3j+SuXOXNT2uqESLVOn5jVQfEF9GzllOw+CMOpUvV1CiOOn+F1ET15vcsfmD7z05WUTA=',
-    # ssh-keygen -t ecdsa -b 384
-    'ecdsa-sha2-nistp384' => 'AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBJIfxNoVK4FX3RuMlkHOwwxXwAh6Fqx5uAp4ftXrJ+64qYuIzb+/zSAkJV698Sre1b1lb0G4LyDdVAvXwaYK9kN25vy8umV3WdfZeHKXJGCcrplMCbbOERWARlpiPNEblg==',
-    # ssh-keygen -t ecdsa -b 521
-    'ecdsa-sha2-nistp521' => 'AAAAE2VjZHNhLXNoYTItbmlzdHA1MjEAAAAIbmlzdHA1MjEAAACFBADLK+u12xwB0JOwpmaxYXv8KnPK4p+SE2405qoo+vpAQ569fMwPMgKzltd770amdeuFogw/MJu17PN9LDdrD3o0uwHMjWee6TpHQDkuEetaxiou6K0WAzgbxx9QsY0MsJgXf1BuMLqdK+xT183wOSXwwumv99G7T32dOJZ5tYrH0y4XMw==',
-    # ssh-keygen -t ed25519
-    'ssh-ed25519' => 'AAAAC3NzaC1lZDI1NTE5AAAAIBWvu7D1KHBPaNXQcEuBsp48+JyPelXAq8ds6K5Du9gd',
-  }.each_pair do |keytype, keydata|
-    it "should be able to parse a #{keytype} key entry" do
-      comment = 'sample_key'
-
-      record = @provider_class.parse_line("#{keytype} #{keydata} #{comment}")
-      expect(record).not_to be_nil
-      expect(record[:name]).to eq(comment)
-      expect(record[:key]).to eq(keydata)
-      expect(record[:type]).to eq(keytype)
-    end
-  end
-
-  describe "prefetch_hook" do
-    let(:path) { '/path/to/keyfile' }
-    let(:input) do
-      { :type        => 'rsa',
-        :key         => 'KEYDATA',
-        :name        => '',
-        :record_type => :parsed,
-        :target      => path,
-      }
-    end
-    it "adds an indexed name to unnamed resources" do
-      expect(@provider_class.prefetch_hook([input])[0][:name]).to match(/^#{path}:unnamed-\d+/)
-    end
-  end
-
-end
-
-describe provider_class, :unless => Puppet.features.microsoft_windows? do
-  before :each do
-    @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :user => "random_bob")
-
-    @provider = provider_class.new(@resource)
-    provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
-    Puppet::Util::SUIDManager.stubs(:asuser).yields
-
-    provider_class.initvars
-  end
-
-  describe "when flushing" do
-    before :each do
-      # Stub file and directory operations
-      Dir.stubs(:mkdir)
-      File.stubs(:chmod)
-      File.stubs(:chown)
-    end
-
-    describe "and both a user and a target have been specified" do
-      before :each do
-        Puppet::Util.stubs(:uid).with("random_bob").returns 12345
-        @resource[:user] = "random_bob"
-        target = "/tmp/.ssh_dir/place_to_put_authorized_keys"
-        @resource[:target] = target
-      end
-
-      it "should create the directory" do
-        Puppet::FileSystem.stubs(:exist?).with("/tmp/.ssh_dir").returns false
-        Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
-        @provider.flush
-      end
-
-      it "should absolutely not chown the directory to the user" do
-        uid = Puppet::Util.uid("random_bob")
-        File.expects(:chown).never
-        @provider.flush
-      end
-
-      it "should absolutely not chown the key file to the user" do
-        uid = Puppet::Util.uid("random_bob")
-        File.expects(:chown).never
-        @provider.flush
-      end
-
-      it "should chmod the key file to 0600" do
-        File.expects(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
-        @provider.flush
-      end
-    end
-
-    describe "and a user has been specified with no target" do
-      before :each do
-        @resource[:user] = "nobody"
-        #
-        # I'd like to use random_bob here and something like
-        #
-        #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
-        #
-        # but mocha objects strenuously to stubbing File.expand_path
-        # so I'm left with using nobody.
-        @dir = File.expand_path("~nobody/.ssh")
-      end
-
-      it "should create the directory if it doesn't exist" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.expects(:mkdir).with(@dir,0700)
-        @provider.flush
-      end
-
-      it "should not create or chown the directory if it already exist" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.expects(:mkdir).never
-        @provider.flush
-      end
-
-      it "should absolutely not chown the directory to the user if it creates it" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.stubs(:mkdir).with(@dir,0700)
-        uid = Puppet::Util.uid("nobody")
-        File.expects(:chown).never
-        @provider.flush
-      end
-
-      it "should not create or chown the directory if it already exist" do
-        Puppet::FileSystem.stubs(:exist?).with(@dir).returns false
-        Dir.expects(:mkdir).never
-        File.expects(:chown).never
-        @provider.flush
-      end
-
-      it "should absolutely not chown the key file to the user" do
-        uid = Puppet::Util.uid("nobody")
-        File.expects(:chown).never
-        @provider.flush
-      end
-
-      it "should chmod the key file to 0600" do
-        File.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
-        @provider.flush
-      end
-    end
-
-    describe "and a target has been specified with no user" do
-      it "should raise an error" do
-        @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :target => "/tmp/.ssh_dir/place_to_put_authorized_keys")
-        @provider = provider_class.new(@resource)
-
-        expect { @provider.flush }.to raise_error(Puppet::Error, /Cannot write SSH authorized keys without user/)
-      end
-    end
-
-    describe "and an invalid user has been specified with no target" do
-      it "should catch an exception and raise a Puppet error" do
-        @resource[:user] = "thisusershouldnotexist"
-
-        expect { @provider.flush }.to raise_error(Puppet::Error)
-      end
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-provider_class = Puppet::Type.type(:sshkey).provider(:parsed)
-
-describe "sshkey parsed provider" do
-  let :type do Puppet::Type.type(:sshkey) end
-  let :provider do type.provider(:parsed) end
-  subject { provider }
-
-  after :each do
-    subject.clear
-  end
-
-  def key
-    'AAAAB3NzaC1yc2EAAAABIwAAAQEAzwHhxXvIrtfIwrudFqc8yQcIfMudrgpnuh1F3AV6d2BrLgu/yQE7W5UyJMUjfj427sQudRwKW45O0Jsnr33F4mUw+GIMlAAmp9g24/OcrTiB8ZUKIjoPy/cO4coxGi8/NECtRzpD/ZUPFh6OEpyOwJPMb7/EC2Az6Otw4StHdXUYw22zHazBcPFnv6zCgPx1hA7QlQDWTu4YcL0WmTYQCtMUb3FUqrcFtzGDD0ytosgwSd+JyN5vj5UwIABjnNOHPZ62EY1OFixnfqX/+dUwrFSs5tPgBF/KkC6R7tmbUfnBON6RrGEmu+ajOTOLy23qUZB4CQ53V7nyAWhzqSK+hw=='
-  end
-
-  it "should parse the name from the first field" do
-    expect(subject.parse_line('test ssh-rsa '+key)[:name]).to eq("test")
-  end
-
-  it "should parse the first component of the first field as the name" do
-    expect(subject.parse_line('test,alias ssh-rsa '+key)[:name]).to eq("test")
-  end
-
-  it "should parse host_aliases from the remaining components of the first field" do
-    expect(subject.parse_line('test,alias ssh-rsa '+key)[:host_aliases]).to eq(["alias"])
-  end
-
-  it "should parse multiple host_aliases" do
-    expect(subject.parse_line('test,alias1,alias2,alias3 ssh-rsa '+key)[:host_aliases]).to eq(["alias1","alias2","alias3"])
-  end
-
-  it "should not drop an empty host_alias" do
-    expect(subject.parse_line('test,alias, ssh-rsa '+key)[:host_aliases]).to eq(["alias",""])
-  end
-
-  it "should recognise when there are no host aliases" do
-    expect(subject.parse_line('test ssh-rsa '+key)[:host_aliases]).to eq([])
-  end
-
-  context "with the sample file" do
-    ['sample', 'sample_with_blank_lines'].each do |sample_file|
-      let :fixture do my_fixture(sample_file) end
-      before :each do subject.stubs(:default_target).returns(fixture) end
-
-      it "should parse to records on prefetch" do
-        expect(subject.target_records(fixture)).to be_empty
-        subject.prefetch
-
-        records = subject.target_records(fixture)
-        expect(records).to be_an Array
-        expect(records).to be_all {|x| expect(x).to be_an Hash }
-      end
-
-      it "should reconstitute the file from records" do
-        subject.prefetch
-        records = subject.target_records(fixture)
-        text = subject.to_file(records).gsub(/^# HEADER.+\n/, '')
-
-        oldlines = File.readlines(fixture).map(&:chomp)
-        newlines = text.chomp.split("\n")
-        expect(oldlines.length).to eq(newlines.length)
-
-        oldlines.zip(newlines).each do |old, new|
-          expect(old.gsub(/\s+/, '')).to eq(new.gsub(/\s+/, ''))
-        end
-      end
-    end
-  end
-
-  context 'default ssh_known_hosts target path' do
-    ['9.10', '9.11', '10.10'].each do |version|
-      it 'should be `/etc/ssh_known_hosts` when OSX version 10.10 or older`' do
-        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
-        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
-        expect(subject.default_target).to eq('/etc/ssh_known_hosts')
-      end
-    end
-
-    ['10.11', '10.13', '11.0', '11.11'].each do |version|
-      it 'should be `/etc/ssh/ssh_known_hosts` when OSX version 10.11 or newer`' do
-        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
-        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
-        expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
-      end
-    end
-
-    it 'should be `/etc/ssh/ssh_known_hosts` on other operating systems' do
-      Facter.expects(:value).with(:operatingsystem).returns('RedHat')
-      expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/provider/vlan/cisco'
-
-provider_class = Puppet::Type.type(:vlan).provider(:cisco)
-
-describe provider_class do
-  before do
-    @device = stub_everything 'device'
-    @resource = stub("resource", :name => "200")
-    @provider = provider_class.new(@device, @resource)
-  end
-
-  it "should have a parent of Puppet::Provider::Cisco" do
-    expect(provider_class).to be < Puppet::Provider::Cisco
-  end
-
-  it "should have an instances method" do
-    expect(provider_class).to respond_to(:instances)
-  end
-
-  describe "when looking up instances at prefetch" do
-    before do
-      @device.stubs(:command).yields(@device)
-    end
-
-    it "should delegate to the device vlans" do
-      @device.expects(:parse_vlans)
-      provider_class.lookup(@device, "200")
-    end
-
-    it "should return only the given vlan" do
-      @device.expects(:parse_vlans).returns({"200" => { :description => "thisone" }, "1" => { :description => "nothisone" }})
-      expect(provider_class.lookup(@device, "200")).to eq({:description => "thisone" })
-    end
-
-  end
-
-  describe "when an instance is being flushed" do
-    it "should call the device update_vlan method with its vlan id, current attributes, and desired attributes" do
-      @instance = provider_class.new(@device, :ensure => :present, :name => "200", :description => "myvlan")
-      @instance.description = "myvlan2"
-      @instance.resource = @resource
-      @resource.stubs(:[]).with(:name).returns("200")
-      device = stub_everything 'device'
-      @instance.stubs(:device).returns(device)
-      device.expects(:command).yields(device)
-      device.expects(:update_vlan).with(@instance.name, {:ensure => :present, :name => "200", :description => "myvlan"},
-                                                   {:ensure => :present, :name => "200", :description => "myvlan2"})
-
-      @instance.flush
-    end
-  end
-end