disposable 0.4.5 → 0.6.0

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

data/test/twin/inherit_test.rb

@@ -40,20 +40,20 @@ class InheritTest < MiniTest::Spec
 
   # definitions are not shared.
   it do
-    Twin::Album.definitions.get(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:fromage=>:_name, :private_name=>:name, :name=>\"name\"}>"
-    Twin::Compilation.definitions.get(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:fromage=>:_name, :private_name=>:name, :name=>\"name\", :writeable=>false}>" # FIXME: where did :inherit go?
+    expect(Twin::Album.definitions.get(:name).extend(Declarative::Inspect).inspect).must_equal "#<Disposable::Twin::Definition: @options={:fromage=>:_name, :private_name=>:name, :name=>\"name\"}>"
+    expect(Twin::Compilation.definitions.get(:name).extend(Declarative::Inspect).inspect).must_equal "#<Disposable::Twin::Definition: @options={:fromage=>:_name, :private_name=>:name, :name=>\"name\", :writeable=>false}>" # FIXME: where did :inherit go?
   end
 
 
   let (:album) { Model::Album.new("In The Meantime And Inbetween Time", [], Model::Artist.new) }
 
-  it { Twin::Album.new(album).artist.artist_id.must_equal 1 }
+  it { expect(Twin::Album.new(album).artist.artist_id).must_equal 1 }
 
   # inherit inline twins when not overriding.
-  it { Twin::EmptyCompilation.new(album).artist.artist_id.must_equal 1 }
+  it { expect(Twin::EmptyCompilation.new(album).artist.artist_id).must_equal 1 }
 
   # inherit inline twins when overriding.
-  it { Twin::Compilation.new(album).artist.artist_id.must_equal 1 }
+  it { expect(Twin::Compilation.new(album).artist.artist_id).must_equal 1 }
 
   describe "custom accessors get inherited" do
     class Singer < Disposable::Twin
@@ -75,11 +75,11 @@ class InheritTest < MiniTest::Spec
 
     it do
       artist = Star.new(model)
-      artist.name.must_equal("neewolleh")
+      expect(artist.name).must_equal("neewolleh")
 
       artist.name = "HELLOWEEN"
       # artist.with_custom_setter = "this gets ignored"
-      artist.name.must_equal("neewolleh")
+      expect(artist.name).must_equal("neewolleh")
     end
   end
 end

data/test/twin/inheritance_test.rb

@@ -20,7 +20,7 @@ class InheritanceTest < Minitest::Spec
 
   it do
     twin = Twin.new(song)
-    twin.id.must_equal 0
+    expect(twin.id).must_equal 0
   end
 
   class TwinComposition < Disposable::Twin
@@ -32,9 +32,9 @@ class InheritanceTest < Minitest::Spec
 
   it do
     twin = TwinComposition.new(song: song)
-    twin.id.must_equal 0
+    expect(twin.id).must_equal 0
     twin.id= 3
-    twin.id.must_equal 3
+    expect(twin.id).must_equal 3
   end
 
 
@@ -50,7 +50,7 @@ class InheritanceTest < Minitest::Spec
 
   it do
     twin = TwinCompositionDefineMethod.new(song: song)
-    twin.id.must_equal 9
+    expect(twin.id).must_equal 9
   end
 
 
@@ -66,8 +66,8 @@ class InheritanceTest < Minitest::Spec
     end
 
     it do
-      TwinWithFrom.new(song).id.must_equal 1
-      InheritingFrom.new(song).id.must_equal 1
+      expect(TwinWithFrom.new(song).id).must_equal 1
+      expect(InheritingFrom.new(song).id).must_equal 1
     end
   end
 end

data/test/twin/parent_test.rb

@@ -27,15 +27,15 @@ class TwinParentTest < MiniTest::Spec
 
   let (:album) { Album.new(Model::Album.new(1, Model::Artist.new("Helloween"), [Model::Song.new("I'm Alive", Model::Artist.new("Kai Hansen"))])) }
 
-  it { album.parent.must_be_nil }
-  it { album.artist.parent.must_equal album }
-  it { album.songs[0].parent.must_equal album }
-  it { album.songs[0].composer.parent.must_equal album.songs[0] }
+  it { expect(album.parent).must_be_nil }
+  it { expect(album.artist.parent).must_equal album }
+  it { expect(album.songs[0].parent).must_equal album }
+  it { expect(album.songs[0].composer.parent).must_equal album.songs[0] }
 
   describe "Collection#append" do
     it do
       album.songs.append(Model::Song.new)
-      album.songs[1].parent.must_equal album
+      expect(album.songs[1].parent).must_equal album
     end
   end
 end

data/test/twin/property_processor_test.rb

@@ -23,14 +23,14 @@ class PropertyProcessorTest < Minitest::Spec
 	    called = []
 	    Disposable::Twin::PropertyProcessor.new(twin.class.definitions.get(:songs), twin).() { |v, i| called << [v.model, i] }
 
-	    called.inspect.must_equal %{[[#<struct PropertyProcessorTest::Song id=1>, 0], [#<struct PropertyProcessorTest::Song id=2>, 1]]}
+	    expect(called.inspect).must_equal %{[[#<struct PropertyProcessorTest::Song id=1>, 0], [#<struct PropertyProcessorTest::Song id=2>, 1]]}
   	end
 
   	it "yields twin" do
 	    called = []
 	    Disposable::Twin::PropertyProcessor.new(twin.class.definitions.get(:songs), twin).() { |v| called << [v.model] }
 
-	    called.inspect.must_equal %{[[#<struct PropertyProcessorTest::Song id=1>], [#<struct PropertyProcessorTest::Song id=2>]]}
+	    expect(called.inspect).must_equal %{[[#<struct PropertyProcessorTest::Song id=1>], [#<struct PropertyProcessorTest::Song id=2>]]}
   	end
 
   	it "allows nil collection" do
@@ -39,7 +39,7 @@ class PropertyProcessorTest < Minitest::Spec
 	    called = []
 	    Disposable::Twin::PropertyProcessor.new(twin.class.definitions.get(:songs), twin).() { |v, i| called << [v.model, i] }
 
-	    called.inspect.must_equal %{[]}
+	    expect(called.inspect).must_equal %{[]}
   	end
   end
 end

data/test/twin/readable_test.rb

@@ -30,21 +30,21 @@ class ReadableTest < MiniTest::Spec
   let (:twin) { PasswordForm.new(cred) }
 
   it {
-    twin.password.must_be_nil            # not readable.
-    twin.credit_card.name.must_equal "Jonny"
-    twin.credit_card.number.must_be_nil  # not readable.
+    expect(twin.password).must_be_nil            # not readable.
+    expect(twin.credit_card.name).must_equal "Jonny"
+    expect(twin.credit_card.number).must_be_nil  # not readable.
 
     # manual setting on the twin works.
     twin.password = "123"
-    twin.password.must_equal "123"
+    expect(twin.password).must_equal "123"
 
     twin.credit_card.number = "456"
-    twin.credit_card.number.must_equal "456"
+    expect(twin.credit_card.number).must_equal "456"
 
     twin.sync
 
     # it writes, but does not read.
-    cred.inspect.must_equal '#<struct ReadableTest::Credentials password="123", credit_card=#<struct ReadableTest::CreditCard name="Jonny", number="456">>'
+    expect(cred.inspect).must_equal '#<struct ReadableTest::Credentials password="123", credit_card=#<struct ReadableTest::CreditCard name="Jonny", number="456">>'
 
     # test sync{}.
     hash = {}
@@ -52,12 +52,12 @@ class ReadableTest < MiniTest::Spec
       hash = nested
     end
 
-    hash.must_equal("password"=> "123", "credit_card"=>{"name"=>"Jonny", "number"=>"456"})
+    expect(hash).must_equal("password"=> "123", "credit_card"=>{"name"=>"Jonny", "number"=>"456"})
   }
 
   # allow passing non-readable value as option.
   it do
     twin = PasswordForm.new(cred, password: "open sesame!")
-    twin.password.must_equal "open sesame!"
+    expect(twin.password).must_equal "open sesame!"
   end
-end
+end

data/test/twin/save_test.rb

@@ -48,29 +48,29 @@ class SaveTest < MiniTest::Spec
     twin.save
 
     # sync happened.
-    album.name.must_equal "Live And Dangerous"
-    album.songs[0].must_be_instance_of Model::Song
-    album.songs[1].must_be_instance_of Model::Song
-    album.songs[0].title.must_equal "Southbound"
-    album.songs[1].title.must_equal "The Boys Are Back In Town"
-    album.songs[1].composer.must_be_instance_of Model::Artist
-    album.songs[1].composer.name.must_equal "Lynott"
-    album.artist.must_be_instance_of Model::Artist
-    album.artist.name.must_equal "Thin Lizzy"
+    expect(album.name).must_equal "Live And Dangerous"
+    expect(album.songs[0]).must_be_instance_of Model::Song
+    expect(album.songs[1]).must_be_instance_of Model::Song
+    expect(album.songs[0].title).must_equal "Southbound"
+    expect(album.songs[1].title).must_equal "The Boys Are Back In Town"
+    expect(album.songs[1].composer).must_be_instance_of Model::Artist
+    expect(album.songs[1].composer.name).must_equal "Lynott"
+    expect(album.artist).must_be_instance_of Model::Artist
+    expect(album.artist.name).must_equal "Thin Lizzy"
 
     # saved?
-    album.saved?.must_equal true
-    album.songs[0].saved?.must_equal true
-    album.songs[1].saved?.must_equal true
-    album.songs[1].composer.saved?.must_equal true
-    album.artist.saved?.must_equal true
+    expect(album.saved?).must_equal true
+    expect(album.songs[0].saved?).must_equal true
+    expect(album.songs[1].saved?).must_equal true
+    expect(album.songs[1].composer.saved?).must_equal true
+    expect(album.artist.saved?).must_equal true
   end
 
   #save returns result.
-  it { twin.save.must_equal true }
+  it { expect(twin.save).must_equal true }
   it do
     album.instance_eval { def save; false; end }
-    twin.save.must_equal false
+    expect(twin.save).must_equal false
   end
 
   # with save{}.
@@ -85,22 +85,22 @@ class SaveTest < MiniTest::Spec
       nested_hash = hash
     end
 
-    nested_hash.must_equal({"name"=>"Live And Dangerous", "songs"=>[{"title"=>"Southbound", "composer"=>nil}, {"title"=>"The Boys Are Back In Town", "composer"=>{"name"=>"Lynott"}}], "artist"=>{"name"=>"Thin Lizzy"}})
+    expect(nested_hash).must_equal({"name"=>"Live And Dangerous", "songs"=>[{"title"=>"Southbound", "composer"=>nil}, {"title"=>"The Boys Are Back In Town", "composer"=>{"name"=>"Lynott"}}], "artist"=>{"name"=>"Thin Lizzy"}})
 
     # nothing written to model.
-    album.name.must_be_nil
-    album.songs[0].title.must_be_nil
-    album.songs[1].title.must_be_nil
-    album.songs[1].composer.name.must_be_nil
-    album.artist.name.must_be_nil
+    expect(album.name).must_be_nil
+    expect(album.songs[0].title).must_be_nil
+    expect(album.songs[1].title).must_be_nil
+    expect(album.songs[1].composer.name).must_be_nil
+    expect(album.artist.name).must_be_nil
 
     # nothing saved.
     # saved?
-    album.saved?.must_be_nil
-    album.songs[0].saved?.must_be_nil
-    album.songs[1].saved?.must_be_nil
-    album.songs[1].composer.saved?.must_be_nil
-    album.artist.saved?.must_be_nil
+    expect(album.saved?).must_be_nil
+    expect(album.songs[0].saved?).must_be_nil
+    expect(album.songs[1].saved?).must_be_nil
+    expect(album.songs[1].composer.saved?).must_be_nil
+    expect(album.artist.saved?).must_be_nil
   end
 
 
@@ -136,22 +136,22 @@ class SaveTest < MiniTest::Spec
     twin.save
 
     # sync happened.
-    album.name.must_equal "Live And Dangerous"
-    album.songs[0].must_be_instance_of Model::Song
-    album.songs[1].must_be_instance_of Model::Song
-    album.songs[0].title.must_equal "Southbound"
-    album.songs[1].title.must_equal "The Boys Are Back In Town"
-    album.songs[1].composer.must_be_instance_of Model::Artist
-    album.songs[1].composer.name.must_equal "Lynott"
-    album.artist.must_be_instance_of Model::Artist
-    album.artist.name.must_equal "Thin Lizzy"
+    expect(album.name).must_equal "Live And Dangerous"
+    expect(album.songs[0]).must_be_instance_of Model::Song
+    expect(album.songs[1]).must_be_instance_of Model::Song
+    expect(album.songs[0].title).must_equal "Southbound"
+    expect(album.songs[1].title).must_equal "The Boys Are Back In Town"
+    expect(album.songs[1].composer).must_be_instance_of Model::Artist
+    expect(album.songs[1].composer.name).must_equal "Lynott"
+    expect(album.artist).must_be_instance_of Model::Artist
+    expect(album.artist.name).must_equal "Thin Lizzy"
 
     # saved?
-    album.saved?.must_equal true
-    album.songs[0].saved?.must_be_nil
-    album.songs[1].saved?.must_be_nil
-    album.songs[1].composer.saved?.must_be_nil # doesn't get saved.
-    album.artist.saved?.must_equal true
+    expect(album.saved?).must_equal true
+    expect(album.songs[0].saved?).must_be_nil
+    expect(album.songs[1].saved?).must_be_nil
+    expect(album.songs[1].composer.saved?).must_be_nil # doesn't get saved.
+    expect(album.artist.saved?).must_equal true
   end
 
   def fill_out!(twin)
@@ -185,8 +185,8 @@ end
 #     length_seconds = 120
 #     form.save(length: lambda { |value, options| form.model.id = "#{value}: #{length_seconds}" })
 
-#     song.title.must_equal "A Poor Man's Memory"
-#     song.length.must_be_nil
-#     song.id.must_equal "10: 120"
+#     song.title).must_equal "A Poor Man's Memory"
+#     song.length).must_be_nil
+#     song.id).must_equal "10: 120"
 #   end
 # end