toystore 0.9.0 → 0.10.0

data/spec/toy/association_serialization_spec.rb

@@ -0,0 +1,103 @@
+require 'helper'
+
+describe Toy::AssociationSerialization do
+  uses_constants('User', 'Game', 'Move')
+
+  before do
+    User.attribute :name, String
+    User.attribute :age, Integer
+  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
+
+      MultiJson.load(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
+      MultiJson.load(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
+
+      MultiJson.load(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
+
+      MultiJson.load(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
+
+      MultiJson.load(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
+
+      MultiJson.load(ActiveSupport::JSON.encode({:games => user.games})).should ==  {
+        'games' => [{
+          'game' => {
+            'id'      => game.id,
+            'user_id' => user.id
+          }
+        }]
+      }
+    end
+  end
+end

data/spec/toy/attribute_spec.rb

@@ -72,6 +72,22 @@ describe Toy::Attribute do
       Toy::Attribute.new(User, :age, String, :default => 1).default.should == 1
     end
 
+    it "allows defaulting to nil" do
+      Toy::Attribute.new(User, :age, String, :default => nil).default.should be_nil
+    end
+
+    it "works with callable default" do
+      default = lambda { 'foo' }
+      attribute = Toy::Attribute.new(User, :age, String, :default => default)
+      attribute.default.should == 'foo'
+    end
+
+    it "passes model to callable default" do
+      default = lambda { |model| model.name.downcase }
+      attribute = Toy::Attribute.new(User, :age, String, :default => default)
+      attribute.default.should == 'user'
+    end
+
     it "returns store_default if set for type" do
       Toy::Attribute.new(User, :skills, Array).default.should == []
     end
@@ -173,4 +189,4 @@ describe Toy::Attribute do
       Toy::Attribute.new(User, :twitter_access_token, String).abbr?.should be_false
     end
   end
-end
+end

data/spec/toy/equality_spec.rb

@@ -17,7 +17,7 @@ describe Toy::Equality do
     end
   end
 
-  describe "equal?" do
+  describe "#equal?" do
     it "returns true if same object" do
       user = User.new(:id => 1)
       user.should equal(user)
@@ -29,4 +29,11 @@ describe Toy::Equality do
       user.should_not equal(other_user)
     end
   end
-end
+
+  describe "#hash" do
+    it "returns the hash of the id" do
+      user = User.new
+      user.hash.should eq(user.id.hash)
+    end
+  end
+end

data/spec/toy/extensions/array_spec.rb

@@ -4,7 +4,7 @@ describe "Array.to_store" do
   it "should convert value to_a" do
     Array.to_store([1, 2, 3, 4]).should == [1, 2, 3, 4]
     Array.to_store('1').should == ['1']
-    Array.to_store({'1' => '2', '3' => '4'}).should == [['1', '2'], ['3', '4']]
+    Array.to_store({'1' => '2'}).should == [['1', '2']]
   end
 end
 
@@ -22,4 +22,4 @@ describe "Array.store_default" do
   it "returns emtpy array" do
     Array.store_default.should == []
   end
-end
+end

data/spec/toy/identity/uuid_key_factory_spec.rb

@@ -4,11 +4,43 @@ describe Toy::Identity::UUIDKeyFactory do
   uses_constants('User')
 
   it "should use String as key_type" do
-    Toy::Identity::UUIDKeyFactory.new.key_type.should be(String)
+    subject.key_type.should be(String)
   end
 
   it "should use uuid for next_key" do
-    Toy::Identity::UUIDKeyFactory.new.next_key(nil).length.should == 36
+    subject.next_key(nil).length.should == 36
+  end
+
+  describe "#eql?" do
+    it "returns true for same class and key type" do
+      subject.eql?(Toy::Identity::UUIDKeyFactory.new).should be_true
+    end
+
+    it "returns false for same class and different key type" do
+      other = Toy::Identity::UUIDKeyFactory.new
+      other.stub(:key_type).and_return(Integer)
+      subject.eql?(other).should be_false
+    end
+
+    it "returns false for different classes" do
+      subject.eql?(Object.new).should be_false
+    end
+  end
+
+  describe "#==" do
+    it "returns true for same class and key type" do
+      subject.==(Toy::Identity::UUIDKeyFactory.new).should be_true
+    end
+
+    it "returns false for same class and different key type" do
+      other = Toy::Identity::UUIDKeyFactory.new
+      other.stub(:key_type).and_return(Integer)
+      subject.==(other).should be_false
+    end
+
+    it "returns false for different classes" do
+      subject.==(Object.new).should be_false
+    end
   end
 
   describe "Declaring key to be uuid" do
@@ -24,4 +56,4 @@ describe Toy::Identity::UUIDKeyFactory do
       User.attributes['id'].type.should be(String)
     end
   end
-end
+end

data/spec/toy/identity_map_spec.rb

@@ -58,6 +58,10 @@ describe Toy::IdentityMap do
       user.adapter.should_not_receive(:read)
       User.get(user.id).should equal(user)
     end
+
+    it "returns nil if not found in map or adapter" do
+      User.get(1).should be_nil
+    end
   end
 
   describe "#reload" do

data/spec/toy/inheritance_spec.rb

@@ -0,0 +1,93 @@
+require 'helper'
+
+describe 'Toy Inheritance' do
+  describe 'using Toy::Object' do
+    before do
+      class ::Parent
+        include Toy::Object
+
+        attribute :name, String
+      end
+
+      class ::Child < Parent; end
+    end
+
+    after do
+      Object.send :remove_const, 'Parent' if defined?(::Parent)
+      Object.send :remove_const, 'Child'  if defined?(::Child)
+    end
+
+    it "duplicates attributes" do
+      Parent.attributes.each do |name, attribute|
+        Child.attributes.key?(name).should be_true
+        Child.attributes[name].should eq(Parent.attributes[name])
+      end
+    end
+
+    it "does not add attributes to the parent" do
+      Child.attribute(:foo, String)
+      Parent.attributes.keys.should_not include(:foo)
+    end
+
+    it "adds type attribute" do
+      Child.attribute?(:type).should be_true
+    end
+
+    it "sets type to class name" do
+      Child.new.type.should eq('Child')
+    end
+
+    it "sets the key factory to same as parent" do
+      Child.key_factory.should eq(Parent.key_factory)
+    end
+  end
+
+  describe 'using Toy::Store' do
+    before do
+      class ::Degree
+        include Toy::Store
+      end
+
+      class ::Parent
+        include Toy::Store
+
+        attribute  :name,    String
+        list       :degrees, Degree
+        reference  :degree,  Degree
+      end
+
+      class ::Child < Parent
+        list       :odd_degrees, Degree
+        reference  :odd_degree,  Degree
+      end
+    end
+
+    after do
+      Object.send :remove_const, 'Parent' if defined?(::Parent)
+      Object.send :remove_const, 'Child'  if defined?(::Child)
+      Object.send :remove_const, 'Degree' if defined?(::Degree)
+    end
+
+    it "duplicates lists" do
+      Child.lists.keys.should include(:degrees)
+      Child.lists.keys.should include(:odd_degrees)
+    end
+
+    it "does not add lists to parent" do
+      Parent.lists.keys.should_not include(:odd_degrees)
+    end
+
+    it "duplicates references" do
+      Child.references.keys.should include(:degree)
+      Child.references.keys.should include(:odd_degree)
+    end
+
+    it "does not add references to parent" do
+      Parent.references.keys.should_not include(:odd_degree)
+    end
+
+    it "sets the adapter to the same as the parent" do
+      Child.adapter.should eq(Parent.adapter)
+    end
+  end
+end

data/spec/toy/inspect_spec.rb

@@ -8,8 +8,16 @@ describe Toy::Attributes do
     User.attribute(:age, Integer)
   end
 
-  it "prints out object id and attributes sorted with values" do
-    user = User.new(:age => 28, :name => 'John')
-    user.inspect.should == %Q(#<User:#{user.object_id} age: 28, id: "#{user.id}", name: "John">)
+  describe ".inspect" do
+    it "prints out attribute names and types" do
+      User.inspect.should == %Q(User(id:String age:Integer name:String))
+    end
   end
-end
+
+  describe "#inspect" do
+    it "prints out object id and attributes sorted with values" do
+      user = User.new(:age => 28, :name => 'John')
+      user.inspect.should == %Q(#<User:#{user.object_id} id: "#{user.id}", age: 28, name: "John">)
+    end
+  end
+end

data/spec/toy/object_spec.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+describe Toy::Object do
+  uses_objects('User')
+
+  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 "#persisted?" do
+    it "returns false" do
+      User.new.persisted?.should be_false
+    end
+  end
+
+  describe "#to_key" do
+    it "returns [id] if persisted" do
+      user = User.new
+      user.stub(:persisted?).and_return(true)
+      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.new
+      user.stub(:persisted?).and_return(true)
+      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

data/spec/toy/plugins_spec.rb

@@ -31,9 +31,9 @@ describe Toy::Plugins do
     end
 
     it "adds plugins to classes declared after plugin was called" do
-      create_constant('Move')
-      Move.foo.should     == 'foo'
-      Move.new.bar.should == 'bar'
+      klass = Class.new { include Toy::Store }
+      klass.foo.should     == 'foo'
+      klass.new.bar.should == 'bar'
     end
   end
-end
+end

data/spec/toy/querying_spec.rb

@@ -1,7 +1,7 @@
 require 'helper'
 
 describe Toy::Querying do
-  uses_constants('User', 'Game')
+  uses_constants 'User', 'Game'
 
   before do
     User.attribute :name, String
@@ -87,20 +87,80 @@ describe Toy::Querying do
     end
   end
 
-  describe ".load (with hash)" do
-    before    { @doc = User.load('1', :name => 'John') }
-    let(:doc) { @doc }
+  describe ".load" do
+    before do
+      class Admin < ::User; end
+    end
+
+    after do
+      Object.send :remove_const, 'Admin' if defined?(Admin)
+    end
+
+    context "without type, hash attrs" do
+      before do
+        @doc = User.load('1', :name => 'John')
+      end
+
+      it "returns instance" do
+        @doc.should be_instance_of(User)
+      end
+
+      it "marks object as persisted" do
+        @doc.should be_persisted
+      end
+
+      it "decodes the object" do
+        @doc.name.should == 'John'
+      end
+    end
 
-    it "returns instance" do
-      doc.should be_instance_of(User)
+    context "without type, nil attrs" do
+      before do
+        @doc = User.load('1', nil)
+      end
+
+      it "returns instance" do
+        @doc.should be_instance_of(User)
+      end
+
+      it "marks object as persisted" do
+        @doc.should be_persisted
+      end
+
+      it "decodes the object" do
+        @doc.name.should be_nil
+      end
+    end
+
+    context "with symbol type" do
+      before do
+        @doc = User.load('1', :type => 'Admin', :name => 'John')
+      end
+
+      it "returns instance of type" do
+        @doc.should be_instance_of(Admin)
+      end
     end
 
-    it "marks object as persisted" do
-      doc.should be_persisted
+    context "with string type" do
+      before do
+        @doc = User.load('1', 'type' => 'Admin', :name => 'John')
+      end
+
+      it "returns instance of type" do
+        @doc.should be_instance_of(Admin)
+      end
     end
 
-    it "decodes the object" do
-      doc.name.should == 'John'
+    context "for type that doesn't exist" do
+      before do
+        Object.send :remove_const, 'Admin' if defined?(::Admin)
+        @doc = User.load('1', 'type' => 'Admin', :name => 'John')
+      end
+
+      it "returns instance of loading class" do
+        @doc.should be_instance_of(User)
+      end
     end
   end
-end
+end