disposable 0.0.9 → 0.1.0

data/test/twin/collection_test.rb

@@ -0,0 +1,223 @@
+require 'test_helper'
+
+# reason: unique API for collection (adding, removing, deleting, etc.)
+#         delay DB write until saving Twin
+
+# TODO: eg "after delete hook (dynamic_delete)", after_add
+
+class TwinCollectionTest < MiniTest::Spec
+  module Model
+    Song  = Struct.new(:id, :title, :album)
+    Album = Struct.new(:id, :name, :songs, :artist)
+  end
+
+
+  module Twin
+    class Album < Disposable::Twin
+      property :id # DISCUSS: needed for #save.
+      property :name
+      collection :songs, :twin => lambda { |*| Song }
+    end
+
+    class Song < Disposable::Twin
+      property :id # DISCUSS: needed for #save.
+      property :title
+      property :album, :twin => Album
+    end
+  end
+
+  let (:song) { Model::Song.new(1, "Broken", nil) }
+  let (:album) { Model::Album.new(1, "The Rest Is Silence", [song]) }
+
+  describe "reader for collection" do
+    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
+
+    end
+  end
+end
+
+require "disposable/twin/sync"
+require "disposable/twin/save"
+
+class TwinCollectionActiveRecordTest < MiniTest::Spec
+  module Twin
+    class Album < Disposable::Twin
+      property :id # DISCUSS: needed for #save.
+      property :name
+      collection :songs, :twin => lambda { |*| Song }
+      property :artist, twin: lambda { |*| Artist }
+
+      include Sync
+      include Save
+      include Setup
+      include Collection::Semantics
+    end
+
+    class Song < Disposable::Twin
+      property :id # DISCUSS: needed for #save.
+      property :title
+
+      # property :persisted?, readonly: true # TODO: implement that!!!! for #sync
+
+      include Sync
+      include Save
+    end
+
+    class Artist < Disposable::Twin
+    end
+  end
+
+  let (:album) { Album.create(name: "The Rest Is Silence") }
+  let (:song1) { Song.new(title: "Snorty Pacifical Rascal") } # unsaved.
+  let (:song2) { Song.create(title: "At Any Cost") } # saved.
+  let (:twin) { Twin::Album.new(album) }
+
+  it do
+    # TODO: test all writers.
+    twin.songs << song1 # assuming that we add AR model here.
+    twin.songs << song2
+
+    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
+
+    # 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
+
+    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"
+
+    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"
+  end
+
+  # test with adding to existing collection [song1] << song2
+
+  # TODO: #delete non-existent twin.
+  describe "#delete" do
+    let (:album) { Album.create(name: "The Rest Is Silence", songs: [song1]) }
+
+    it do
+      twin.songs.delete(twin.songs.first)
+
+      twin.songs.size.must_equal 0
+      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
+    end
+
+    # non-existant delete.
+    it do
+      twin.songs.delete("non-existant") # won't delete anything.
+      twin.songs.size.must_equal 1
+    end
+  end
+
+  describe "#destroy" do
+    let (:album) { Album.create(name: "The Rest Is Silence", songs: [song1]) }
+
+    it do
+      twin.songs.destroy(twin.songs.first)
+
+      twin.songs.size.must_equal 0
+      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
+    end
+  end
+
+
+  describe "#added" do
+    let (:album) { Album.create(name: "The Rest Is Silence", songs: [song1]) }
+
+    it do
+      twin = Twin::Album.new(album)
+
+      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]]
+
+      # 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]) }
+
+    it do
+      twin = Twin::Album.new(album)
+
+      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]]
+
+      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 []
+    end
+  end
+end
+
+
+class CollectionUnitTest < MiniTest::Spec
+  module Twin
+    class Album < Disposable::Twin
+    end
+
+    class Song < Disposable::Twin
+      property :album, twin: Twin::Album
+    end
+  end
+
+  module Model
+    Album = Struct.new(:id, :name, :songs, :artist)
+  end
+
+  let(:collection) { Disposable::Twin::Collection.new(Disposable::Twin::Twinner.new(Twin::Song.representer_class.representable_attrs.get(:album)), []) }
+
+  # #insert(index, model)
+  it do
+    collection.insert(0, Model::Album.new).must_be_instance_of Twin::Album
+  end
+
+  # #<<
+  it do
+    collection << Model::Album.new
+    collection[0].must_be_instance_of Twin::Album
+  end
+end

data/test/twin/composition_test.rb

@@ -1,20 +1,18 @@
 require 'test_helper'
 
-require 'disposable/twin/composition'
-
+# Disposable::Twin::Composition.
 class TwinCompositionTest < MiniTest::Spec
-  class Request < Disposable::Twin::Composition
-    property :song_title, :on => :song, :from => :title
-    property :song_id,    :on => :song, :from => :id
-
-    property :name,       :on => :requester
-    property :id,         :on => :requester
+  class Request < Disposable::Twin
+    include Sync
+    include Save
+    include Composition
 
-    # map ...
+    property :song_title, on: :song, from: :title
+    property :song_id,    on: :song, from: :id
 
-    # def id
-    # make map(name, options)
-    # option :played?
+    property :name,       on: :requester
+    property :id,         on: :requester
+    property :captcha,    readable: false, writeable: false, on: :requester # TODO: allow both, virtual with and without :on.
   end
 
   module Model
@@ -22,24 +20,57 @@ class TwinCompositionTest < MiniTest::Spec
     Requester = Struct.new(:id, :name)
   end
 
-  let (:requester) { Model::Requester.new(1, "Greg Howe") }
-  let (:song) { Model::Song.new(2, "Extraction") }
+  let (:requester) { Model::Requester.new(1, "Greg Howe").extend(Disposable::Saveable) }
+  let (:song) { Model::Song.new(2, "Extraction").extend(Disposable::Saveable) }
+
+  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
+
+    request.song_title = "Tease"
+    request.name = "Wooten"
+
+
+    request.song_title.must_equal "Tease"
+    request.name.must_equal "Wooten"
+
+    # does not write to model.
+    song.title.must_equal "Extraction"
+    requester.name.must_equal "Greg Howe"
+
+
+    request.save
+
+    # 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"
+
+    song.saved?.must_equal true
+    requester.saved?.must_equal true
+  end
 
-  let (:request) { Request.new(:song => song, :requester => requester) }
+  # save with block.
+  it do
+    request.song_title = "Tease"
+    request.name = "Wooten"
+    request.captcha = "Awesome!"
 
-  it { request.song_title.must_equal "Extraction" }
-  it { request.name.must_equal "Greg Howe" }
+    # does not write to model.
+    song.title.must_equal "Extraction"
+    requester.name.must_equal "Greg Howe"
 
 
-  describe "setter" do
-    before do
-      request.song_title = "Tease"
-      request.name = "Wooten"
+    nested_hash = nil
+    request.save do |hash|
+      nested_hash = hash
     end
 
-    it { request.song_title.must_equal "Tease" }
-    # no writing to model.
-    it { song.title.must_equal "Extraction" }
-    it { request.name.must_equal "Wooten" }
+    nested_hash.must_equal(:song=>{"title"=>"Tease", "id"=>2}, :requester=>{"name"=>"Wooten", "id"=>1, "captcha"=>"Awesome!"})
   end
 end

data/test/twin/expose_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+# Disposable::Twin::Expose.
+class TwinExposeTest < MiniTest::Spec
+  class Request < Disposable::Twin
+    feature Sync
+    feature Save
+    feature Expose
+
+    property :song_title, from: :title
+    property :id
+    # virtual.
+    property :captcha,    readable: false, writeable: false
+    # nested.
+    property :album do
+      property :name, from: :getName
+    end
+  end
+
+  module Model
+    Song  = Struct.new(:id, :title, :album)
+    Album = Struct.new(:getName)
+  end
+
+  let (:album) { Model::Album.new("Appeal To Reason").extend(Disposable::Saveable) }
+  let (:song) { Model::Song.new(2, "Extraction", album).extend(Disposable::Saveable) }
+
+  let (:request) { Request.new(song) }
+
+  it do
+    request.song_title.must_equal "Extraction"
+    request.id.must_equal 2
+
+    request.song_title = "Tease"
+    request.id = 1
+
+
+    request.song_title.must_equal "Tease"
+    request.id.must_equal 1
+
+    # does not write to model.
+    song.title.must_equal "Extraction"
+    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.
+
+    song.saved?.must_equal true
+  end
+
+  # save with block.
+  it do
+    request.song_title = "Tease"
+    request.id = 1
+    request.captcha = "Awesome!"
+
+    nested_hash = nil
+    request.save do |hash|
+      nested_hash = hash
+    end
+
+    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"
+  end
+end

data/test/twin/feature_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class FeatureTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  module Date
+    def date
+      "May 16"
+    end
+  end
+
+  module Instrument
+    def instrument
+      "Violins"
+    end
+  end
+
+  class AlbumForm < Disposable::Twin
+    include Setup
+    feature Date
+    property :name
+
+    collection :songs do
+      include Setup
+      property :title
+
+      property :composer do
+        include Setup
+        feature Instrument
+        property :name
+      end
+    end
+
+    property :artist do
+      include Setup
+      property :name
+    end
+  end
+
+  let (:song)               { Song.new("Broken") }
+  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let (:composer)           { Artist.new("Greg Graffin") }
+  let (:artist)             { Artist.new("Bad Religion") }
+  let (:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+
+  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"
+  end
+end