disposable 0.4.6 → 0.4.7

data/test/expose_test.rb

@@ -24,8 +24,8 @@ class ExposeTest < MiniTest::Spec
 
   describe "readers" do
     it  do
-      subject.id.must_equal 1
-      subject.title.must_equal "Dick Sandwich"
+      expect(subject.id).must_equal 1
+      expect(subject.title).must_equal "Dick Sandwich"
     end
   end
 
@@ -35,10 +35,10 @@ class ExposeTest < MiniTest::Spec
       subject.id = 3
       subject.title = "Eclipse"
 
-      subject.id.must_equal 3
-      subject.title.must_equal "Eclipse"
-      album.id.must_equal 3
-      album.name.must_equal "Eclipse"
+      expect(subject.id).must_equal 3
+      expect(subject.title).must_equal "Eclipse"
+      expect(album.id).must_equal 3
+      expect(album.name).must_equal "Eclipse"
     end
   end
 end
@@ -69,9 +69,9 @@ class ExposeCompositionTest < MiniTest::Spec
 
 
   describe "readers" do
-    it { subject.id.must_equal 2 }
-    it { subject.band_id.must_equal 1 }
-    it { subject.name.must_equal "Dick Sandwich" }
+    it { expect(subject.id).must_equal 2 }
+    it { expect(subject.band_id).must_equal 1 }
+    it { expect(subject.name).must_equal "Dick Sandwich" }
   end
 
 
@@ -81,12 +81,12 @@ class ExposeCompositionTest < MiniTest::Spec
       subject.band_id = 4
       subject.name = "Eclipse"
 
-      subject.id.must_equal 3
-      subject.band_id.must_equal 4
-      subject.name.must_equal "Eclipse"
-      band.id.must_equal 4
-      album.id.must_equal 3
-      album.name.must_equal "Eclipse"
+      expect(subject.id).must_equal 3
+      expect(subject.band_id).must_equal 4
+      expect(subject.name).must_equal "Eclipse"
+      expect(band.id).must_equal 4
+      expect(album.id).must_equal 3
+      expect(album.name).must_equal "Eclipse"
     end
   end
-end
+end

data/test/persisted_test.rb

@@ -29,36 +29,36 @@ class PersistedTest < MiniTest::Spec
     album   = Album.new(artist: artist, songs: [ex_song, song])
 
 
-    artist.persisted?.must_equal false
-    album.persisted?.must_equal false
-    ex_song.persisted?.must_equal true
-    song.persisted?.must_equal false
+    expect(artist.persisted?).must_equal false
+    expect(album.persisted?).must_equal false
+    expect(ex_song.persisted?).must_equal true
+    expect(song.persisted?).must_equal false
 
     twin = AlbumTwin.new(album)
-    twin.persisted?.must_equal false
-    twin.changed?(:persisted?).must_equal false
-    twin.artist.persisted?.must_equal false
-    twin.artist.changed?(:persisted?).must_equal false
-    twin.songs[0].persisted?.must_equal true
-    twin.songs[0].changed?(:persisted?).must_equal false
-    twin.songs[1].persisted?.must_equal false
-    twin.songs[1].changed?(:persisted?).must_equal false
+    expect(twin.persisted?).must_equal false
+    expect(twin.changed?(:persisted?)).must_equal false
+    expect(twin.artist.persisted?).must_equal false
+    expect(twin.artist.changed?(:persisted?)).must_equal false
+    expect(twin.songs[0].persisted?).must_equal true
+    expect(twin.songs[0].changed?(:persisted?)).must_equal false
+    expect(twin.songs[1].persisted?).must_equal false
+    expect(twin.songs[1].changed?(:persisted?)).must_equal false
 
     twin.save
 
-    artist.persisted?.must_equal true
-    album.persisted?.must_equal true
-    ex_song.persisted?.must_equal true
-    song.persisted?.must_equal true
-
-    twin.persisted?.must_equal true
-    twin.changed?(:persisted?).must_equal true
-    twin.artist.persisted?.must_equal true
-    twin.artist.changed?(:persisted?).must_equal true
-    twin.songs[0].persisted?.must_equal true
-    twin.songs[0].changed?(:persisted?).must_equal false
-    twin.songs[1].persisted?.must_equal true
-    twin.songs[1].changed?(:persisted?).must_equal true
+    expect(artist.persisted?).must_equal true
+    expect(album.persisted?).must_equal true
+    expect(ex_song.persisted?).must_equal true
+    expect(song.persisted?).must_equal true
+
+    expect(twin.persisted?).must_equal true
+    expect(twin.changed?(:persisted?)).must_equal true
+    expect(twin.artist.persisted?).must_equal true
+    expect(twin.artist.changed?(:persisted?)).must_equal true
+    expect(twin.songs[0].persisted?).must_equal true
+    expect(twin.songs[0].changed?(:persisted?)).must_equal false
+    expect(twin.songs[1].persisted?).must_equal true
+    expect(twin.songs[1].changed?(:persisted?)).must_equal true
   end
 
 
@@ -66,17 +66,17 @@ class PersistedTest < MiniTest::Spec
     it do
       twin = AlbumTwin.new(Album.new)
 
-      twin.created?.must_equal false
+      expect(twin.created?).must_equal false
       twin.save
-      twin.created?.must_equal true
+      expect(twin.created?).must_equal true
     end
 
     it do
       twin = AlbumTwin.new(Album.create)
 
-      twin.created?.must_equal false
+      expect(twin.created?).must_equal false
       twin.save
-      twin.created?.must_equal false
+      expect(twin.created?).must_equal false
     end
   end
 
@@ -98,4 +98,4 @@ class PersistedTest < MiniTest::Spec
   #     twin.updated?.must_equal true
   #   end
   # end
-end
+end

data/test/rescheme_test.rb

@@ -37,22 +37,22 @@ class ReschemeTest < MiniTest::Spec
     )
 
     # include: works.
-    decorator.new(nil).hello.must_equal "hello"
-    decorator.new(nil).ciao.must_equal "ciao"
+    expect(decorator.new(nil).hello).must_equal "hello"
+    expect(decorator.new(nil).ciao).must_equal "ciao"
 
-    decorator.representable_attrs.get(:id).inspect.must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[]}>"
-    decorator.representable_attrs.get(:title).inspect.must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :deserializer=>{:skip_parse=>\"skip lambda\"}, :name=>\"title\", :parse_filter=>[], :render_filter=>[], :skip_parse=>\"skip lambda\"}>"
+    expect(decorator.representable_attrs.get(:id).inspect).must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:title).inspect).must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :deserializer=>{:skip_parse=>\"skip lambda\"}, :name=>\"title\", :parse_filter=>[], :render_filter=>[], :skip_parse=>\"skip lambda\"}>"
 
     songs = decorator.representable_attrs.get(:songs)
     options = songs.instance_variable_get(:@options)
     options[:nested].extend(Declarative::Inspect)
-    options.inspect.must_equal "{:readable=>false, :deserializer=>{:skip_parse=>\"another lambda\", :music=>true, :writeable=>false}, :nested=>#<Class:>, :extend=>#<Class:>, :name=>\"songs\", :parse_filter=>[], :render_filter=>[], :skip_parse=>\"another lambda\", :music=>true, :writeable=>false}"
+    expect(options.inspect).must_equal "{:readable=>false, :deserializer=>{:skip_parse=>\"another lambda\", :music=>true, :writeable=>false}, :nested=>#<Class:>, :extend=>#<Class:>, :name=>\"songs\", :parse_filter=>[], :render_filter=>[], :skip_parse=>\"another lambda\", :music=>true, :writeable=>false}"
 
     # nested works.
-    options[:nested].new(nil).hello.must_equal "hello"
-    options[:nested].new(nil).ciao.must_equal "ciao"
+    expect(options[:nested].new(nil).hello).must_equal "hello"
+    expect(options[:nested].new(nil).ciao).must_equal "ciao"
 
-    options[:nested].representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :deserializer=>{:skip_parse=>\"a crazy cool instance method\"}, :name=>\"name\", :parse_filter=>[], :render_filter=>[], :skip_parse=>\"a crazy cool instance method\"}>"
+    expect(options[:nested].representable_attrs.get(:name).inspect).must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :deserializer=>{:skip_parse=>\"a crazy cool instance method\"}, :name=>\"name\", :parse_filter=>[], :render_filter=>[], :skip_parse=>\"a crazy cool instance method\"}>"
   end
 
   # :options_from and :include is optional
@@ -61,8 +61,8 @@ class ReschemeTest < MiniTest::Spec
       definitions_from: lambda { |nested| nested.definitions }
     )
 
-    decorator.representable_attrs.get(:id).inspect.must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[]}>"
-    decorator.representable_attrs.get(:title).inspect.must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :deserializer=>{:skip_parse=>\"skip lambda\"}, :name=>\"title\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:id).inspect).must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:title).inspect).must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :deserializer=>{:skip_parse=>\"skip lambda\"}, :name=>\"title\", :parse_filter=>[], :render_filter=>[]}>"
   end
 
 
@@ -73,9 +73,9 @@ class ReschemeTest < MiniTest::Spec
       exclude_options: [:deserializer]
     )
 
-    decorator.representable_attrs.get(:id).inspect.must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[]}>"
-    decorator.representable_attrs.get(:title).inspect.must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :name=>\"title\", :parse_filter=>[], :render_filter=>[]}>"
-    decorator.representable_attrs.get(:songs).representer_module.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :name=>\"name\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:id).inspect).must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:title).inspect).must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :name=>\"title\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:songs).representer_module.representable_attrs.get(:name).inspect).must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :name=>\"name\", :parse_filter=>[], :render_filter=>[]}>"
   end
 
 
@@ -85,8 +85,8 @@ class ReschemeTest < MiniTest::Spec
       definitions_from: lambda { |nested| nested.definitions },
     ) { |dfn| dfn.merge!(amazing: true) }
 
-    decorator.representable_attrs.get(:id).inspect.must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[], :amazing=>true}>"
-    decorator.representable_attrs.get(:songs).representer_module.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :deserializer=>{:skip_parse=>\"a crazy cool instance method\"}, :name=>\"name\", :parse_filter=>[], :render_filter=>[], :amazing=>true}>"
+    expect(decorator.representable_attrs.get(:id).inspect).must_equal "#<Representable::Definition ==>id @options={:name=>\"id\", :parse_filter=>[], :render_filter=>[], :amazing=>true}>"
+    expect(decorator.representable_attrs.get(:songs).representer_module.representable_attrs.get(:name).inspect).must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :deserializer=>{:skip_parse=>\"a crazy cool instance method\"}, :name=>\"name\", :parse_filter=>[], :render_filter=>[], :amazing=>true}>"
   end
 
   it "recursive: false only copies first level" do
@@ -97,8 +97,8 @@ class ReschemeTest < MiniTest::Spec
       exclude_options: [:deserializer]
     )
 
-    decorator.representable_attrs.get(:title).inspect.must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :name=>\"title\", :parse_filter=>[], :render_filter=>[]}>"
-    decorator.representable_attrs.get(:songs).representer_module.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :deserializer=>{:skip_parse=>\"a crazy cool instance method\"}, :name=>\"name\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:title).inspect).must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :name=>\"title\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(decorator.representable_attrs.get(:songs).representer_module.representable_attrs.get(:name).inspect).must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :deserializer=>{:skip_parse=>\"a crazy cool instance method\"}, :name=>\"name\", :parse_filter=>[], :render_filter=>[]}>"
   end
 
   describe ":exclude_properties" do
@@ -121,8 +121,8 @@ class ReschemeTest < MiniTest::Spec
         exclude_properties: [:id]
       )
 
-      decorator.definitions.keys.must_equal ["songs"]
-      decorator.definitions.get(:songs).representer_module.definitions.keys.must_equal ["name"]
+      expect(decorator.definitions.keys).must_equal ["songs"]
+      expect(decorator.definitions.get(:songs).representer_module.definitions.keys).must_equal ["name"]
     end
   end
 end
@@ -145,8 +145,8 @@ class TwinReschemeTest < MiniTest::Spec
     artist = decorator.representable_attrs.get(:artist)
     options = artist.instance_variable_get(:@options)
     nested_extend = options[:nested]
-    options.extend(Declarative::Inspect).inspect.must_equal "{:private_name=>:artist, :nested=>#<Class:>, :name=>\"artist\", :extend=>#<Class:>, :parse_filter=>[], :render_filter=>[]}"
+    expect(options.extend(Declarative::Inspect).inspect).must_equal "{:private_name=>:artist, :nested=>#<Class:>, :name=>\"artist\", :extend=>#<Class:>, :parse_filter=>[], :render_filter=>[]}"
     assert nested_extend < Representable::Decorator
-    nested_extend.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:private_name=>:name, :name=>\"name\", :parse_filter=>[], :render_filter=>[]}>"
+    expect(nested_extend.representable_attrs.get(:name).inspect).must_equal "#<Representable::Definition ==>name @options={:private_name=>:name, :name=>\"name\", :parse_filter=>[], :render_filter=>[]}>"
   end
-end
+end

data/test/skip_getter_test.rb

@@ -26,20 +26,20 @@ class SkipGetterTest < MiniTest::Spec
     album = Album.new("Wild Frontier", Artist.new("Gary Moore"))
     twin  = AlbumTwin.new(album)
 
-    twin.title.must_equal "reitnorF dliW"
-    twin.artist.name.must_equal "GARY MOORE"
+    expect(twin.title).must_equal "reitnorF dliW"
+    expect(twin.artist.name).must_equal "GARY MOORE"
 
     twin.sync # does NOT call getter.
 
-    album.title.must_equal "Wild Frontier"
-    album.artist.name.must_equal "Gary Moore"
+    expect(album.title).must_equal "Wild Frontier"
+    expect(album.artist.name).must_equal "Gary Moore"
 
     # nested hash.
     nested_hash = nil
     twin.sync do |hash|
       nested_hash = hash
     end
-    nested_hash.must_equal({"title"=>"Wild Frontier", "artist"=>{"name"=>"Gary Moore"}})
+    expect(nested_hash).must_equal({"title"=>"Wild Frontier", "artist"=>{"name"=>"Gary Moore"}})
   end
 end
 
@@ -68,8 +68,8 @@ class SkipSetterTest < MiniTest::Spec
   it do
     twin = AlbumTwin.new(Album.new("Wild Frontier", Artist.new("Gary Moore")))
 
-    twin.title.must_equal "Wild Frontier"
-    twin.artist.name.must_equal "Gary Moore"
+    expect(twin.title).must_equal "Wild Frontier"
+    expect(twin.artist.name).must_equal "Gary Moore"
   end
 end
 
@@ -111,18 +111,18 @@ class SkipGetterAndSetterWithChangedTest < MiniTest::Spec
     twin  = AlbumTwin.new(album) # does not call getter (Changed).
 
 
-    twin.title.must_equal "reitnorF dliW"
-    twin.artist.name.must_equal "GARY MOORE"
+    expect(twin.title).must_equal "reitnorF dliW"
+    expect(twin.artist.name).must_equal "GARY MOORE"
 
-    twin.changed?.must_equal false
-    twin.artist.changed?.must_equal false
+    expect(twin.changed?).must_equal false
+    expect(twin.artist.changed?).must_equal false
 
     twin.title = "Self-Entitled"
     twin.artist.name = "Nofx"
 
     twin.sync # does NOT call getter.
 
-    album.title.must_equal "deltitnE-fleS"
-    album.artist.name.must_equal "Nof"
+    expect(album.title).must_equal "deltitnE-fleS"
+    expect(album.artist.name).must_equal "Nof"
   end
-end
+end

data/test/twin/builder_test.rb

@@ -26,7 +26,7 @@ class BuilderTest < MiniTest::Spec
   end
 
 
-  it { Twin.build(Model::Song.new).must_be_instance_of Twin }
-  it { Twin.build(Model::Hit.new).must_be_instance_of  Hit }
-  it { Twin.build(Model::Evergreen.new, evergreen: true).must_be_instance_of Evergreen }
+  it { expect(Twin.build(Model::Song.new)).must_be_instance_of Twin }
+  it { expect(Twin.build(Model::Hit.new)).must_be_instance_of  Hit }
+  it { expect(Twin.build(Model::Evergreen.new, evergreen: true)).must_be_instance_of Evergreen }
 end

data/test/twin/changed_test.rb

@@ -39,19 +39,19 @@ class ChangedWithSetupTest < MiniTest::Spec
 
   # setup: changed? is always false
   it do
-    twin.changed?(:name).must_equal false
-    twin.changed?.must_equal false
+    expect(twin.changed?(:name)).must_equal false
+    expect(twin.changed?).must_equal false
 
-    twin.songs[0].changed?.must_equal false
-    twin.songs[0].changed?(:title).must_equal false
-    twin.songs[1].changed?.must_equal false
-    twin.songs[1].changed?(:title).must_equal false
+    expect(twin.songs[0].changed?).must_equal false
+    expect(twin.songs[0].changed?(:title)).must_equal false
+    expect(twin.songs[1].changed?).must_equal false
+    expect(twin.songs[1].changed?(:title)).must_equal false
 
-    twin.songs[1].composer.changed?(:name).must_equal false
-    twin.songs[1].composer.changed?.must_equal false
+    expect(twin.songs[1].composer.changed?(:name)).must_equal false
+    expect(twin.songs[1].composer.changed?).must_equal false
 
-    twin.artist.changed?(:name).must_equal false
-    twin.artist.changed?.must_equal false
+    expect(twin.artist.changed?(:name)).must_equal false
+    expect(twin.artist.changed?).must_equal false
   end
 
   # only when a property is assigned, it's changed.
@@ -62,46 +62,46 @@ class ChangedWithSetupTest < MiniTest::Spec
     twin.songs[1].composer.name= "Ingemar Jansson & Mikael Danielsson"
     twin.artist.name = "No Fun At All"
 
-    twin.changed?(:name).must_equal true
-    twin.changed?.must_equal true
+    expect(twin.changed?(:name)).must_equal true
+    expect(twin.changed?).must_equal true
 
-    twin.songs[0].changed?.must_equal true
-    twin.songs[0].changed?(:title).must_equal true
-    twin.songs[1].changed?.must_equal true
-    twin.songs[1].changed?(:title).must_equal true
+    expect(twin.songs[0].changed?).must_equal true
+    expect(twin.songs[0].changed?(:title)).must_equal true
+    expect(twin.songs[1].changed?).must_equal true
+    expect(twin.songs[1].changed?(:title)).must_equal true
 
-    twin.songs[1].composer.changed?(:name).must_equal true
-    twin.songs[1].composer.changed?.must_equal true
+    expect(twin.songs[1].composer.changed?(:name)).must_equal true
+    expect(twin.songs[1].composer.changed?).must_equal true
 
-    twin.artist.changed?(:name).must_equal true
-    twin.artist.changed?.must_equal true
+    expect(twin.artist.changed?(:name)).must_equal true
+    expect(twin.artist.changed?).must_equal true
 
     # you can also ask for nested twins by name.
-    twin.changed?(:songs).must_equal true
-    twin.songs[0].changed?(:composer).must_equal false
-    twin.songs[1].changed?(:composer).must_equal true
-    twin.changed?(:artist).must_equal true
+    expect(twin.changed?(:songs)).must_equal true
+    expect(twin.songs[0].changed?(:composer)).must_equal false
+    expect(twin.songs[1].changed?(:composer)).must_equal true
+    expect(twin.changed?(:artist)).must_equal true
   end
 
   # nested changes should propagate up.
   it do
-    twin.changed?.must_equal false
+    expect(twin.changed?).must_equal false
 
     twin.songs[1].composer.name = "Nofx"
 
-    twin.changed?.must_equal true
+    expect(twin.changed?).must_equal true
 
     assert twin.songs.changed?
-    twin.songs[1].changed?.must_equal true
-    twin.songs[0].changed?.must_equal false
+    expect(twin.songs[1].changed?).must_equal true
+    expect(twin.songs[0].changed?).must_equal false
 
-    twin.artist.changed?.must_equal false
+    expect(twin.artist.changed?).must_equal false
   end
 
   # setting identical value doesn't change.
   it do
     twin.name = "The Rest Is Silence"
-    twin.changed?.must_equal false
+    expect(twin.changed?).must_equal false
   end
 end
 
@@ -119,18 +119,18 @@ class ChangedWithCoercionTest < MiniTest::Spec
 
   it do
     twin = SongTwin.new(Song.new)
-    twin.changed?(:released).must_equal false
+    expect(twin.changed?(:released)).must_equal false
     twin.released = 'true'
-    twin.released.must_equal true
-    twin.changed?(:released).must_equal true
+    expect(twin.released).must_equal true
+    expect(twin.changed?(:released)).must_equal true
   end
 
   it do
     twin = SongTwin.new(Song.new(true))
-    twin.changed?(:released).must_equal false
+    expect(twin.changed?(:released)).must_equal false
     twin.released = 'true' # it coerces, then assigns, then compares, which makes this NOT changed.
-    twin.changed?(:released).must_equal false
+    expect(twin.changed?(:released)).must_equal false
     twin.released = 'false'
-    twin.changed?(:released).must_equal true
+    expect(twin.changed?(:released)).must_equal true
   end
 end

data/test/twin/coercion_test.rb

@@ -37,9 +37,9 @@ class CoercionTest < MiniTest::Spec
     }
 
     it "NOT coerce values in setup" do
-      subject.released_at.must_equal "31/03/1981"
-      subject.hit.length.must_equal "312"
-      subject.band.label.value.must_equal "9999.99"
+      expect(subject.released_at).must_equal "31/03/1981"
+      expect(subject.hit.length).must_equal "312"
+      expect(subject.band.label.value).must_equal "9999.99"
     end
 
 
@@ -49,11 +49,11 @@ class CoercionTest < MiniTest::Spec
       subject.hit.length = "312"
       subject.band.label.value = "9999.99"
 
-      subject.released_at.must_be_kind_of DateTime
-      subject.released_at.must_equal DateTime.parse("30/03/1981")
-      subject.hit.length.must_equal 312
-      subject.hit.good.must_be_nil
-      subject.band.label.value.must_equal 9999.99
+      expect(subject.released_at).must_be_kind_of DateTime
+      expect(subject.released_at).must_equal DateTime.parse("30/03/1981")
+      expect(subject.hit.length).must_equal 312
+      expect(subject.hit.good).must_be_nil
+      expect(subject.band.label.value).must_equal 9999.99
     end
   end
 
@@ -69,9 +69,9 @@ class CoercionTest < MiniTest::Spec
     end
 
     it "coerce values in setup and when using a setter" do
-      subject.id.must_equal 1
+      expect(subject.id).must_equal 1
       subject.id = "2"
-      subject.id.must_equal 2
+      expect(subject.id).must_equal 2
     end
   end
 
@@ -85,8 +85,15 @@ class CoercionTest < MiniTest::Spec
     property :id, type: const_get("Types::Coercible::#{DRY_TYPES_INT_CONSTANT}"), nilify: true
   end
 
-  describe "with Nilify" do
+  class TwinWithoutTypeWithNilify < Disposable::Twin
+    feature Coercion
+
+    property :date_of_birth, nilify: true
+    property :date_of_death_by_unicorns, type: DRY_TYPES_CONSTANT::Nil | DRY_TYPES_CONSTANT::Date
+    property :id, type: const_get("Types::Coercible::#{DRY_TYPES_INT_CONSTANT}"), nilify: true
+  end
 
+  describe "with Nilify" do
     subject do
       TwinWithNilify.new(OpenStruct.new(date_of_birth: '1990-01-12',
                                         date_of_death_by_unicorns: '2037-02-18',
@@ -94,23 +101,54 @@ class CoercionTest < MiniTest::Spec
     end
 
     it "coerce values correctly" do
-      subject.date_of_birth.must_equal Date.parse('1990-01-12')
-      subject.date_of_death_by_unicorns.must_equal Date.parse('2037-02-18')
+      expect(subject.date_of_birth).must_equal Date.parse('1990-01-12')
+      expect(subject.date_of_death_by_unicorns).must_equal Date.parse('2037-02-18')
     end
 
     it "coerce empty values to nil when using option nilify: true" do
       subject.date_of_birth = ""
-      subject.date_of_birth.must_be_nil
+      expect(subject.date_of_birth).must_be_nil
     end
 
     it "coerce empty values to nil when using dry-types | operator" do
       subject.date_of_death_by_unicorns = ""
-      subject.date_of_death_by_unicorns.must_be_nil
+      expect(subject.date_of_death_by_unicorns).must_be_nil
     end
 
     it "converts blank string to nil, without :type option" do
       subject.id = ""
-      subject.id.must_be_nil
+      expect(subject.id).must_be_nil
+    end
+  end
+
+  describe "without Type With Nilify" do
+    let(:date_of_birth) { '1990-01-12' }
+    subject do
+      TwinWithoutTypeWithNilify.new(
+        OpenStruct.new(
+          date_of_birth: date_of_birth,
+          date_of_death_by_unicorns: '2037-02-18',
+          id: 1
+        )
+      )
+    end
+
+    it 'raise error for new dry-types v - work as expected for older versions' do
+      if Disposable::Twin::Coercion::DRY_TYPES_VERSION >= Gem::Version.new("1.0")
+        assert_raises(Dry::Types::CoercionError) { subject.date_of_birth }
+        assert_raises(Dry::Types::CoercionError) { subject.date_of_death_by_unicorns }
+      else
+        expect(subject.date_of_birth).must_equal '1990-01-12'
+        expect(subject.date_of_death_by_unicorns).must_equal Date.parse('2037-02-18')
+      end
+    end
+
+    describe 'when passing nil' do
+      let(:date_of_birth) { '' }
+
+      it 'coerce values correctly' do
+        expect(subject.date_of_birth).must_be_nil
+      end
     end
   end
 end
@@ -135,13 +173,13 @@ class CoercionTypingTest < MiniTest::Spec
     # with type: Dry::Types::Strict::String
     # assert_raises(Dry::Types::ConstraintError) { twin.title = nil }
     twin.title = nil
-    twin.title.must_be_nil
+    expect(twin.title).must_be_nil
 
     twin.title = "Yo"
-    twin.title.must_equal "Yo"
+    expect(twin.title).must_equal "Yo"
 
     twin.title = ""
-    twin.title.must_equal ""
+    expect(twin.title).must_equal ""
 
     assert_raises(Dry::Types::ConstraintError) { twin.title = :bla }
     assert_raises(Dry::Types::ConstraintError) { twin.title = 1 }
@@ -167,16 +205,16 @@ class CoercionTypingTest < MiniTest::Spec
 
     # assert_raises(Dry::Types::ConstraintError) { twin.title = nil } # in form, we either have a blank string or the key's not present at all.
     twin.title = nil
-    twin.title.must_be_nil
+    expect(twin.title).must_be_nil
 
     twin.title = "" # nilify blank strings
-    twin.title.must_be_nil
+    expect(twin.title).must_be_nil
 
     twin.title = "Yo"
-    twin.title.must_equal "Yo"
+    expect(twin.title).must_equal "Yo"
 
     # twin.enabled = " TRUE"
-    # twin.enabled.must_equal true
+    #expect(twin.enabled).must_equal true
   end
 end