disposable 0.4.3 → 0.5.0

data/test/twin/coercion_test.rb

@@ -3,16 +3,15 @@ require "test_helper"
 require "disposable/twin/coercion"
 
 class CoercionTest < MiniTest::Spec
-
   class TwinWithSkipSetter < Disposable::Twin
     feature Coercion
     feature Setup::SkipSetter
 
     property :id
-    property :released_at, type: Types::Form::DateTime
+    property :released_at, type: DRY_TYPES_CONSTANT::DateTime
 
     property :hit do
-      property :length, type: Types::Coercible::Int
+      property :length, type: const_get("Types::Coercible::#{DRY_TYPES_INT_CONSTANT}")
       property :good,   type: Types::Bool
     end
 
@@ -24,7 +23,6 @@ class CoercionTest < MiniTest::Spec
   end
 
   describe "with Setup::SkipSetter" do
-
     subject do
       TwinWithSkipSetter.new(album)
     end
@@ -39,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
 
 
@@ -51,17 +49,17 @@ 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_equal 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
 
   class TwinWithoutSkipSetter < Disposable::Twin
     feature Coercion
-    property :id, type: Types::Coercible::Int
+    property :id, type: const_get("Types::Coercible::#{DRY_TYPES_INT_CONSTANT}")
   end
 
   describe "without Setup::SkipSetter" do
@@ -71,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
 
@@ -81,14 +79,21 @@ class CoercionTest < MiniTest::Spec
     feature Coercion
 
     property :date_of_birth,
-             type: Types::Form::Date, nilify: true
+             type: DRY_TYPES_CONSTANT::Date, nilify: true
     property :date_of_death_by_unicorns,
-             type: Types::Form::Nil | Types::Form::Date
-    property :id, nilify: true
+             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
+  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',
@@ -96,39 +101,70 @@ 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_equal 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_equal 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_equal 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
 
 # this converts "" to nil and then breaks because it's strict.
-# Types::Strict::String.constructor(Dry::Types::Coercions::Form.method(:to_nil))
+# Types::Strict::String.constructor(Dry::Types::Params.method(:to_nil))
 
 class CoercionTypingTest < MiniTest::Spec
   class Song < Disposable::Twin
     include Coercion
     include Setup::SkipSetter
 
-    # property :title, type: Dry::Types::Strict::String.constructor(Dry::Types::Coercions::Form.method(:to_nil))
+    # property :title, type: Dry::Types::Strict::String.constructor(Dry::Types::Params.method(:to_nil))
     property :title, type: Types::Strict::String.optional # this is the behavior of the "DB" data twin. this is NOT the form.
 
-    # property :name, type: Types::Form::String
+    # property :name, type: Types::Params::String
   end
 
   it do
@@ -137,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 }
@@ -155,12 +191,13 @@ class CoercionTypingTest < MiniTest::Spec
     include Setup::SkipSetter
 
 
-    # property :title, type: Dry::Types::Strict::String.constructor(Dry::Types::Coercions::Form.method(:to_nil))
-    property :title, type: Types::Strict::String.optional.constructor(Dry::Types::Coercions::Form.method(:to_nil)) # this is the behavior of the "DB" data twin. this is NOT the form.
+    # property :title, type: Dry::Types::Strict::String.constructor(Dry::Types::Params.method(:to_nil))
+
+    property :title, type: DRY_TYPES_CONSTANT::Nil | Types::Strict::String # this is the behavior of the "DB" data twin. this is NOT the form.
 
-    # property :name, type: Types::Form::String
+    # property :name, type: Types::Params::String
 
-    property :enabled, type: Types::Form::Bool
+    property :enabled, type: DRY_TYPES_CONSTANT::Bool
     # property :enabled, Bool.constructor(:trim!)
   end
   it do
@@ -168,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
 

data/test/twin/collection_test.rb

@@ -33,9 +33,9 @@ class TwinCollectionTest < MiniTest::Spec
     it do
       twin = Twin::Album.new(album)
 
-      twin.songs.size.must_equal 1
-      twin.songs[0].title.must_equal "Broken"
-      twin.songs.must_be_instance_of Disposable::Twin::Collection
+      expect(twin.songs.size).must_equal 1
+      expect(twin.songs[0].title).must_equal "Broken"
+      expect(twin.songs).must_be_instance_of Disposable::Twin::Collection
 
     end
   end
@@ -44,10 +44,10 @@ class TwinCollectionTest < MiniTest::Spec
     let (:album) { Model::Album.new(1, "The Rest Is Silence", [Model::Song.new(3), Model::Song.new(4)]) }
     let (:twin) { Twin::Album.new(album) }
 
-    it { twin.songs.find_by(id: 1).must_equal nil }
-    it { twin.songs.find_by(id: 3).must_equal twin.songs[0] }
-    it { twin.songs.find_by(id: 4).must_equal twin.songs[1] }
-    it { twin.songs.find_by(id: "4").must_equal twin.songs[1] }
+    it { expect(twin.songs.find_by(id: 1)).must_be_nil }
+    it { expect(twin.songs.find_by(id: 3)).must_equal twin.songs[0] }
+    it { expect(twin.songs.find_by(id: 4)).must_equal twin.songs[1] }
+    it { expect(twin.songs.find_by(id: "4")).must_equal twin.songs[1] }
   end
 end
 
@@ -92,31 +92,31 @@ class TwinCollectionActiveRecordTest < MiniTest::Spec
     twin.songs << song1 # assuming that we add AR model here.
     twin.songs << song2
 
-    twin.songs.size.must_equal 2
+    expect(twin.songs.size).must_equal 2
 
-    twin.songs[0].must_be_instance_of Twin::Song # twin wraps << added in twin.
-    twin.songs[1].must_be_instance_of Twin::Song
+    expect(twin.songs[0]).must_be_instance_of Twin::Song # twin wraps << added in twin.
+    expect(twin.songs[1]).must_be_instance_of Twin::Song
 
-    # twin.songs[0].persisted?.must_equal false
-    twin.songs[0].send(:model).persisted?.must_equal false
-    twin.songs[1].send(:model).persisted?.must_equal true
+    # expect(twin.songs[0].persisted?).must_equal false
+    expect(twin.songs[0].send(:model).persisted?).must_equal false
+    expect(twin.songs[1].send(:model).persisted?).must_equal true
 
-    album.songs.size.must_equal 0 # nothing synced, yet.
+    expect(album.songs.size).must_equal 0 # nothing synced, yet.
 
     # sync: delete removed items, add new?
 
     # save
     twin.save
 
-    album.persisted?.must_equal true
-    album.name.must_equal "The Rest Is Silence"
+    expect(album.persisted?).must_equal true
+    expect(album.name).must_equal "The Rest Is Silence"
 
-    album.songs.size.must_equal 2 # synced!
+    expect(album.songs.size).must_equal 2 # synced!
 
-    album.songs[0].persisted?.must_equal true
-    album.songs[1].persisted?.must_equal true
-    album.songs[0].title.must_equal "Snorty Pacifical Rascal"
-    album.songs[1].title.must_equal "At Any Cost"
+    expect(album.songs[0].persisted?).must_equal true
+    expect(album.songs[1].persisted?).must_equal true
+    expect(album.songs[0].title).must_equal "Snorty Pacifical Rascal"
+    expect(album.songs[1].title).must_equal "At Any Cost"
   end
 
   # test with adding to existing collection [song1] << song2
@@ -128,20 +128,20 @@ class TwinCollectionActiveRecordTest < MiniTest::Spec
     it do
       twin.songs.delete(twin.songs.first)
 
-      twin.songs.size.must_equal 0
-      album.songs.size.must_equal 1 # not synced, yet.
+      expect(twin.songs.size).must_equal 0
+      expect(album.songs.size).must_equal 1 # not synced, yet.
 
       twin.save
 
-      twin.songs.size.must_equal 0
-      album.songs.size.must_equal 0
-      song1.persisted?.must_equal true
+      expect(twin.songs.size).must_equal 0
+      expect(album.songs.size).must_equal 0
+      expect(song1.persisted?).must_equal true
     end
 
     # non-existant delete.
     it do
       twin.songs.delete("non-existant") # won't delete anything.
-      twin.songs.size.must_equal 1
+      expect(twin.songs.size).must_equal 1
     end
   end
 
@@ -151,14 +151,14 @@ class TwinCollectionActiveRecordTest < MiniTest::Spec
     it do
       twin.songs.destroy(twin.songs.first)
 
-      twin.songs.size.must_equal 0
-      album.songs.size.must_equal 1 # not synced, yet.
+      expect(twin.songs.size).must_equal 0
+      expect(album.songs.size).must_equal 1 # not synced, yet.
 
       twin.save
 
-      twin.songs.size.must_equal 0
-      album.songs.size.must_equal 0
-      song1.persisted?.must_equal false
+      expect(twin.songs.size).must_equal 0
+      expect(album.songs.size).must_equal 0
+      expect(song1.persisted?).must_equal false
     end
   end
 
@@ -169,36 +169,36 @@ class TwinCollectionActiveRecordTest < MiniTest::Spec
     it do
       twin = Twin::Album.new(album)
 
-      twin.songs.added.must_equal []
+      expect(twin.songs.added).must_equal []
       twin.songs << song2
-      twin.songs.added.must_equal [twin.songs[1]]
-      twin.songs.insert(2, song3 = Song.new)
-      twin.songs.added.must_equal [twin.songs[1], twin.songs[2]]
+      expect(twin.songs.added).must_equal [twin.songs[1]]
+      twin.songs.insert(2, Song.new)
+      expect(twin.songs.added).must_equal [twin.songs[1], twin.songs[2]]
 
       # TODO: what to do if we override an item (insert)?
     end
   end
 
   describe "#deleted" do
-    let (:album) { Album.create(name: "The Rest Is Silence", songs: [song1, song2, song3 = Song.new]) }
+    let (:album) { Album.create(name: "The Rest Is Silence", songs: [song1, song2, Song.new]) }
 
     it do
       twin = Twin::Album.new(album)
 
-      twin.songs.deleted.must_equal []
+      expect(twin.songs.deleted).must_equal []
 
       twin.songs.delete(deleted1 = twin.songs[-1])
       twin.songs.delete(deleted2 = twin.songs[-1])
 
-      twin.songs.must_equal [twin.songs[0]]
+      expect(twin.songs).must_equal [twin.songs[0]]
 
-      twin.songs.deleted.must_equal [deleted1, deleted2]
+      expect(twin.songs.deleted).must_equal [deleted1, deleted2]
     end
 
     # non-existant delete.
     it do
       twin.songs.delete("non-existant") # won't delete anything.
-      twin.songs.deleted.must_equal []
+      expect(twin.songs.deleted).must_equal []
     end
   end
 end
@@ -223,24 +223,24 @@ class CollectionUnitTest < MiniTest::Spec
 
   # #insert(index, model)
   it do
-    collection.insert(0, Model::Album.new).must_be_instance_of Twin::Album
+    expect(collection.insert(0, Model::Album.new)).must_be_instance_of Twin::Album
   end
 
   # #append(model)
   it do
-    collection.append(Model::Album.new).must_be_instance_of Twin::Album
-    collection[0].must_be_instance_of Twin::Album
+    expect(collection.append(Model::Album.new)).must_be_instance_of Twin::Album
+    expect(collection[0]).must_be_instance_of Twin::Album
 
     # allows subsequent calls.
     collection.append(Model::Album.new)
-    collection[1].must_be_instance_of Twin::Album
+    expect(collection[1]).must_be_instance_of Twin::Album
 
-    collection.size.must_equal 2
+    expect(collection.size).must_equal 2
   end
 
   # #<<
   it do
-    (collection << Model::Album.new).must_be_instance_of Array
-    collection[0].must_be_instance_of Twin::Album
+    expect((collection << Model::Album.new)).must_be_instance_of Array
+    expect(collection[0]).must_be_instance_of Twin::Album
   end
 end

data/test/twin/composition_test.rb

@@ -26,34 +26,34 @@ class TwinCompositionTest < MiniTest::Spec
   let (:request) { Request.new(song: song, requester: requester) }
 
   it do
-    request.song_title.must_equal "Extraction"
-    request.song_id.must_equal 2
-    request.name.must_equal "Greg Howe"
-    request.id.must_equal 1
+    expect(request.song_title).must_equal "Extraction"
+    expect(request.song_id).must_equal 2
+    expect(request.name).must_equal "Greg Howe"
+    expect(request.id).must_equal 1
 
     request.song_title = "Tease"
     request.name = "Wooten"
 
 
-    request.song_title.must_equal "Tease"
-    request.name.must_equal "Wooten"
+    expect(request.song_title).must_equal "Tease"
+    expect(request.name).must_equal "Wooten"
 
     # does not write to model.
-    song.title.must_equal "Extraction"
-    requester.name.must_equal "Greg Howe"
+    expect(song.title).must_equal "Extraction"
+    expect(requester.name).must_equal "Greg Howe"
 
 
     res = request.save
-    res.must_equal true
+    expect(res).must_equal true
 
     # make sure models got synced and saved.
-    song.id.must_equal 2
-    song.title.must_equal "Tease"
-    requester.id.must_equal 1
-    requester.name.must_equal "Wooten"
+    expect(song.id).must_equal 2
+    expect(song.title).must_equal "Tease"
+    expect(requester.id).must_equal 1
+    expect(requester.name).must_equal "Wooten"
 
-    song.saved?.must_equal true
-    requester.saved?.must_equal true
+    expect(song.saved?).must_equal true
+    expect(requester.saved?).must_equal true
   end
 
   # save with block.
@@ -63,8 +63,8 @@ class TwinCompositionTest < MiniTest::Spec
     request.captcha = "Awesome!"
 
     # does not write to model.
-    song.title.must_equal "Extraction"
-    requester.name.must_equal "Greg Howe"
+    expect(song.title).must_equal "Extraction"
+    expect(requester.name).must_equal "Greg Howe"
 
 
     nested_hash = nil
@@ -72,13 +72,13 @@ class TwinCompositionTest < MiniTest::Spec
       nested_hash = hash
     end
 
-    nested_hash.must_equal(:song=>{"title"=>"Tease", "id"=>2}, :requester=>{"name"=>"Wooten", "id"=>1, "captcha"=>"Awesome!"})
+    expect(nested_hash).must_equal(:song=>{"title"=>"Tease", "id"=>2}, :requester=>{"name"=>"Wooten", "id"=>1, "captcha"=>"Awesome!"})
   end
 
   # save with one unsaveable model.
     #save returns result.
   it do
     song.instance_eval { def save; false; end }
-    request.save.must_equal false
+    expect(request.save).must_equal false
   end
-end
+end