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

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

@@ -1,171 +0,0 @@
-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
-    allow(provider.class).to receive(:which).with('zfs').and_return(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
-      expect(provider.class).to receive(:zfs).with(:list,'-H').and_return(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
-      expect(provider).to receive(:zfs).with(:create, name)
-
-      provider.create
-    end
-
-    Puppet::Type.type(:zfs).validproperties.each do |prop|
-      next if [:ensure, :volsize].include?(prop)
-      it "should include property #{prop}" do
-        resource[prop] = prop
-
-        expect(provider).to receive(:zfs).with(:create, '-o', "#{prop}=#{prop}", name)
-
-        provider.create
-      end
-    end
-
-    it "should use -V for the volsize property" do
-      resource[:volsize] = "10"
-      expect(provider).to receive(:zfs).with(:create, '-V', "10", name)
-      provider.create
-    end
-  end
-
-  context "#destroy" do
-    it "should execute zfs destroy" do
-      expect(provider).to receive(: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
-      expect(provider).to receive(:zfs).with(:list, name)
-
-      expect(provider).to be_exists
-    end
-
-    it "should return false if returned values don't match the name" do
-      expect(provider).to receive(:zfs).with(:list, name).and_raise(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].each do |prop|
-      it "should get #{prop}" do
-        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', prop, name).and_return("value\n")
-
-        expect(provider.send(prop)).to eq('value')
-      end
-
-      it "should set #{prop}=value" do
-        expect(provider).to receive(:zfs).with(:set, "#{prop}=value", name)
-
-        provider.send("#{prop}=", "value")
-      end
-    end
-  end
-
-  describe "zoned" do
-    context "on FreeBSD" do
-      before do
-        allow(Facter).to receive(:value).with(:operatingsystem).and_return("FreeBSD")
-      end
-
-      it "should get 'jailed' property" do
-        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :jailed, name).and_return("value\n")
-        expect(provider.send("zoned")).to eq('value')
-      end
-
-      it "should set jalied=value" do
-        expect(provider).to receive(:zfs).with(:set, "jailed=value", name)
-        provider.send("zoned=", "value")
-      end
-    end
-
-    context "when not running FreeBSD" do
-      before do
-        allow(Facter).to receive(:value).with(:operatingsystem).and_return("Solaris")
-      end
-
-      it "should get 'zoned' property" do
-        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :zoned, name).and_return("value\n")
-        expect(provider.send("zoned")).to eq('value')
-      end
-
-      it "should set zoned=value" do
-        expect(provider).to receive(:zfs).with(:set, "zoned=value", name)
-        provider.send("zoned=", "value")
-      end
-    end
-  end
-
-  describe "acltype" do
-    context "when available" do
-      it "should get 'acltype' property" do
-        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :acltype, name).and_return("value\n")
-        expect(provider.send("acltype")).to eq('value')
-      end
-
-      it "should set acltype=value" do
-        expect(provider).to receive(:zfs).with(:set, "acltype=value", name)
-        provider.send("acltype=", "value")
-      end
-    end
-
-    context "when not available" do
-      it "should get '-' for the acltype property" do
-        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :acltype, name).and_raise(RuntimeError, 'not valid')
-        expect(provider.send("acltype")).to eq('-')
-      end
-
-      it "should not error out when trying to set acltype" do
-        expect(provider).to receive(:zfs).with(:set, "acltype=value", name).and_raise(RuntimeError, 'not valid')
-        expect{provider.send("acltype=", "value")}.to_not raise_error
-      end
-    end
-  end
-end

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

@@ -1,261 +0,0 @@
-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
-      allow(resource).to receive(:properties).and_return([])
-      resource[:create_args] = "create_args"
-      expect(provider).to receive(:setconfig).with("create -b create_args")
-      provider.configure
-    end
-
-    it "should add the create args to the create str" do
-      iptype = double("property")
-      allow(iptype).to receive(:name).with(no_args).and_return(:iptype)
-      allow(iptype).to receive(:safe_insync?).with(iptype).and_return(false)
-      allow(provider).to receive(:properties).and_return({:iptype => iptype})
-      allow(resource).to receive(:properties).with(no_args).and_return([iptype])
-      resource[:create_args] = "create_args"
-      expect(provider).to receive(: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
-        expect(provider).to receive(:zoneadm).with(:install)
-        provider.install
-      end
-
-      it "with the resource's clone attribute" do
-        resource[:clone] = :clone_argument
-        expect(provider).to receive(: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.
-        allow(resource).to receive(:[]).with(:clone).and_return(nil)
-        allow(resource).to receive(:[]).with(:install_args).and_return(nil)
-        expect(provider).to receive(: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.
-        allow(resource).to receive(:[]).with(:clone).and_return(nil)
-        allow(resource).to receive(:[]).with(:install_args).and_return('install args')
-        expect(provider).to receive(:zoneadm).with(:install, ["install", "args"])
-        provider.install
-      end
-    end
-  end
-
-  context "#instances" do
-    it "should list the instances correctly" do
-      expect(described_class).to receive(:adm).with(:list, "-cp").and_return("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
-      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
-      expect(provider).to receive(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({:out=>'', :exit => 0})
-      provider.setconfig("set zonepath=\/")
-      provider.flush
-    end
-
-    it "should correctly warn on 'not allowed'" do
-      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
-      expect(provider).to receive(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({: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
-        expect(provider).to receive(:zonecfg).with(:info).and_return(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
-        expect(provider).to receive(:zonecfg).with(:info).and_return(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
-
-        expect(provider).to receive(:zonecfg).with(:info).and_return(erroneous_zone_info)
-        expect(provider).to receive('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"
-        expect(provider).to receive(:zonecfg).with(:info).and_return(unrecognized_zone_info)
-        expect(provider).to receive('debug').with("Ignoring zone output 'dummy'")
-        provider.getconfig
-      end
-    end
-  end
-
-  context "#flush" do
-    it "should correctly execute pending commands" do
-      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
-      expect(provider).to receive(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({:out=>'', :exit => 0})
-      provider.setconfig("set iptype=shared")
-      provider.flush
-    end
-
-    it "should correctly raise error on failure" do
-      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
-      expect(provider).to receive(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({: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'
-      allow(Puppet::FileSystem).to receive(:exist?).with('/mypath/root/etc/sysidcfg').and_return(true)
-      allow(File).to receive(:directory?).with('/mypath/root/etc').and_return(true)
-      expect(provider).to receive(:zoneadm).with(:boot)
-      provider.start
-    end
-
-    it "should require path if sysidcfg is specified" do
-      allow(resource).to receive(:[]).with(:path).and_return(nil)
-      allow(resource).to receive(:[]).with(:sysidcfg).and_return('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
-      allow(provider).to receive(:properties).with(no_args).and_return({: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
-        expect(provider).to receive((p.to_s + '_conf').intern).and_return('dummy')
-        expect(provider).to receive(:setconfig).with('dummy').and_return('dummy2')
-        expect(provider.send(p.to_s + '=', 'dummy')).to eq('dummy2')
-      end
-    end
-  end
-end

data/spec/unit/provider/zpool/zpool_spec.rb

@@ -1,250 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:zpool).provider(:zpool) do
-  let(:name) { 'mypool' }
-  let(:zpool) { '/usr/sbin/zpool' }
-
-  let(:resource) do
-    Puppet::Type.type(:zpool).new(:name => name, :provider => :zpool)
-  end
-
-  let(:provider) { resource.provider }
-
-  before do
-    allow(provider.class).to receive(:which).with('zpool').and_return(zpool)
-  end
-
-  context '#current_pool' do
-    it "should call process_zpool_data with the result of get_pool_data only once" do
-      allow(provider).to receive(:get_pool_data).and_return(["foo", "disk"])
-      expect(provider).to receive(:process_zpool_data).with(["foo", "disk"]).and_return("stuff").once
-
-      provider.current_pool
-      provider.current_pool
-    end
-  end
-
-  describe "self.instances" do
-    it "should have an instances method" do
-      expect(provider.class).to respond_to(:instances)
-    end
-
-    it "should list instances" do
-      expect(provider.class).to receive(:zpool).with(:list,'-H').and_return(File.read(my_fixture('zpool-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 => 'mypool', :ensure => :present})
-    end
-  end
-
-  context '#flush' do
-    it "should reload the pool" do
-      allow(provider).to receive(:get_pool_data)
-      expect(provider).to receive(:process_zpool_data).and_return("stuff").twice
-      provider.current_pool
-      provider.flush
-      provider.current_pool
-    end
-  end
-
-  context '#process_zpool_data' do
-    let(:zpool_data) { ["foo", "disk"] }
-
-    describe "when there is no data" do
-      it "should return a hash with ensure=>:absent" do
-        expect(provider.process_zpool_data([])[:ensure]).to eq(:absent)
-      end
-    end
-
-    describe "when there is a spare" do
-      it "should add the spare disk to the hash" do
-        zpool_data.concat ["spares", "spare_disk"]
-        expect(provider.process_zpool_data(zpool_data)[:spare]).to eq(["spare_disk"])
-      end
-    end
-
-    describe "when there are two spares" do
-      it "should add the spare disk to the hash as a single string" do
-        zpool_data.concat ["spares", "spare_disk", "spare_disk2"]
-        expect(provider.process_zpool_data(zpool_data)[:spare]).to eq(["spare_disk spare_disk2"])
-      end
-    end
-
-    describe "when there is a log" do
-      it "should add the log disk to the hash" do
-        zpool_data.concat ["logs", "log_disk"]
-        expect(provider.process_zpool_data(zpool_data)[:log]).to eq(["log_disk"])
-      end
-    end
-
-    describe "when there are two logs" do
-      it "should add the log disks to the hash as a single string" do
-        zpool_data.concat ["spares", "spare_disk", "spare_disk2"]
-        expect(provider.process_zpool_data(zpool_data)[:spare]).to eq(["spare_disk spare_disk2"])
-      end
-    end
-
-    describe "when the vdev is a single mirror" do
-      it "should call create_multi_array with mirror" do
-        zpool_data = ["mirrorpool", "mirror", "disk1", "disk2"]
-        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2"])
-      end
-    end
-
-    describe "when the vdev is a single mirror on solaris 10u9 or later" do
-      it "should call create_multi_array with mirror" do
-        zpool_data = ["mirrorpool", "mirror-0", "disk1", "disk2"]
-        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2"])
-      end
-    end
-
-    describe "when the vdev is a double mirror" do
-      it "should call create_multi_array with mirror" do
-        zpool_data = ["mirrorpool", "mirror", "disk1", "disk2", "mirror", "disk3", "disk4"]
-        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2", "disk3 disk4"])
-      end
-    end
-
-    describe "when the vdev is a double mirror on solaris 10u9 or later" do
-      it "should call create_multi_array with mirror" do
-        zpool_data = ["mirrorpool", "mirror-0", "disk1", "disk2", "mirror-1", "disk3", "disk4"]
-        expect(provider.process_zpool_data(zpool_data)[:mirror]).to eq(["disk1 disk2", "disk3 disk4"])
-      end
-    end
-
-    describe "when the vdev is a raidz1" do
-      it "should call create_multi_array with raidz1" do
-        zpool_data = ["mirrorpool", "raidz1", "disk1", "disk2"]
-        expect(provider.process_zpool_data(zpool_data)[:raidz]).to eq(["disk1 disk2"])
-      end
-    end
-
-    describe "when the vdev is a raidz1 on solaris 10u9 or later" do
-      it "should call create_multi_array with raidz1" do
-        zpool_data = ["mirrorpool", "raidz1-0", "disk1", "disk2"]
-        expect(provider.process_zpool_data(zpool_data)[:raidz]).to eq(["disk1 disk2"])
-      end
-    end
-
-    describe "when the vdev is a raidz2" do
-      it "should call create_multi_array with raidz2 and set the raid_parity" do
-        zpool_data = ["mirrorpool", "raidz2", "disk1", "disk2"]
-        pool = provider.process_zpool_data(zpool_data)
-        expect(pool[:raidz]).to eq(["disk1 disk2"])
-        expect(pool[:raid_parity]).to eq("raidz2")
-      end
-    end
-
-    describe "when the vdev is a raidz2 on solaris 10u9 or later" do
-      it "should call create_multi_array with raidz2 and set the raid_parity" do
-        zpool_data = ["mirrorpool", "raidz2-0", "disk1", "disk2"]
-        pool = provider.process_zpool_data(zpool_data)
-        expect(pool[:raidz]).to eq(["disk1 disk2"])
-        expect(pool[:raid_parity]).to eq("raidz2")
-      end
-    end
-  end
-
-  describe "when calling the getters and setters" do
-    [:disk, :mirror, :raidz, :log, :spare].each do |field|
-      describe "when calling #{field}" do
-        it "should get the #{field} value from the current_pool hash" do
-          pool_hash = {}
-          pool_hash[field] = 'value'
-          allow(provider).to receive(:current_pool).and_return(pool_hash)
-
-          expect(provider.send(field)).to eq('value')
-        end
-      end
-
-      describe "when setting the #{field}" do
-        it "should fail if readonly #{field} values change" do
-          allow(provider).to receive(:current_pool).and_return(Hash.new("currentvalue"))
-          expect {
-            provider.send((field.to_s + "=").intern, "shouldvalue")
-          }.to raise_error(Puppet::Error, /can\'t be changed/)
-        end
-      end
-    end
-  end
-
-  context '#create' do
-    context "when creating disks for a zpool" do
-      before do
-        resource[:disk] = "disk1"
-      end
-
-      it "should call create with the build_vdevs value" do
-        expect(provider).to receive(:zpool).with(:create, name, 'disk1')
-        provider.create
-      end
-
-      it "should call create with the 'spares' and 'log' values" do
-        resource[:spare] = ['value1']
-        resource[:log] = ['value2']
-        expect(provider).to receive(:zpool).with(:create, name, 'disk1', 'spare', 'value1', 'log', 'value2')
-        provider.create
-      end
-    end
-
-    context "when creating mirrors for a zpool" do
-      it "executes 'create' for a single group of mirrored devices" do
-        resource[:mirror] = ["disk1 disk2"]
-        expect(provider).to receive(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2')
-        provider.create
-      end
-
-      it "repeats the 'mirror' keyword between groups of mirrored devices" do
-        resource[:mirror] = ["disk1 disk2", "disk3 disk4"]
-        expect(provider).to receive(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2', 'mirror', 'disk3', 'disk4')
-        provider.create
-      end
-    end
-
-    describe "when creating raidz for a zpool" do
-      it "executes 'create' for a single raidz group" do
-        resource[:raidz] = ["disk1 disk2"]
-        expect(provider).to receive(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2')
-        provider.create
-      end
-
-      it "execute 'create' for a single raidz2 group" do
-        resource[:raidz] = ["disk1 disk2"]
-        resource[:raid_parity] = 'raidz2'
-        expect(provider).to receive(:zpool).with(:create, name, 'raidz2', 'disk1', 'disk2')
-        provider.create
-      end
-
-      it "repeats the 'raidz1' keyword between each group of raidz devices" do
-        resource[:raidz] = ["disk1 disk2", "disk3 disk4"]
-        expect(provider).to receive(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2', 'raidz1', 'disk3', 'disk4')
-        provider.create
-      end
-    end
-  end
-
-  context '#delete' do
-    it "should call zpool with destroy and the pool name" do
-      expect(provider).to receive(:zpool).with(:destroy, name)
-      provider.destroy
-    end
-  end
-
-  context '#exists?' do
-    it "should get the current pool" do
-      expect(provider).to receive(:current_pool).and_return({:pool => 'somepool'})
-      provider.exists?
-    end
-
-    it "should return false if the current_pool is absent" do
-      expect(provider).to receive(:current_pool).and_return({:pool => :absent})
-      expect(provider).not_to be_exists
-    end
-
-    it "should return true if the current_pool has values" do
-      expect(provider).to receive(:current_pool).and_return({:pool => name})
-      expect(provider).to be_exists
-    end
-  end
-end