puppet 5.0.0 → 6.0.0

data/spec/unit/provider/yumrepo/inifile_spec.rb

@@ -1,326 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:yumrepo).provider(:inifile) do
-
-  after(:each) do
-    described_class.clear
-  end
-
-  describe "enumerating all yum repo files" do
-    it "reads all files in the directories specified by reposdir" do
-      described_class.expects(:reposdir).returns ['/etc/yum.repos.d']
-
-      Dir.expects(:glob).with("/etc/yum.repos.d/*.repo").returns(['/etc/yum.repos.d/first.repo', '/etc/yum.repos.d/second.repo'])
-
-      actual = described_class.repofiles
-      expect(actual).to include("/etc/yum.repos.d/first.repo")
-      expect(actual).to include("/etc/yum.repos.d/second.repo")
-    end
-
-    it "includes '/etc/yum.conf' as the first element" do
-      described_class.expects(:reposdir).returns []
-
-      actual = described_class.repofiles
-      expect(actual[0]).to eq "/etc/yum.conf"
-    end
-  end
-
-  describe "generating the virtual inifile" do
-    let(:files) { ['/etc/yum.repos.d/first.repo', '/etc/yum.repos.d/second.repo', '/etc/yum.conf'] }
-    let(:collection) { mock('virtual inifile') }
-
-    before do
-      described_class.clear
-      Puppet::Util::IniConfig::FileCollection.expects(:new).returns collection
-    end
-
-    it "reads all files in the directories specified by self.repofiles" do
-      described_class.expects(:repofiles).returns(files)
-
-      files.each do |file|
-        Puppet::FileSystem.stubs(:file?).with(file).returns true
-        collection.expects(:read).with(file)
-      end
-      described_class.virtual_inifile
-    end
-
-    it "ignores repofile entries that are not files" do
-      described_class.expects(:repofiles).returns(files)
-
-      Puppet::FileSystem.stubs(:file?).with('/etc/yum.repos.d/first.repo').returns true
-      Puppet::FileSystem.stubs(:file?).with('/etc/yum.repos.d/second.repo').returns false
-      Puppet::FileSystem.stubs(:file?).with('/etc/yum.conf').returns true
-
-      collection.expects(:read).with('/etc/yum.repos.d/first.repo').once
-      collection.expects(:read).with('/etc/yum.repos.d/second.repo').never
-      collection.expects(:read).with('/etc/yum.conf').once
-      described_class.virtual_inifile
-    end
-  end
-
-  describe 'creating provider instances' do
-    let(:virtual_inifile) { stub('virtual inifile') }
-
-    before :each do
-      described_class.stubs(:virtual_inifile).returns(virtual_inifile)
-    end
-
-    let(:main_section) do
-      sect = Puppet::Util::IniConfig::Section.new('main', '/some/imaginary/file')
-      sect.entries << ['distroverpkg', 'centos-release']
-      sect.entries << ['plugins', '1']
-
-      sect
-    end
-
-    let(:updates_section) do
-      sect = Puppet::Util::IniConfig::Section.new('updates', '/some/imaginary/file')
-      sect.entries << ['name', 'Some long description of the repo']
-      sect.entries << ['enabled', '1']
-
-      sect
-    end
-
-    it "ignores the main section" do
-      virtual_inifile.expects(:each_section).multiple_yields(main_section, updates_section)
-
-      instances = described_class.instances
-      expect(instances).to have(1).items
-      expect(instances[0].name).to eq 'updates'
-    end
-
-    it "creates provider instances for every non-main section that was found" do
-      virtual_inifile.expects(:each_section).multiple_yields(main_section, updates_section)
-
-      sect = described_class.instances.first
-      expect(sect.name).to eq 'updates'
-      expect(sect.descr).to eq 'Some long description of the repo'
-      expect(sect.enabled).to eq '1'
-    end
-  end
-
-  describe "retrieving a section from the inifile" do
-
-    let(:collection) { stub('ini file collection') }
-
-    let(:ini_section) { stub('ini file section') }
-
-    before do
-      described_class.stubs(:virtual_inifile).returns(collection)
-    end
-
-    describe "and the requested section exists" do
-      before do
-        collection.stubs(:[]).with('updates').returns ini_section
-      end
-
-      it "returns the existing section" do
-        expect(described_class.section('updates')).to eq ini_section
-      end
-
-      it "doesn't create a new section" do
-        collection.expects(:add_section).never
-        described_class.section('updates')
-      end
-    end
-
-    describe "and the requested section doesn't exist" do
-      it "creates a section in the preferred repodir" do
-        described_class.stubs(:reposdir).returns ['/etc/yum.repos.d', '/etc/alternate.repos.d']
-        collection.expects(:[]).with('updates')
-        collection.expects(:add_section).with('updates', '/etc/alternate.repos.d/updates.repo')
-
-        described_class.section('updates')
-      end
-
-      it "creates a section in yum.conf if no repodirs exist" do
-        described_class.stubs(:reposdir).returns []
-        collection.expects(:[]).with('updates')
-        collection.expects(:add_section).with('updates', '/etc/yum.conf')
-
-        described_class.section('updates')
-      end
-    end
-  end
-
-  describe "setting and getting properties" do
-
-    let(:type_instance) do
-      Puppet::Type.type(:yumrepo).new(
-        :name     => 'puppetlabs-products',
-        :ensure   => :present,
-        :baseurl  => 'http://yum.puppetlabs.com/el/6/products/$basearch',
-        :descr    => 'Puppet Labs Products El 6 - $basearch',
-        :enabled  => '1',
-        :gpgcheck => '1',
-        :gpgkey   => 'file:///etc/pki/rpm-gpg/RPM-GPG-KEY-puppetlabs'
-      )
-    end
-
-    let(:provider) do
-      described_class.new(type_instance)
-    end
-
-    let(:section) do
-      stub('inifile puppetlabs section', :name => 'puppetlabs-products')
-    end
-
-    before do
-      type_instance.provider = provider
-      described_class.stubs(:section).with('puppetlabs-products').returns(section)
-    end
-
-    describe "methods used by ensurable" do
-      it "#create sets the yumrepo properties on the according section" do
-        section.expects(:[]=).with('baseurl', 'http://yum.puppetlabs.com/el/6/products/$basearch')
-        section.expects(:[]=).with('name', 'Puppet Labs Products El 6 - $basearch')
-        section.expects(:[]=).with('enabled', '1')
-        section.expects(:[]=).with('gpgcheck', '1')
-        section.expects(:[]=).with('gpgkey', 'file:///etc/pki/rpm-gpg/RPM-GPG-KEY-puppetlabs')
-
-        provider.create
-      end
-
-      it "#exists? checks if the repo has been marked as present" do
-        described_class.stubs(:section).returns(stub(:[]= => nil))
-        provider.create
-        expect(provider).to be_exist
-      end
-
-      it "#destroy deletes the associated ini file section" do
-        described_class.expects(:section).returns(section)
-        section.expects(:destroy=).with(true)
-        provider.destroy
-      end
-    end
-
-    describe "getting properties" do
-      it "maps the 'descr' property to the 'name' INI property" do
-        section.expects(:[]).with('name').returns 'Some rather long description of the repository'
-        expect(provider.descr).to eq 'Some rather long description of the repository'
-      end
-
-      it "gets the property from the INI section" do
-        section.expects(:[]).with('enabled').returns '1'
-        expect(provider.enabled).to eq '1'
-      end
-
-      it "sets the property as :absent if the INI property is nil" do
-        section.expects(:[]).with('exclude').returns nil
-        expect(provider.exclude).to eq :absent
-      end
-    end
-
-    describe "setting properties" do
-      it "maps the 'descr' property to the 'name' INI property" do
-        section.expects(:[]=).with('name', 'Some rather long description of the repository')
-        provider.descr = 'Some rather long description of the repository'
-      end
-
-      it "sets the property on the INI section" do
-        section.expects(:[]=).with('enabled', '0')
-        provider.enabled = '0'
-      end
-
-      it "sets the section field to nil when the specified value is absent" do
-        section.expects(:[]=).with('exclude', nil)
-        provider.exclude = :absent
-      end
-    end
-  end
-
-  describe 'reposdir' do
-    let(:defaults) { ['/etc/yum.repos.d', '/etc/yum/repos.d'] }
-
-    before do
-      Puppet::FileSystem.stubs(:exist?).with('/etc/yum.repos.d').returns(true)
-      Puppet::FileSystem.stubs(:exist?).with('/etc/yum/repos.d').returns(true)
-    end
-
-    it "returns the default directories if yum.conf doesn't contain a `reposdir` entry" do
-      described_class.stubs(:find_conf_value).with('reposdir', '/etc/yum.conf')
-      expect(described_class.reposdir('/etc/yum.conf')).to eq(defaults)
-    end
-
-    it "includes the directory specified by the yum.conf 'reposdir' entry when the directory is present" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
-
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d"
-      expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d")
-    end
-
-    it "includes the directory if the value is split by whitespace" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/misc.repos.d").returns(true)
-
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d /etc/yum/misc.repos.d"
-      expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d", "/etc/yum/misc.repos.d")
-    end
-
-    it "includes the directory if the value is split by new lines" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/misc.repos.d").returns(true)
-
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d\n/etc/yum/misc.repos.d"
-      expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d", "/etc/yum/misc.repos.d")
-    end
-
-    it "doesn't include the directory specified by the yum.conf 'reposdir' entry when the directory is absent" do
-      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(false)
-
-      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d"
-      expect(described_class.reposdir('/etc/yum.conf')).not_to include("/etc/yum/extra.repos.d")
-    end
-
-    it "logs a warning and returns an empty array if none of the specified repo directories exist" do
-      Puppet::FileSystem.unstub(:exist?)
-      Puppet::FileSystem.stubs(:exist?).returns false
-
-      described_class.stubs(:find_conf_value).with('reposdir', '/etc/yum.conf')
-      Puppet.expects(:debug).with('No yum directories were found on the local filesystem')
-      expect(described_class.reposdir('/etc/yum.conf')).to be_empty
-    end
-  end
-
-  describe "looking up a conf value" do
-    describe "and the file doesn't exist" do
-      it "returns nil" do
-        Puppet::FileSystem.stubs(:exist?).returns false
-        expect(described_class.find_conf_value('reposdir')).to be_nil
-      end
-    end
-
-    describe "and the file exists" do
-      let(:pfile) { stub('yum.conf physical file') }
-      let(:sect) { stub('ini section') }
-
-      before do
-        Puppet::FileSystem.stubs(:exist?).with('/etc/yum.conf').returns true
-        Puppet::Util::IniConfig::PhysicalFile.stubs(:new).with('/etc/yum.conf').returns pfile
-        pfile.expects(:read)
-      end
-
-      it "creates a PhysicalFile to parse the given file" do
-        pfile.expects(:get_section)
-        described_class.find_conf_value('reposdir')
-      end
-
-      it "returns nil if the file exists but the 'main' section doesn't exist" do
-        pfile.expects(:get_section).with('main')
-        expect(described_class.find_conf_value('reposdir')).to be_nil
-      end
-
-      it "returns nil if the file exists but the INI property doesn't exist" do
-        pfile.expects(:get_section).with('main').returns sect
-        sect.expects(:[]).with('reposdir')
-        expect(described_class.find_conf_value('reposdir')).to be_nil
-      end
-
-      it "returns the value if the value is defined in the PhysicalFile" do
-        pfile.expects(:get_section).with('main').returns sect
-        sect.expects(:[]).with('reposdir').returns '/etc/alternate.repos.d'
-        expect(described_class.find_conf_value('reposdir')).to eq '/etc/alternate.repos.d'
-      end
-    end
-  end
-end

data/spec/unit/provider/zfs/zfs_spec.rb

@@ -1,106 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Type.type(:zfs).provider(:zfs) do
-  let(:name) { 'myzfs' }
-  let(:zfs) { '/usr/sbin/zfs' }
-
-  let(:resource) do
-    Puppet::Type.type(:zfs).new(:name => name, :provider => :zfs)
-  end
-
-  let(:provider) { resource.provider }
-
-  before do
-    provider.class.stubs(:which).with('zfs').returns(zfs)
-  end
-
-  context ".instances" do
-    it "should have an instances method" do
-      expect(provider.class).to respond_to(:instances)
-    end
-
-    it "should list instances" do
-      provider.class.expects(:zfs).with(:list,'-H').returns File.read(my_fixture('zfs-list.out'))
-      instances = provider.class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-      expect(instances.size).to eq(2)
-      expect(instances[0]).to eq({:name => 'rpool', :ensure => :present})
-      expect(instances[1]).to eq({:name => 'rpool/ROOT', :ensure => :present})
-    end
-  end
-
-  context '#add_properties' do
-    it 'should return an array of properties' do
-      resource[:mountpoint] = '/foo'
-
-      expect(provider.add_properties).to eq(['-o', "mountpoint=/foo"])
-    end
-
-    it 'should return an empty array' do
-      expect(provider.add_properties).to eq([])
-    end
-  end
-
-  context "#create" do
-    it "should execute zfs create" do
-      provider.expects(:zfs).with(:create, name)
-
-      provider.create
-    end
-
-    Puppet::Type.type(:zfs).validproperties.each do |prop|
-      next if prop == :ensure
-      it "should include property #{prop}" do
-        resource[prop] = prop
-
-        provider.expects(:zfs).with(:create, '-o', "#{prop}=#{prop}", name)
-
-        provider.create
-      end
-    end
-  end
-
-  context "#destroy" do
-    it "should execute zfs destroy" do
-      provider.expects(:zfs).with(:destroy, name)
-
-      provider.destroy
-    end
-  end
-
-  context "#exists?" do
-    it "should return true if the resource exists" do
-      #return stuff because we have to slice and dice it
-      provider.expects(:zfs).with(:list, name)
-
-      expect(provider).to be_exists
-    end
-
-    it "should return false if returned values don't match the name" do
-      provider.expects(:zfs).with(:list, name).raises(Puppet::ExecutionFailure, "Failed")
-
-      expect(provider).not_to be_exists
-    end
-  end
-
-  describe "zfs properties" do
-    [:aclinherit, :aclmode, :atime, :canmount, :checksum,
-     :compression, :copies, :dedup, :devices, :exec, :logbias,
-     :mountpoint, :nbmand,  :primarycache, :quota, :readonly,
-     :recordsize, :refquota, :refreservation, :reservation,
-     :secondarycache, :setuid, :shareiscsi, :sharenfs, :sharesmb,
-     :snapdir, :version, :volsize, :vscan, :xattr, :zoned].each do |prop|
-      it "should get #{prop}" do
-        provider.expects(:zfs).with(:get, '-H', '-o', 'value', prop, name).returns("value\n")
-
-        expect(provider.send(prop)).to eq('value')
-      end
-
-      it "should set #{prop}=value" do
-        provider.expects(:zfs).with(:set, "#{prop}=value", name)
-
-        provider.send("#{prop}=", "value")
-      end
-    end
-  end
-end

data/spec/unit/provider/zone/solaris_spec.rb

@@ -1,247 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Type.type(:zone).provider(:solaris) do
-  let(:resource) { Puppet::Type.type(:zone).new(:name => 'dummy', :path => '/', :provider => :solaris) }
-  let(:provider) { described_class.new(resource) }
-
-  context "#configure" do
-    it "should add the create args to the create str" do
-      resource.stubs(:properties).returns([])
-      resource[:create_args] = "create_args"
-      provider.expects(:setconfig).with("create -b create_args")
-      provider.configure
-    end
-    it "should add the create args to the create str" do
-      iptype = stub "property"
-      iptype.stubs(:name).with().returns(:iptype)
-      iptype.stubs(:safe_insync?).with(iptype).returns(false)
-      provider.stubs(:properties).returns({:iptype => iptype})
-      resource.stubs(:properties).with().returns([iptype])
-      resource[:create_args] = "create_args"
-      provider.expects(:setconfig).with("create -b create_args\nset ip-type=shared")
-      provider.configure
-    end
-  end
-
-  context "#install" do
-    context "clone" do
-      it "should call zoneadm" do
-        provider.expects(:zoneadm).with(:install)
-        provider.install
-      end
-
-      it "with the resource's clone attribute" do
-        resource[:clone] = :clone_argument
-        provider.expects(:zoneadm).with(:clone, :clone_argument)
-        provider.install
-      end
-    end
-
-    context "not clone" do
-      it "should just install if there are no install args" do
-        # there is a nil check in type.rb:[]= so we cannot directly set nil.
-        resource.stubs(:[]).with(:clone).returns(nil)
-        resource.stubs(:[]).with(:install_args).returns(nil)
-        provider.expects(:zoneadm).with(:install)
-        provider.install
-      end
-
-      it "should add the install args to the command if they exist" do
-        # there is a nil check in type.rb:[]= so we cannot directly set nil.
-        resource.stubs(:[]).with(:clone).returns(nil)
-        resource.stubs(:[]).with(:install_args).returns('install args')
-        provider.expects(:zoneadm).with(:install, ["install", "args"])
-        provider.install
-      end
-    end
-  end
-  context "#instances" do
-    it "should list the instances correctly" do
-      described_class.expects(:adm).with(:list, "-cp").returns("0:dummy:running:/::native:shared")
-      instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-      expect(instances.size).to eq(1)
-      expect(instances[0]).to eq({
-        :name=>"dummy",
-        :ensure=>:running,
-      })
-    end
-  end
-  context "#setconfig" do
-    it "should correctly set configuration" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 0})
-      provider.setconfig("set zonepath=\/")
-      provider.flush
-    end
-
-    it "should correctly warn on 'not allowed'" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>"Zone z2 already installed; set zonepath not allowed.\n", :exit => 0})
-      provider.setconfig("set zonepath=\/")
-      expect {
-        provider.flush
-      }.to raise_error(ArgumentError, /Failed to apply configuration/)
-    end
-  end
-  context "#getconfig" do
-    describe "with a shared iptype zone" do
-      zone_info =<<-EOF
-zonename: dummy
-zonepath: /dummy/z
-brand: native
-autoboot: true
-bootargs:
-pool:
-limitpriv:
-scheduling-class:
-ip-type: shared
-hostid:
-net:
-        address: 1.1.1.1
-        physical: ex0001
-        defrouter not specified
-net:
-        address: 1.1.1.2
-        physical: ex0002
-        defrouter not specified
-      EOF
-      it "should correctly parse zone info" do
-        provider.expects(:zonecfg).with(:info).returns(zone_info)
-        expect(provider.getconfig).to eq({
-          :brand=>"native",
-          :autoboot=>"true",
-          :"ip-type"=>"shared",
-          :zonename=>"dummy",
-          "net"=>[{:physical=>"ex0001", :address=>"1.1.1.1"}, {:physical=>"ex0002", :address=>"1.1.1.2"}],
-          :zonepath=>"/dummy/z"
-        })
-      end
-    end
-    describe "with an exclusive iptype zone" do
-      zone_info =<<-EOF
-zonename: dummy
-zonepath: /dummy/z
-brand: native
-autoboot: true
-bootargs:
-pool:
-limitpriv:
-scheduling-class:
-ip-type: exclusive
-hostid:
-net:
-        address not specified
-        allowed-address not specified
-        configure-allowed-address: true
-        physical: net1
-        defrouter not specified
-      EOF
-      it "should correctly parse zone info" do
-        provider.expects(:zonecfg).with(:info).returns(zone_info)
-        expect(provider.getconfig).to eq({
-          :brand=>"native",
-          :autoboot=>"true",
-          :"ip-type"=>"exclusive",
-          :zonename=>"dummy",
-          "net"=>[{:physical=>"net1",:'configure-allowed-address'=>"true"}],
-          :zonepath=>"/dummy/z"
-        })
-      end
-    end
-    describe "with an invalid or unrecognized config" do
-      it "should produce an error message with provider context when given an invalid config" do
-        erroneous_zone_info =<<-EOF
-          physical: net1'
-        EOF
-
-        provider.expects(:zonecfg).with(:info).returns(erroneous_zone_info)
-        provider.expects('err').with("Ignoring '          physical: net1''")
-        provider.getconfig
-      end
-
-
-      it "should produce a debugging message with provider context when given an unrecognized config" do
-        unrecognized_zone_info = "dummy"
-        provider.expects(:zonecfg).with(:info).returns(unrecognized_zone_info)
-        provider.expects('debug').with("Ignoring zone output 'dummy'")
-        provider.getconfig
-      end
-    end
-  end
-  context "#flush" do
-    it "should correctly execute pending commands" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 0})
-      provider.setconfig("set iptype=shared")
-      provider.flush
-    end
-
-    it "should correctly raise error on failure" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 1})
-      provider.setconfig("set iptype=shared")
-      expect {
-        provider.flush
-      }.to raise_error(ArgumentError, /Failed to apply/)
-    end
-  end
-  context "#start" do
-    it "should not require path if sysidcfg is specified" do
-      resource[:path] = '/mypath'
-      resource[:sysidcfg] = 'dummy'
-      Puppet::FileSystem.stubs(:exist?).with('/mypath/root/etc/sysidcfg').returns true
-      File.stubs(:directory?).with('/mypath/root/etc').returns true
-      provider.expects(:zoneadm).with(:boot)
-      provider.start
-    end
-
-    it "should require path if sysidcfg is specified" do
-      resource.stubs(:[]).with(:path).returns nil
-      resource.stubs(:[]).with(:sysidcfg).returns 'dummy'
-      expect {
-        provider.start
-      }.to raise_error(Puppet::Error, /Path is required/)
-    end
-  end
-  context "#line2hash" do
-    it "should parse lines correctly" do
-      expect(described_class.line2hash('0:dummy:running:/z::native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"})
-    end
-    it "should parse lines correctly(2)" do
-      expect(described_class.line2hash('0:dummy:running:/z:ipkg:native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"})
-    end
-    it "should parse lines correctly(3)" do
-      expect(described_class.line2hash('-:dummy:running:/z:ipkg:native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy"})
-    end
-    it "should parse lines correctly(3)" do
-      expect(described_class.line2hash('-:dummy:running:/z:ipkg:native:exclusive')).to eq({:ensure=>:running, :iptype=>"exclusive", :path=>"/z", :name=>"dummy"})
-    end
-  end
-  context "#multi_conf" do
-    it "should correctly add and remove properties" do
-      provider.stubs(:properties).with().returns({:ip => ['1.1.1.1', '2.2.2.2']})
-      should = ['1.1.1.1', '3.3.3.3']
-      p = Proc.new do |a, str|
-        case a
-        when :add; 'add:' + str
-        when :rm; 'rm:' + str
-        end
-      end
-      expect(provider.multi_conf(:ip, should, &p)).to eq("rm:2.2.2.2\nadd:3.3.3.3")
-    end
-  end
-  context "single props" do
-    {:iptype => /set ip-type/, :autoboot => /set autoboot/, :path => /set zonepath/, :pool => /set pool/, :shares => /add rctl/}.each do |p, v|
-      it "#{p.to_s}: should correctly return conf string" do
-        expect(provider.send(p.to_s + '_conf', 'dummy')).to match(v)
-      end
-      it "#{p.to_s}: should correctly set property string" do
-        provider.expects((p.to_s + '_conf').intern).returns('dummy')
-        provider.expects(:setconfig).with('dummy').returns('dummy2')
-        expect(provider.send(p.to_s + '=', 'dummy')).to eq('dummy2')
-      end
-
-    end
-  end
-end