puppet 3.8.7 → 4.0.0

data/spec/unit/type/user_spec.rb

@@ -17,47 +17,47 @@ describe Puppet::Type.type(:user) do
   end
 
   it "should be able to create an instance" do
-    described_class.new(:name => "foo").should_not be_nil
+    expect(described_class.new(:name => "foo")).not_to be_nil
   end
 
   it "should have an allows_duplicates feature" do
-    described_class.provider_feature(:allows_duplicates).should_not be_nil
+    expect(described_class.provider_feature(:allows_duplicates)).not_to be_nil
   end
 
   it "should have a manages_homedir feature" do
-    described_class.provider_feature(:manages_homedir).should_not be_nil
+    expect(described_class.provider_feature(:manages_homedir)).not_to be_nil
   end
 
   it "should have a manages_passwords feature" do
-    described_class.provider_feature(:manages_passwords).should_not be_nil
+    expect(described_class.provider_feature(:manages_passwords)).not_to be_nil
   end
 
   it "should have a manages_solaris_rbac feature" do
-    described_class.provider_feature(:manages_solaris_rbac).should_not be_nil
+    expect(described_class.provider_feature(:manages_solaris_rbac)).not_to be_nil
   end
 
   it "should have a manages_expiry feature" do
-    described_class.provider_feature(:manages_expiry).should_not be_nil
+    expect(described_class.provider_feature(:manages_expiry)).not_to be_nil
   end
 
   it "should have a manages_password_age feature" do
-    described_class.provider_feature(:manages_password_age).should_not be_nil
+    expect(described_class.provider_feature(:manages_password_age)).not_to be_nil
   end
 
   it "should have a system_users feature" do
-    described_class.provider_feature(:system_users).should_not be_nil
+    expect(described_class.provider_feature(:system_users)).not_to be_nil
   end
 
   it "should have a manages_shell feature" do
-    described_class.provider_feature(:manages_shell).should_not be_nil
+    expect(described_class.provider_feature(:manages_shell)).not_to be_nil
   end
 
-  describe :managehome do
+  context "managehome" do
     let (:provider) { @provider_class.new(:name => 'foo', :ensure => :absent) }
     let (:instance) { described_class.new(:name => 'foo', :provider => provider) }
 
     it "defaults to false" do
-      instance[:managehome].should be_false
+      expect(instance[:managehome]).to be_falsey
     end
 
     it "can be set to false" do
@@ -79,10 +79,10 @@ describe Puppet::Type.type(:user) do
     it "should delegate existence questions to its provider" do
       @provider = @provider_class.new(:name => 'foo', :ensure => :absent)
       instance = described_class.new(:name => "foo", :provider => @provider)
-      instance.exists?.should == false
+      expect(instance.exists?).to eq(false)
 
       @provider.set(:ensure => :present)
-      instance.exists?.should == true
+      expect(instance.exists?).to eq(true)
     end
   end
 
@@ -90,11 +90,11 @@ describe Puppet::Type.type(:user) do
 
   properties.each do |property|
     it "should have a #{property} property" do
-      described_class.attrclass(property).ancestors.should be_include(Puppet::Property)
+      expect(described_class.attrclass(property).ancestors).to be_include(Puppet::Property)
     end
 
     it "should have documentation for its #{property} property" do
-      described_class.attrclass(property).doc.should be_instance_of(String)
+      expect(described_class.attrclass(property).doc).to be_instance_of(String)
     end
   end
 
@@ -102,16 +102,16 @@ describe Puppet::Type.type(:user) do
 
   list_properties.each do |property|
     it "should have a list '#{property}'" do
-      described_class.attrclass(property).ancestors.should be_include(Puppet::Property::List)
+      expect(described_class.attrclass(property).ancestors).to be_include(Puppet::Property::List)
     end
   end
 
   it "should have an ordered list 'profiles'" do
-    described_class.attrclass(:profiles).ancestors.should be_include(Puppet::Property::OrderedList)
+    expect(described_class.attrclass(:profiles).ancestors).to be_include(Puppet::Property::OrderedList)
   end
 
   it "should have key values 'keys'" do
-    described_class.attrclass(:keys).ancestors.should be_include(Puppet::Property::KeyValue)
+    expect(described_class.attrclass(:keys).ancestors).to be_include(Puppet::Property::KeyValue)
   end
 
   describe "when retrieving all current values" do
@@ -123,17 +123,17 @@ describe Puppet::Type.type(:user) do
     it "should return a hash containing values for all set properties" do
       @user[:gid] = 10
       values = @user.retrieve
-      [@user.property(:uid), @user.property(:gid)].each { |property| values.should be_include(property) }
+      [@user.property(:uid), @user.property(:gid)].each { |property| expect(values).to be_include(property) }
     end
 
     it "should set all values to :absent if the user is absent" do
       @user.property(:ensure).expects(:retrieve).returns :absent
       @user.property(:uid).expects(:retrieve).never
-      @user.retrieve[@user.property(:uid)].should == :absent
+      expect(@user.retrieve[@user.property(:uid)]).to eq(:absent)
     end
 
     it "should include the result of retrieving each property's current value if the user is present" do
-      @user.retrieve[@user.property(:uid)].should == 15
+      expect(@user.retrieve[@user.property(:uid)]).to eq(15)
     end
   end
 
@@ -161,45 +161,45 @@ describe Puppet::Type.type(:user) do
     describe "and determining the current state" do
       it "should return :present when the provider indicates the user exists" do
         @provider = @provider_class.new(:name => 'foo', :ensure => :present)
-        described_class.new(:name => 'foo', :ensure => :absent, :provider => @provider).parameter(:ensure).retrieve.should == :present
+        expect(described_class.new(:name => 'foo', :ensure => :absent, :provider => @provider).parameter(:ensure).retrieve).to eq(:present)
       end
 
       it "should return :absent when the provider indicates the user does not exist" do
         @provider = @provider_class.new(:name => 'foo', :ensure => :absent)
-        described_class.new(:name => 'foo', :ensure => :present, :provider => @provider).parameter(:ensure).retrieve.should == :absent
+        expect(described_class.new(:name => 'foo', :ensure => :present, :provider => @provider).parameter(:ensure).retrieve).to eq(:absent)
       end
     end
   end
 
   describe "when managing the uid property" do
     it "should convert number-looking strings into actual numbers" do
-      described_class.new(:name => 'foo', :uid => '50')[:uid].should == 50
+      expect(described_class.new(:name => 'foo', :uid => '50')[:uid]).to eq(50)
     end
 
     it "should support UIDs as numbers" do
-      described_class.new(:name => 'foo', :uid => 50)[:uid].should == 50
+      expect(described_class.new(:name => 'foo', :uid => 50)[:uid]).to eq(50)
     end
 
     it "should support :absent as a value" do
-      described_class.new(:name => 'foo', :uid => :absent)[:uid].should == :absent
+      expect(described_class.new(:name => 'foo', :uid => :absent)[:uid]).to eq(:absent)
     end
   end
 
   describe "when managing the gid" do
     it "should support :absent as a value" do
-      described_class.new(:name => 'foo', :gid => :absent)[:gid].should == :absent
+      expect(described_class.new(:name => 'foo', :gid => :absent)[:gid]).to eq(:absent)
     end
 
     it "should convert number-looking strings into actual numbers" do
-      described_class.new(:name => 'foo', :gid => '50')[:gid].should == 50
+      expect(described_class.new(:name => 'foo', :gid => '50')[:gid]).to eq(50)
     end
 
     it "should support GIDs specified as integers" do
-      described_class.new(:name => 'foo', :gid => 50)[:gid].should == 50
+      expect(described_class.new(:name => 'foo', :gid => 50)[:gid]).to eq(50)
     end
 
     it "should support groups specified by name" do
-      described_class.new(:name => 'foo', :gid => 'foo')[:gid].should == 'foo'
+      expect(described_class.new(:name => 'foo', :gid => 'foo')[:gid]).to eq('foo')
     end
 
     describe "when testing whether in sync" do
@@ -207,20 +207,20 @@ describe Puppet::Type.type(:user) do
         # this is currently not the case because gid has no default value, so we would never even
         # call insync? on that property
         if param = described_class.new(:name => 'foo').parameter(:gid)
-          param.must be_safe_insync(500)
+          expect(param).to be_safe_insync(500)
         end
       end
 
       it "should return true if any of the specified groups are equal to the current integer" do
         Puppet::Util.expects(:gid).with("foo").returns 300
         Puppet::Util.expects(:gid).with("bar").returns 500
-        described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid).must be_safe_insync(500)
+        expect(described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid)).to be_safe_insync(500)
       end
 
       it "should return false if none of the specified groups are equal to the current integer" do
         Puppet::Util.expects(:gid).with("foo").returns 300
         Puppet::Util.expects(:gid).with("bar").returns 500
-        described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid).must_not be_safe_insync(700)
+        expect(described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid)).to_not be_safe_insync(700)
       end
     end
 
@@ -265,24 +265,24 @@ describe Puppet::Type.type(:user) do
 
       it "should not care about order" do
         @property = described_class.new(:name => 'foo', :groups => [ 'a', 'c', 'b' ]).property(:groups)
-        @property.must be_safe_insync([ 'a', 'b', 'c' ])
-        @property.must be_safe_insync([ 'a', 'c', 'b' ])
-        @property.must be_safe_insync([ 'b', 'a', 'c' ])
-        @property.must be_safe_insync([ 'b', 'c', 'a' ])
-        @property.must be_safe_insync([ 'c', 'a', 'b' ])
-        @property.must be_safe_insync([ 'c', 'b', 'a' ])
+        expect(@property).to be_safe_insync([ 'a', 'b', 'c' ])
+        expect(@property).to be_safe_insync([ 'a', 'c', 'b' ])
+        expect(@property).to be_safe_insync([ 'b', 'a', 'c' ])
+        expect(@property).to be_safe_insync([ 'b', 'c', 'a' ])
+        expect(@property).to be_safe_insync([ 'c', 'a', 'b' ])
+        expect(@property).to be_safe_insync([ 'c', 'b', 'a' ])
       end
 
       it "should merge current value and desired value if membership minimal" do
         @instance = described_class.new(:name => 'foo', :groups => [ 'a', 'c', 'b' ], :provider => @provider)
         @instance[:membership] = :minimum
-        @instance[:groups].should == 'a,b,c,e,f'
+        expect(@instance[:groups]).to eq('a,b,c,e,f')
       end
 
       it "should not treat a subset of groups insync if membership inclusive" do
         @instance = described_class.new(:name => 'foo', :groups => [ 'a', 'c', 'b' ], :provider => @provider)
         @instance[:membership] = :inclusive
-        @instance[:groups].should == 'a,b,c'
+        expect(@instance[:groups]).to eq('a,b,c')
       end
     end
   end
@@ -320,19 +320,19 @@ describe Puppet::Type.type(:user) do
     end
 
     it "should not include the password in the change log when adding the password" do
-      @password.change_to_s(:absent, "mypass").should_not be_include("mypass")
+      expect(@password.change_to_s(:absent, "mypass")).not_to be_include("mypass")
     end
 
     it "should not include the password in the change log when changing the password" do
-      @password.change_to_s("other", "mypass").should_not be_include("mypass")
+      expect(@password.change_to_s("other", "mypass")).not_to be_include("mypass")
     end
 
     it "should redact the password when displaying the old value" do
-      @password.is_to_s("currentpassword").should =~ /^\[old password hash redacted\]$/
+      expect(@password.is_to_s("currentpassword")).to match(/^\[old password hash redacted\]$/)
     end
 
     it "should redact the password when displaying the new value" do
-      @password.should_to_s("newpassword").should =~ /^\[new password hash redacted\]$/
+      expect(@password.should_to_s("newpassword")).to match(/^\[new password hash redacted\]$/)
     end
 
     it "should fail if a ':' is included in the password" do
@@ -347,10 +347,10 @@ describe Puppet::Type.type(:user) do
   describe "when managing comment on Ruby 1.9", :if => String.method_defined?(:encode) do
     it "should force value encoding to ASCII-8BIT" do
       value = 'abcd™'
-      value.encoding.should == Encoding::UTF_8
+      expect(value.encoding).to eq(Encoding::UTF_8)
       user = described_class.new(:name => 'foo', :comment => value)
-      user[:comment].encoding.should == Encoding::ASCII_8BIT
-      user[:comment].should == value.force_encoding(Encoding::ASCII_8BIT)
+      expect(user[:comment].encoding).to eq(Encoding::ASCII_8BIT)
+      expect(user[:comment]).to eq(value.force_encoding(Encoding::ASCII_8BIT))
     end
   end
 
@@ -371,8 +371,8 @@ describe Puppet::Type.type(:user) do
       Puppet::Type::User::ProviderDirectoryservice.stubs(:get_macosx_version_major).returns "10.5"
 
       rel = testuser.autorequire[0]
-      rel.source.ref.should == testrole.ref
-      rel.target.ref.should == testuser.ref
+      expect(rel.source.ref).to eq(testrole.ref)
+      expect(rel.target.ref).to eq(testuser.ref)
     end
   end
 
@@ -494,24 +494,24 @@ describe Puppet::Type.type(:user) do
         let(:resources) { subject.generate }
         it "should contain a resource for each key" do
           names = resources.collect { |res| res.name }
-          names.should include("key1 name")
-          names.should include("keyname2")
+          expect(names).to include("key1 name")
+          expect(names).to include("keyname2")
         end
         it "should not include keys in comment lines" do
           names = resources.collect { |res| res.name }
-          names.should_not include("keyname3")
+          expect(names).not_to include("keyname3")
         end
         it "should generate names for unnamed keys" do
           names = resources.collect { |res| res.name }
           fixture_path = File.join(my_fixture_dir, 'authorized_keys')
-          names.should include("#{fixture_path}:unnamed-1")
+          expect(names).to include("#{fixture_path}:unnamed-1")
         end
         it "should each have a value for the user property" do
-          resources.map { |res|
+          expect(resources.map { |res|
             res[:user]
           }.reject { |user_name|
             user_name == "test_user_name"
-          }.should be_empty
+          }).to be_empty
         end
       end
     end

data/spec/unit/type/vlan_spec.rb

@@ -4,23 +4,23 @@ require 'spec_helper'
 describe Puppet::Type.type(:vlan) do
 
   it "should have a 'name' parameter'" do
-    Puppet::Type.type(:vlan).new(:name => "200")[:name].should == "200"
+    expect(Puppet::Type.type(:vlan).new(:name => "200")[:name]).to eq("200")
   end
 
   it "should have a 'device_url' parameter'" do
-    Puppet::Type.type(:vlan).new(:name => "200", :device_url => :device)[:device_url].should == :device
+    expect(Puppet::Type.type(:vlan).new(:name => "200", :device_url => :device)[:device_url]).to eq(:device)
   end
 
   it "should be applied on device" do
-    Puppet::Type.type(:vlan).new(:name => "200").must be_appliable_to_device
+    expect(Puppet::Type.type(:vlan).new(:name => "200")).to be_appliable_to_device
   end
 
   it "should have an ensure property" do
-    Puppet::Type.type(:vlan).attrtype(:ensure).should == :property
+    expect(Puppet::Type.type(:vlan).attrtype(:ensure)).to eq(:property)
   end
 
   it "should have a description property" do
-    Puppet::Type.type(:vlan).attrtype(:description).should == :property
+    expect(Puppet::Type.type(:vlan).attrtype(:description)).to eq(:property)
   end
 
   describe "when validating attribute values" do
@@ -38,7 +38,7 @@ describe Puppet::Type.type(:vlan) do
     end
 
     it "should fail if vlan name is not a number" do
-      lambda { Puppet::Type.type(:vlan).new(:name => "notanumber", :ensure => :present) }.should raise_error
+      expect { Puppet::Type.type(:vlan).new(:name => "notanumber", :ensure => :present) }.to raise_error
     end
   end
 end

data/spec/unit/type/whit_spec.rb

@@ -5,6 +5,6 @@ whit = Puppet::Type.type(:whit)
 
 describe whit do
   it "should stringify in a way that users will regognise" do
-    whit.new(:name => "Foo::Bar").to_s.should == "Foo::Bar"
+    expect(whit.new(:name => "Foo::Bar").to_s).to eq("Foo::Bar")
   end
 end

data/spec/unit/type/yumrepo_spec.rb

@@ -344,6 +344,11 @@ describe Puppet::Type.type(:yumrepo) do
       it_behaves_like "a yumrepo parameter that accepts a single URL", :metalink
     end
 
+    describe "assumeyes" do
+      it_behaves_like "a yumrepo parameter that expects a boolean parameter", :assumeyes
+      it_behaves_like "a yumrepo parameter that can be absent", :assumeyes
+    end
+
 
     describe "cost" do
       it_behaves_like "a yumrepo parameter that can be absent", :cost
@@ -383,5 +388,15 @@ describe Puppet::Type.type(:yumrepo) do
       it_behaves_like "a yumrepo parameter that can be absent", :mirrorlist_expire
       it_behaves_like "a yumrepo parameter that expects a natural value", :mirrorlist_expire
     end
+
+    describe "deltarpm_percentage" do
+      it_behaves_like "a yumrepo parameter that can be absent", :deltarpm_percentage
+      it_behaves_like "a yumrepo parameter that expects a natural value", :deltarpm_percentage
+    end
+
+    describe "deltarpm_metadata_percentage" do
+      it_behaves_like "a yumrepo parameter that can be absent", :deltarpm_metadata_percentage
+      it_behaves_like "a yumrepo parameter that expects a natural value", :deltarpm_metadata_percentage
+    end
   end
 end

data/spec/unit/type/zfs_spec.rb

@@ -8,7 +8,7 @@ describe zfs do
 
   properties.each do |property|
     it "should have a #{property} property" do
-      zfs.attrclass(property).ancestors.should be_include(Puppet::Property)
+      expect(zfs.attrclass(property).ancestors).to be_include(Puppet::Property)
     end
   end
 
@@ -16,7 +16,7 @@ describe zfs do
 
   parameters.each do |parameter|
     it "should have a #{parameter} parameter" do
-      zfs.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+      expect(zfs.attrclass(parameter).ancestors).to be_include(Puppet::Parameter)
     end
   end
 
@@ -41,6 +41,6 @@ describe zfs do
 
     req = foo_bar_baz_buz_zfs.autorequire.collect { |edge| edge.source.ref }
 
-    [foo_pool.ref, foo_bar_zfs.ref, foo_bar_baz_zfs.ref].each { |ref| req.include?(ref).should == true }
+    [foo_pool.ref, foo_bar_zfs.ref, foo_bar_baz_zfs.ref].each { |ref| expect(req.include?(ref)).to eq(true) }
   end
 end

data/spec/unit/type/zone_spec.rb

@@ -12,7 +12,7 @@ describe Puppet::Type.type(:zone) do
 
   parameters.each do |parameter|
     it "should have a #{parameter} parameter" do
-      described_class.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+      expect(described_class.attrclass(parameter).ancestors).to be_include(Puppet::Parameter)
     end
   end
 
@@ -20,7 +20,7 @@ describe Puppet::Type.type(:zone) do
 
   properties.each do |property|
     it "should have a #{property} property" do
-      described_class.attrclass(property).ancestors.should be_include(Puppet::Property)
+      expect(described_class.attrclass(property).ancestors).to be_include(Puppet::Property)
     end
   end
 
@@ -30,10 +30,10 @@ describe Puppet::Type.type(:zone) do
         prop.stubs(:should).returns []
       end
       [inherit, ip, dataset].each do |prop|
-        prop.insync?(nil).should be_true
+        expect(prop.insync?(nil)).to be_truthy
       end
       [inherit, ip, dataset].each do |prop|
-        prop.insync?(:absent).should be_true
+        expect(prop.insync?(:absent)).to be_truthy
       end
     end
   end
@@ -43,10 +43,10 @@ describe Puppet::Type.type(:zone) do
         prop.stubs(:should).returns ['a','b']
       end
       [inherit, ip, dataset].each do |prop|
-        prop.insync?(nil).should be_false
+        expect(prop.insync?(nil)).to be_falsey
       end
       [inherit, ip, dataset].each do |prop|
-        prop.insync?(:absent).should be_false
+        expect(prop.insync?(:absent)).to be_falsey
       end
     end
   end
@@ -56,10 +56,10 @@ describe Puppet::Type.type(:zone) do
         prop.stubs(:should).returns ['a','b']
       end
       [inherit, ip, dataset].each do |prop|
-        prop.insync?(['b', 'a']).should be_true
+        expect(prop.insync?(['b', 'a'])).to be_truthy
       end
       [inherit, ip, dataset].each do |prop|
-        prop.insync?(['a']).should be_false
+        expect(prop.insync?(['a'])).to be_falsey
       end
     end
   end
@@ -115,7 +115,7 @@ describe Puppet::Type.type(:zone) do
 
 
     relationship_graph.populate_from(catalog)
-    relationship_graph.dependencies(zone).should == [zfs]
+    expect(relationship_graph.dependencies(zone)).to eq([zfs])
   end
   describe Puppet::Zone::StateMachine do
     let (:sm) { Puppet::Zone::StateMachine.new }
@@ -129,43 +129,43 @@ describe Puppet::Type.type(:zone) do
     context ":insert_state" do
       it "should insert state in correct order" do
         sm.insert_state :dummy, :left => :right
-        sm.index(:dummy).should == 4
+        expect(sm.index(:dummy)).to eq(4)
       end
     end
     context ":alias_state" do
       it "should alias state" do
         sm.alias_state :dummy, :running
-        sm.name(:dummy).should == :running
+        expect(sm.name(:dummy)).to eq(:running)
       end
     end
     context ":name" do
       it "should get an aliased state correctly" do
         sm.alias_state :dummy, :running
-        sm.name(:dummy).should == :running
+        expect(sm.name(:dummy)).to eq(:running)
       end
       it "should get an un aliased state correctly" do
-        sm.name(:dummy).should == :dummy
+        expect(sm.name(:dummy)).to eq(:dummy)
       end
     end
     context ":index" do
       it "should return the state index correctly" do
         sm.insert_state :dummy, :left => :right
-        sm.index(:dummy).should == 4
+        expect(sm.index(:dummy)).to eq(4)
       end
     end
     context ":sequence" do
       it "should correctly return the actions to reach state specified" do
-        sm.sequence(:absent, :running).map{|p|p[:up]}.should ==  [:configure,:install,:start]
+        expect(sm.sequence(:absent, :running).map{|p|p[:up]}).to eq([:configure,:install,:start])
       end
       it "should correctly return the actions to reach state specified(2)" do
-        sm.sequence(:running, :absent).map{|p|p[:down]}.should == [:stop, :uninstall, :destroy]
+        expect(sm.sequence(:running, :absent).map{|p|p[:down]}).to eq([:stop, :uninstall, :destroy])
       end
     end
     context ":cmp" do
       it "should correctly compare state sequence values" do
-        sm.cmp?(:absent, :running).should == true
-        sm.cmp?(:running, :running).should == false
-        sm.cmp?(:running, :absent).should == false
+        expect(sm.cmp?(:absent, :running)).to eq(true)
+        expect(sm.cmp?(:running, :running)).to eq(false)
+        expect(sm.cmp?(:running, :absent)).to eq(false)
       end
     end
   end

data/spec/unit/type/zpool_spec.rb

@@ -13,7 +13,7 @@ describe zpool do
 
   properties.each do |property|
     it "should have a #{property} property" do
-      zpool.attrclass(property).ancestors.should be_include(Puppet::Property)
+      expect(zpool.attrclass(property).ancestors).to be_include(Puppet::Property)
     end
   end
 
@@ -21,7 +21,7 @@ describe zpool do
 
   parameters.each do |parameter|
     it "should have a #{parameter} parameter" do
-      zpool.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
+      expect(zpool.attrclass(parameter).ancestors).to be_include(Puppet::Parameter)
     end
   end
 end
@@ -37,27 +37,27 @@ describe vdev_property do
 
   it "should be insync if the devices are the same" do
     @property.should = ["dev1 dev2"]
-    @property.safe_insync?(["dev2 dev1"]).must be_true
+    expect(@property.safe_insync?(["dev2 dev1"])).to be_truthy
   end
 
   it "should be out of sync if the devices are not the same" do
     @property.should = ["dev1 dev3"]
-    @property.safe_insync?(["dev2 dev1"]).must be_false
+    expect(@property.safe_insync?(["dev2 dev1"])).to be_falsey
   end
 
-  it "should be insync if the devices are the same and the should values are comma seperated" do
+  it "should be insync if the devices are the same and the should values are comma separated" do
     @property.should = ["dev1", "dev2"]
-    @property.safe_insync?(["dev2 dev1"]).must be_true
+    expect(@property.safe_insync?(["dev2 dev1"])).to be_truthy
   end
 
   it "should be out of sync if the device is absent and should has a value" do
     @property.should = ["dev1", "dev2"]
-    @property.safe_insync?(:absent).must be_false
+    expect(@property.safe_insync?(:absent)).to be_falsey
   end
 
   it "should be insync if the device is absent and should is absent" do
     @property.should = [:absent]
-    @property.safe_insync?(:absent).must be_true
+    expect(@property.safe_insync?(:absent)).to be_truthy
   end
 end
 
@@ -72,38 +72,38 @@ describe multi_vdev_property do
 
   it "should be insync if the devices are the same" do
     @property.should = ["dev1 dev2"]
-    @property.safe_insync?(["dev2 dev1"]).must be_true
+    expect(@property.safe_insync?(["dev2 dev1"])).to be_truthy
   end
 
   it "should be out of sync if the devices are not the same" do
     @property.should = ["dev1 dev3"]
-    @property.safe_insync?(["dev2 dev1"]).must be_false
+    expect(@property.safe_insync?(["dev2 dev1"])).to be_falsey
   end
 
   it "should be out of sync if the device is absent and should has a value" do
     @property.should = ["dev1", "dev2"]
-    @property.safe_insync?(:absent).must be_false
+    expect(@property.safe_insync?(:absent)).to be_falsey
   end
 
   it "should be insync if the device is absent and should is absent" do
     @property.should = [:absent]
-    @property.safe_insync?(:absent).must be_true
+    expect(@property.safe_insync?(:absent)).to be_truthy
   end
 
   describe "when there are multiple lists of devices" do
     it "should be in sync if each group has the same devices" do
       @property.should = ["dev1 dev2", "dev3 dev4"]
-      @property.safe_insync?(["dev2 dev1", "dev3 dev4"]).must be_true
+      expect(@property.safe_insync?(["dev2 dev1", "dev3 dev4"])).to be_truthy
     end
 
     it "should be out of sync if any group has the different devices" do
       @property.should = ["dev1 devX", "dev3 dev4"]
-      @property.safe_insync?(["dev2 dev1", "dev3 dev4"]).must be_false
+      expect(@property.safe_insync?(["dev2 dev1", "dev3 dev4"])).to be_falsey
     end
 
     it "should be out of sync if devices are in the wrong group" do
       @property.should = ["dev1 dev2", "dev3 dev4"]
-      @property.safe_insync?(["dev2 dev3", "dev1 dev4"]).must be_false
+      expect(@property.safe_insync?(["dev2 dev3", "dev1 dev4"])).to be_falsey
     end
   end
 end