toystore 0.8.3 → 0.9.0

data/spec/toy/embedded_lists_spec.rb

@@ -1,172 +0,0 @@
-require 'helper'
-
-describe Toy::Lists do
-  uses_constants('Game', 'Move')
-
-  it "defaults lists to empty hash" do
-    Game.embedded_lists.should == {}
-  end
-
-  it "does not share with regular lists" do
-    Game.list(:moves)
-    Game.embedded_lists.should == {}
-  end
-
-  describe ".embedded_list?" do
-    before do
-      Game.embedded_list(:moves)
-    end
-
-    it "returns true if attribute (symbol)" do
-      Game.embedded_list?(:moves).should be_true
-    end
-
-    it "returns true if attribute (string)" do
-      Game.embedded_list?('moves').should be_true
-    end
-
-    it "returns false if not attribute" do
-      Game.embedded_list?(:foobar).should be_false
-    end
-  end
-
-  describe ".parent_reference" do
-    before do
-      Game.embedded_list(:moves)
-    end
-
-    context "with single name" do
-      before do
-        Move.parent_reference(:game)
-        @game = Game.new
-        @move = Move.new
-      end
-
-      it "defines method that calls parent_reference" do
-        @move.parent_reference = @game
-        @move.game.should == @game
-      end
-
-      it "defaults boolean method that checks parent_reference existence" do
-        @move.game?.should be_false
-        @move.parent_reference = @game
-        @move.game?.should be_true
-      end
-    end
-
-    context "with multiple names" do
-      before do
-        Move.parent_reference(:game, :yaypants)
-        @game = Game.new
-        @move = Move.new
-      end
-
-      it "defines method that calls parent_reference" do
-        @move.parent_reference = @game
-        @move.game.should == @game
-        @move.yaypants.should == @game
-      end
-
-      it "defaults boolean method that checks parent_reference existence" do
-        @move.game?.should be_false
-        @move.yaypants?.should be_false
-        @move.parent_reference = @game
-        @move.game?.should be_true
-        @move.yaypants?.should be_true
-      end
-    end
-  end
-
-  describe '.parent_references' do
-    it 'keeps track of single names' do
-      Move.parent_reference(:game)
-      Move.parent_references.should == [:game]
-    end
-
-    it 'keeps track of single names' do
-      Move.parent_reference(:game, :yaypants)
-      Move.parent_references.should == [:game, :yaypants]
-    end
-  end
-
-  describe '.parent_reference?' do
-    before do
-      Move.parent_reference(:game)
-    end
-
-    it 'returns true if attribute (symbol)' do
-      Move.parent_reference?(:game).should be_true
-    end
-
-    it 'returns true if attribute (string)' do
-      Move.parent_reference?('game').should be_true
-    end
-
-    it 'returns false if not an attribute' do
-      Move.parent_reference?(:foobar).should be_false
-    end
-  end
-
-  describe "declaring an embedded list" do
-    describe "using conventions" do
-      before do
-        @list = Game.embedded_list(:moves)
-      end
-
-      it "knows about its lists" do
-        Game.embedded_lists[:moves].should == Toy::EmbeddedList.new(Game, :moves)
-      end
-
-      it "returns list" do
-        @list.should == Toy::EmbeddedList.new(Game, :moves)
-      end
-    end
-
-    describe "with type" do
-      before do
-        @list = Game.embedded_list(:recent_moves, Move)
-      end
-      let(:list) { @list }
-
-      it "sets type" do
-        list.type.should be(Move)
-      end
-
-      it "sets options to hash" do
-        list.options.should be_instance_of(Hash)
-      end
-    end
-
-    describe "with options" do
-      before do
-        @list = Game.embedded_list(:moves, :some_option => true)
-      end
-      let(:list) { @list }
-
-      it "sets type" do
-        list.type.should be(Move)
-      end
-
-      it "sets options" do
-        list.options.should have_key(:some_option)
-        list.options[:some_option].should be_true
-      end
-    end
-
-    describe "with type and options" do
-      before do
-        @list = Game.embedded_list(:recent_moves, Move, :some_option => true)
-      end
-      let(:list) { @list }
-
-      it "sets type" do
-        list.type.should be(Move)
-      end
-
-      it "sets options" do
-        list.options.should have_key(:some_option)
-        list.options[:some_option].should be_true
-      end
-    end
-  end
-end

data/spec/toy/index_spec.rb

@@ -1,230 +0,0 @@
-require 'helper'
-
-describe Toy::Index do
-  uses_constants('User', 'Student', 'Friendship')
-
-  before do
-    User.attribute(:ssn, String)
-    @index = User.index(:ssn)
-  end
-  let(:index) { @index }
-
-  it "has a model" do
-    index.model.should == User
-  end
-
-  it "has a name" do
-    index.name.should == :ssn
-  end
-
-  it "raises error if attribute does not exist" do
-    lambda {
-      User.index :student_id
-    }.should raise_error(ArgumentError, "No attribute student_id for index")
-  end
-
-  it "has a sha1'd key for a value" do
-    index.key('some_value').should == 'User:ssn:8c818171573b03feeae08b0b4ffeb6999e3afc05'
-  end
-
-  it "adds index to model" do
-    User.indices.keys.should include(:ssn)
-  end
-
-  describe "#eql?" do
-    it "returns true if same class, model, and name" do
-      index.should eql(index)
-    end
-
-    it "returns false if not same class" do
-      index.should_not eql({})
-    end
-
-    it "returns false if not same model" do
-      Student.attribute :ssn, String
-      index.should_not eql(Toy::Index.new(Student, :ssn))
-    end
-
-    it "returns false if not the same name" do
-      User.attribute :student_id, String
-      index.should_not eql(Toy::Index.new(User, :student_id))
-    end
-  end
-
-  describe "single key" do
-    describe "creating with index" do
-      before do
-        @user = User.create(:ssn => '555-00-1234')
-      end
-      let(:user) { @user }
-
-      it "creates key for indexed value" do
-        User.store.should be_key("User:ssn:f6edc9155d79e311ad2d4a6e1b54004f31497f4c")
-      end
-
-      it "adds instance id to index array" do
-        User.get_index(:ssn, '555-00-1234').should == [user.id]
-      end
-    end
-
-    describe "creating second record for same index value" do
-      before do
-        @user1 = User.create(:ssn => '555-00-1234')
-        @user2 = User.create(:ssn => '555-00-1234')
-      end
-
-      it "adds both instances to index" do
-        User.get_index(:ssn, '555-00-1234').should == [@user1.id, @user2.id]
-      end
-    end
-
-    describe "destroying with index" do
-      before do
-        @user = User.create(:ssn => '555-00-1234')
-        @user.destroy
-      end
-
-      it "removes id from index" do
-        User.get_index(:ssn, '555-00-1234').should == []
-      end
-    end
-
-    describe "updating record and changing indexed value" do
-      before do
-        @user = User.create(:ssn => '555-00-1234')
-        @user.update_attributes(:ssn => '555-00-4321')
-      end
-
-      it "removes from old index" do
-        User.get_index(:ssn, '555-00-1234').should == []
-      end
-
-      it "adds to new index" do
-        User.get_index(:ssn, '555-00-4321').should == [@user.id]
-      end
-    end
-
-    describe "updating record without changing indexed value" do
-      before do
-        @user = User.create(:ssn => '555-00-1234')
-        @user.update_attributes(:ssn => '555-00-1234')
-      end
-
-      it "leaves index alone" do
-        User.get_index(:ssn, '555-00-1234').should == [@user.id]
-      end
-    end
-
-    describe "first by index" do
-      it "should not find values that are not in index" do
-        User.first_by_ssn('does-not-exist').should be_nil
-      end
-
-      it "should find indexed value" do
-        user = User.create(:ssn => '555-00-1234')
-        User.first_by_ssn('555-00-1234').should == user
-      end
-    end
-
-    describe "first or new by index" do
-      it "initializes if not existing" do
-        user = User.first_or_new_by_ssn('does-not-exist')
-        user.ssn.should == 'does-not-exist'
-        user.should_not be_persisted
-      end
-
-      it "returns if existing" do
-        user = User.create(:ssn => '555-00-1234')
-        User.first_or_new_by_ssn('555-00-1234').should == user
-      end
-    end
-
-    describe "first or create by index" do
-      it "creates if not existing" do
-        user = User.first_or_create_by_ssn('does-not-exist')
-        user.ssn.should == 'does-not-exist'
-        user.should be_persisted
-      end
-
-      it "returns if existing" do
-        user = User.create(:ssn => '555-00-1234')
-        User.first_or_create_by_ssn('555-00-1234').should == user
-      end
-    end
-  end
-
-  describe "array key" do
-    before do
-      User.list :friendships
-      Friendship.list :users
-      Friendship.index :user_ids
-      @user1 = User.create(:ssn => '555-00-1234')
-      @user2 = User.create(:ssn => '555-00-9876')
-      @friendship = Friendship.create(:user_ids => [@user1.id, @user2.id])
-    end
-    let(:user1) { @user1 }
-    let(:user2) { @user2 }
-    let(:friendship) { @friendship }
-
-    describe "creating with index" do
-      it "creates key for indexed values sorted" do
-        sha_value = Digest::SHA1.hexdigest([user1.id, user2.id].sort.join(''))
-        Friendship.store.should be_key("Friendship:user_ids:#{sha_value}")
-      end
-
-      it "adds instance id to index array" do
-        Friendship.get_index(:user_ids, [user1.id, user2.id]).should == [friendship.id]
-        Friendship.get_index(:user_ids, [user2.id, user1.id]).should == [friendship.id]
-      end
-    end
-
-    describe "destroying with index" do
-      before do
-        friendship.destroy
-      end
-
-      it "removes id from index" do
-        Friendship.get_index(:user_ids, [user2.id, user1.id]).should == []
-      end
-    end
-
-    describe "first by index" do
-      it "should not find values that are not in index" do
-        Friendship.first_by_user_ids([user1.id, 'does-not-exist']).should be_nil
-      end
-
-      it "should find indexed value" do
-        Friendship.first_by_user_ids([user1.id, user2.id]).should == friendship
-        Friendship.first_by_user_ids([user2.id, user1.id]).should == friendship
-      end
-    end
-
-    describe "first or new by index" do
-      it "initializes if not existing" do
-        new_friend = User.create(:ssn => '555-00-1928')
-        new_friendship = Friendship.first_or_new_by_user_ids([user1.id, new_friend.id])
-        new_friendship.user_ids.sort.should == [user1.id, new_friend.id].sort
-        new_friendship.should_not be_persisted
-      end
-
-      it "returns if existing" do
-        Friendship.first_or_new_by_user_ids([user1.id, user2.id]).should == friendship
-        Friendship.first_or_new_by_user_ids([user2.id, user1.id]).should == friendship
-      end
-    end
-
-    describe "first or create by index" do
-      it "creates if not existing" do
-        new_friend = User.create(:ssn => '555-00-1928')
-        new_friendship = Friendship.first_or_create_by_user_ids([user1.id, new_friend.id])
-        new_friendship.user_ids.sort.should == [user1.id, new_friend.id].sort
-        new_friendship.should be_persisted
-      end
-
-      it "returns if existing" do
-        Friendship.first_or_create_by_user_ids([user1.id, user2.id]).should == friendship
-        Friendship.first_or_create_by_user_ids([user2.id, user1.id]).should == friendship
-      end
-    end
-  end
-end

data/spec/toy/indices_spec.rb

@@ -1,141 +0,0 @@
-require 'helper'
-
-describe Toy::Indices do
-  uses_constants('User')
-
-  it "defaults lists to empty hash" do
-    User.indices.should == {}
-  end
-
-  describe "declaring a list" do
-    before do
-      User.attribute :ssn, String
-      @index = User.index(:ssn)
-    end
-
-    it "knows about its lists" do
-      User.indices[:ssn].should == Toy::Index.new(User, :ssn)
-    end
-
-    it "returns list" do
-      @index.should == Toy::Index.new(User, :ssn)
-    end
-
-    it "adds indices instance method" do
-      User.new.indices.should == User.indices
-    end
-  end
-
-  describe ".index_key" do
-    it "returns key if index exists" do
-      sha = Digest::SHA1.hexdigest('taco@bell.com')
-      User.attribute(:email, String)
-      User.index(:email)
-      User.index_key(:email, 'taco@bell.com').should == "User:email:#{sha}"
-    end
-
-    it "works with string name" do
-      sha = Digest::SHA1.hexdigest('taco@bell.com')
-      User.attribute(:email, String)
-      User.index(:email)
-      User.index_key('email', 'taco@bell.com').should == "User:email:#{sha}"
-    end
-
-    it "raises error if index does not exist" do
-      lambda {
-        User.index_key(:email, 'taco@bell.com')
-      }.should raise_error(ArgumentError, 'Index for email does not exist')
-    end
-  end
-
-  describe ".get_index (existing)" do
-    before do
-      User.attribute(:email, String)
-      User.index(:email)
-      User.create_index(:email, 'taco@bell.com', 1)
-      User.create_index(:email, 'taco@bell.com', 2)
-      @index = User.get_index(:email, 'taco@bell.com')
-    end
-
-    it "returns decoded array" do
-      @index.should == [1, 2]
-    end
-  end
-
-  describe ".get_index (missing)" do
-    before do
-      User.attribute(:email, String)
-      User.index(:email)
-      @index = User.get_index(:email, 'taco@bell.com')
-    end
-
-    it "returns empty array" do
-      @index.should == []
-    end
-  end
-
-  describe ".create_index (single value)" do
-    before do
-      User.attribute(:email, String)
-      User.index(:email)
-      User.create_index(:email, 'taco@bell.com', 1)
-    end
-
-    it "stores id in array" do
-      User.get_index(:email, 'taco@bell.com').should == [1]
-    end
-  end
-
-  describe ".create_index (multiple values)" do
-    before do
-      User.attribute(:email, String)
-      User.index(:email)
-      User.create_index(:email, 'taco@bell.com', 1)
-      User.create_index(:email, 'taco@bell.com', 2)
-      User.create_index(:email, 'taco@bell.com', 3)
-    end
-
-    it "stores each value in array" do
-      User.get_index(:email, 'taco@bell.com').should == [1, 2, 3]
-    end
-  end
-
-  describe ".create_index (same value multiple times)" do
-    before do
-      User.attribute(:email, String)
-      User.index(:email)
-      User.create_index(:email, 'taco@bell.com', 1)
-      User.create_index(:email, 'taco@bell.com', 2)
-      User.create_index(:email, 'taco@bell.com', 1)
-    end
-
-    it "stores value only once and doesn't change order" do
-      User.get_index(:email, 'taco@bell.com').should == [1, 2]
-    end
-  end
-
-  describe ".destroy_index (for missing index)" do
-    before do
-      User.attribute(:email, String)
-      User.index(:email)
-      User.destroy_index(:email, 'taco@bell.com', 1)
-    end
-
-    it "sets index to empty array" do
-      User.get_index(:email, 'taco@bell.com').should == []
-    end
-  end
-
-  describe ".destroy_index (for indexed id)" do
-    before do
-      User.attribute(:email, String)
-      User.index(:email)
-      User.create_index(:email, 'taco@bell.com', 1)
-      User.destroy_index(:email, 'taco@bell.com', 1)
-    end
-
-    it "removes the value from the index" do
-      User.get_index(:email, 'taco@bell.com').should == []
-    end
-  end
-end