toystore 0.5

data/spec/toy/references_spec.rb

@@ -0,0 +1,86 @@
+require 'helper'
+
+describe Toy::References do
+  uses_constants('User', 'Game')
+
+  it "defaults references to empty hash" do
+    User.references.should == {}
+  end
+
+  describe ".reference?" do
+    before do
+      Game.reference(:user)
+    end
+
+    it "returns true if attribute (symbol)" do
+      Game.reference?(:user).should be_true
+    end
+
+    it "returns true if attribute (string)" do
+      Game.reference?('user').should be_true
+    end
+
+    it "returns false if not attribute" do
+      Game.reference?(:foobar).should be_false
+    end
+  end
+
+  describe "declaring a reference" do
+    before do
+      @reference = Game.reference(:user)
+    end
+
+    it "knows about its references" do
+      Game.references[:user].should == Toy::Reference.new(Game, :user)
+    end
+
+    it "returns reference" do
+      @reference.should == Toy::Reference.new(Game, :user)
+    end
+  end
+
+  describe "declaring a reference with options" do
+    before do
+      @reference = Game.reference(:user, :some_option => true)
+    end
+    let(:reference) { @reference }
+
+    it "sets type" do
+      reference.type.should be(User)
+    end
+
+    it "sets options" do
+      reference.options.should == {:some_option => true}
+    end
+  end
+
+  describe "declaring a reference with type" do
+    before do
+      @reference = Game.reference(:creator, User)
+    end
+    let(:reference) { @reference }
+
+    it "sets type" do
+      reference.type.should be(User)
+    end
+
+    it "sets options" do
+      reference.options.should == {}
+    end
+  end
+
+  describe "declaring a reference with type and options" do
+    before do
+      @reference = Game.reference(:creator, User, :some_option => true)
+    end
+    let(:reference) { @reference }
+
+    it "sets type" do
+      reference.type.should be(User)
+    end
+
+    it "sets options" do
+      reference.options.should == {:some_option => true}
+    end
+  end
+end

data/spec/toy/serialization_spec.rb

@@ -0,0 +1,354 @@
+require 'helper'
+
+describe Toy::Serialization do
+  uses_constants('User', 'Game', 'Move', 'Tile')
+
+  before do
+    User.attribute :name, String
+    User.attribute :age, Integer
+  end
+
+  it "serializes to json" do
+    doc = User.new(:name => 'John', :age => 28)
+    ActiveSupport::JSON.decode(doc.to_json).should == {
+      'user' => {
+        'name' => 'John',
+        'id' => doc.id,
+        'age' => 28
+      }
+    }
+  end
+
+  it "serializes to xml" do
+    doc = User.new(:name => 'John', :age => 28)
+    Hash.from_xml(doc.to_xml).should == {
+      'user' => {
+        'name' => 'John',
+        'id' => doc.id,
+        'age' => 28
+      }
+    }
+
+  end
+
+  it "correctly serializes methods" do
+    User.class_eval do
+      def foo
+        {'foo' => 'bar'}
+      end
+    end
+    json = User.new.to_json(:methods => [:foo])
+    ActiveSupport::JSON.decode(json)['user']['foo'].should == {'foo' => 'bar'}
+  end
+
+  it "allows using :only" do
+    user = User.new
+    json = user.to_json(:only => :id)
+    ActiveSupport::JSON.decode(json).should == {'user' => {'id' => user.id}}
+  end
+
+  it "allows using :only with strings" do
+    user = User.new
+    json = user.to_json(:only => 'id')
+    ActiveSupport::JSON.decode(json).should == {'user' => {'id' => user.id}}
+  end
+
+  it "allows using :except" do
+    user = User.new
+    json = user.to_json(:except => :id)
+    ActiveSupport::JSON.decode(json)['user'].should_not have_key('id')
+  end
+
+  it "allows using :except with strings" do
+    user = User.new
+    json = user.to_json(:except => 'id')
+    ActiveSupport::JSON.decode(json)['user'].should_not have_key('id')
+  end
+
+  describe "serializing with embedded documents" do
+    before do
+      Game.reference(:creator, User)
+
+      Move.attribute(:index,  Integer)
+      Move.attribute(:points, Integer)
+      Move.attribute(:words,  Array)
+
+      Tile.attribute(:row,    Integer)
+      Tile.attribute(:column, Integer)
+      Tile.attribute(:index,  Integer)
+
+      Game.embedded_list(:moves)
+      Move.embedded_list(:tiles)
+
+      @user = User.create
+      @game = Game.create!(:creator => @user, :move_attributes => [
+        :index            => 0,
+        :points           => 15,
+        :tile_attributes => [
+          {:column => 7, :row => 7, :index => 23},
+          {:column => 8, :row => 7, :index => 24},
+        ],
+      ])
+    end
+
+    it "includes all embedded attributes by default" do
+      move = @game.moves.first
+      tile1 = move.tiles[0]
+      tile2 = move.tiles[1]
+      ActiveSupport::JSON.decode(@game.to_json).should == {
+        'game' => {
+          'id'         => @game.id,
+          'creator_id' => @user.id,
+          'moves'      => [
+            {
+              'id'     => move.id,
+              'index'  => 0,
+              'points' => 15,
+              'words'  => [],
+              'tiles'  => [
+                {'id' => tile1.id, 'column' => 7, 'row' => 7, 'index' => 23},
+                {'id' => tile2.id, 'column' => 8, 'row' => 7, 'index' => 24},
+              ]
+            },
+          ],
+        }
+      }
+    end
+  end
+
+  describe "serializing relationships" do
+    before do
+      User.list :games, :inverse_of => :user
+      Game.reference :user
+    end
+
+    it "should include references" do
+      user = User.create(:name => 'John', :age => 28)
+      game = user.games.create
+
+      ActiveSupport::JSON.decode(game.to_json(:include => [:user])).should == {
+        'game' => {
+          'id'      => game.id,
+          'user_id' => user.id,
+          'user'    => {
+            'name'     => 'John',
+            'game_ids' => [game.id],
+            'id'       => user.id,
+            'age'      => 28,
+          }
+        }
+      }
+    end
+
+    it "should include lists" do
+      user = User.create(:name => 'John', :age => 28)
+      game = user.games.create
+      ActiveSupport::JSON.decode(user.to_json(:include => [:games])).should == {
+        'user' => {
+          'name'     => 'John',
+          'game_ids' => [game.id],
+          'id'       => user.id,
+          'age'      => 28,
+          'games'    => [{'id' => game.id, 'user_id' => user.id}],
+        }
+      }
+    end
+
+    it "should not cause circular reference JSON errors for references" do
+      user = User.create(:name => 'John', :age => 28)
+      game = user.games.create
+
+      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(game.user)).should == {
+        'user' => {
+          'name'     => 'John',
+          'game_ids' => [game.id],
+          'id'       => user.id,
+          'age'      => 28
+        }
+      }
+    end
+
+    it "should not cause circular reference JSON errors for references when called indirectly" do
+      user = User.create(:name => 'John', :age => 28)
+      game = user.games.create
+
+      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode([game.user])).should == [
+        'user' => {
+          'name'     => 'John',
+          'game_ids' => [game.id],
+          'id'       => user.id,
+          'age'      => 28
+        }
+      ]
+    end
+
+    it "should not cause circular reference JSON errors for lists" do
+      user = User.create(:name => 'John', :age => 28)
+      game = user.games.create
+
+      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(user.games)).should ==  [{
+        'game' => {
+          'id'      => game.id,
+          'user_id' => user.id
+        }
+      }]
+    end
+
+    it "should not cause circular reference JSON errors for lists when called indirectly" do
+      user = User.create(:name => 'John', :age => 28)
+      game = user.games.create
+
+      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode({:games => user.games})).should ==  {
+        'games' => [{
+          'game' => {
+            'id'      => game.id,
+            'user_id' => user.id
+          }
+        }]
+      }
+    end
+  end
+
+  describe "serializing parent relationships" do
+    before do
+      Game.embedded_list :moves
+      Move.parent_reference :game
+    end
+
+    it "should include references" do
+      game = Game.create
+      move = game.moves.create
+
+      ActiveSupport::JSON.decode(move.to_json(:include => [:game])).should == {
+        'move' => {
+          'id' => move.id,
+          'game' => {
+            'id' => game.id,
+            'moves' => [{
+              'id' => move.id
+            }]
+          }
+        }
+      }
+    end
+  end
+
+  describe "serializing specific attributes" do
+    before do
+      Move.attribute(:index,  Integer)
+      Move.attribute(:points, Integer)
+      Move.attribute(:words,  Array)
+    end
+
+    it "should default to all attributes" do
+      move = Move.new(:index => 0, :points => 15, :words => ['QI', 'XI'])
+      move.serializable_attributes.should == [:id, :index, :points, :words]
+    end
+
+    it "should be set per model" do
+      Move.class_eval do
+        def serializable_attributes
+          attribute_names = super - [:index]
+          attribute_names
+        end
+      end
+
+      move = Move.new(:index => 0, :points => 15, :words => ['QI', 'XI'])
+      move.serializable_attributes.should == [:id, :points, :words]
+    end
+
+    it "should only serialize specified attributes" do
+      Move.class_eval do
+        def serializable_attributes
+          attribute_names = super - [:index]
+          attribute_names
+        end
+      end
+
+      move = Move.new(:index => 0, :points => 15, :words => ['QI', 'XI'])
+      ActiveSupport::JSON.decode(move.to_json).should == {
+       'move' => {
+         'id'     => move.id,
+         'points' => 15,
+         'words'  => ["QI", "XI"]
+        }
+      }
+    end
+
+    it "should serialize additional methods along with attributes" do
+      Move.class_eval do
+        def serializable_attributes
+          attribute_names = super + [:calculated_attribute]
+          attribute_names
+        end
+
+        def calculated_attribute
+          'some value'
+        end
+      end
+
+      move = Move.new(:index => 0, :points => 15, :words => ['QI', 'XI'])
+      ActiveSupport::JSON.decode(move.to_json).should == {
+       'move' => {
+         'id'                   => move.id,
+         'index'                => 0,
+         'points'               => 15,
+         'words'                => ["QI", "XI"],
+         'calculated_attribute' => 'some value'
+        }
+      }
+    end
+  end
+
+  describe "#serializable_hash" do
+    context "with embedded list" do
+      before do
+        Game.embedded_list :moves
+        Move.parent_reference :game
+
+        @game = Game.create
+        @move = game.moves.create
+      end
+      let(:game) { @game }
+
+      it "returns a hash the whole way through" do
+        game.serializable_hash.should == {
+          'id' => game.id,
+          'moves' => [
+            {'id' => game.moves.first.id}
+          ]
+        }
+      end
+
+      it "allows using only with embedded" do
+        game.serializable_hash(:only => :moves).should == {
+          'moves' => [
+            {'id' => game.moves.first.id}
+          ]
+        }
+      end
+
+      it "allows using except to not include embedded" do
+        game.serializable_hash(:except => :moves).should == {
+          'id' => game.id,
+        }
+      end
+    end
+
+    context "with method that is another toystore object" do
+      before do
+        Game.reference(:creator, User)
+        @game = Game.create(:creator => User.create)
+      end
+      let(:game) { @game }
+
+      it "returns serializable hash of object" do
+        game.serializable_hash(:methods => [:creator]).should == {
+          'id'         => game.id,
+          'creator_id' => game.creator_id,
+          'creator'    => {'id' => game.creator.id}
+        }
+      end
+    end
+  end
+end

data/spec/toy/store_spec.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+describe Toy::Store do
+  uses_constants('User')
+
+  describe "including" do
+    it "adds model naming" do
+      model_name = User.model_name
+      model_name.should           == 'User'
+      model_name.singular.should  == 'user'
+      model_name.plural.should    == 'users'
+    end
+
+    it "adds to_model" do
+      user = User.new
+      user.to_model.should == user
+    end
+
+    describe "#to_key" do
+      it "returns [id] if persisted" do
+        user = User.create
+        user.to_key.should == [user.id]
+      end
+
+      it "returns nil if not persisted" do
+        User.new.to_key.should be_nil
+      end
+    end
+
+    describe "#to_param" do
+      it "returns key joined by - if to_key present" do
+        user = User.create
+        user.to_param.should == user.to_key.join('-')
+      end
+
+      it "returns nil if to_key nil" do
+        User.new.to_param.should be_nil
+      end
+    end
+  end
+end