ricordami 0.0.1

data/spec/ricordami/can_have_relationships_spec.rb

@@ -0,0 +1,255 @@
+# -*- encoding: utf-8 -*-
+require "spec_helper"
+require "ricordami/can_have_relationships"
+
+describe Ricordami::CanHaveRelationships do
+  uses_constants("Computer", "Software", "Editor")
+
+  before(:each) do
+    Computer.send(:include, Ricordami::CanHaveRelationships)
+    Computer.attribute :model
+    Computer.index :unique => :model, :get_by => true
+    Computer.references_many :softwares
+    Software.send(:include, Ricordami::CanHaveRelationships)
+    Software.attribute :name
+    Software.index :unique => :name, :get_by => true
+    Software.referenced_in :computer
+    Software.referenced_in :editor
+    Editor.send(:include, Ricordami::CanHaveRelationships)
+    Editor.attribute :corp_name
+    Editor.index :unique => :corp_name, :get_by => true
+    Editor.references_one :software
+  end
+
+  describe "class" do
+    it "can declare a :referenced_in relationship with #referenced_in" do
+      Software.referenced_in :computer
+      Software.relationships[:computer].should be_a(Ricordami::Relationship)
+      Software.relationships[:computer].type.should == :referenced_in
+      Software.relationships[:computer].name.should == :computer
+      Software.relationships[:computer].object_kind.should == :computer
+    end
+
+    it "can declare a :references_many relationship with #references_many" do
+      Computer.references_many :softwares, :dependent => :nullify, :as => :softs
+      Computer.relationships[:softs].should be_a(Ricordami::Relationship)
+      Computer.relationships[:softs].type.should == :references_many
+      Computer.relationships[:softs].name.should == :softs
+      Computer.relationships[:softs].object_kind.should == :software
+      Computer.relationships[:softs].dependent.should == :nullify
+    end
+
+    it "can declare a :references_one relationship with #references_one" do
+      Editor.references_one :software, :dependent => :nullify
+      Editor.relationships[:software].should be_a(Ricordami::Relationship)
+      Editor.relationships[:software].type.should == :references_one
+      Editor.relationships[:software].name.should == :software
+      Editor.relationships[:software].object_kind.should == :software
+      Editor.relationships[:software].dependent.should == :nullify
+    end
+  end
+
+  describe "instance that is referenced..." do
+    it "creates an attribute for the referrer id" do
+      game = Software.create(:name => "Masquerade")
+      game.computer_id.should be_nil
+    end
+
+    it "indexes the referrer id" do
+      iic = Computer.create(:model => "IIc")
+      mac = Computer.create(:model => "Macintosh")
+      Software.create(:name => "Masquerade", :computer_id => iic.id)
+      Software.create(:name => "Transylvania", :computer_id => iic.id)
+      Software.create(:name => "Dungeon Master", :computer_id => mac.id)
+      Software.where(:computer_id => iic.id).map(&:name).should =~ ["Masquerade", "Transylvania"]
+    end
+
+    it "can access the referrer with a method of the name of the reference" do
+      game = Software.create(:name => "Masquerade")
+      game.computer.should be_nil
+      computer = Computer.create(:model => "IIc")
+      game.computer_id = computer.id
+      game.computer.should be_a(Computer)
+      game.computer.model.should == "IIc"
+    end
+
+    describe "handling caching" do
+      before(:each) do
+        %w(IIc Macintosh).each { |model| Computer.create(:model => model).should be_true }
+      end
+
+      it "caches the referrer isntance after it was cached" do
+        computer = Computer.get_by_model("IIc")
+        game = Software.create(:name => "Masquerade", :computer_id => computer.id)
+        game.computer.should == game.computer
+      end
+
+      it "updates the referrer when changing the referrer id" do
+        game = Software.create(:name => "Sorcery")
+        game.computer.should be_nil
+        game.computer_id = Computer.get_by_model("IIc").id
+        game.computer.model.should == "IIc"
+        game.computer_id = Computer.get_by_model("Macintosh").id
+        game.computer.model.should == "Macintosh"
+        game.computer_id = nil
+        game.computer.should be_nil
+      end
+
+      it "sweeps the referrer instance from the cache after it is reloaded" do
+        game = Software.create(:name => "Swashbuckler",
+                               :computer_id => Computer.get_by_model("IIc").id)
+        game.computer.model.should == "IIc"
+        game.update_attributes(:computer_id => Computer.get_by_model("Macintosh").id)
+        game.computer.model.should == "Macintosh"
+      end
+    end
+  end
+
+  describe "instance that references many..." do
+    before(:each) do
+      @iic = Computer.create(:model => "IIc")
+      @mac = Computer.create(:model => "MacBook Air")
+      [
+        [@iic, "Masquerade"], [@iic, "Transylvania"], [@iic, "Bruce Lee"],
+        [@iic, "Karateka"], [@mac, "Half-Life"], [@mac, "Chopper 2"]
+      ].each do |computer, soft_name|
+        Software.create(:name => soft_name, :computer_id => computer.id)
+      end
+    end
+
+    it "has a method to access its referenced objects" do
+      @iic.should respond_to(:softwares)
+    end
+
+    it "can list all the objects it references with the reference method" do
+      @iic.softwares.map(&:name).should =~ ["Masquerade", "Transylvania",
+                                            "Bruce Lee", "Karateka"]
+      @mac.softwares.map(&:name).should =~ ["Half-Life", "Chopper 2"]
+    end
+
+    it "can return there is no reference objects when non persisted" do
+      Computer.new.softwares.map(&:name).should == []
+      Computer.new.softwares.should be_empty
+      Computer.new.softwares.count.should == 0
+    end
+
+    it "can build a new reference object through the reference method" do
+      soft = @mac.softwares.build
+      soft.should_not be_persisted
+      soft.computer_id.should == @mac.id
+    end
+
+    it "can create a new reference object through the reference method" do
+      soft = @mac.softwares.create(:name => "Call of Duty 4")
+      soft.should be_persisted
+      soft.computer_id.should == @mac.id
+      soft.name.should == "Call of Duty 4"
+    end
+
+    it "can have more than 1 reference for the same type of object" do
+      Computer.references_many :softwares, :as => :softs, :alias => :host, :dependent => :delete
+      Software.referenced_in :computer, :as => :host, :alias => :softs
+      iie = Computer.create(:model => "IIe")
+      iie.softs.create(:name => "Masquerade")
+      iie.softwares.create(:name => "Conan")
+      iie.softs.map(&:name).should == ["Masquerade"]
+      iie.softwares.map(&:name).should == ["Conan"]
+    end
+
+    it "deletes dependents when delete is set to :dependent" do
+      Computer.references_many :softwares, :as => :softs, :dependent => :delete
+      iie = Computer.create(:model => "IIe")
+      iie.softs.create(:name => "Castle Wolfenstein")
+      Software.get_by_name("Castle Wolfenstein").should_not be_nil
+      iie.delete
+      lambda {
+        Software.get_by_name("Castle Wolfenstein")
+      }.should raise_error(Ricordami::NotFound)
+    end
+
+    it "sets to nil reference's referrer_id when delete is set to :nullify" do
+      Computer.references_many :softwares, :as => :softs, :alias => :host, :dependent => :nullify
+      Software.referenced_in :computer, :as => :host, :alias => :softs
+      iie = Computer.create(:model => "IIe")
+      iie.reload
+      iie.softs.create(:name => "Castle Wolfenstein")
+      Software.get_by_name("Castle Wolfenstein").host_id.should == iie.id
+      iie.delete
+      Software.get_by_name("Castle Wolfenstein").host_id.should be_empty
+    end
+
+    it "can build a new referrer object through a build referrer method" do
+      software = Software.create(:name => "Karateka")
+      editor = software.build_editor(:corp_name => "Brøderbund")
+      editor.should_not be_persisted
+      editor.id.should == software.editor_id
+    end
+  end
+
+  describe "instance that references one..." do
+    before(:each) do
+      @aes = Editor.create(:corp_name => "American Eagle Software")
+      Software.create(:name => "Masquerade", :editor_id => @aes.id)
+      @datasoft = Editor.create(:corp_name => "Datasoft")
+      Software.create(:name => "Bruce Lee", :editor_id => @datasoft.id)
+    end
+
+    it "has a method to access its referenced object" do
+      @aes.should respond_to(:software)
+    end
+
+    it "can fetch the object it references with the reference method" do
+      @aes.software.name.should == "Masquerade"
+      @datasoft.software.name.should == "Bruce Lee"
+    end
+
+    it "can return there is no reference objects when non persisted" do
+      Editor.new.software.should be_nil
+    end
+
+    it "can build a new reference object through a build reference method" do
+      soft = @aes.build_software
+      soft.should_not be_persisted
+      soft.editor_id.should == @aes.id
+    end
+
+    it "can create a new reference object through the reference method" do
+      soft = @datasoft.create_software(:name => "Alternate Reality: The City")
+      soft.should be_persisted
+      soft.editor_id.should == @datasoft.id
+      soft.name.should == "Alternate Reality: The City"
+    end
+
+    it "can have more than 1 reference for the same type of object" do
+      Editor.references_one :software, :as => :soft, :alias => :second_editor, :dependent => :delete
+      Software.referenced_in :editor, :as => :second_editor, :alias => :soft
+      broderbund = Editor.create(:corp_name => "Brøderbund")
+      broderbund.create_software(:name => "Karateka")
+      broderbund.create_soft(:name => "Lode Runner")
+      broderbund.software.name.should == "Karateka"
+      broderbund.soft.name.should == "Lode Runner"
+    end
+
+    it "deletes dependents when delete is set to :dependent" do
+      Editor.references_one :software, :as => :soft, :dependent => :delete
+      broderbund = Editor.create(:corp_name => "Brøderbund")
+      broderbund.create_soft(:name => "Karateka")
+      Software.get_by_name("Karateka").should_not be_nil
+      broderbund.delete
+      lambda {
+        Software.get_by_name("Karateka")
+      }.should raise_error(Ricordami::NotFound)
+    end
+
+    it "sets to nil reference's referrer_id when delete is set to :nullify" do
+      Editor.references_one  :software, :as => :soft, :alias => :developper, :dependent => :nullify
+      Software.referenced_in :editor, :as => :developper, :alias => :soft
+      broderbund = Editor.create(:corp_name => "Brøderbund")
+      broderbund.reload
+      broderbund.create_soft(:name => "Choplifter")
+      Software.get_by_name("Choplifter").developper_id.should == broderbund.id
+      broderbund.delete
+      Software.get_by_name("Choplifter").developper_id.should be_empty
+    end
+  end
+end

data/spec/ricordami/configuration_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Ricordami::Configuration, " using #configure" do
+  it "raises an error of no block is given" do
+    lambda { Ricordami.configure }.should raise_error(ArgumentError)
+  end
+
+  it "raises an error when a config attribute doesn't exist" do
+    lambda {
+      Ricordami.configuration.does_not_exist
+    }.should raise_error(Ricordami::AttributeNotSupported)
+  end
+
+  it "can configure redis host with #redis_host" do
+    Ricordami.configure { |config| config.redis_host = "my_host" }
+    Ricordami.configuration.redis_host.should == "my_host"
+  end
+
+  it "can configure redis port with #redis_port" do
+    Ricordami.configure { |config| config.redis_port = 6379 }
+    Ricordami.configuration.redis_port.should == 6379
+  end
+
+  it "can configure redis db (0, 1, 2, ..., 8) with #redis_db" do
+    Ricordami.configure { |config| config.redis_db = 1 }
+    Ricordami.configuration.redis_db.should == 1
+  end
+
+  it "can configure redis to use as thread-safe with #thread_safe" do
+    Ricordami.configure { |config| config.thread_safe = true }
+    Ricordami.configuration.thread_safe.should be_true
+  end
+
+  it "can configure all attributes at once using #from_hash" do
+    Ricordami.configure do |config|
+      config.from_hash(:redis_host => "serge",
+                       :redis_port => 6380,
+                       :redis_db   => 2)
+    end
+    Ricordami.configuration.redis_host.should == "serge"
+    Ricordami.configuration.redis_port.should == 6380
+    Ricordami.configuration.redis_db.should == 2
+    Ricordami.configuration.thread_safe.should be_false
+  end
+end

data/spec/ricordami/connection_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+require "rspec/mocks"
+
+describe Ricordami::Connection do
+  describe "the module" do
+    before(:all) do
+      module Mixer
+        extend self
+        include Ricordami::Connection
+      end
+      RSpec::Mocks::setup(self)
+      @config = mock(:config)
+      [:redis_host, :redis_port, :redis_db, :thread_safe].each do |name|
+        @config.stub!(name)
+      end
+      Mixer.stub!(:configuration).and_return(@config)
+    end
+
+    it "has a connection to Redis" do
+      Mixer.driver.should be_a(Redis)
+      Mixer.driver.get("not_exist")
+      Mixer.driver.client.connection.should be_connected
+    end
+  end
+end

data/spec/ricordami/exceptions_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Ricordami::Error do
+  it "has an error to notify when data was not found on the server" do
+    Ricordami::NotFound.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when an attribute is not supported" do
+    Ricordami::AttributeNotSupported.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify an attempty to change a read-only attribute" do
+    Ricordami::ReadOnlyAttribute.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when an index declaration is invalid" do
+    Ricordami::InvalidIndexDefinition.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when a model is deleted" do
+    Ricordami::ModelHasBeenDeleted.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when a type is not supported" do
+    Ricordami::TypeNotSupported.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when an index is missing" do
+    Ricordami::MissingIndex.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when an event is not supported" do
+    Ricordami::EventNotSupported.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when an option value is invalid" do
+    Ricordami::OptionValueInvalid.new.should be_a_kind_of(Ricordami::Error)
+  end
+
+  it "has an error to notify when mandatory arguments are missing" do
+    Ricordami::MissingMandatoryArgs.new.should be_a_kind_of(Ricordami::Error)
+  end
+end

data/spec/ricordami/has_attributes_spec.rb

@@ -0,0 +1,266 @@
+require "spec_helper"
+
+describe Ricordami::HasAttributes do
+  describe "the class" do
+    uses_constants("Boat")
+
+    it "can declare attributes using #attribute" do
+      Boat.attribute :sail
+      Boat.attributes[:sail].should be_a(Ricordami::Attribute)
+      Boat.attributes[:sail].name.should == :sail
+    end
+
+    it "can pass attribute options when declaring an attribute" do
+      Boat.attribute :color, :default => "black", :read_only => true
+      Boat.attributes[:color].default_value.should == "black"
+      Boat.attributes[:color].should be_read_only
+    end
+
+    it "creates an index if :indexed is set" do
+      Boat.attribute :size, :indexed => :value
+      Boat.indices.should have_key(:size)
+    end
+
+    it "creates a unique index if :indexed is :unique" do
+      Boat.attribute :size, :indexed => :unique
+      Boat.indices[:size].should be_a(Ricordami::UniqueIndex)
+    end
+
+    it "creates a value index if :indexed is :value" do
+      Boat.attribute :size, :indexed => :value
+      Boat.indices[:size].should be_a(Ricordami::ValueIndex)
+    end
+
+    it "replaces :initial value with a generator if it's a symbol" do
+      Boat.attribute :id, :initial => :sequence
+      attribute = Boat.attributes[:id]
+      attribute.initial_value.should == "1"
+      attribute.initial_value.should == "2"
+      attribute.initial_value.should == "3"
+    end
+  end
+
+  describe "an instance" do
+    uses_constants("User")
+
+    it "can be initialized with a hash of attribute values" do
+      User.attribute :name
+      User.attribute :age
+      User.attribute :ssn
+      user = User.new(:name => "jean", :age => "20", :ssn => "1234567890")
+      user.name.should == "jean"
+      user.age.should == "20"
+      user.ssn.should == "1234567890"
+    end
+
+    it "can set attributes using writers" do
+      User.attribute :email
+      user = User.new
+      user.email.should be_nil
+      user.email = "blah@toto.com"
+      user.email.should == "blah@toto.com"
+    end
+
+    it "sets default values when initializing without argument" do
+      User.attribute :age, :default => "18"
+      User.new.age.should == "18"
+    end
+
+    it "overwrites default values with arguments when initializing" do
+      User.attribute :age, :default => "18"
+      User.new(:age => "12").age.should == "12"
+    end
+
+    it "can't change a read-only attribute that was initialized" do
+      User.attribute :name
+      User.attribute :ssn, :read_only => true
+      user = User.new(:name => "James Bond", :ssn => "007")
+      lambda {
+        user.ssn = "1234567890"
+      }.should raise_error(Ricordami::ReadOnlyAttribute)
+      lambda {
+        user.name = "Titi"
+      }.should_not raise_error(Ricordami::ReadOnlyAttribute)
+    end
+
+    it "can set a read-only attribute only once if it was not initialized" do
+      User.attribute :name
+      User.attribute :ssn, :read_only => true
+      user = User.new
+      lambda {
+        user.ssn = "1234567890"
+        user.name = "Titi"
+        user.name = "Bob Loblaw"
+      }.should_not raise_error(Ricordami::ReadOnlyAttribute)
+      lambda {
+        user.ssn = "0987654321"
+      }.should raise_error(Ricordami::ReadOnlyAttribute)
+    end
+
+    it "has an 'id' attribute set by default to a sequence if not overriden when saved" do
+      user = User.create
+      user.id.should be_present
+      user.id.should == "1"
+    end
+
+    it "overides the value of its 'id' attribute when a value is passed" do
+      user = User.create(:id => "foo")
+      user.id.should == "foo"
+    end
+
+    it "defines 'id' as a read_only attribute" do
+      user = User.create
+      lambda {
+        user.id = "try me"
+      }.should raise_error(Ricordami::ReadOnlyAttribute)
+    end
+
+    it "returns the name of the attributes key with #attributes_key_name" do
+      user = User.new(:id => "ze_id")
+      user.instance_eval { attributes_key_name }.should == "User:att:ze_id"
+    end
+
+    it "updates the attribute values in memory with #update_mem_attributes!" do
+      User.attribute :age
+      User.attribute :sex
+      user = User.new(:age => "12", :sex => "male")
+      user.update_mem_attributes!(:age => "18", :sex => "female")
+      user.age.should == "18"
+      user.sex.should == "female"
+    end
+
+    it "can't change read-only attributes with #update_mem_attributes!" do
+      User.attribute :name
+      User.attribute :ssn, :read_only => true
+      user = User.new(:name => "James Bond", :ssn => "007")
+      lambda {
+        user.update_mem_attributes!(:ssn => "1234567890")
+      }.should raise_error(Ricordami::ReadOnlyAttribute)
+    end
+
+    it "updates the attribute values in memory with #update_mem_attributes" do
+      User.attribute :age
+      user = User.new(:age => "12")
+      user.update_mem_attributes(:age => "18")
+      user.age.should == "18"
+    end
+
+    it "changes read-only attributes with #update_mem_attributes" do
+      User.attribute :ssn, :read_only => true
+      user = User.new(:ssn => "007")
+      lambda {
+        user.update_mem_attributes(:ssn => "1234567890")
+      }.should_not raise_error
+    end
+
+    it "can't change the attributes of a model that was deleted" do
+      User.attribute :age
+      user = User.create(:age => "42")
+      user.delete
+      lambda { user.age = "12" }.should raise_error(Ricordami::ModelHasBeenDeleted)
+    end
+  end
+
+  describe "keeps track of dirty attributes" do
+    uses_constants("Plane")
+    before(:each) do
+      Plane.attribute :brand
+      Plane.attribute :model
+    end
+
+    describe "a new record" do
+      before(:each) { @plane = Plane.new }
+      let(:plane) { @plane }
+
+      it "was not changed if it doesn't have attributes" do
+        plane.should_not be_changed
+        plane.changed.should be_empty
+        plane.changes.should be_empty
+      end
+
+      it "was changed when initialized with attributes" do
+        plane = Plane.new(:brand => "Airbus", :model => "320")
+        plane.should be_changed
+        plane.changed.should =~ ["brand", "model"]
+        plane.changes.should == {"brand" => [nil, "Airbus"], "model" => [nil, "320"]}
+      end
+
+      it "knows when an attribute value changes" do
+        plane.brand = "Boeing"
+        plane.should be_changed
+        plane.changed.should == ["brand"]
+        plane.changes["brand"].should == [nil, "Boeing"]
+      end
+
+      it "knows when an attribute value actually didn't change" do
+        plane.brand = nil
+        plane.should_not be_changed
+      end
+
+      it "was not changed after it was saved" do
+        plane.model = "380"
+        plane.save
+        plane.should_not be_changed
+      end
+
+      it "knows when it was changed before being saved" do
+        plane.model = "380"
+        plane.save
+        plane.previous_changes["model"].should == [nil, "380"]
+      end
+    end
+
+    describe "a persisted record" do
+      before(:each) { Plane.create(:id => "A320", :brand => "Airbus", :model => "320") }
+      let(:plane) { Plane["A320"] }
+
+      it "was not changed when it's just loaded from the DB" do
+        plane.should_not be_changed
+      end
+
+      it "was not changed after reloading it with #reload" do
+        plane.brand = "Toys'R US"
+        plane.reload
+        plane.should_not be_changed
+      end
+
+      it "knows when an attribute value actually didn't change" do
+        plane.brand = "Airbus"
+        plane.should_not be_changed
+        plane.brand = "Boeing"
+        plane.brand = "Airbus"
+        plane.should_not be_changed
+      end
+
+      it "knows which attributes changed when running #update_attributes" do
+        plane.brand = "Boeing"
+        plane.update_attributes(:brand => "Airbus", :model => "380")
+        plane.should_not be_changed
+        plane.previous_changes.should == {"model" => ["320", "380"]}
+      end
+    end
+
+    describe "attribute value typing" do
+      uses_constants("Person")
+      before(:each) do
+        Person.attribute :name
+        Person.attribute :age, :type => :integer
+        Person.attribute :parts, :type => :float
+      end
+
+      it "converts value types when initializing an object" do
+        person = Person.new(:name => 123, :age => "21", :parts => "5.2")
+        person.name.should == "123"
+        person.age.should == 21
+        person.parts.should == 5.2
+      end
+
+      it "doesn't convert the value type if value is nil" do
+        person = Person.new(:name => nil, :age => nil, :parts => nil)
+        person.name.should be_nil
+        person.age.should be_nil
+        person.parts.should be_nil
+      end
+    end
+  end
+end