toystore 0.5

data/spec/toy/lists_spec.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+describe Toy::Lists do
+  uses_constants('User', 'Game', 'Move')
+
+  it "defaults lists to empty hash" do
+    User.lists.should == {}
+  end
+
+  it "does not share with embedded lists" do
+    Game.embedded_list(:moves)
+    Game.lists.should == {}
+  end
+
+  describe ".list?" do
+    before do
+      User.list(:games)
+    end
+
+    it "returns true if attribute (symbol)" do
+      User.list?(:games).should be_true
+    end
+
+    it "returns true if attribute (string)" do
+      User.list?('games').should be_true
+    end
+
+    it "returns false if not attribute" do
+      User.list?(:foobar).should be_false
+    end
+  end
+
+  describe "declaring a list" do
+    describe "using conventions" do
+      before do
+        @list = User.list(:games)
+      end
+
+      it "knows about its lists" do
+        User.lists[:games].should == Toy::List.new(User, :games)
+      end
+
+      it "returns list" do
+        @list.should == Toy::List.new(User, :games)
+      end
+    end
+
+    describe "with type" do
+      before do
+        @list = User.list(:active_games, Game)
+      end
+      let(:list) { @list }
+
+      it "sets type" do
+        list.type.should be(Game)
+      end
+
+      it "sets options to hash" do
+        list.options.should be_instance_of(Hash)
+      end
+    end
+
+    describe "with options" do
+      before do
+        @list = User.list(:games, :dependent => true)
+      end
+      let(:list) { @list }
+
+      it "sets type" do
+        list.type.should be(Game)
+      end
+
+      it "sets options" do
+        list.options.should have_key(:dependent)
+        list.options[:dependent].should be_true
+      end
+    end
+
+    describe "with type and options" do
+      before do
+        @list = User.list(:active_games, Game, :dependent => true)
+      end
+      let(:list) { @list }
+
+      it "sets type" do
+        list.type.should be(Game)
+      end
+
+      it "sets options" do
+        list.options.should have_key(:dependent)
+        list.options[:dependent].should be_true
+      end
+    end
+  end
+end

data/spec/toy/logger_spec.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+describe Toy::Logger do
+  uses_constants('User')
+
+  it "should use Toy.logger for class" do
+    User.logger.should == Toy.logger
+  end
+
+  it "should use Toy.logger for instance" do
+    User.new.logger.should == Toy.logger
+  end
+
+  describe ".log_operation" do
+    let(:adapter) { Adapter[:memory].new({}) }
+
+    it "logs operation" do
+      User.logger.should_receive(:debug).with('ToyStore GET :memory "foo"')
+      User.logger.should_receive(:debug).with('  "bar"')
+      User.log_operation('GET', adapter, 'foo', 'bar')
+    end
+  end
+
+  describe "#log_operation" do
+    let(:adapter) { Adapter[:memory].new({}) }
+
+    it "logs operation" do
+      User.logger.should_receive(:debug).with('ToyStore GET :memory "foo"')
+      User.logger.should_receive(:debug).with('  "bar"')
+      User.log_operation('GET', adapter, 'foo', 'bar')
+    end
+  end
+end

data/spec/toy/mass_assignment_security_spec.rb

@@ -0,0 +1,116 @@
+require 'helper'
+
+describe Toy::MassAssignmentSecurity do
+  uses_constants('User', 'Game')
+
+  describe 'A class with accessible attributes' do
+    before do
+      User.attribute :name,  String
+      User.attribute :admin, Boolean, :default => false
+
+      User.attr_accessible :name
+      @user = User.create(:name => 'Steve Sloan')
+    end
+
+    it 'should have accessible attributes class method' do
+      User.accessible_attributes.should include(:name)
+    end
+
+    it "should default accessible attributes to empty" do
+      Game.accessible_attributes.should be_empty
+    end
+
+    it "should assign inaccessible attribute through accessor" do
+      @user.admin = true
+      @user.admin.should be_true
+    end
+
+    it "should ignore inaccessible attribute on #initialize" do
+      user = User.new(:name => 'John', :admin => true)
+      user.admin.should be_false
+      user.name.should == 'John'
+    end
+
+    it "should not ignore inaccessible attributes on #initialize from the database" do
+      user = User.new(:name => 'John')
+      user.admin = true
+      user.save!
+
+      user = User.get(user.id)
+      user.admin.should be_true
+      user.name.should == 'John'
+    end
+
+    it "should ignore inaccessible attribute on #update_attributes" do
+      @user.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @user.name.should == 'Ren Hoek'
+      @user.admin.should be_false
+    end
+
+    it "should be indifferent to whether the accessible keys are strings or symbols" do
+      @user.update_attributes("name" => 'Stimpson J. Cat', "admin" => true)
+      @user.name.should == 'Stimpson J. Cat'
+      @user.admin.should be_false
+    end
+
+    it "should accept nil as constructor's argument without raising exception" do
+      lambda { User.new(nil) }.should_not raise_error
+    end
+  end
+
+  describe 'A class with protected attributes' do
+    before do
+      User.attribute :name, String
+      User.attribute :admin, Boolean, :default => false
+
+      User.attr_protected :admin
+
+      @user = User.create(:name => 'Steve Sloan')
+    end
+
+    it "should have protected attributes class method" do
+      User.protected_attributes.should include(:admin)
+    end
+
+    it "should default protected attributes to empty" do
+      Game.protected_attributes.should be_empty
+    end
+
+    it "should assign protected attribute through accessor" do
+      @user.admin = true
+      @user.admin.should be_true
+    end
+
+    it "should ignore protected attribute on #initialize" do
+      user = User.new(:name => 'John', :admin => true)
+      user.admin.should be_false
+      user.name.should == 'John'
+    end
+
+    it "should not ignore protected attributes on #initialize from the database" do
+      user = User.new(:name => 'John')
+      user.admin = true
+      user.save!
+
+      user = User.get(user.id)
+      user.admin.should be_true
+      user.name.should == 'John'
+    end
+
+    it "should ignore protected attribute on #update_attributes" do
+      @user.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @user.name.should == 'Ren Hoek'
+      @user.admin.should be_false
+    end
+
+    it "should be indifferent to whether the protected keys are strings or symbols" do
+      @user.update_attributes("name" => 'Stimpson J. Cat', "admin" => true)
+      @user.name.should == 'Stimpson J. Cat'
+      @user.admin.should be_false
+    end
+
+    it "should accept nil as constructor's argument without raising exception" do
+      lambda { User.new(nil) }.should_not raise_error
+    end
+  end
+end

data/spec/toy/persistence_spec.rb

@@ -0,0 +1,312 @@
+require 'helper'
+
+describe Toy::Persistence do
+  uses_constants('User')
+
+  let(:klass) do
+    Class.new { include Toy::Store }
+  end
+
+  describe ".store" do
+    it "sets if arguments and reads if not" do
+      User.store(:memory, {})
+      User.store.should == Adapter[:memory].new({})
+    end
+
+    it "works with options" do
+      Adapter[:memory].should_receive(:new).with({}, :something => true)
+      User.store(:memory, {}, :something => true)
+    end
+
+    it "raises argument error if name provided but not client" do
+      lambda do
+        klass.store(:memory)
+      end.should raise_error(ArgumentError, 'Client is required')
+    end
+
+    it "raises argument error if no name or client provided and has not been set" do
+      lambda do
+        klass.store
+      end.should raise_error(StandardError, 'No store has been set')
+    end
+  end
+
+  describe ".cache" do
+    it "sets if arguments and reads if not" do
+      klass.cache(:memory, {})
+      klass.cache.should == Adapter[:memory].new({})
+    end
+
+    it "raises argument error if name provided but not client" do
+      lambda do
+        klass.cache(:memory)
+      end.should raise_error(ArgumentError, 'Client is required')
+    end
+
+    it "raises argument error if no name or client provided and has not been set" do
+      lambda do
+        klass.cache
+      end.should raise_error(StandardError, 'No cache has been set')
+    end
+  end
+
+  describe ".has_store?" do
+    it "returns true if cache set" do
+      klass.store(:memory, {})
+      klass.has_store?.should be_true
+    end
+
+    it "returns false if cache not set" do
+      klass.has_store?.should be_false
+    end
+  end
+
+  describe ".has_cache?" do
+    it "returns true if cache set" do
+      klass.cache(:memory, {})
+      klass.has_cache?.should be_true
+    end
+
+    it "returns false if cache not set" do
+      klass.has_cache?.should be_false
+    end
+  end
+
+  describe ".store_key" do
+    it "returns namespace and id" do
+      doc = User.new
+
+      User.store_key(doc.id).should == "User:#{doc.id}"
+      User.namespace('Crazy')
+      User.store_key(doc.id).should == "Crazy:#{doc.id}"
+    end
+  end
+
+  describe ".namespace" do
+    it "defaults to class name" do
+      User.namespace.should == 'User'
+    end
+
+    it "sets if argument and reads if not" do
+      User.namespace('CrazyUser')
+      User.namespace.should == 'CrazyUser'
+    end
+  end
+
+  describe ".create" do
+    before do
+      User.attribute :name, String
+      User.attribute :age, Integer
+      @doc = User.create(:name => 'John', :age => 50)
+    end
+    let(:doc) { @doc }
+
+    it "creates key in database with attributes" do
+      User.store.read(doc.store_key).should == {
+        'name' => 'John',
+        'id'   => doc.id,
+        'age'  => 50,
+      }
+    end
+
+    it "returns instance of model" do
+      doc.should be_instance_of(User)
+    end
+  end
+
+  describe ".delete(*ids)" do
+    it "should delete a single record" do
+      doc = User.create
+      User.delete(doc.id)
+      User.key?(doc.id).should be_false
+    end
+
+    it "should delete multiple records" do
+      doc1 = User.create
+      doc2 = User.create
+
+      User.delete(doc1.id, doc2.id)
+
+      User.key?(doc1.id).should be_false
+      User.key?(doc2.id).should be_false
+    end
+
+    it "should not complain when records do not exist" do
+      doc = User.create
+      User.delete("taco:bell:tacos")
+    end
+  end
+
+  describe ".destroy(*ids)" do
+    it "should destroy a single record" do
+      doc = User.create
+      User.destroy(doc.id)
+      User.key?(doc.id).should be_false
+    end
+
+    it "should destroy multiple records" do
+      doc1 = User.create
+      doc2 = User.create
+
+      User.destroy(doc1.id, doc2.id)
+
+      User.key?(doc1.id).should be_false
+      User.key?(doc2.id).should be_false
+    end
+
+    it "should not complain when records do not exist" do
+      doc = User.create
+      User.destroy("taco:bell:tacos")
+    end
+  end
+
+  describe "#store" do
+    it "delegates to class" do
+      User.new.store.should equal(User.store)
+    end
+  end
+
+  describe "#store_key" do
+    it "returns pluralized human name and id" do
+      doc = User.new
+      doc.store_key.should == "User:#{doc.id}"
+    end
+  end
+
+  describe "#new_record?" do
+    it "returns true if new" do
+      User.new.should be_new_record
+    end
+
+    it "returns false if not new" do
+      User.create.should_not be_new_record
+    end
+  end
+
+  describe "#persisted?" do
+    it "returns true if persisted" do
+      User.create.should be_persisted
+    end
+
+    it "returns false if not persisted" do
+      User.new.should_not be_persisted
+    end
+
+    it "returns false if deleted" do
+      doc = User.create
+      doc.delete
+      doc.should_not be_persisted
+    end
+  end
+
+  describe "#save" do
+    before do
+      User.attribute :name, String
+      User.attribute :age, Integer
+      User.attribute :accepted_terms, Boolean, :virtual => true
+    end
+
+    context "with new record" do
+      before do
+        @doc = User.new(:name => 'John', :age => 28, :accepted_terms => true)
+        @doc.save
+      end
+
+      it "saves to key" do
+        User.key?(@doc.id)
+      end
+
+      it "does not persist virtual attributes" do
+        @doc.store.read(@doc.store_key).should_not include('accepted_terms')
+      end
+    end
+
+    context "with existing record" do
+      before do
+        @doc      = User.create(:name => 'John', :age => 28)
+        @key      = @doc.store_key
+        @value    = User.store.read(@doc.store_key)
+        @doc.name = 'Bill'
+        @doc.accepted_terms = false
+        @doc.save
+      end
+      let(:doc) { @doc }
+
+      it "stores in same key" do
+        doc.store_key.should == @key
+      end
+
+      it "updates value in store" do
+        User.store.read(doc.store_key).should_not == @value
+      end
+
+      it "does not persist virtual attributes" do
+        @doc.store.read(@doc.store_key).should_not include('accepted_terms')
+      end
+
+      it "updates the attributes in the instance" do
+        doc.name.should == 'Bill'
+      end
+    end
+  end
+
+  describe "#update_attributes" do
+    before do
+      User.attribute :name, String
+    end
+
+    it "should change attribute and save" do
+      user = User.create(:name => 'John')
+      User.get(user.id).name.should == 'John'
+
+      user.update_attributes(:name => 'Geoffrey')
+      User.get(user.id).name.should == 'Geoffrey'
+    end
+  end
+
+  describe "#delete" do
+    it "should remove the instance from the store" do
+      doc = User.create
+      doc.delete
+      User.key?(doc.id).should be_false
+    end
+  end
+
+  describe "#destroy" do
+    it "should remove the instance from the store" do
+      doc = User.create
+      doc.destroy
+      User.key?(doc.id).should be_false
+    end
+  end
+
+  describe "#destroyed?" do
+    it "should be false if not deleted" do
+      doc = User.create
+      doc.should_not be_destroyed
+    end
+
+    it "should be true if deleted" do
+      doc = User.create
+      doc.delete
+      doc.should be_destroyed
+    end
+  end
+
+  describe "with cache store" do
+    before do
+      @cache  = User.cache(:memory, {})
+      @memory = User.store(:memory, {})
+      @user   = User.create
+    end
+
+    let(:cache)   { @cache }
+    let(:memory)  { @memory }
+    let(:user)    { @user }
+
+    it "writes to cache and store" do
+      cache[user.store_key].should == user.persisted_attributes
+      memory[user.store_key].should    == user.persisted_attributes
+    end
+  end
+end