toystore 0.5

data/spec/toy/plugins_spec.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+describe Toy::Plugins do
+  uses_constants('User', 'Game')
+
+  it "keeps track of class that include toy store" do
+    Toy.models.should == [User, Game].to_set
+  end
+
+  describe ".plugin" do
+    before do
+      class_methods_mod    = Module.new { def foo; 'foo' end }
+      instance_methods_mod = Module.new { def bar; 'bar' end }
+
+      @mod = Module.new { extend ActiveSupport::Concern }
+      @mod.const_set(:ClassMethods,    class_methods_mod)
+      @mod.const_set(:InstanceMethods, instance_methods_mod)
+
+      Toy.plugin(@mod)
+    end
+
+    it "includes module in all models" do
+      [User, Game].each do |model|
+        model.foo.should     == 'foo'
+        model.new.bar.should == 'bar'
+      end
+    end
+
+    it "adds plugin to plugins" do
+      Toy.plugins.should == [@mod].to_set
+    end
+
+    it "adds plugins to classes declared after plugin was called" do
+      create_constant('Move')
+      Move.foo.should     == 'foo'
+      Move.new.bar.should == 'bar'
+    end
+  end
+end

data/spec/toy/querying_spec.rb

@@ -0,0 +1,162 @@
+require 'helper'
+
+describe Toy::Querying do
+  uses_constants('User', 'Game')
+
+  before do
+    User.attribute :name, String
+  end
+
+  describe ".get" do
+    it "returns document if found" do
+      john = User.create(:name => 'John')
+      User.get(john.id).name.should == 'John'
+    end
+
+    it "returns nil if not found" do
+      User.get('1').should be_nil
+    end
+  end
+
+  describe ".get!" do
+    it "returns document if found" do
+      john = User.create(:name => 'John')
+      User.get!(john.id).name.should == 'John'
+    end
+
+    it "raises not found exception if not found" do
+      lambda {
+        User.get!('1')
+      }.should raise_error(Toy::NotFound, 'Could not find document with id: "1"')
+    end
+  end
+
+  describe ".get_multi" do
+    it "returns array of documents" do
+      john  = User.create(:name => 'John')
+      steve = User.create(:name => 'Steve')
+      User.get_multi(john.id, steve.id).should == [john, steve]
+    end
+  end
+
+  describe ".get_or_new" do
+    it "returns found" do
+      user = User.create
+      User.get_or_new(user.id).should == user
+    end
+
+    it "creates new with id set if not found" do
+      user = User.get_or_new('foo')
+      user.should be_instance_of(User)
+      user.id.should == 'foo'
+    end
+  end
+
+  describe ".get_or_create" do
+    it "returns found" do
+      user = User.create
+      User.get_or_create(user.id).should == user
+    end
+
+    it "creates new with id set if not found" do
+      user = User.get_or_create('foo')
+      user.should be_instance_of(User)
+      user.id.should == 'foo'
+    end
+  end
+
+  describe ".key?" do
+    it "returns true if key exists" do
+      user = User.create(:name => 'John')
+      User.key?(user.id).should be_true
+    end
+
+    it "returns false if key does not exist" do
+      User.key?('taco:bell:tacos').should be_false
+    end
+  end
+
+  describe ".has_key?" do
+    it "returns true if key exists" do
+      user = User.create(:name => 'John')
+      User.has_key?(user.id).should be_true
+    end
+
+    it "returns false if key does not exist" do
+      User.has_key?('taco:bell:tacos').should be_false
+    end
+  end
+
+  describe ".load (with hash)" do
+    before    { @doc = User.load(:id => '1', :name => 'John') }
+    let(:doc) { @doc }
+
+    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
+
+  describe "with cache store" do
+    before do
+      @cache  = User.cache(:memory, {})
+      @memory = User.store(:memory, {})
+      @user   = User.create
+      Toy.identity_map.clear # ensure we are just working with database
+    end
+
+    let(:cache)   { @cache }
+    let(:memory)  { @memory }
+    let(:user)    { @user }
+
+    describe "not found in cache or store" do
+      before do
+        cache.delete(user.store_key)
+        memory.delete(user.store_key)
+      end
+
+      it "returns nil" do
+        User.get('foo').should be_nil
+      end
+    end
+
+    describe "not found in cache" do
+      before do
+        cache.delete(user.store_key)
+      end
+
+      it "returns from store" do
+        User.get(user.id).should == user
+      end
+
+      it "populates cache" do
+        cache.key?(user.store_key).should be_false
+        User.get(user.id)
+        cache.key?(user.store_key).should be_true
+      end
+    end
+
+    describe "found in cache" do
+      before do
+        cache.key?(user.store_key).should be_true
+      end
+
+      it "returns from cache" do
+        cache.should_receive(:read).with(user.store_key).and_return(user.persisted_attributes)
+        User.get(user.id)
+      end
+
+      it "does not hit store" do
+        memory.should_not_receive(:read)
+        User.get(user.id)
+      end
+    end
+  end
+end

data/spec/toy/reference_spec.rb

@@ -0,0 +1,400 @@
+require 'helper'
+
+describe Toy::Reference do
+  uses_constants('User', 'Game', 'Move')
+
+  before do
+    @reference = Game.reference(:user)
+  end
+
+  let(:reference)  { @reference }
+
+  it "has model" do
+    reference.model.should == Game
+  end
+
+  it "has name" do
+    reference.name.should == :user
+  end
+
+  it "has type" do
+    reference.type.should == User
+  end
+
+  it "has key" do
+    reference.key.should == :user_id
+  end
+
+  it "has instance_variable" do
+    reference.instance_variable.should == :@_user
+  end
+
+  it "adds reference to model" do
+    Game.references.keys.should include(:user)
+  end
+
+  it "adds attribute to model" do
+    Game.attributes.keys.should include('user_id')
+  end
+
+  it "adds reader method" do
+    Game.new.should respond_to(:user)
+  end
+
+  it "adds writer method" do
+    Game.new.should respond_to(:user=)
+  end
+
+  describe "#eql?" do
+    it "returns true if same class, model, and name" do
+      reference.should eql(reference)
+    end
+
+    it "returns false if not same class" do
+      reference.should_not eql({})
+    end
+
+    it "returns false if not same model" do
+      reference.should_not eql(Toy::Reference.new(Move, :user))
+    end
+
+    it "returns false if not the same name" do
+      reference.should_not eql(Toy::Reference.new(Game, :move))
+    end
+  end
+
+  describe "setting reference type" do
+    before do
+      @reference = Game.reference(:creator, User)
+    end
+    let(:reference) { @reference }
+
+    it "uses type provided instead of inferring from name" do
+      reference.type.should be(User)
+    end
+
+    it "works properly when reading and writing" do
+      user = User.create
+      game = Game.create
+      game.creator = user
+      game.creator.should == user
+    end
+  end
+
+  describe "reference reader" do
+    before do
+      @user = User.create
+      @game = Game.create(:user_id => @user.id)
+    end
+
+    it "returns instance" do
+      @game.user.should == @user
+    end
+
+    it "memoizes result" do
+      @game.user.should == @user
+      User.should_not_receive(:get)
+      @game.user.should == @user
+    end
+
+    it "does not query if id attribute is blank" do
+      game = Game.create
+      User.should_not_receive(:get)
+      game.user
+    end
+  end
+
+  describe "reference writer" do
+    before do
+      @user1 = User.create
+      @user2 = User.create
+      @game  = Game.create
+      @game.user = @user1
+    end
+
+    it "sets the attribute" do
+      @game.user_id.should == @user1.id
+    end
+
+    it "unmemoizes the reader" do
+      @game.user.should == @user1
+      @game.user = @user2
+      @game.user.should == @user2
+    end
+
+    it "raises error if wrong type assigned" do
+      lambda {
+        @game.user = Move.new
+      }.should raise_error(ArgumentError, "User expected, but was Move")
+    end
+
+    it "should not reload target when setting to an object" do
+      User.should_not_receive(:get)
+      user = User.new
+      @game.user = user
+      @game.user.should == user
+    end
+
+    describe "with nil value" do
+      before do
+        @game.user = nil
+      end
+
+      it "returns nil for reader" do
+        @game.user.should be_nil
+      end
+
+      it "returns nil for attribute" do
+        @game.user_id.should be_nil
+      end
+    end
+  end
+
+  describe "reference boolean" do
+    before do
+      @user = User.create
+      @game = Game.create
+    end
+
+    it "returns false if not set" do
+      @game.user?.should be_false
+    end
+
+    it "returns true if set" do
+      @game.user = @user
+      @game.user?.should be_true
+    end
+  end
+
+  describe "reference#nil?" do
+    before do
+      @user = User.create
+      @game = Game.create
+    end
+
+    it "returns true if nil" do
+      @game.user.should be_nil
+    end
+
+    it "returns false if not nil" do
+      @game.user = @user
+      @game.user.should_not be_nil
+    end
+  end
+
+  describe "reference#blank?" do
+    before do
+      @user = User.create
+      @game = Game.create
+    end
+
+    it "returns true if nil" do
+      @game.user.should be_blank
+    end
+
+    it "returns false if not nil" do
+      @game.user = @user
+      @game.user.should_not be_blank
+    end
+  end
+
+  describe "reference#present?" do
+    before do
+      @user = User.create
+      @game = Game.create
+    end
+
+    it "returns true if present" do
+      @game.user = @user
+      @game.user.should be_present
+    end
+
+    it "returns false if not present" do
+      @game.user.should_not be_present
+    end
+  end
+
+  describe "reference#reset" do
+    before do
+      @user = User.create
+      @game = Game.create(:user => @user)
+    end
+
+    it "unmemoizes the list" do
+      @game.user.should == @user
+      @game.user.reset
+      User.should_receive(:get).and_return(@user)
+      @game.user.should == @user
+    end
+
+    it "should be reset when owner is reloaded" do
+      @game.reload
+      User.should_receive(:get).and_return(@user)
+      @game.user.should == @user
+    end
+  end
+
+  context "delegating" do
+    describe "when target is nil" do
+      before do
+        @game = Game.create
+      end
+
+      it "returns nil if nil" do
+        @game.user.inspect.should == 'nil'
+      end
+
+      it "delegates #kind_of?" do
+        @game.user.kind_of?(NilClass).should be_true
+        @game.user.kind_of?(User).should be_false
+      end
+
+      it "delegates #instance_of?" do
+        @game.user.instance_of?(NilClass).should be_true
+        @game.user.instance_of?(User).should be_false
+      end
+
+      it "delegates #is_a?" do
+        @game.user.is_a?(NilClass).should be_true
+        @game.user.is_a?(User).should be_false
+      end
+
+      it "delegates #eql?" do
+        @game.user.should eql(nil)
+        @game.user.should_not eql(User.create)
+        @game.user.should_not eql(@game)
+      end
+
+      it "delegates #equal?" do
+        @game.user.should equal(nil)
+        @game.user.should_not equal(User.create)
+        @game.user.should_not equal(@game)
+      end
+    end
+
+    describe "when target is not nil" do
+      before do
+        @user = User.create
+        @game = Game.create(:user => @user)
+      end
+
+      it "delegates #inspect" do
+        @game.user = @user
+        @game.user.inspect.should == %Q(#<User:#{@user.object_id} id: "#{@user.id}">)
+      end
+
+      it "delegates #==" do
+        (@game.user == @user).should be_true
+        (@user == @game.user).should be_true
+      end
+
+      it "delegates #is_a?" do
+        @game.user.is_a?(User).should be_true
+        @game.user.is_a?(Game).should be_false
+      end
+
+      it "delegates #kind_of?" do
+        @game.user.kind_of?(User).should be_true
+        @game.user.kind_of?(Game).should be_false
+      end
+
+      it "delegates #instance_of?" do
+        @game.user.instance_of?(User).should be_true
+        @game.user.instance_of?(Game).should be_false
+      end
+
+      it "delegates #eql?" do
+        @game.user.should eql(@user)
+        @game.user.should_not eql(User.create)
+        @game.user.should_not eql(@game)
+      end
+
+      it "delegates #equal?" do
+        @game.user.should equal(@user)
+        @user.should equal(@game.user)
+        @game.user.should equal(User.get(@user.id)) # identity map
+        @game.user.should_not equal(User.create)
+        @game.user.should_not equal(@game)
+      end
+    end
+  end
+
+  shared_examples_for 'reference#create' do
+    it "returns instance" do
+      @user.should be_instance_of(User)
+    end
+
+    it "creates instance" do
+      @user.should be_persisted
+    end
+
+    it "sets id attribute" do
+      @game.user_id.should == @user.id
+    end
+  end
+
+  describe "reference#create" do
+    before do
+      @game = Game.create
+      @user = @game.user.create
+    end
+
+    it_should_behave_like 'reference#create'
+  end
+
+  describe "reference#create (with attributes)" do
+    before do
+      User.attribute(:name, String)
+      @game = Game.create
+      @user = @game.user.create(:name => 'John')
+    end
+
+    it_should_behave_like 'reference#create'
+
+    it "sets attributes" do
+      @user.name.should == 'John'
+    end
+  end
+
+  shared_examples_for 'reference#build' do
+    it "returns instance" do
+      @user.should be_instance_of(User)
+    end
+
+    it "builds instance" do
+      @user.should_not be_persisted
+    end
+
+    it "sets id attribute" do
+      @game.user_id.should == @user.id
+    end
+
+    it "does not save owner" do
+      @game.should_not_receive(:save)
+      @game.user.build
+    end
+  end
+
+  describe "reference#build" do
+    before do
+      @game = Game.create
+      @user = @game.user.build
+    end
+
+    it_should_behave_like 'reference#build'
+  end
+
+  describe "reference#build (with attributes)" do
+    before do
+      User.attribute(:name, String)
+      @game = Game.create
+      @user = @game.user.build(:name => 'John')
+    end
+
+    it_should_behave_like 'reference#build'
+
+    it "sets attributes" do
+      @user.name.should == 'John'
+    end
+  end
+end