disposable 0.4.6 → 0.6.1

data/test/twin/setup_test.rb

@@ -44,16 +44,16 @@ class TwinSetupTest < MiniTest::Spec
     it do
       twin = Twin::Album.new(album)
 
-      twin.songs.size.must_equal 2
-      twin.songs.must_be_instance_of Disposable::Twin::Collection
+      expect(twin.songs.size).must_equal 2
+      expect(twin.songs).must_be_instance_of Disposable::Twin::Collection
 
-      twin.songs[0].must_be_instance_of Twin::Song
-      twin.songs[0].id.must_equal 1
+      expect(twin.songs[0]).must_be_instance_of Twin::Song
+      expect(twin.songs[0].id).must_equal 1
 
-      twin.songs[1].must_be_instance_of Twin::Song
-      twin.songs[1].id.must_equal 1
-      twin.songs[1].composer.must_be_instance_of Twin::Artist
-      twin.songs[1].composer.id.must_equal 2
+      expect(twin.songs[1]).must_be_instance_of Twin::Song
+      expect(twin.songs[1].id).must_equal 1
+      expect(twin.songs[1].composer).must_be_instance_of Twin::Artist
+      expect(twin.songs[1].composer.id).must_equal 2
     end
   end
 
@@ -63,8 +63,8 @@ class TwinSetupTest < MiniTest::Spec
     it do
       twin = Twin::Album.new(album)
 
-      twin.songs.size.must_equal 0
-      twin.songs.must_be_instance_of Disposable::Twin::Collection
+      expect(twin.songs.size).must_equal 0
+      expect(twin.songs).must_be_instance_of Disposable::Twin::Collection
     end
   end
 
@@ -75,7 +75,7 @@ class TwinSetupTest < MiniTest::Spec
   #   it do
   #     twin = Twin::Album.new(album)
 
-  #     twin.songs.size.must_equal 0
+  #     twin.songs.size).must_equal 0
   #     twin.songs.must_be_instance_of Disposable::Twin::Collection
   #   end
   # end
@@ -118,23 +118,23 @@ class TwinSetupWithInlineTwinsTest < MiniTest::Spec
     twin = AlbumForm.new(album)
     # pp twin
 
-    twin.id.must_equal 0
-    twin.name.must_equal "Toto Live"
+    expect(twin.id).must_equal 0
+    expect(twin.name).must_equal "Toto Live"
 
-    twin.artist.must_be_kind_of Disposable::Twin
-    twin.artist.id.must_equal 9
+    expect(twin.artist).must_be_kind_of Disposable::Twin
+    expect(twin.artist.id).must_equal 9
 
-    twin.songs.must_be_instance_of Disposable::Twin::Collection
+    expect(twin.songs).must_be_instance_of Disposable::Twin::Collection
 
     # nil nested objects work (no composer)
-    twin.songs[0].must_be_kind_of Disposable::Twin
-    twin.songs[0].id.must_equal 1
+    expect(twin.songs[0]).must_be_kind_of Disposable::Twin
+    expect(twin.songs[0].id).must_equal 1
 
-    twin.songs[1].must_be_kind_of Disposable::Twin
-    twin.songs[1].id.must_equal 3
+    expect(twin.songs[1]).must_be_kind_of Disposable::Twin
+    expect(twin.songs[1].id).must_equal 3
 
-    twin.songs[1].composer.must_be_kind_of Disposable::Twin
-    twin.songs[1].composer.id.must_equal 2
+    expect(twin.songs[1].composer).must_be_kind_of Disposable::Twin
+    expect(twin.songs[1].composer.id).must_equal 2
   end
 end
 
@@ -149,7 +149,7 @@ class TwinWithVirtualSetupTest < MiniTest::Spec
 
   it do
     twin = AlbumTwin.new(Song.new(1), is_online: true)
-    twin.id.must_equal 1
-    twin.is_online.must_equal true
+    expect(twin.id).must_equal 1
+    expect(twin.is_online).must_equal true
   end
-end
+end

data/test/twin/skip_unchanged_test.rb

@@ -53,12 +53,12 @@ class SkipUnchangedTest < MiniTest::Spec
     twin.sync
 
     # unchanged, and no exception raised.
-    album.name.must_equal "30 Years Live"
-    song_with_composer.title.must_equal "American Jesus"
-    artist.name.must_equal "Bad Religion"
+    expect(album.name).must_equal "30 Years Live"
+    expect(song_with_composer.title).must_equal "American Jesus"
+    expect(artist.name).must_equal "Bad Religion"
 
     # this actually got synced.
-    song_with_composer.composer.name.must_equal "Greg Graffin" # was nil.
-    song.title.must_equal "Resist Stance" # was nil.
+    expect(song_with_composer.composer.name).must_equal "Greg Graffin" # was nil.
+    expect(song.title).must_equal "Resist Stance" # was nil.
   end
-end
+end

data/test/twin/struct/coercion_test.rb

@@ -21,16 +21,16 @@ class StructCoercionTest < Minitest::Spec
     twin = Expense.new( ExpenseModel.new({}) )
 
     #- direct access, without unnest
-    twin.content.amount.must_be_nil
+    expect(twin.content.amount).must_be_nil
     twin.content.amount = "1.8"
-    twin.content.amount.must_equal 1.8
+    expect(twin.content.amount).must_equal 1.8
   end
 
   it "via unnest" do
     twin = Expense.new( ExpenseModel.new({}) )
 
-    twin.amount.must_be_nil
+    expect(twin.amount).must_be_nil
     twin.amount = "1.8"
-    twin.amount.must_equal 1.8
+    expect(twin.amount).must_equal 1.8
   end
 end

data/test/twin/struct_test.rb

@@ -11,19 +11,22 @@ class TwinStructTest < MiniTest::Spec
   end
 
   # empty hash
-  # it { Song.new({}).number.must_equal 1 }
-  it { Song.new({}).number.must_be_nil } # TODO: implement default.
+  # it { Song.new({}).number).must_equal 1 }
+  it { expect(Song.new({}).number).must_be_nil } # TODO: implement default.
 
   # model hash
-  it { Song.new(number: 2).number.must_equal 2 }
+  it { expect(Song.new(number: 2).number).must_equal 2 }
 
   # with hash and options as one hash.
-  it { Song.new(number: 3, cool?: true).cool?.must_equal true }
-  it { Song.new(number: 3, cool?: true).number.must_equal 3 }
+  it { expect(Song.new(number: 3, cool?: true).cool?).must_equal true }
+  it { expect(Song.new(number: 3, cool?: true).number).must_equal 3 }
 
   # with model hash and options hash separated.
-  it { Song.new({number: 3}, {cool?: true}).cool?.must_equal true }
-  it { Song.new({number: 3}, {cool?: true}).number.must_equal 3 }
+  it { expect(Song.new({number: 3}, {cool?: true}).cool?).must_equal true }
+  it { expect(Song.new({number: 3}, {cool?: true}).number).must_equal 3 }
+
+  # with string key and false value
+  it { Song.new('number' => 3, 'cool?' => false).cool?.must_equal false }
 
 
   describe "writing" do
@@ -33,8 +36,8 @@ class TwinStructTest < MiniTest::Spec
     # writer
     it do
       song.number = 9
-      song.number.must_equal 9
-      model[:number].must_equal 3
+      expect(song.number).must_equal 9
+      expect(model[:number]).must_equal 3
     end
 
     # writer with sync
@@ -42,10 +45,10 @@ class TwinStructTest < MiniTest::Spec
       song.number = 9
       model = song.sync
 
-      song.number.must_equal 9
-      model["number"].must_equal 9
+      expect(song.number).must_equal 9
+      expect(model["number"]).must_equal 9
 
-      # song.send(:model).object_id.must_equal model.object_id
+      # song.send(:model).object_id).must_equal model.object_id
     end
   end
 end
@@ -79,26 +82,26 @@ class TwinWithNestedStructTest < MiniTest::Spec
     preferences: {show_image: true, play_teaser: 2}, roles: [{name: "user"}]}) }
 
   # public "hash" reader
-  it { Song.new(model).options.recorded.must_equal true }
+  it { expect(Song.new(model).options.recorded).must_equal true }
 
   # public "hash" writer
   it {
     song = Song.new(model)
 
     song.options.recorded = "yo"
-    song.options.recorded.must_equal "yo"
+    expect(song.options.recorded).must_equal "yo"
 
-    song.options.preferences.show_image.must_equal true
-    song.options.preferences.play_teaser.must_equal 2
+    expect(song.options.preferences.show_image).must_equal true
+    expect(song.options.preferences.play_teaser).must_equal 2
 
     song.options.preferences.show_image= 9
 
 
     song.sync # this is only called on the top model, e.g. in Reform#save.
 
-    model.title.must_equal "Seed of Fear and Anger"
-    model.options["recorded"].must_equal "yo"
-    model.options["preferences"].must_equal({"show_image" => 9, "play_teaser"=>2})
+    expect(model.title).must_equal "Seed of Fear and Anger"
+    expect(model.options["recorded"]).must_equal "yo"
+    expect(model.options["preferences"]).must_equal({"show_image" => 9, "play_teaser"=>2})
   }
 
   describe "nested writes" do
@@ -111,14 +114,14 @@ class TwinWithNestedStructTest < MiniTest::Spec
       role = song.options.roles.append({}) # add empty "model" to hash collection.
       role.name = "admin"
 
-      song.options.roles.size.must_equal 2
-      song.options.roles[0].name.must_equal "user"
-      song.options.roles[1].name.must_equal "admin"
-      model.options[:roles].must_equal([{:name=>"user"}]) # model hasn't changed, of course.
+      expect(song.options.roles.size).must_equal 2
+      expect(song.options.roles[0].name).must_equal "user"
+      expect(song.options.roles[1].name).must_equal "admin"
+      expect(model.options[:roles]).must_equal([{:name=>"user"}]) # model hasn't changed, of course.
 
       song.sync
 
-      model.options.must_equal({"recorded"=>true, "released"=>1, "preferences"=>{"show_image"=>true, "play_teaser"=>2}, "roles"=>[{"name"=>"user"}, {"name"=>"admin"}]})
+      expect(model.options).must_equal({"recorded"=>true, "released"=>1, "preferences"=>{"show_image"=>true, "play_teaser"=>2}, "roles"=>[{"name"=>"user"}, {"name"=>"admin"}]})
     end
 
     # overwriting nested property via #preferences=.
@@ -126,7 +129,7 @@ class TwinWithNestedStructTest < MiniTest::Spec
       song.options.preferences = {play_teaser: :maybe}
       song.sync
 
-      model.options.must_equal({"recorded"=>true, "released"=>1, "preferences"=>{"play_teaser"=>:maybe}, "roles"=>[{"name"=>"user"}]})
+      expect(model.options).must_equal({"recorded"=>true, "released"=>1, "preferences"=>{"play_teaser"=>:maybe}, "roles"=>[{"name"=>"user"}]})
     end
 
     # overwriting collection via #roles=.
@@ -134,7 +137,7 @@ class TwinWithNestedStructTest < MiniTest::Spec
       song.options.roles = [{name: "wizard"}]
       song.sync
 
-      model.options.must_equal({"recorded"=>true, "released"=>1, "preferences"=>{"show_image"=>true, "play_teaser"=>2}, "roles"=>[{"name"=>"wizard"}]})
+      expect(model.options).must_equal({"recorded"=>true, "released"=>1, "preferences"=>{"show_image"=>true, "play_teaser"=>2}, "roles"=>[{"name"=>"wizard"}]})
     end
   end
 
@@ -146,7 +149,7 @@ class TwinWithNestedStructTest < MiniTest::Spec
 
   #   song.sync
 
-  #   model[:options][:roles].must_equal({    })
+  #   model[:options][:roles]).must_equal({    })
 
   #   pp song
 
@@ -178,8 +181,8 @@ class StructReadableWriteableTest < Minitest::Spec
 
   it "ignores readable: false" do
     song = Song.new(length: 123, id: 1)
-    song.length.must_equal 123
-    song.id.must_be_nil
+    expect(song.length).must_equal 123
+    expect(song.id).must_be_nil
   end
 
   it "ignores writeable: false" do
@@ -209,20 +212,20 @@ class DefaultWithStructTest < Minitest::Spec
   # all given.
   it do
     twin = Twin.new(Song.new({enabled: true, roles: {admin: false}}))
-    twin.settings.enabled.must_equal true
-    twin.settings.roles.admin.must_equal false
+    expect(twin.settings.enabled).must_equal true
+    expect(twin.settings.roles.admin).must_equal false
   end
 
   # defaults, please.
   it do
     song = Song.new
     twin = Twin.new(song)
-    twin.settings.enabled.must_equal "yes"
-    twin.settings.roles.admin.must_equal "maybe"
+    expect(twin.settings.enabled).must_equal "yes"
+    expect(twin.settings.roles.admin).must_equal "maybe"
 
     twin.sync
 
-    song.settings.must_equal({"enabled"=>"yes", "roles"=>{"admin"=>"maybe"}})
+    expect(song.settings).must_equal({"enabled"=>"yes", "roles"=>{"admin"=>"maybe"}})
   end
 end
 
@@ -258,7 +261,7 @@ class CompositionWithStructTest < Minitest::Spec
 
     twin.sync
 
-    model.content.must_equal({"tags"=>["history"], "notes"=>[{"text"=>"Freedom", "index"=>0}, {"text"=>"Like", "index"=>1}, {"text"=>"Canberra trip", "index"=>2}]})
+    expect(model.content).must_equal({"tags"=>["history"], "notes"=>[{"text"=>"Freedom", "index"=>0}, {"text"=>"Like", "index"=>1}, {"text"=>"Canberra trip", "index"=>2}]})
   end
 
   class Sheet < Disposable::Twin
@@ -319,9 +322,9 @@ class CompositionWithStructTest < Minitest::Spec
 
 
 
-    sheet.tags.must_equal "#hashtag"
-    sheet.notes[0].text.must_equal "Freedom"
-    sheet.notes[0].index.must_equal 0
+    expect(sheet.tags).must_equal "#hashtag"
+    expect(sheet.notes[0].text).must_equal "Freedom"
+    expect(sheet.notes[0].index).must_equal 0
 
     sheet.notes[0].index = 2
 

data/test/twin/sync_test.rb

@@ -47,23 +47,23 @@ class TwinSyncTest < MiniTest::Spec
       fill_out!(twin)
 
       # not written to model, yet.
-      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
 
       twin.sync
 
-      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"
     end
 
     # with empty, not populated model.
@@ -82,16 +82,16 @@ class TwinSyncTest < MiniTest::Spec
       twin.songs[1].composer.name = "Lynott"
 
       # not written to model, yet.
-      album.name.must_be_nil
-      album.songs.must_equal []
-      album.artist.must_be_nil
+      expect(album.name).must_be_nil
+      expect(album.songs).must_equal []
+      expect(album.artist).must_be_nil
 
       twin.sync # this assigns a new collection via #songs=.
 
-      album.name.must_equal "Live And Dangerous"
-      album.songs[0].title.must_equal "Southbound"
-      album.songs[1].title.must_equal "The Boys Are Back In Town"
-      album.songs[1].composer.name.must_equal "Lynott"
+      expect(album.name).must_equal "Live And Dangerous"
+      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.name).must_equal "Lynott"
     end
 
     # save with block.
@@ -107,14 +107,14 @@ class TwinSyncTest < 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
       end
 
       describe "nil values" do
@@ -127,7 +127,7 @@ class TwinSyncTest < MiniTest::Spec
           nested_hash = nil
           twin.sync { |hash| nested_hash = hash }
 
-          nested_hash.must_equal({"name"=>nil, "artist"=>nil})
+          expect(nested_hash).must_equal({"name"=>nil, "artist"=>nil})
         end
 
         it "includes empty collections" do
@@ -139,7 +139,7 @@ class TwinSyncTest < MiniTest::Spec
           nested_hash = nil
           twin.sync { |hash| nested_hash = hash }
 
-          nested_hash.must_equal({"name"=>nil, "songs"=>[], "artist"=>nil})
+          expect(nested_hash).must_equal({"name"=>nil, "songs"=>[], "artist"=>nil})
         end
       end
     end

data/test/twin/twin_test.rb

@@ -35,17 +35,17 @@ class TwinTest < MiniTest::Spec
       twin = Twin::Song.new(song)
       song.id = 2
       # :from maps public name
-      twin.title.must_equal "Broken" # public: #record_name
-      twin.id.must_equal 1
+      expect(twin.title).must_equal "Broken" # public: #record_name
+      expect(twin.id).must_equal 1
     end
 
     # allows passing options.
     it do
       # override twin's value...
-      Twin::Song.new(song, :title => "Kenny").title.must_equal "Kenny"
+      expect(Twin::Song.new(song, :title => "Kenny").title).must_equal "Kenny"
 
       # .. but do not write to the model!
-      song.title.must_equal "Broken"
+      expect(song.title).must_equal "Broken"
     end
   end
 
@@ -59,28 +59,28 @@ class TwinTest < MiniTest::Spec
       twin.album = album # this is a model, not a twin.
 
       # updates twin
-      twin.id.must_equal 3
-      twin.title.must_equal "Lucky"
+      expect(twin.id).must_equal 3
+      expect(twin.title).must_equal "Lucky"
 
       # setter for nested property will twin value.
       twin.album.extend(Disposable::Comparable)
-      assert twin.album == Twin::Album.new(album) # FIXME: why does must_equal not call #== ?
+      assert twin.album == Twin::Album.new(album) # FIXME: why does) must_equal not call #== ?
 
       # setter for nested collection.
 
       # DOES NOT update model
-      song.id.must_equal 1
-      song.title.must_equal "Broken"
+      expect(song.id).must_equal 1
+      expect(song.title).must_equal "Broken"
     end
 
     describe "deleting" do
       it "allows overwriting nested twin with nil" do
         album = Model::Album.new(1, "Uncertain Terms", [], Model::Artist.new("Greg Howe"))
         twin = Twin::Album.new(album)
-        twin.artist.id.must_equal "Greg Howe"
+        expect(twin.artist.id).must_equal "Greg Howe"
 
         twin.artist = nil
-        twin.artist.must_be_nil
+        expect(twin.artist).must_be_nil
       end
     end
 
@@ -109,8 +109,8 @@ class OverridingAccessorsTest < TwinTest
   end
 
   let (:model) { Model::Song.new(1, "A Tale That Wasn't Right") }
-  it { Song.new(model).title.must_equal "a tale that wasn't right" }
-  it { Song.new(model).id.must_equal 2 }
+  it { expect(Song.new(model).title).must_equal "a tale that wasn't right" }
+  it { expect(Song.new(model).id).must_equal 2 }
 end
 
 
@@ -148,7 +148,7 @@ class AccessorsTest < Minitest::Spec
 
   it do
     twin = Twin.new(Song.new("bla"))
-    twin.format.must_equal "bla"
+    expect(twin.format).must_equal "bla"
     twin.format = "blubb"
   end
 end

data/test/twin/unnest_test.rb

@@ -16,22 +16,22 @@ class UnnestTest < MiniTest::Spec
   end
 
   it "copies property option" do
-    Twin.definitions.get(:id).extend(Declarative::Inspect).inspect.must_equal %{#<Disposable::Twin::Definition: @options={:nice=>\"yes\", :private_name=>:id, :name=>\"id\", :readable=>false, :writeable=>false}>}
-    Twin.definitions.get(:ids).extend(Declarative::Inspect).inspect.must_equal %{#<Disposable::Twin::Definition: @options={:status=>\"healthy\", :collection=>true, :private_name=>:ids, :name=>\"ids\", :readable=>false, :writeable=>false}>}
+    expect(Twin.definitions.get(:id).extend(Declarative::Inspect).inspect).must_equal %{#<Disposable::Twin::Definition: @options={:nice=>\"yes\", :private_name=>:id, :name=>\"id\", :readable=>false, :writeable=>false}>}
+    expect(Twin.definitions.get(:ids).extend(Declarative::Inspect).inspect).must_equal %{#<Disposable::Twin::Definition: @options={:status=>\"healthy\", :collection=>true, :private_name=>:ids, :name=>\"ids\", :readable=>false, :writeable=>false}>}
     # also copies :nested.
-    Twin.definitions.get(:email).extend(Declarative::Inspect).inspect.must_equal %{#<Disposable::Twin::Definition: @options={:private_name=>:email, :nested=>#<Class:>, :name=>\"email\", :readable=>false, :writeable=>false}>}
+    expect(Twin.definitions.get(:email).extend(Declarative::Inspect).inspect).must_equal %{#<Disposable::Twin::Definition: @options={:private_name=>:email, :nested=>#<Class:>, :name=>\"email\", :readable=>false, :writeable=>false}>}
   end
 
   it "exposes accessors on top-level twin" do
     twin = Twin.new(OpenStruct.new(content: OpenStruct.new()))
 
-    twin.email.must_be_nil
+    expect(twin.email).must_be_nil
     twin.email= 2
-    twin.email.model.must_equal 2
+    expect(twin.email.model).must_equal 2
 
 
-    twin.id.must_be_nil
+    expect(twin.id).must_be_nil
     twin.id = 1
-    twin.id.must_equal 1
+    expect(twin.id).must_equal 1
   end
 end

data/test/twin/virtual_test.rb

@@ -11,7 +11,7 @@ class VirtualTest < MiniTest::Spec
   it {
     twin.credit_card_number = "123"
 
-    twin.credit_card_number.must_equal "123"  # this is still readable in the UI.
+    expect(twin.credit_card_number).must_equal "123"  # this is still readable in the UI.
 
     twin.sync
 
@@ -20,7 +20,7 @@ class VirtualTest < MiniTest::Spec
       hash = nested
     end
 
-    hash.must_equal("credit_card_number"=> "123")
+    expect(hash).must_equal("credit_card_number"=> "123")
   }
 
   describe "setter should never be called with virtual:true" do
@@ -33,7 +33,7 @@ class VirtualTest < MiniTest::Spec
     end
 
     it "what" do
-      Raising.new(Object.new).id.must_be_nil
+      expect(Raising.new(Object.new).id).must_be_nil
     end
   end
 end

data/test/twin/writeable_test.rb

@@ -30,20 +30,20 @@ class WriteableTest < MiniTest::Spec
   let (:twin) { PasswordForm.new(cred) }
 
   it {
-    twin.password.must_equal "secret"
-    twin.credit_card.name.must_equal "Jonny"
-    twin.credit_card.number.must_equal "0987654321"
+    expect(twin.password).must_equal "secret"
+    expect(twin.credit_card.name).must_equal "Jonny"
+    expect(twin.credit_card.number).must_equal "0987654321"
 
     # 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
 
-    cred.inspect.must_equal '#<struct WriteableTest::Credentials password="secret", credit_card=#<struct WriteableTest::CreditCard name="Jonny", number="0987654321">>'
+    expect(cred.inspect).must_equal '#<struct WriteableTest::Credentials password="secret", credit_card=#<struct WriteableTest::CreditCard name="Jonny", number="0987654321">>'
 
     # test sync{}.
     hash = {}
@@ -51,6 +51,6 @@ class WriteableTest < 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"})
   }
-end
+end