puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/pops/types/type_factory_spec.rb

@@ -4,177 +4,177 @@ require 'puppet/pops'
 describe 'The type factory' do
   context 'when creating' do
     it 'integer() returns PIntegerType' do
-      Puppet::Pops::Types::TypeFactory.integer().class().should == Puppet::Pops::Types::PIntegerType
+      expect(Puppet::Pops::Types::TypeFactory.integer().class()).to eq(Puppet::Pops::Types::PIntegerType)
     end
 
     it 'float() returns PFloatType' do
-      Puppet::Pops::Types::TypeFactory.float().class().should == Puppet::Pops::Types::PFloatType
+      expect(Puppet::Pops::Types::TypeFactory.float().class()).to eq(Puppet::Pops::Types::PFloatType)
     end
 
     it 'string() returns PStringType' do
-      Puppet::Pops::Types::TypeFactory.string().class().should == Puppet::Pops::Types::PStringType
+      expect(Puppet::Pops::Types::TypeFactory.string().class()).to eq(Puppet::Pops::Types::PStringType)
     end
 
     it 'boolean() returns PBooleanType' do
-      Puppet::Pops::Types::TypeFactory.boolean().class().should == Puppet::Pops::Types::PBooleanType
+      expect(Puppet::Pops::Types::TypeFactory.boolean().class()).to eq(Puppet::Pops::Types::PBooleanType)
     end
 
     it 'pattern() returns PPatternType' do
-      Puppet::Pops::Types::TypeFactory.pattern().class().should == Puppet::Pops::Types::PPatternType
+      expect(Puppet::Pops::Types::TypeFactory.pattern().class()).to eq(Puppet::Pops::Types::PPatternType)
     end
 
     it 'regexp() returns PRegexpType' do
-      Puppet::Pops::Types::TypeFactory.regexp().class().should == Puppet::Pops::Types::PRegexpType
+      expect(Puppet::Pops::Types::TypeFactory.regexp().class()).to eq(Puppet::Pops::Types::PRegexpType)
     end
 
     it 'enum() returns PEnumType' do
-      Puppet::Pops::Types::TypeFactory.enum().class().should == Puppet::Pops::Types::PEnumType
+      expect(Puppet::Pops::Types::TypeFactory.enum().class()).to eq(Puppet::Pops::Types::PEnumType)
     end
 
     it 'variant() returns PVariantType' do
-      Puppet::Pops::Types::TypeFactory.variant().class().should == Puppet::Pops::Types::PVariantType
+      expect(Puppet::Pops::Types::TypeFactory.variant().class()).to eq(Puppet::Pops::Types::PVariantType)
     end
 
     it 'scalar() returns PScalarType' do
-      Puppet::Pops::Types::TypeFactory.scalar().class().should == Puppet::Pops::Types::PScalarType
+      expect(Puppet::Pops::Types::TypeFactory.scalar().class()).to eq(Puppet::Pops::Types::PScalarType)
     end
 
     it 'data() returns PDataType' do
-      Puppet::Pops::Types::TypeFactory.data().class().should == Puppet::Pops::Types::PDataType
+      expect(Puppet::Pops::Types::TypeFactory.data().class()).to eq(Puppet::Pops::Types::PDataType)
     end
 
     it 'optional() returns POptionalType' do
-      Puppet::Pops::Types::TypeFactory.optional().class().should == Puppet::Pops::Types::POptionalType
+      expect(Puppet::Pops::Types::TypeFactory.optional().class()).to eq(Puppet::Pops::Types::POptionalType)
     end
 
     it 'collection() returns PCollectionType' do
-      Puppet::Pops::Types::TypeFactory.collection().class().should == Puppet::Pops::Types::PCollectionType
+      expect(Puppet::Pops::Types::TypeFactory.collection().class()).to eq(Puppet::Pops::Types::PCollectionType)
     end
 
     it 'catalog_entry() returns PCatalogEntryType' do
-      Puppet::Pops::Types::TypeFactory.catalog_entry().class().should == Puppet::Pops::Types::PCatalogEntryType
+      expect(Puppet::Pops::Types::TypeFactory.catalog_entry().class()).to eq(Puppet::Pops::Types::PCatalogEntryType)
     end
 
     it 'struct() returns PStructType' do
-      Puppet::Pops::Types::TypeFactory.struct().class().should == Puppet::Pops::Types::PStructType
+      expect(Puppet::Pops::Types::TypeFactory.struct().class()).to eq(Puppet::Pops::Types::PStructType)
     end
 
     it 'tuple() returns PTupleType' do
-      Puppet::Pops::Types::TypeFactory.tuple().class().should == Puppet::Pops::Types::PTupleType
+      expect(Puppet::Pops::Types::TypeFactory.tuple().class()).to eq(Puppet::Pops::Types::PTupleType)
     end
 
     it 'undef() returns PUndefType' do
-      Puppet::Pops::Types::TypeFactory.undef().class().should == Puppet::Pops::Types::PUndefType
+      expect(Puppet::Pops::Types::TypeFactory.undef().class()).to eq(Puppet::Pops::Types::PUndefType)
     end
 
     it 'default() returns PDefaultType' do
-      Puppet::Pops::Types::TypeFactory.default().class().should == Puppet::Pops::Types::PDefaultType
+      expect(Puppet::Pops::Types::TypeFactory.default().class()).to eq(Puppet::Pops::Types::PDefaultType)
     end
 
     it 'range(to, from) returns PIntegerType' do
       t = Puppet::Pops::Types::TypeFactory.range(1,2)
-      t.class().should == Puppet::Pops::Types::PIntegerType
-      t.from.should == 1
-      t.to.should == 2
+      expect(t.class()).to eq(Puppet::Pops::Types::PIntegerType)
+      expect(t.from).to eq(1)
+      expect(t.to).to eq(2)
     end
 
     it 'range(default, default) returns PIntegerType' do
       t = Puppet::Pops::Types::TypeFactory.range(:default,:default)
-      t.class().should == Puppet::Pops::Types::PIntegerType
-      t.from.should == nil
-      t.to.should == nil
+      expect(t.class()).to eq(Puppet::Pops::Types::PIntegerType)
+      expect(t.from).to eq(nil)
+      expect(t.to).to eq(nil)
     end
 
     it 'float_range(to, from) returns PFloatType' do
       t = Puppet::Pops::Types::TypeFactory.float_range(1.0, 2.0)
-      t.class().should == Puppet::Pops::Types::PFloatType
-      t.from.should == 1.0
-      t.to.should == 2.0
+      expect(t.class()).to eq(Puppet::Pops::Types::PFloatType)
+      expect(t.from).to eq(1.0)
+      expect(t.to).to eq(2.0)
     end
 
     it 'float_range(default, default) returns PFloatType' do
       t = Puppet::Pops::Types::TypeFactory.float_range(:default, :default)
-      t.class().should == Puppet::Pops::Types::PFloatType
-      t.from.should == nil
-      t.to.should == nil
+      expect(t.class()).to eq(Puppet::Pops::Types::PFloatType)
+      expect(t.from).to eq(nil)
+      expect(t.to).to eq(nil)
     end
 
     it 'resource() creates a generic PResourceType' do
       pr = Puppet::Pops::Types::TypeFactory.resource()
-      pr.class().should == Puppet::Pops::Types::PResourceType
-      pr.type_name.should == nil
+      expect(pr.class()).to eq(Puppet::Pops::Types::PResourceType)
+      expect(pr.type_name).to eq(nil)
     end
 
     it 'resource(x) creates a PResourceType[x]' do
       pr = Puppet::Pops::Types::TypeFactory.resource('x')
-      pr.class().should == Puppet::Pops::Types::PResourceType
-      pr.type_name.should == 'x'
+      expect(pr.class()).to eq(Puppet::Pops::Types::PResourceType)
+      expect(pr.type_name).to eq('x')
     end
 
     it 'host_class() creates a generic PHostClassType' do
       hc = Puppet::Pops::Types::TypeFactory.host_class()
-      hc.class().should == Puppet::Pops::Types::PHostClassType
-      hc.class_name.should == nil
+      expect(hc.class()).to eq(Puppet::Pops::Types::PHostClassType)
+      expect(hc.class_name).to eq(nil)
     end
 
     it 'host_class(x) creates a PHostClassType[x]' do
       hc = Puppet::Pops::Types::TypeFactory.host_class('x')
-      hc.class().should == Puppet::Pops::Types::PHostClassType
-      hc.class_name.should == 'x'
+      expect(hc.class()).to eq(Puppet::Pops::Types::PHostClassType)
+      expect(hc.class_name).to eq('x')
     end
 
     it 'host_class(::x) creates a PHostClassType[x]' do
       hc = Puppet::Pops::Types::TypeFactory.host_class('::x')
-      hc.class().should == Puppet::Pops::Types::PHostClassType
-      hc.class_name.should == 'x'
+      expect(hc.class()).to eq(Puppet::Pops::Types::PHostClassType)
+      expect(hc.class_name).to eq('x')
     end
 
     it 'array_of(fixnum) returns PArrayType[PIntegerType]' do
       at = Puppet::Pops::Types::TypeFactory.array_of(1)
-      at.class().should == Puppet::Pops::Types::PArrayType
-      at.element_type.class.should == Puppet::Pops::Types::PIntegerType
+      expect(at.class()).to eq(Puppet::Pops::Types::PArrayType)
+      expect(at.element_type.class).to eq(Puppet::Pops::Types::PIntegerType)
     end
 
     it 'array_of(PIntegerType) returns PArrayType[PIntegerType]' do
       at = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::PIntegerType.new())
-      at.class().should == Puppet::Pops::Types::PArrayType
-      at.element_type.class.should == Puppet::Pops::Types::PIntegerType
+      expect(at.class()).to eq(Puppet::Pops::Types::PArrayType)
+      expect(at.element_type.class).to eq(Puppet::Pops::Types::PIntegerType)
     end
 
     it 'array_of_data returns PArrayType[PDataType]' do
       at = Puppet::Pops::Types::TypeFactory.array_of_data
-      at.class().should == Puppet::Pops::Types::PArrayType
-      at.element_type.class.should == Puppet::Pops::Types::PDataType
+      expect(at.class()).to eq(Puppet::Pops::Types::PArrayType)
+      expect(at.element_type.class).to eq(Puppet::Pops::Types::PDataType)
     end
 
     it 'hash_of_data returns PHashType[PScalarType,PDataType]' do
       ht = Puppet::Pops::Types::TypeFactory.hash_of_data
-      ht.class().should == Puppet::Pops::Types::PHashType
-      ht.key_type.class.should == Puppet::Pops::Types::PScalarType
-      ht.element_type.class.should == Puppet::Pops::Types::PDataType
+      expect(ht.class()).to eq(Puppet::Pops::Types::PHashType)
+      expect(ht.key_type.class).to eq(Puppet::Pops::Types::PScalarType)
+      expect(ht.element_type.class).to eq(Puppet::Pops::Types::PDataType)
     end
 
     it 'ruby(1) returns PRuntimeType[ruby, \'Fixnum\']' do
       ht = Puppet::Pops::Types::TypeFactory.ruby(1)
-      ht.class().should == Puppet::Pops::Types::PRuntimeType
-      ht.runtime.should == :ruby
-      ht.runtime_type_name.should == 'Fixnum'
+      expect(ht.class()).to eq(Puppet::Pops::Types::PRuntimeType)
+      expect(ht.runtime).to eq(:ruby)
+      expect(ht.runtime_type_name).to eq('Fixnum')
     end
 
     it 'a size constrained collection can be created from array' do
       t = Puppet::Pops::Types::TypeFactory.array_of_data()
-      Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2).should == t
-      t.size_type.class.should == Puppet::Pops::Types::PIntegerType
-      t.size_type.from.should == 1
-      t.size_type.to.should == 2
+      expect(Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2)).to eq(t)
+      expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      expect(t.size_type.from).to eq(1)
+      expect(t.size_type.to).to eq(2)
     end
 
     it 'a size constrained collection can be created from hash' do
       t = Puppet::Pops::Types::TypeFactory.hash_of_data()
-      Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2).should == t
-      t.size_type.class.should == Puppet::Pops::Types::PIntegerType
-      t.size_type.from.should == 1
-      t.size_type.to.should == 2
+      expect(Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2)).to eq(t)
+      expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      expect(t.size_type.from).to eq(1)
+      expect(t.size_type.to).to eq(2)
     end
 
     context 'callable types' do

data/spec/unit/pops/types/type_parser_spec.rb

@@ -66,14 +66,6 @@ describe Puppet::Pops::Types::TypeParser do
     expect(parser.parse("Hash[Scalar, Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
-  it 'interprets an Integer with one parameter to have unbounded upper range' do
-    expect(parser.parse('Integer[0]')).to eq(parser.parse('Integer[0,default]'))
-  end
-
-  it 'interprets a Float with one parameter to have unbounded upper range' do
-    expect(parser.parse('Float[0]')).to eq(parser.parse('Float[0,default]'))
-  end
-
   it "parses a parameterized type into the type object" do
     parameterized_array = types.array_of(types.integer)
     parameterized_hash = types.hash_of(types.integer, types.boolean)
@@ -112,7 +104,7 @@ describe Puppet::Pops::Types::TypeParser do
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
   end
 
-  it "parses tuple type with occurence constraint" do
+  it "parses tuple type with occurrence constraint" do
     tuple_t = types.tuple(Integer, String)
     types.constrain_size(tuple_t, 2, 5)
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
@@ -220,7 +212,7 @@ describe Puppet::Pops::Types::TypeParser do
       calc.assignable?(actual, type) && calc.assignable?(type, actual)
     end
 
-    failure_message_for_should do |actual|
+    failure_message do |actual|
       "expected #{calc.string(type)}, but was #{calc.string(actual)}"
     end
   end

data/spec/unit/pops/validator/validator_spec.rb

@@ -19,8 +19,9 @@ describe "validating 4x" do
   end
 
   it 'should raise error for illegal names' do
-    expect(validate(parse('class aaa::_bbb {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
-    expect(validate(parse('class Aaa {}'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
+    pending "validation was too strict, now too relaxed - validation missing"
+    expect(validate(fqn('Aaa'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
+    expect(validate(fqn('AAA'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
   end
 
   it 'should raise error for illegal variable names' do
@@ -119,30 +120,6 @@ describe "validating 4x" do
     end
   end
 
-  context 'for future reserved words' do
-    ['application', 'produces', 'consumes'].each do |word|
-      it "produces an issue for the word '#{word}'" do
-        source = "$a = #{word}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
-      end
-
-      it 'produces a warning issue when used as a class name' do
-        source = "class #{word} {}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
-      end
-
-      it 'produces no warning or error when used as a parameter name' do
-        source = "define foo($#{word}) { notice $#{word} }"
-        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
-      end
-
-      it 'produces no warning or error when used as an attribute name' do
-        source = "foo { bar: #{word} => ok }"
-        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
-      end
-    end
-  end
-
   context 'for reserved type names' do
     [# type/Type, is a reserved name but results in syntax error because it is a keyword in lower case form
     'any',
@@ -177,18 +154,6 @@ describe "validating 4x" do
     end
   end
 
-  context 'for parameter names' do
-    ['class', 'define'].each do |word|
-      it "should require that #{word} parameter names are unique" do
-        expect(validate(parse("#{word} foo($a = 10, $a = 20) {}"))).to have_issue(Puppet::Pops::Issues::DUPLICATE_PARAMETER)
-      end
-    end
-
-    it "should require that template parameter names are unique" do
-      expect(validate(parse_epp("<%-| $a, $a |-%><%= $a == doh %>"))).to have_issue(Puppet::Pops::Issues::DUPLICATE_PARAMETER)
-    end
-  end
-
   context 'for reserved parameter names' do
     ['name', 'title'].each do |word|
       it "produces an error when $#{word} is used as a parameter in a class" do
@@ -213,25 +178,6 @@ describe "validating 4x" do
     end
   end
 
-  context 'for badly formed non-numeric parameter names' do
-    ['Ateam', 'a::team'].each do |word|
-      it "produces an error when $#{word} is used as a parameter in a class" do
-        source = "class x ($#{word}) {}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_PARAM_NAME)
-      end
-
-      it "produces an error when $#{word} is used as a parameter in a define" do
-        source = "define x ($#{word}) {}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_PARAM_NAME)
-      end
-
-      it "produces an error when $#{word} is used as a parameter in a lambda" do
-        source = "with() |$#{word}| {}"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_PARAM_NAME)
-      end
-    end
-  end
-
   context 'top level constructs in conditionals' do
     ['class', 'define', 'node'].each do |word|
       it "produces an error when $#{word} is nested in an if expression" do

data/spec/unit/pops/visitor_spec.rb

@@ -29,7 +29,7 @@ describe Puppet::Pops::Visitor do
     it "should select the expected method when there are no arguments" do
       duck = Duck.new
       duck_processor = DuckProcessor.new
-      duck_processor.hi(duck).should == "Hi Duck"
+      expect(duck_processor.hi(duck)).to eq("Hi Duck")
     end
 
     it "should fail if there are too many arguments" do
@@ -40,12 +40,12 @@ describe Puppet::Pops::Visitor do
 
     it "should select method for superclass" do
       duck_processor = DuckProcessor.new
-      duck_processor.hi(42).should == "Howdy Fixnum"
+      expect(duck_processor.hi(42)).to eq("Howdy Fixnum")
     end
 
     it "should select method for superclass" do
       duck_processor = DuckProcessor.new
-      duck_processor.hi(42.0).should == "Howdy Float"
+      expect(duck_processor.hi(42.0)).to eq("Howdy Float")
     end
 
     it "should fail if class not handled" do
@@ -76,7 +76,7 @@ describe Puppet::Pops::Visitor do
     it "should select the expected method when there are is one arguments" do
       duck = Duck.new
       duck_processor = DuckProcessor2.new
-      duck_processor.hi(duck, "water").should == "Hi Duck, drink=water, eat=grain"
+      expect(duck_processor.hi(duck, "water")).to eq("Hi Duck, drink=water, eat=grain")
     end
 
     it "should fail if there are too many arguments" do

data/spec/unit/property/boolean_spec.rb

@@ -7,12 +7,12 @@ describe Puppet::Property::Boolean do
 
   [ true, :true, 'true', :yes, 'yes', 'TrUe', 'yEs' ].each do |arg|
     it "should munge #{arg.inspect} as true" do
-      subject.munge(arg).should == true
+      expect(subject.munge(arg)).to eq(true)
     end
   end
   [ false, :false, 'false', :no, 'no', 'FaLSE', 'nO' ].each do |arg|
     it "should munge #{arg.inspect} as false" do
-      subject.munge(arg).should == false
+      expect(subject.munge(arg)).to eq(false)
     end
   end
   [ nil, :undef, 'undef', '0', 0, '1', 1, 9284 ].each do |arg|

data/spec/unit/property/ensure_spec.rb

@@ -7,6 +7,6 @@ klass = Puppet::Property::Ensure
 
 describe klass do
   it "should be a subclass of Property" do
-    klass.superclass.must == Puppet::Property
+    expect(klass.superclass).to eq(Puppet::Property)
   end
 end

data/spec/unit/property/keyvalue_spec.rb

@@ -8,7 +8,7 @@ klass = Puppet::Property::KeyValue
 describe klass do
 
   it "should be a subclass of Property" do
-    klass.superclass.must == Puppet::Property
+    expect(klass.superclass).to eq(Puppet::Property)
   end
 
   describe "as an instance" do
@@ -20,15 +20,15 @@ describe klass do
     end
 
     it "should have a , as default delimiter" do
-      @property.delimiter.should == ";"
+      expect(@property.delimiter).to eq(";")
     end
 
     it "should have a = as default separator" do
-      @property.separator.should == "="
+      expect(@property.separator).to eq("=")
     end
 
     it "should have a :membership as default membership" do
-      @property.membership.should == :key_value_membership
+      expect(@property.membership).to eq(:key_value_membership)
     end
 
     it "should return the same value passed into should_to_s" do
@@ -39,7 +39,7 @@ describe klass do
       s = @property.is_to_s({"foo" => "baz" , "bar" => "boo"})
 
       # We can't predict the order the hash is processed in...
-      ["foo=baz;bar=boo", "bar=boo;foo=baz"].should be_include s
+      expect(["foo=baz;bar=boo", "bar=boo;foo=baz"]).to be_include s
     end
 
     describe "when calling inclusive?" do
@@ -52,35 +52,35 @@ describe klass do
       it "should return true when @resource[membership] == inclusive" do
         @property.stubs(:membership).returns(:key_value_membership)
         @resource.stubs(:[]).with(:key_value_membership).returns(:inclusive)
-        @property.inclusive?.must == true
+        expect(@property.inclusive?).to eq(true)
       end
 
       it "should return false when @resource[membership] != inclusive" do
         @property.stubs(:membership).returns(:key_value_membership)
         @resource.stubs(:[]).with(:key_value_membership).returns(:minimum)
-        @property.inclusive?.must == false
+        expect(@property.inclusive?).to eq(false)
       end
     end
 
     describe "when calling process_current_hash" do
       it "should return {} if hash is :absent" do
-        @property.process_current_hash(:absent).must == {}
+        expect(@property.process_current_hash(:absent)).to eq({})
       end
 
       it "should set every key to nil if inclusive?" do
         @property.stubs(:inclusive?).returns(true)
-        @property.process_current_hash({:foo => "bar", :do => "re"}).must == { :foo => nil, :do => nil }
+        expect(@property.process_current_hash({:foo => "bar", :do => "re"})).to eq({ :foo => nil, :do => nil })
       end
 
       it "should return the hash if !inclusive?" do
         @property.stubs(:inclusive?).returns(false)
-        @property.process_current_hash({:foo => "bar", :do => "re"}).must == {:foo => "bar", :do => "re"}
+        expect(@property.process_current_hash({:foo => "bar", :do => "re"})).to eq({:foo => "bar", :do => "re"})
       end
     end
 
     describe "when calling should" do
       it "should return nil if @should is nil" do
-        @property.should.must == nil
+        expect(@property.should).to eq(nil)
       end
 
       it "should call process_current_hash" do
@@ -94,14 +94,14 @@ describe klass do
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:retrieve).returns({:do => "re", :mi => "fa" })
         @property.expects(:inclusive?).returns(true)
-        @property.should.must == { :foo => "baz", :bar => "boo", :do => nil, :mi => nil }
+        expect(@property.should).to eq({ :foo => "baz", :bar => "boo", :do => nil, :mi => nil })
       end
 
       it "should return the hashed @should + the unique values of retrieve if !inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:retrieve).returns({:foo => "diff", :do => "re", :mi => "fa"})
         @property.expects(:inclusive?).returns(false)
-        @property.should.must == { :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" }
+        expect(@property.should).to eq({ :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" })
       end
     end
 
@@ -132,7 +132,7 @@ describe klass do
 
     describe "when calling hashify" do
       it "should return the array hashified" do
-        @property.hashify(["foo=baz", "bar=boo"]).must == { :foo => "baz", :bar => "boo" }
+        expect(@property.hashify(["foo=baz", "bar=boo"])).to eq({ :foo => "baz", :bar => "boo" })
       end
     end
 
@@ -156,14 +156,14 @@ describe klass do
         @provider.stubs(:prop_name).returns({ :foo => "baz", :bar => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:inclusive?).returns(true)
-        @property.safe_insync?({ :foo => "baz", :bar => "boo" }).must == true
+        expect(@property.safe_insync?({ :foo => "baz", :bar => "boo" })).to eq(true)
       end
 
       it "should return false if prepared value != should value" do
         @provider.stubs(:prop_name).returns({ "foo" => "bee", "bar" => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:inclusive?).returns(true)
-        @property.safe_insync?({ "foo" => "bee", "bar" => "boo" }).must == false
+        expect(@property.safe_insync?({ "foo" => "bee", "bar" => "boo" })).to eq(false)
       end
     end
   end