toystore 0.5

data/spec/toy/caching_spec.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+describe Toy::Caching do
+  uses_constants('User')
+
+  context "new" do
+    before do
+      @user = User.new
+    end
+
+    it "should be class:new" do
+      @user.cache_key.should == 'User:new'
+    end
+
+    it "should work with suffix" do
+      @user.cache_key(:foo).should == 'User:new:foo'
+
+      @user.cache_key(:foo, :bar).should == 'User:new:foo:bar'
+    end
+  end
+
+  context "not new" do
+    context "with updated_at" do
+      before do
+        User.timestamps
+        @now = Time.now.utc
+        Timecop.freeze(@now) do
+          @user = User.create
+        end
+      end
+
+      it "should be class:id-timestamp" do
+        @user.cache_key.should == "User:#{@user.id}-#{@now.to_s(:number)}"
+      end
+
+      it "should work with suffix" do
+        @user.cache_key(:foo).should == "User:#{@user.id}-#{@now.to_s(:number)}:foo"
+
+        @user.cache_key(:foo, :bar).should == "User:#{@user.id}-#{@now.to_s(:number)}:foo:bar"
+      end
+    end
+
+    context "without updated_at" do
+      before do
+        @now = Time.now.utc
+        Timecop.freeze(@now) do
+          @user = User.create
+        end
+      end
+
+      it "should be class:id" do
+        @user.cache_key.should == "User:#{@user.id}"
+      end
+
+      it "should work with suffix" do
+        @user.cache_key(:foo).should == "User:#{@user.id}:foo"
+
+        @user.cache_key(:foo, :bar, :baz). should == "User:#{@user.id}:foo:bar:baz"
+      end
+    end
+  end
+end

data/spec/toy/callbacks_spec.rb

@@ -0,0 +1,97 @@
+require 'helper'
+
+module CallbackHelper
+  extend ActiveSupport::Concern
+
+  included do
+    [ :before_create,  :after_create,
+      :before_update,  :after_update,
+      :before_save,    :after_save,
+      :before_destroy, :after_destroy].each do |callback|
+      callback_method = "#{callback}_callback"
+      send(callback, callback_method)
+      define_method(callback_method) { history << callback.to_sym }
+    end
+  end
+
+  def history
+    @history ||= []
+  end
+
+  def clear_history
+    @history = nil
+  end
+end
+
+describe Toy::Callbacks do
+  uses_constants('Game', 'Move')
+
+  context "regular" do
+    before do
+      Game.send(:include, CallbackHelper)
+    end
+
+    it "runs callbacks in correct order for create" do
+      doc = Game.create
+      doc.history.should == [:before_save, :before_create, :after_create, :after_save]
+    end
+
+    it "runs callbacks in correct order for update" do
+      doc = Game.create
+      doc.clear_history
+      doc.save
+      doc.history.should == [:before_save, :before_update, :after_update, :after_save]
+    end
+
+    it "runs callbacks in correct order for destroy" do
+      doc = Game.create
+      doc.clear_history
+      doc.destroy
+      doc.history.should == [:before_destroy, :after_destroy]
+    end
+  end
+
+  context "embedded" do
+    before do
+      Game.embedded_list(:moves)
+      Move.send(:include, CallbackHelper)
+
+      @move = Move.new
+      @game = Game.create(:moves => [@move])
+    end
+
+    it "runs callbacks for save of parent" do
+      @move.history.should == [:before_save, :before_create, :after_create, :after_save]
+    end
+
+    it "runs callbacks for update of parent" do
+      @move.clear_history
+      @game.save
+      @move.history.should == [:before_save, :before_update, :after_update, :after_save]
+    end
+
+    it "runs callbacks for destroy of parent" do
+      @move.clear_history
+      @game.destroy
+      @move.history.should == [:before_destroy, :after_destroy]
+    end
+
+    it "does not attempt to run callback defined on parent that is not defined on embedded" do
+      Game.define_callbacks :win
+      @move.clear_history
+
+      lambda do
+        @game.run_callbacks(:win)
+        @move.history.should be_empty
+      end.should_not raise_error
+    end
+
+    it "runs create callback when saving new embbeded doc on existing parent" do
+      @game.save
+      move = Move.new
+      @game.moves << move
+      @game.save
+      move.history.should == [:before_save, :before_create, :after_create, :after_save]
+    end
+  end
+end

data/spec/toy/connection_spec.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+describe Toy::Connection do
+  uses_constants('User')
+
+  before do
+    @logger = Toy.logger
+  end
+
+  after do
+    Toy.logger = @logger
+  end
+
+  describe ".logger" do
+    it "should set the default logger" do
+      logger = stub
+      Toy.logger = logger
+      Toy.logger.should == logger
+    end
+
+    it "should be an instance of Logger if not set" do
+      Toy.logger = nil
+      Toy.logger.should be_instance_of(Logger)
+    end
+
+    it "should use RAILS_DEFAULT_LOGGER if defined" do
+      remove_constants("RAILS_DEFAULT_LOGGER")
+      RAILS_DEFAULT_LOGGER = stub
+
+      Toy.logger = nil
+      Toy.logger.should == RAILS_DEFAULT_LOGGER
+    end
+  end
+
+  describe ".key_factory" do
+    it "should set the default key_factory" do
+      key_factory = stub
+      Toy.key_factory = key_factory
+      Toy.key_factory.should == key_factory
+    end
+
+    it "should default to the UUIDKeyFactory" do
+      Toy.key_factory = nil
+      Toy.key_factory.should be_instance_of(Toy::Identity::UUIDKeyFactory)
+    end
+  end
+end

data/spec/toy/dirty_spec.rb

@@ -0,0 +1,99 @@
+require 'helper'
+
+describe Toy::Dirty do
+  uses_constants('User')
+
+  before do
+    User.attribute(:name, String)
+  end
+
+  it "has no changes for new with no attributes" do
+    User.new.should_not be_changed
+    User.new.changed.should be_empty
+    User.new.changes.should be_empty
+  end
+
+  it "has changes for new with attributes" do
+    user = User.new(:name => 'Geoffrey')
+    user.should be_changed
+    user.changed.should include('name')
+    user.changes.should == {'name' => [nil, 'Geoffrey']}
+  end
+
+  it "knows attribute changed through writer" do
+    user = User.new
+    user.name = 'John'
+    user.should be_changed
+    user.changed.should include('name')
+    user.changes['name'].should == [nil, 'John']
+  end
+
+  it "knows when attribute did not change" do
+    user = User.create(:name => 'Geoffrey')
+    user.name = 'Geoffrey'
+    user.should_not be_changed
+  end
+
+  describe "#save" do
+    before      { @user = User.create(:name => 'Geoffrey') }
+    let(:user)  { @user }
+
+    it "clears changes" do
+      user.name = 'John'
+      user.should be_changed
+      user.save
+      user.should_not be_changed
+    end
+
+    it "sets previous changes" do
+      user.previous_changes.should == {'name' => [nil, 'Geoffrey']}
+    end
+  end
+
+  it "does not have changes when loaded from database" do
+    user = User.create
+    loaded = User.get(user.id)
+    loaded.should_not be_changed
+  end
+
+  describe "#reload" do
+    before      { @user = User.create(:name => 'John') }
+    let(:user)  { @user }
+
+    it "clears changes" do
+      user.name = 'Steve'
+      user.reload
+      user.should_not be_changed
+    end
+
+    it "clears previously changed" do
+      user.reload
+      user.previous_changes.should be_empty
+    end
+  end
+
+  it "has attribute changed? method" do
+    user = User.new
+    user.should_not be_name_changed
+    user.name = 'John'
+    user.should be_name_changed
+  end
+
+  it "has attribute was method" do
+    user = User.create(:name => 'John')
+    user.name = 'Steve'
+    user.name_was.should == 'John'
+  end
+
+  it "has attribute change method" do
+    user = User.create(:name => 'John')
+    user.name = 'Steve'
+    user.name_change.should == ['John', 'Steve']
+  end
+
+  it "has attribute will change! method" do
+    user = User.create
+    user.name_will_change!
+    user.should be_changed
+  end
+end

data/spec/toy/dolly_spec.rb

@@ -0,0 +1,76 @@
+require 'helper'
+
+describe Toy::Connection do
+  uses_constants('User', 'Game', 'Move')
+
+  before do
+    Game.embedded_list(:moves)
+    User.attribute(:name, String)
+    User.attribute(:skills, Array)
+    User.list(:games)
+
+    @move = Move.new
+    @game = Game.create(:moves => [@move])
+    @user = User.create({
+      :name   => 'John',
+      :skills => ['looking awesome', 'growing beards'],
+      :games  => [@game],
+    })
+  end
+  let(:move)  { @move }
+  let(:game)  { @game }
+  let(:user)  { @user }
+
+  describe "#clone" do
+    it "returns new instance" do
+      user.clone.should be_new_record
+    end
+
+    it "has no changes" do
+      user.clone.should_not be_changed
+    end
+
+    it "is never destroyed" do
+      user.destroy
+      user.clone.should_not be_destroyed
+    end
+
+    it "clones the @attributes hash" do
+      user.clone.instance_variable_get("@attributes").should_not equal(user.instance_variable_get("@attributes"))
+    end
+
+    it "copies the attributes" do
+      user.clone.tap do |clone|
+        clone.name.should == user.name
+        clone.skills.should == user.skills
+      end
+    end
+
+    it "clones duplicable attributes" do
+      user.clone.skills.should_not equal(user.skills)
+    end
+
+    it "regenerates id" do
+      user.clone.tap do |clone|
+        clone.id.should_not be_nil
+        clone.id.should_not == user.id
+      end
+    end
+
+    it "clones list id attributes" do
+      user.clone.game_ids.should_not equal(user.game_ids)
+    end
+
+    it "clones the list" do
+      user.clone.games.should_not equal(user.games)
+    end
+
+    it "clones embedded list objects" do
+      game.clone.moves.first.should_not equal(game.moves.first)
+    end
+
+    it "regenerates ids for embedded list objects" do
+      game.clone.moves.first.id.should_not == game.moves.first.id
+    end
+  end
+end

data/spec/toy/embedded_list_spec.rb

@@ -0,0 +1,607 @@
+require 'helper'
+
+describe Toy::List do
+  uses_constants('Game', 'Move')
+
+  before do
+    @list = Game.embedded_list(:moves)
+  end
+
+  let(:list)  { @list }
+
+  it "has model" do
+    list.model.should == Game
+  end
+
+  it "has name" do
+    list.name.should == :moves
+  end
+
+  it "has type" do
+    list.type.should == Move
+  end
+
+  it "has instance_variable" do
+    list.instance_variable.should == :@_moves
+  end
+
+  it "adds list to model" do
+    Game.embedded_lists.keys.should include(:moves)
+  end
+
+  it "adds reader method" do
+    Game.new.should respond_to(:moves)
+  end
+
+  it "adds writer method" do
+    Game.new.should respond_to(:moves=)
+  end
+
+  describe "#eql?" do
+    it "returns true if same class, model, and name" do
+      list.should eql(list)
+    end
+
+    it "returns false if not same class" do
+      list.should_not eql({})
+    end
+
+    it "returns false if not same model" do
+      list.should_not eql(Toy::List.new(Move, :moves))
+    end
+
+    it "returns false if not the same name" do
+      list.should_not eql(Toy::List.new(Game, :recent_moves))
+    end
+  end
+
+  describe "setting list type" do
+    before do
+      @list = Game.embedded_list(:recent_moves, Move)
+    end
+    let(:list) { @list }
+
+    it "uses type provided instead of inferring from name" do
+      list.type.should be(Move)
+    end
+
+    it "works properly when reading and writing" do
+      game = Game.create
+      move = Move.create
+      game.recent_moves         = [move]
+      game.recent_moves.should == [move]
+    end
+  end
+
+  describe "list reader" do
+    before do
+      Move.attribute(:index, Integer)
+      @game = Game.create(:move_attributes => [{:index => 0}, {:index => 1}])
+    end
+
+    it "returns instances" do
+      @game.moves.each do |move|
+        move.should be_instance_of(Move)
+      end
+      @game.moves[0].id.should_not be_nil
+      @game.moves[1].id.should_not be_nil
+      @game.moves[0].index.should == 0
+      @game.moves[1].index.should == 1
+    end
+
+    it "sets reference to parent for each instance" do
+      @game.moves.each do |move|
+        move.parent_reference.should == @game
+      end
+    end
+  end
+
+  describe "list writer" do
+    before do
+      @move1 = Move.new
+      @move2 = Move.new
+      @game  = Game.create(:moves => [@move2])
+    end
+
+    it "set attribute" do
+      @game.move_attributes.should == [@move2.attributes]
+    end
+
+    it "unmemoizes reader" do
+      @game.moves.should == [@move2]
+      @game.moves         = [@move1]
+      @game.moves.should == [@move1]
+    end
+
+    it "sets reference to parent for each instance" do
+      @game.moves.each do |move|
+        move.parent_reference.should == @game
+      end
+    end
+  end
+
+  describe "list attribute writer" do
+    before do
+      Move.attribute(:index, Integer)
+      @game = Game.new('move_attributes' => [
+        {'index' => '1'}
+      ])
+    end
+
+    it "typecasts hash values correctly" do
+      @game.move_attributes.should == [
+        {'id' => @game.moves[0].id, 'index' => 1}
+      ]
+    end
+
+    it "accepts hash of hashes" do
+      game = Game.new('move_attributes' => {
+        '0' => {'index' => 1},
+        '1' => {'index' => 2},
+        '2' => {'index' => 3},
+      })
+      game.move_attributes.should == [
+        {'id' => game.moves[0].id, 'index' => 1},
+        {'id' => game.moves[1].id, 'index' => 2},
+        {'id' => game.moves[2].id, 'index' => 3},
+      ]
+    end
+
+    it "sets ids if present" do
+      game = Game.new('move_attributes' => [
+        {'id' => 'foo', 'index' => '1'}
+      ])
+      game.move_attributes.should == [
+        {'id' => 'foo', 'index' => 1},
+      ]
+    end
+  end
+
+  describe "list#push" do
+    before do
+      @move = Move.new
+      @game = Game.new
+      @game.moves.push(@move)
+    end
+
+    it "raises error if wrong type assigned" do
+      lambda {
+        @game.moves.push(Game.new)
+      }.should raise_error(ArgumentError, "Move expected, but was Game")
+    end
+
+    it "sets reference to parent" do
+      # right now pushing a move adds a different instance to the proxy
+      # so i'm checking that it adds reference to both
+      @game.moves.each do |move|
+        move.parent_reference.should == @game
+      end
+      @move.parent_reference.should == @game
+    end
+
+    it "instances should not be persisted" do
+      @game.moves.each do |move|
+        move.should_not be_persisted
+      end
+    end
+
+    it "marks instances as persisted when parent saved" do
+      @game.save
+      @game.moves.each do |move|
+        move.should be_persisted
+      end
+    end
+
+    it "should save list" do
+      moves = @game.moves.target
+      @game.save
+      @game.reload
+      @game.moves.should == moves
+    end
+
+    it "should keep existing instances as persisted when adding a new instance" do
+      @game.save
+      @game.moves.push(Move.new)
+      @game.moves.first.should be_persisted
+      @game.moves.last.should_not be_persisted
+    end
+
+    it "marks instances as persisted when updated" do
+      @game.save
+      game = @game.reload
+      move = Move.new
+      game.moves.push(move)
+      move.should_not be_persisted
+      game.save
+      game.moves.each do |move|
+        move.should be_persisted
+      end
+      # move.should be_persisted
+    end
+  end
+
+  describe "list#<<" do
+    before do
+      @move = Move.new
+      @game = Game.new
+      @game.moves << @move
+    end
+
+    it "raises error if wrong type assigned" do
+      lambda {
+        @game.moves << Game.new
+      }.should raise_error(ArgumentError, "Move expected, but was Game")
+    end
+
+    it "sets reference to parent" do
+      # right now pushing a move adds a different instance to the proxy
+      # so i'm checking that it adds reference to both
+      @game.moves.each do |move|
+        move.parent_reference.should == @game
+      end
+      @move.parent_reference.should == @game
+    end
+
+    it "instances should not be persisted" do
+      @game.moves.each do |move|
+        move.should_not be_persisted
+      end
+    end
+
+    it "marks instances as persisted when parent saved" do
+      @game.save
+      @game.moves.each do |move|
+        move.should be_persisted
+      end
+    end
+  end
+
+  describe "list#concat" do
+    before do
+      @move1 = Move.new
+      @move2 = Move.new
+      @game  = Game.new
+      @game.moves.concat(@move1, @move2)
+    end
+
+    it "raises error if wrong type assigned" do
+      lambda {
+        @game.moves.concat(Game.new, Move.new)
+      }.should raise_error(ArgumentError, "Move expected, but was Game")
+    end
+
+    it "sets reference to parent" do
+      # right now pushing a move adds a different instance to the proxy
+      # so i'm checking that it adds reference to both
+      @game.moves.each do |move|
+        move.parent_reference.should == @game
+      end
+      @move1.parent_reference.should == @game
+      @move2.parent_reference.should == @game
+    end
+
+    it "instances should not be persisted" do
+      @game.moves.each do |move|
+        move.should_not be_persisted
+      end
+    end
+
+    it "marks instances as persisted when parent saved" do
+      @game.save
+      @game.moves.each do |move|
+        move.should be_persisted
+      end
+    end
+  end
+
+  describe "list#concat (with array)" do
+    before do
+      @move1 = Move.new
+      @move2 = Move.new
+      @game  = Game.create
+      @game.moves.concat([@move1, @move2])
+    end
+
+    it "raises error if wrong type assigned" do
+      lambda {
+        @game.moves.concat([Game.new, Move.new])
+      }.should raise_error(ArgumentError, "Move expected, but was Game")
+    end
+
+    it "sets reference to parent" do
+      # right now pushing a move adds a different instance to the proxy
+      # so i'm checking that it adds reference to both
+      @game.moves.each do |move|
+        move.parent_reference.should == @game
+      end
+      @move1.parent_reference.should == @game
+      @move2.parent_reference.should == @game
+    end
+
+    it "instances should not be persisted" do
+      @game.moves.each do |move|
+        move.should_not be_persisted
+      end
+    end
+
+    it "marks instances as persisted when parent saved" do
+      @game.save
+      @game.moves.each do |move|
+        move.should be_persisted
+      end
+    end
+  end
+
+  shared_examples_for("embedded_list#create") do
+    it "creates instance" do
+      @move.should be_persisted
+    end
+
+    it "assigns reference to parent" do
+      @move.parent_reference.should == @game
+    end
+
+    it "assigns id" do
+      @move.id.should_not be_nil
+    end
+
+    it "adds instance to reader" do
+      @game.moves.should == [@move]
+    end
+
+    it "marks instance as persisted" do
+      @move.should be_persisted
+    end
+  end
+
+  describe "list#create" do
+    before do
+      @game = Game.create
+      @move = @game.moves.create
+    end
+
+    it_should_behave_like "embedded_list#create"
+  end
+
+  describe "list#create (with attributes)" do
+    before do
+      Move.attribute(:move_index, Integer)
+      @game = Game.create
+      @move = @game.moves.create(:move_index => 0)
+    end
+
+    it_should_behave_like "embedded_list#create"
+
+    it "sets attributes on instance" do
+      @move.move_index.should == 0
+    end
+  end
+
+  describe "list#create (invalid)" do
+    before do
+      @game = Game.create
+      @game.moves.should_not_receive(:push)
+      @game.moves.should_not_receive(:reset)
+      @game.should_not_receive(:reload)
+      @game.should_not_receive(:save)
+
+      Move.attribute(:move_index, Integer)
+      Move.validates_presence_of(:move_index)
+
+      @move = @game.moves.create
+    end
+
+    it "returns instance" do
+      @move.should be_instance_of(Move)
+    end
+
+    it "is not persisted" do
+      @move.should_not be_persisted
+    end
+
+    it "assigns reference to parent" do
+      @move.parent_reference.should == @game
+    end
+  end
+
+  describe "list#create (valid with invalid root that validates embedded)" do
+    before do
+      Game.attribute(:user_id, String)
+      Game.validates_presence_of(:user_id)
+
+      @game = Game.new
+      @move = @game.moves.create
+    end
+
+    it "is not persisted" do
+      @move.should_not be_persisted
+    end
+
+    it "is persisted when root is valid and saved" do
+      @game.user_id = '1'
+      @game.save!
+      @move.should be_persisted
+    end
+  end
+
+  describe "list#destroy" do
+    before do
+      Move.attribute(:move_index, Integer)
+      @game = Game.create
+      @move1 = @game.moves.create(:move_index => 0)
+      @move2 = @game.moves.create(:move_index => 1)
+    end
+
+    it "should take multiple ids" do
+      @game.moves.destroy(@move1.id, @move2.id)
+      @game.moves.should be_empty
+      @game.reload
+      @game.moves.should be_empty
+    end
+
+    it "should take an array of ids" do
+      @game.moves.destroy([@move1.id, @move2.id])
+      @game.moves.should be_empty
+      @game.reload
+      @game.moves.should be_empty
+    end
+
+    it "should take a block to filter on" do
+      @game.moves.destroy { |move| move.move_index == 1 }
+      @game.moves.should == [@move1]
+      @game.reload
+      @game.moves.should == [@move1]
+    end
+  end
+
+  describe "list#destroy_all" do
+    before do
+      Move.attribute(:move_index, Integer)
+      @game = Game.create
+      @move1 = @game.moves.create(:move_index => 0)
+      @move2 = @game.moves.create(:move_index => 1)
+    end
+
+    it "should destroy all" do
+      @game.moves.destroy_all
+      @game.moves.should be_empty
+      @game.reload
+      @game.moves.should be_empty
+    end
+  end
+
+  describe "list#each" do
+    before do
+      @move1 = Move.new
+      @move2 = Move.new
+      @game  = Game.create(:moves => [@move1, @move2])
+    end
+
+    it "iterates through each instance" do
+      moves = []
+      @game.moves.each do |move|
+        moves << move
+      end
+      moves.should == [@move1, @move2]
+    end
+  end
+
+  describe "enumerating" do
+    before do
+      Move.attribute(:move_index, Integer)
+      @move1 = Move.new(:move_index => 0)
+      @move2 = Move.new(:move_index => 1)
+      @game  = Game.create(:moves => [@move1, @move2])
+    end
+
+    it "works" do
+      @game.moves.select { |move| move.move_index > 0 }.should == [@move2]
+      @game.moves.reject { |move| move.move_index > 0 }.should == [@move1]
+    end
+  end
+
+  describe "list#include?" do
+    before do
+      @move1 = Move.new
+      @move2 = Move.new
+      @game = Game.create(:moves => [@move1])
+    end
+
+    it "returns true if instance in association" do
+      @game.moves.should include(@move1)
+    end
+
+    it "returns false if instance not in association" do
+      @game.moves.should_not include(@move2)
+    end
+
+    it "returns false for nil" do
+      @game.moves.should_not include(nil)
+    end
+  end
+
+  describe "list with block" do
+    before do
+      Move.attribute(:old, Boolean)
+      Game.embedded_list(:moves) do
+        def old
+          target.select { |move| move.old? }
+        end
+      end
+
+      @move_new = Move.create(:old => false)
+      @move_old = Move.create(:old => true)
+      @game     = Game.create(:moves => [@move_new, @move_old])
+    end
+
+    it "extends block methods onto proxy" do
+      @game.moves.respond_to?(:old).should be_true
+      @game.moves.old.should == [@move_old]
+    end
+  end
+
+  describe "list extension with :extensions option" do
+    before do
+      old_module = Module.new do
+        def old
+          target.select { |m| m.old? }
+        end
+      end
+
+      recent_proc = Proc.new do
+        def recent
+          target.select { |m| !m.old? }
+        end
+      end
+
+      Move.attribute(:old, Boolean)
+      Game.embedded_list(:moves, :extensions => [old_module, recent_proc])
+
+      @move_new = Move.new(:old => false)
+      @move_old = Move.new(:old => true)
+      @game     = Game.create(:moves => [@move_new, @move_old])
+    end
+
+    it "extends modules" do
+      @game.moves.respond_to?(:old).should be_true
+      @game.moves.old.should    == [@move_old]
+    end
+
+    it "extends procs" do
+      @game.moves.respond_to?(:recent).should be_true
+      @game.moves.recent.should == [@move_new]
+    end
+  end
+
+  describe "list#get" do
+    before do
+      @game = Game.create
+      @move = @game.moves.create
+    end
+
+    it "should not find items that don't exist" do
+      @game.moves.get('does-not-exist').should be_nil
+    end
+
+    it "should find items that are in list" do
+      @game.moves.get(@move.id).should == @move
+    end
+  end
+
+  describe "list#get!" do
+    before do
+      @game = Game.create
+      @move = @game.moves.create
+    end
+
+    it "should not find items that don't exist" do
+      lambda {
+        @game.moves.get!('does-not-exist')
+      }.should raise_error(Toy::NotFound, 'Could not find document with id: "does-not-exist"')
+    end
+
+    it "should find items that are in list" do
+      @game.moves.get!(@move.id).should == @move
+    end
+  end
+end