enumerize 2.4.0 → 2.5.0

data/test/attribute_test.rb

@@ -13,33 +13,33 @@ describe Enumerize::Attribute do
 
   it 'returns values' do
     build_attr nil, :foo, :in => [:a, :b]
-    attr.values.must_equal %w[a b]
+    expect(attr.values).must_equal %w[a b]
   end
 
   it 'returns frozen values' do
     build_attr nil, :foo, :in => [:a, :b]
-    attr.values.map(&:frozen?).must_equal [true, true]
+    expect(attr.values.map(&:frozen?)).must_equal [true, true]
   end
 
   it 'converts name to symbol' do
     build_attr nil, 'foo', :in => %w[a b]
-    attr.name.must_equal :foo
+    expect(attr.name).must_equal :foo
   end
 
   it 'uses custom value class' do
     value_class = Class.new(Enumerize::Value)
     build_attr nil, 'foo', :in => %w[a b], :value_class => value_class
-    attr.values.first.must_be_instance_of value_class
+    expect(attr.values.first).must_be_instance_of value_class
   end
 
   describe 'i18n scopes' do
     it 'returns scopes from options' do
       build_attr nil, 'foo', :in => %w[a b], :i18n_scope => %w[bar buzz]
-      attr.i18n_scopes.must_equal %w[bar buzz]
+      expect(attr.i18n_scopes).must_equal %w[bar buzz]
     end
 
     it 'accepts only string scopes' do
-      proc { build_attr nil, 'foo', :in => %w[a b], :i18n_scope => [%w[bar buzz], "bar.buzz"] }.must_raise ArgumentError
+      expect(proc { build_attr nil, 'foo', :in => %w[a b], :i18n_scope => [%w[bar buzz], "bar.buzz"] }).must_raise ArgumentError
     end
   end
 
@@ -47,32 +47,32 @@ describe Enumerize::Attribute do
     it 'returns all options for select' do
       store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
         build_attr nil, :foo, :in => %w[a b]
-        attr.options.must_equal [['a text', 'a'], ['b text', 'b']]
+        expect(attr.options).must_equal [['a text', 'a'], ['b text', 'b']]
       end
     end
 
     it 'returns requested options for select via :only' do
       store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
         build_attr nil, :foo, :in => %w[a b]
-        attr.options(:only => :a).must_equal [['a text', 'a']]
-        attr.options(:only => [:b]).must_equal [['b text', 'b']]
-        attr.options(:only => []).must_equal []
+        expect(attr.options(:only => :a)).must_equal [['a text', 'a']]
+        expect(attr.options(:only => [:b])).must_equal [['b text', 'b']]
+        expect(attr.options(:only => [])).must_equal []
       end
     end
 
     it 'returns requested options for select via :except' do
       store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
         build_attr nil, :foo, :in => %w[a b]
-        attr.options(:except => :a).must_equal [['b text', 'b']]
-        attr.options(:except => :b).must_equal [['a text', 'a']]
-        attr.options(:except => []).must_equal [['a text', 'a'], ['b text', 'b']]
+        expect(attr.options(:except => :a)).must_equal [['b text', 'b']]
+        expect(attr.options(:except => :b)).must_equal [['a text', 'a']]
+        expect(attr.options(:except => [])).must_equal [['a text', 'a'], ['b text', 'b']]
       end
     end
 
     it 'does not work with both :only and :except' do
       store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
         build_attr nil, :foo, :in => %w[a b]
-        proc { attr.options(:except => [], :only => []) }.must_raise ArgumentError
+        expect(proc { attr.options(:except => [], :only => []) }).must_raise ArgumentError
       end
     end
   end
@@ -83,25 +83,25 @@ describe Enumerize::Attribute do
     end
 
     it 'returns hash keys as values' do
-      attr.values.must_equal %w[a b]
+      expect(attr.values).must_equal %w[a b]
     end
 
     it 'finds values by hash values' do
-      attr.find_value(1).must_equal 'a'
-      attr.find_value(2).must_equal 'b'
+      expect(attr.find_value(1)).must_equal 'a'
+      expect(attr.find_value(2)).must_equal 'b'
     end
   end
 
   it 'sets up shortcut methods for each value' do
     build_attr nil, :foo, :in => {:a => 1, :b => 2}
 
-    attr.must_respond_to :a
-    attr.must_respond_to :b
+    expect(attr).must_respond_to :a
+    expect(attr).must_respond_to :b
 
-    attr.a.value.must_equal 1
-    attr.b.value.must_equal 2
-    attr.a.text.must_equal 'A'
-    attr.b.text.must_equal 'B'
+    expect(attr.a.value).must_equal 1
+    expect(attr.b.value).must_equal 2
+    expect(attr.a.text).must_equal 'A'
+    expect(attr.b.text).must_equal 'B'
   end
 
   describe 'values hash with zero' do
@@ -110,17 +110,17 @@ describe Enumerize::Attribute do
     end
 
     it 'returns hash keys as values' do
-      attr.values.must_equal %w[a b c]
+      expect(attr.values).must_equal %w[a b c]
     end
 
     it 'finds values by hash values' do
-      attr.find_value(1).must_equal 'a'
-      attr.find_value(2).must_equal 'b'
-      attr.find_value(0).must_equal 'c'
+      expect(attr.find_value(1)).must_equal 'a'
+      expect(attr.find_value(2)).must_equal 'b'
+      expect(attr.find_value(0)).must_equal 'c'
     end
 
     it 'finds all values by hash values' do
-      attr.find_values(1, 2, 0).must_equal ['a', 'b', 'c']
+      expect(attr.find_values(1, 2, 0)).must_equal ['a', 'b', 'c']
     end
   end
 
@@ -130,12 +130,12 @@ describe Enumerize::Attribute do
     end
 
     it 'returns hash keys as values' do
-      attr.values.must_equal %w[a b]
+      expect(attr.values).must_equal %w[a b]
     end
 
     it 'finds values by hash values' do
-      attr.find_value(true).must_equal 'a'
-      attr.find_value(false).must_equal 'b'
+      expect(attr.find_value(true)).must_equal 'a'
+      expect(attr.find_value(false)).must_equal 'b'
     end
   end
 end

data/test/base_test.rb

@@ -17,29 +17,29 @@ describe Enumerize::Base do
 
   it 'returns nil when not set' do
     kklass.enumerize(:foo, :in => [:a, :b])
-    object.foo.must_be_nil
+    expect(object.foo).must_be_nil
   end
 
   it 'returns value that was set' do
     kklass.enumerize(:foo, :in => [:a, :b])
     object.foo = :a
-    object.foo.must_equal 'a'
+    expect(object.foo).must_equal 'a'
   end
 
   it 'returns translation' do
     store_translations(:en, :enumerize => {:foo => {:a => 'a text'}}) do
       kklass.enumerize(:foo, :in => [:a, :b])
       object.foo = :a
-      object.foo.text.must_equal 'a text'
-      object.foo_text.must_equal 'a text'
-      object.foo_text.must_equal 'a text'
+      expect(object.foo.text).must_equal 'a text'
+      expect(object.foo_text).must_equal 'a text'
+      expect(object.foo_text).must_equal 'a text'
     end
   end
 
   it 'returns nil as translation when value is nil' do
     store_translations(:en, :enumerize => {:foo => {:a => 'a text'}}) do
       kklass.enumerize(:foo, :in => [:a, :b])
-      object.foo_text.must_be_nil
+      expect(object.foo_text).must_be_nil
     end
   end
 
@@ -56,8 +56,8 @@ describe Enumerize::Base do
     store_translations(:en, :enumerize => {:example_class => {:foo => {:a => 'a text scoped'}}}) do
       kklass.enumerize(:foo, :in => [:a, :b])
       object.foo = :a
-      object.foo.text.must_equal 'a text scoped'
-      object.foo_text.must_equal 'a text scoped'
+      expect(object.foo.text).must_equal 'a text scoped'
+      expect(object.foo_text).must_equal 'a text scoped'
     end
   end
 
@@ -65,88 +65,88 @@ describe Enumerize::Base do
     store_translations(:en, :enumerize => {}) do
       kklass.enumerize(:foo, :in => [:a, :b])
       object.foo = :a
-      object.foo_text.must_equal 'A'
+      expect(object.foo_text).must_equal 'A'
     end
   end
 
   it 'stores value as string' do
     kklass.enumerize(:foo, :in => [:a, :b])
     object.foo = :a
-    object.instance_variable_get(:@foo).must_be_instance_of String
+    expect(object.instance_variable_get(:@foo)).must_be_instance_of String
   end
 
   it 'handles default value' do
     kklass.enumerize(:foo, :in => [:a, :b], :default => :b)
-    object.foo.must_equal 'b'
+    expect(object.foo).must_equal 'b'
   end
 
   it 'handles default value with lambda' do
     kklass.enumerize(:foo, :in => [:a, :b], :default => lambda { :b })
-    object.foo.must_equal 'b'
+    expect(object.foo).must_equal 'b'
   end
 
   it 'injects object instance into lamda default value' do
     kklass.enumerize(:foo, :in => [:a, :b], :default => lambda { |obj| :b if obj.is_a? kklass })
-    object.foo.must_equal 'b'
+    expect(object.foo).must_equal 'b'
   end
 
   it 'raises exception on invalid default value' do
-    proc {
+    expect(proc {
       kklass.enumerize(:foo, :in => [:a, :b], :default => :c)
-    }.must_raise ArgumentError
+    }).must_raise ArgumentError
   end
 
   it 'has enumerized attributes' do
-    kklass.enumerized_attributes.must_be_empty
+    expect(kklass.enumerized_attributes).must_be_empty
     kklass.enumerize(:foo, :in => %w[a b])
-    kklass.enumerized_attributes[:foo].must_be_instance_of Enumerize::Attribute
+    expect(kklass.enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
   end
 
   it "doesn't override existing method" do
     method = kklass.method(:name)
     kklass.enumerize(:name, :in => %w[a b], :default => 'a')
-    kklass.method(:name).must_equal method
+    expect(kklass.method(:name)).must_equal method
   end
 
   it "inherits enumerized attributes from a parent class" do
     kklass.enumerize(:foo, :in => %w[a b])
-    subklass.enumerized_attributes[:foo].must_be_instance_of Enumerize::Attribute
+    expect(subklass.enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
   end
 
   it "inherits enumerized attributes from a grandparent class" do
     kklass.enumerize(:foo, :in => %w[a b])
-    Class.new(subklass).enumerized_attributes[:foo].must_be_instance_of Enumerize::Attribute
+    expect(Class.new(subklass).enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
   end
 
   it "doesn't add enumerized attributes to parent class" do
     kklass.enumerize(:foo, :in => %w[a b])
     subklass.enumerize(:bar, :in => %w[c d])
 
-    kklass.enumerized_attributes[:bar].must_be_nil
+    expect(kklass.enumerized_attributes[:bar]).must_be_nil
   end
 
   it 'adds new parent class attributes to subclass' do
     subklass = Class.new(kklass)
     kklass.enumerize :foo, :in => %w[a b]
-    subklass.enumerized_attributes[:foo].must_be_instance_of Enumerize::Attribute
+    expect(subklass.enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
   end
 
   it 'stores nil value' do
     kklass.enumerize(:foo, :in => [:a, :b])
     object.foo = nil
-    object.instance_variable_get(:@foo).must_be_nil
+    expect(object.instance_variable_get(:@foo)).must_be_nil
   end
 
   it 'casts value to string for validation' do
     kklass.enumerize(:foo, :in => [:a, :b])
     object.foo = :c
-    object.read_attribute_for_validation(:foo).must_equal 'c'
+    expect(object.read_attribute_for_validation(:foo)).must_equal 'c'
   end
 
   it "doesn't cast nil to string for validation" do
     kklass.enumerize(:foo, :in => [:a, :b])
     object.foo = nil
-    object.read_attribute_for_validation(:foo).must_be_nil
+    expect(object.read_attribute_for_validation(:foo)).must_be_nil
   end
 
   it 'calls super in the accessor method' do
@@ -172,33 +172,33 @@ describe Enumerize::Base do
     end
 
     object = klass.new
-    object.foo.must_be_nil
-    object.attributes.must_equal({})
+    expect(object.foo).must_be_nil
+    expect(object.attributes).must_equal({})
 
     object.foo = 'test'
-    object.foo.must_equal 'test'
-    object.attributes.must_equal(:foo => 'test')
+    expect(object.foo).must_equal 'test'
+    expect(object.attributes).must_equal(:foo => 'test')
   end
 
   it 'stores hash values' do
     kklass.enumerize(:foo, :in => {:a => 1, :b => 2})
 
     object.foo = :a
-    object.instance_variable_get(:@foo).must_equal 1
-    object.foo.must_equal 'a'
+    expect(object.instance_variable_get(:@foo)).must_equal 1
+    expect(object.foo).must_equal 'a'
 
     object.foo = :b
-    object.instance_variable_get(:@foo).must_equal 2
-    object.foo.must_equal 'b'
+    expect(object.instance_variable_get(:@foo)).must_equal 2
+    expect(object.foo).must_equal 'b'
   end
 
   it 'returns custom value' do
     kklass.enumerize(:foo, :in => {:a => 1, :b => 2})
 
     object.foo = :a
-    object.foo_value.must_equal 1
+    expect(object.foo_value).must_equal 1
 
     object.foo = :b
-    object.foo_value.must_equal 2
+    expect(object.foo_value).must_equal 2
   end
 end

data/test/module_attributes_test.rb

@@ -11,9 +11,9 @@ class ModuleAttributesSpec < MiniTest::Spec
 
     klass = Class.new
     klass.send :include, mod
-    klass.enumerized_attributes[:sex].must_be_instance_of Enumerize::Attribute
-    klass.new.sex.must_equal 'male'
-    klass.sex.must_be_instance_of Enumerize::Attribute
+    expect(klass.enumerized_attributes[:sex]).must_be_instance_of Enumerize::Attribute
+    expect(klass.new.sex).must_equal 'male'
+    expect(klass.sex).must_be_instance_of Enumerize::Attribute
   end
 
   it 'uses new attributes from the module' do
@@ -24,9 +24,9 @@ class ModuleAttributesSpec < MiniTest::Spec
     klass = Class.new
     klass.send :include, mod
     mod.enumerize :sex, :in => %w[male female], :default => 'male'
-    klass.enumerized_attributes[:sex].must_be_instance_of Enumerize::Attribute
-    klass.new.sex.must_equal 'male'
-    klass.sex.must_be_instance_of Enumerize::Attribute
+    expect(klass.enumerized_attributes[:sex]).must_be_instance_of Enumerize::Attribute
+    expect(klass.new.sex).must_equal 'male'
+    expect(klass.sex).must_be_instance_of Enumerize::Attribute
   end
 
   it 'validates attributes' do
@@ -46,7 +46,7 @@ class ModuleAttributesSpec < MiniTest::Spec
 
     object = klass.new
     object.sex = 'wrong'
-    object.wont_be :valid?
-    object.errors[:sex].must_include 'is not included in the list'
+    expect(object).wont_be :valid?
+    expect(object.errors[:sex]).must_include 'is not included in the list'
   end
 end

data/test/mongo_mapper_test.rb

@@ -32,7 +32,7 @@ describe Enumerize do
   it 'sets nil if invalid value is passed' do
     user = model.new
     user.sex = :invalid
-    user.sex.must_be_nil
+    expect(user.sex).must_be_nil
   end
 
   it 'saves value' do
@@ -40,7 +40,7 @@ describe Enumerize do
     user = model.new
     user.sex = :female
     user.save!
-    user.sex.must_equal 'female'
+    expect(user.sex).must_equal 'female'
   end
 
   it 'loads value' do
@@ -48,25 +48,25 @@ describe Enumerize do
     model.create!(:sex => :male)
     store_translations(:en, :enumerize => {:sex => {:male => 'Male'}}) do
       user = model.first
-      user.sex.must_equal 'male'
-      user.sex_text.must_equal 'Male'
+      expect(user.sex).must_equal 'male'
+      expect(user.sex_text).must_equal 'Male'
     end
   end
 
   it 'has default value' do
-    model.new.role.must_equal 'user'
+    expect(model.new.role).must_equal 'user'
   end
 
   it 'validates inclusion' do
     user = model.new
     user.role = 'wrong'
-    user.wont_be :valid?
+    expect(user).wont_be :valid?
   end
 
   it 'does not validate inclusion when :skip_validations option passed' do
     user = model.new
     user.foo = 'wrong'
-    user.must_be :valid?
+    expect(user).must_be :valid?
   end
 
   it 'assigns value on loaded record' do
@@ -74,7 +74,7 @@ describe Enumerize do
     model.create!(:sex => :male)
     user = model.first
     user.sex = :female
-    user.sex.must_equal 'female'
+    expect(user.sex).must_equal 'female'
   end
 end
 

data/test/mongoid_test.rb

@@ -40,7 +40,7 @@ describe Enumerize do
   it 'sets nil if invalid value is passed' do
     user = model.new
     user.sex = :invalid
-    user.sex.must_be_nil
+    expect(user.sex).must_be_nil
   end
 
   it 'saves value' do
@@ -48,7 +48,7 @@ describe Enumerize do
     user = model.new
     user.sex = :female
     user.save!
-    user.sex.must_equal 'female'
+    expect(user.sex).must_equal 'female'
   end
 
   it 'loads value' do
@@ -56,13 +56,13 @@ describe Enumerize do
     model.create!(:sex => :male)
     store_translations(:en, :enumerize => {:sex => {:male => 'Male'}}) do
       user = model.first
-      user.sex.must_equal 'male'
-      user.sex_text.must_equal 'Male'
+      expect(user.sex).must_equal 'male'
+      expect(user.sex_text).must_equal 'Male'
     end
   end
 
   it 'has default value' do
-    model.new.role.must_equal 'user'
+    expect(model.new.role).must_equal 'user'
   end
 
   it 'uses after_initialize callback to set default value' do
@@ -70,7 +70,7 @@ describe Enumerize do
     model.create!(sex: 'male', role: nil)
 
     user = model.where(sex: 'male').first
-    user.role.must_equal 'user'
+    expect(user.role).must_equal 'user'
   end
 
   it 'does not set default value for not selected attributes' do
@@ -83,21 +83,21 @@ describe Enumerize do
   it 'validates inclusion' do
     user = model.new
     user.role = 'wrong'
-    user.wont_be :valid?
+    expect(user).wont_be :valid?
   end
 
   it 'does not validate inclusion when :skip_validations option passed' do
     user = model.new
     user.foo = 'wrong'
-    user.must_be :valid?
+    expect(user).must_be :valid?
   end
 
   it 'sets value to enumerized field from db when record is reloaded' do
     user = model.create!(mult: [:one])
     model.find(user.id).update(mult: %i[two three])
-    user.mult.must_equal %w[one]
+    expect(user.mult).must_equal %w[one]
     user.reload
-    user.mult.must_equal %w[two three]
+    expect(user.mult).must_equal %w[two three]
   end
 
   it 'assigns value on loaded record' do
@@ -105,7 +105,7 @@ describe Enumerize do
     model.create!(:sex => :male)
     user = model.first
     user.sex = :female
-    user.sex.must_equal 'female'
+    expect(user.sex).must_equal 'female'
   end
 
   it 'loads multiple properly' do
@@ -113,29 +113,32 @@ describe Enumerize do
 
     model.create!(:mult => ['one', 'two'])
     user = model.first
-    user.mult.to_a.must_equal ['one', 'two']
+    expect(user.mult.to_a).must_equal ['one', 'two']
   end
 
   it 'adds scope' do
     model.delete_all
 
-    user_1 = model.create!(sex: :male, role: :admin)
-    user_2 = model.create!(sex: :female, role: :user)
+    user_1 = model.create!(sex: :male, skill: :noob, role: :admin, account_type: :basic)
+    user_2 = model.create!(sex: :female, skill: :noob, role: :user, account_type: :basic)
     user_3 = model.create!(skill: :pro, account_type: :premium)
 
-    model.with_sex(:male).to_a.must_equal [user_1]
-    model.with_sex(:female).to_a.must_equal [user_2]
-    model.with_sex(:male, :female).to_set.must_equal [user_1, user_2].to_set
+    expect(model.with_sex(:male).to_a).must_equal [user_1]
+    expect(model.with_sex(:female).to_a).must_equal [user_2]
+    expect(model.with_sex(:male, :female).to_set).must_equal [user_1, user_2].to_set
 
-    model.without_sex(:male).to_set.must_equal [user_2, user_3].to_set
-    model.without_sex(:female).to_set.must_equal [user_1, user_3].to_set
-    model.without_sex(:male, :female).to_a.must_equal [user_3]
+    expect(model.without_sex(:male).to_set).must_equal [user_2, user_3].to_set
+    expect(model.without_sex(:female).to_set).must_equal [user_1, user_3].to_set
+    expect(model.without_sex(:male, :female).to_a).must_equal [user_3]
 
-    model.having_role(:admin).to_a.must_equal [user_1]
-    model.having_role(:user).to_a.must_equal [user_2, user_3]
+    expect(model.having_role(:admin).to_a).must_equal [user_1]
+    expect(model.having_role(:user).to_a).must_equal [user_2, user_3]
 
-    model.pro.to_a.must_equal [user_3]
-    model.premium.to_a.must_equal [user_3]
+    expect(model.pro.to_a).must_equal [user_3]
+    expect(model.premium.to_a).must_equal [user_3]
+
+    expect(model.not_pro.to_set).must_equal [user_1, user_2].to_set
+    expect(model.not_premium.to_set).must_equal [user_1, user_2].to_set
   end
 
   it 'chains scopes' do
@@ -145,14 +148,14 @@ describe Enumerize do
     user_2 = model.create!(status: :warning)
     user_3 = model.create!(status: :error)
 
-    model.with_status(:notice, :warning).with_status(:notice, :error).to_a.must_equal [user_1]
-    model.with_status(:notice, :warning).union.with_status(:notice, :error).to_a.must_equal [user_1, user_2, user_3]
+    expect(model.with_status(:notice, :warning).with_status(:notice, :error).to_a).must_equal [user_1]
+    expect(model.with_status(:notice, :warning).union.with_status(:notice, :error).to_a).must_equal [user_1, user_2, user_3]
   end
 
   it 'ignores not enumerized values that passed to the scope method' do
     model.delete_all
 
-    model.with_sex(:foo).must_equal []
+    expect(model.with_sex(:foo)).must_equal []
   end
 end
 

data/test/multiple_test.rb

@@ -17,38 +17,38 @@ describe Enumerize::Base do
 
   it 'returns [] when not set' do
     kklass.enumerize :foos, in: %w(a b), multiple: true
-    object.foos.must_equal []
+    expect(object.foos).must_equal []
   end
 
   it 'returns setted array' do
     kklass.enumerize :foos, in: %w(a b c), multiple: true
     object.foos = %w(a c)
-    object.foos.must_equal %w(a c)
+    expect(object.foos).must_equal %w(a c)
   end
 
   it 'sets default value as single value' do
     kklass.enumerize :foos, in: %w(a b c), default: 'b', multiple: true
-    object.foos.must_equal %w(b)
+    expect(object.foos).must_equal %w(b)
   end
 
   it 'sets default value as array of one element' do
     kklass.enumerize :foos, in: %w(a b c), default: %w(b), multiple: true
-    object.foos.must_equal %w(b)
+    expect(object.foos).must_equal %w(b)
   end
 
   it 'sets default value as array of several elements' do
     kklass.enumerize :foos, in: %w(a b c), default: %w(b c), multiple: true
-    object.foos.must_equal %w(b c)
+    expect(object.foos).must_equal %w(b c)
   end
 
   it "doesn't define _text method" do
     kklass.enumerize :foos, in: %w(a b c), multiple: true
-    object.wont_respond_to :foos_text
+    expect(object).wont_respond_to :foos_text
   end
 
   it "doesn't define _value method" do
     kklass.enumerize :foos, in: %w(a b c), multiple: true
-    object.wont_respond_to :foos_value
+    expect(object).wont_respond_to :foos_value
   end
 
   it "cannot define multiple with scope" do
@@ -60,6 +60,6 @@ describe Enumerize::Base do
   it 'assign a name with the first letter capitalized' do
     kklass.enumerize :Foos, in: %w(a b c), multiple: true
     object.Foos = %w(a c)
-    object.Foos.must_equal %w(a c)
+    expect(object.Foos).must_equal %w(a c)
   end
 end