disposable 0.4.3 → 0.5.0

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_equal 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(song = Model::Song.new)
-      album.songs[1].parent.must_equal album
+      album.songs.append(Model::Song.new)
+      expect(album.songs[1].parent).must_equal album
     end
   end
 end

data/test/twin/property_processor_test.rb

@@ -5,7 +5,7 @@ class PropertyProcessorTest < Minitest::Spec
 	Artist = Struct.new(:name)
 	Song   = Struct.new(:id)
 
- 	class AlbumTwin < Disposable::Twin
+  class AlbumTwin < Disposable::Twin
     property :title
 
     property :artist do
@@ -23,23 +23,23 @@ 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
   		twin   = AlbumTwin.new(Album.new("Live!", Artist.new, nil))
-	    
+
 	    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_equal nil            # not readable.
-    twin.credit_card.name.must_equal "Jonny"
-    twin.credit_card.number.must_equal 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_equal nil
-    album.songs[0].title.must_equal nil
-    album.songs[1].title.must_equal nil
-    album.songs[1].composer.name.must_equal nil
-    album.artist.name.must_equal 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_equal nil
-    album.songs[0].saved?.must_equal nil
-    album.songs[1].saved?.must_equal nil
-    album.songs[1].composer.saved?.must_equal nil
-    album.artist.saved?.must_equal 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_equal nil
-    album.songs[1].saved?.must_equal nil
-    album.songs[1].composer.saved?.must_equal 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_equal 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

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

@@ -0,0 +1,36 @@
+require "test_helper"
+require "disposable/twin/coercion"
+require "disposable/twin/property/struct"
+
+class StructCoercionTest < Minitest::Spec
+  ExpenseModel = Struct.new(:content)
+
+  class Expense < Disposable::Twin
+    feature Property::Struct
+    feature Coercion
+
+    property :content do
+      property :amount, type: DRY_TYPES_CONSTANT::Float | DRY_TYPES_CONSTANT::Nil
+    end
+
+    unnest :amount, from: :content
+  end
+
+
+  it do
+    twin = Expense.new( ExpenseModel.new({}) )
+
+    #- direct access, without unnest
+    expect(twin.content.amount).must_be_nil
+    twin.content.amount = "1.8"
+    expect(twin.content.amount).must_equal 1.8
+  end
+
+  it "via unnest" do
+    twin = Expense.new( ExpenseModel.new({}) )
+
+    expect(twin.amount).must_be_nil
+    twin.amount = "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_equal 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_equal 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