disposable 0.4.6 → 0.4.7

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_be_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,11 +169,11 @@ 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]]
+      expect(twin.songs.added).must_equal [twin.songs[1]]
       twin.songs.insert(2, Song.new)
-      twin.songs.added.must_equal [twin.songs[1], twin.songs[2]]
+      expect(twin.songs.added).must_equal [twin.songs[1], twin.songs[2]]
 
       # TODO: what to do if we override an item (insert)?
     end
@@ -185,20 +185,20 @@ class TwinCollectionActiveRecordTest < MiniTest::Spec
     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

data/test/twin/default_test.rb

@@ -19,28 +19,28 @@ class DefaultTest < Minitest::Spec
   # all given.
   it do
     twin = Twin.new(Song.new("Anarchy Camp", false, true, "Punk", Composer.new("Nofx")))
-    twin.title.must_equal "Anarchy Camp"
-    twin.genre.must_equal "Punk"
-    twin.composer.name.must_equal "Nofx"
-    twin.published.must_equal true
-    twin.new_album.must_equal false
+    expect(twin.title).must_equal "Anarchy Camp"
+    expect(twin.genre).must_equal "Punk"
+    expect(twin.composer.name).must_equal "Nofx"
+    expect(twin.published).must_equal true
+    expect(twin.new_album).must_equal false
   end
 
   # defaults, please.
   it do
     twin = Twin.new(Song.new)
-    twin.title.must_equal "Medio-Core"
-    twin.composer.name.must_equal "NOFX"
-    twin.genre.must_equal "Punk Rock DefaultTest::Song"
-    twin.published.must_equal false
-    twin.new_album.must_equal true
+    expect(twin.title).must_equal "Medio-Core"
+    expect(twin.composer.name).must_equal "NOFX"
+    expect(twin.genre).must_equal "Punk Rock DefaultTest::Song"
+    expect(twin.published).must_equal false
+    expect(twin.new_album).must_equal true
   end
 
   # false value is not defaulted.
   it do
     twin = Twin.new(Song.new(false, false))
-    twin.title.must_equal false
-    twin.new_album.must_equal false
+    expect(twin.title).must_equal false
+    expect(twin.new_album).must_equal false
   end
 
   describe "inheritance" do
@@ -51,7 +51,7 @@ class DefaultTest < Minitest::Spec
     class MegaTwin < SuperTwin
     end
 
-    it { MegaTwin.new(Composer.new).name.must_equal "n/a" }
+    it { expect(MegaTwin.new(Composer.new).name).must_equal "n/a" }
   end
 end
 
@@ -65,8 +65,8 @@ class DefaultAndVirtualTest < Minitest::Spec
 
   it do
     twin = Twin.new(Object.new)
-    twin.title.must_equal "0"
-    # twin.changed.must_equal []
+    expect(twin.title).must_equal "0"
+    # expect(twin.changed).must_equal []
   end
 end
 

data/test/twin/expose_test.rb

@@ -28,28 +28,28 @@ class TwinExposeTest < MiniTest::Spec
   let (:request) { Request.new(song) }
 
   it do
-    request.song_title.must_equal "Extraction"
-    request.id.must_equal 2
+    expect(request.song_title).must_equal "Extraction"
+    expect(request.id).must_equal 2
 
     request.song_title = "Tease"
     request.id = 1
 
 
-    request.song_title.must_equal "Tease"
-    request.id.must_equal 1
+    expect(request.song_title).must_equal "Tease"
+    expect(request.id).must_equal 1
 
     # does not write to model.
-    song.title.must_equal "Extraction"
-    song.id.must_equal 2
+    expect(song.title).must_equal "Extraction"
+    expect(song.id).must_equal 2
 
     request.save
 
     # make sure models got synced and saved.
-    song.id.must_equal 1
-    song.title.must_equal "Tease"
-    song.album.must_equal album # nested objects don't get twinned or anything.
+    expect(song.id).must_equal 1
+    expect(song.title).must_equal "Tease"
+    expect(song.album).must_equal album # nested objects don't get twinned or anything.
 
-    song.saved?.must_equal true
+    expect(song.saved?).must_equal true
   end
 
   # save with block.
@@ -63,11 +63,11 @@ class TwinExposeTest < MiniTest::Spec
       nested_hash = hash
     end
 
-    nested_hash.must_equal({"title"=>"Tease", "id"=>1, "captcha" => "Awesome!", "album"=>{"getName"=>"Appeal To Reason"}})
+    expect(nested_hash).must_equal({"title"=>"Tease", "id"=>1, "captcha" => "Awesome!", "album"=>{"getName"=>"Appeal To Reason"}})
 
     # does not write to model.
-    song.title.must_equal "Extraction"
-    song.id.must_equal 2
-    album.getName.must_equal "Appeal To Reason"
+    expect(song.title).must_equal "Extraction"
+    expect(song.id).must_equal 2
+    expect(album.getName).must_equal "Appeal To Reason"
   end
-end
+end

data/test/twin/feature_test.rb

@@ -44,14 +44,14 @@ class FeatureTest < MiniTest::Spec
   let (:form) { AlbumForm.new(album) }
 
   it do
-    form.date.must_equal "May 16"
-    form.artist.date.must_equal "May 16"
-    form.songs[0].date.must_equal "May 16"
-    form.songs[1].date.must_equal "May 16"
-    form.songs[1].composer.date.must_equal "May 16"
-    form.songs[1].wont_be_kind_of(Instrument)
-    form.songs[1].composer.must_be_kind_of(Instrument)
-    form.songs[1].composer.instrument.must_equal "Violins"
-    form.artist.date.must_equal "May 16"
+    expect(form.date).must_equal "May 16"
+    expect(form.artist.date).must_equal "May 16"
+    expect(form.songs[0].date).must_equal "May 16"
+    expect(form.songs[1].date).must_equal "May 16"
+    expect(form.songs[1].composer.date).must_equal "May 16"
+    expect(form.songs[1]).wont_be_kind_of(Instrument)
+    expect(form.songs[1].composer).must_be_kind_of(Instrument)
+    expect(form.songs[1].composer.instrument).must_equal "Violins"
+    expect(form.artist.date).must_equal "May 16"
   end
-end
+end

data/test/twin/from_collection_test.rb

@@ -20,10 +20,10 @@ class TwinFromCollectionDecoratorTest < MiniTest::Spec
     it do
       twined_collection = Twin::Artist.from_collection(collection)
 
-      twined_collection[0].must_be_instance_of Twin::Artist
-      twined_collection[0].model.must_equal artist1
-      twined_collection[1].must_be_instance_of Twin::Artist
-      twined_collection[1].model.must_equal artist2
+      expect(twined_collection[0]).must_be_instance_of Twin::Artist
+      expect(twined_collection[0].model).must_equal artist1
+      expect(twined_collection[1]).must_be_instance_of Twin::Artist
+      expect(twined_collection[1].model).must_equal artist2
     end
   end
 end

data/test/twin/from_test.rb

@@ -27,11 +27,11 @@ class FromTest < MiniTest::Spec
   let (:twin)     { Twin::Album.new(album) }
 
   it do
-    twin.full_name.must_equal "Black Sails In The Sunset"
-    twin.artist.name.must_equal "AFI"
+    expect(twin.full_name).must_equal "Black Sails In The Sunset"
+    expect(twin.artist.name).must_equal "AFI"
 
     twin.save
 
 
   end
-end
+end

data/test/twin/hash_test.rb

@@ -29,31 +29,31 @@ class HashTest < MiniTest::Spec
 
   it "allows reading from existing hash" do
     model = Model.new(1, {})
-    model.inspect.must_equal "#<struct HashTest::Model id=1, content={}>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=1, content={}>"
 
     song = Song.new(model)
-    song.id.must_equal 1
-    song.content.title.must_be_nil
-    song.content.band.name.must_be_nil
-    song.content.band.label.location.must_be_nil
-    song.content.releases.must_equal []
+    expect(song.id).must_equal 1
+    expect(song.content.title).must_be_nil
+    expect(song.content.band.name).must_be_nil
+    expect(song.content.band.label.location).must_be_nil
+    expect(song.content.releases).must_equal []
 
     # model's hash hasn't changed.
-    model.inspect.must_equal "#<struct HashTest::Model id=1, content={}>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=1, content={}>"
   end
 
   it "defaults to hash when value is nil" do
     model = Model.new(1)
-    model.inspect.must_equal "#<struct HashTest::Model id=1, content=nil>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=1, content=nil>"
 
     song = Song.new(model)
-    song.id.must_equal 1
-    song.content.title.must_be_nil
-    song.content.band.name.must_be_nil
-    song.content.band.label.location.must_be_nil
+    expect(song.id).must_equal 1
+    expect(song.content.title).must_be_nil
+    expect(song.content.band.name).must_be_nil
+    expect(song.content.band.label.location).must_be_nil
 
     # model's hash hasn't changed.
-    model.inspect.must_equal "#<struct HashTest::Model id=1, content=nil>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=1, content=nil>"
   end
 
   it "#sync writes to model" do
@@ -64,7 +64,7 @@ class HashTest < MiniTest::Spec
 
     song.sync
 
-    model.inspect.must_equal "#<struct HashTest::Model id=nil, content={\"band\"=>{\"label\"=>{\"location\"=>\"San Francisco\"}}, \"releases\"=>[]}>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=nil, content={\"band\"=>{\"label\"=>{\"location\"=>\"San Francisco\"}}, \"releases\"=>[]}>"
   end
 
   it "#appends to collections" do
@@ -76,7 +76,7 @@ class HashTest < MiniTest::Spec
 
     song.sync
 
-    model.inspect.must_equal "#<struct HashTest::Model id=nil, content={\"band\"=>{\"label\"=>{}}, \"releases\"=>[{\"version\"=>1}]}>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=nil, content={\"band\"=>{\"label\"=>{}}, \"releases\"=>[{\"version\"=>1}]}>"
   end
 
   it "doesn't erase existing, undeclared content" do
@@ -88,7 +88,7 @@ class HashTest < MiniTest::Spec
     # puts song.content.class.ancestors
     song.sync
 
-    model.inspect.must_equal "#<struct HashTest::Model id=nil, content={\"artist\"=>{}, \"band\"=>{\"label\"=>{\"location\"=>\"San Francisco\"}}, \"releases\"=>[]}>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=nil, content={\"artist\"=>{}, \"band\"=>{\"label\"=>{\"location\"=>\"San Francisco\"}}, \"releases\"=>[]}>"
   end
 
   it "doesn't erase existing, undeclared content in existing content" do
@@ -99,7 +99,7 @@ class HashTest < MiniTest::Spec
 
     song.sync
 
-    model.inspect.must_equal "#<struct HashTest::Model id=nil, content={\"band\"=>{\"label\"=>{\"owner\"=>\"Brett Gurewitz\", \"location\"=>\"San Francisco\"}, \"genre\"=>\"Punkrock\"}, \"releases\"=>[]}>"
+    expect(model.inspect).must_equal "#<struct HashTest::Model id=nil, content={\"band\"=>{\"label\"=>{\"owner\"=>\"Brett Gurewitz\", \"location\"=>\"San Francisco\"}, \"genre\"=>\"Punkrock\"}, \"releases\"=>[]}>"
   end
 
 
@@ -125,9 +125,9 @@ class HashTest < MiniTest::Spec
 
     it "includes features into all nested twins" do
       song = Hit.new(Model.new)
-      song.uuid.must_equal "1224"
-      song.content.uuid.must_equal "1224"
-      song.content.band.uuid.must_equal "1224"
+      expect(song.uuid).must_equal "1224"
+      expect(song.content.uuid).must_equal "1224"
+      expect(song.content.band.uuid).must_equal "1224"
     end
   end
 
@@ -149,9 +149,9 @@ class HashTest < MiniTest::Spec
     it "coerces" do
       song = Coercing.new(Model.new(1))
       song.id = "9"
-      song.id.must_equal 9
+      expect(song.id).must_equal 9
       song.content.band.name = 18
-      song.content.band.name.must_equal "18"
+      expect(song.content.band.name).must_equal "18"
     end
   end
 
@@ -190,18 +190,18 @@ class HashTest < MiniTest::Spec
       song = Unnesting.new(model)
 
       # singular scalar accessors
-      song.content.title.must_equal "Bedroom Eyes"
-      song.title.must_equal "Bedroom Eyes"
+      expect(song.content.title).must_equal "Bedroom Eyes"
+      expect(song.title).must_equal "Bedroom Eyes"
 
       song.title = "Notorious"
-      song.title.must_equal "Notorious"
-      song.content.title.must_equal "Notorious"
+      expect(song.title).must_equal "Notorious"
+      expect(song.content.title).must_equal "Notorious"
 
       # singular nested accessors
-      song.band.name.must_be_nil
-      song.content.band.name.must_be_nil
+      expect(song.band.name).must_be_nil
+      expect(song.content.band.name).must_be_nil
       song.band.name = "Duran Duran"
-      song.band.name.must_equal "Duran Duran"
+      expect(song.band.name).must_equal "Duran Duran"
     end
   end
 
@@ -237,18 +237,18 @@ class HashTest < MiniTest::Spec
 
       song1 = contract.songs[0]
 
-      song1.title.must_equal "Sherry"
-      song1.band.name.must_equal 'The Four Seasons'
-      song1.band.label.location.must_equal 'US'
-      song1.featured_artists[0].name.must_equal 'Frankie Valli'
-      song1.featured_artists[1].name.must_equal 'The Variatones'
+      expect(song1.title).must_equal "Sherry"
+      expect(song1.band.name).must_equal 'The Four Seasons'
+      expect(song1.band.label.location).must_equal 'US'
+      expect(song1.featured_artists[0].name).must_equal 'Frankie Valli'
+      expect(song1.featured_artists[1].name).must_equal 'The Variatones'
 
       song2 = contract.songs[1]
 
-      song2.title.must_equal "Walk Like a Man"
-      song2.band.name.must_equal 'The Four Seasons'
-      song2.band.label.location.must_equal 'US'
-      song2.featured_artists[0].name.must_equal 'Frankie Valli'
+      expect(song2.title).must_equal "Walk Like a Man"
+      expect(song2.band.name).must_equal 'The Four Seasons'
+      expect(song2.band.label.location).must_equal 'US'
+      expect(song2.featured_artists[0].name).must_equal 'Frankie Valli'
     end
   end
 end