ricordami 0.0.1

data/spec/ricordami/has_indices_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Ricordami::HasIndices do
+  describe "the class" do
+    uses_constants("Car")
+    before(:each) do
+      Car.attribute :model
+      Car.attribute :name
+    end
+
+    it "raises an error when declaring an index that's neither unique or a value index" do
+      lambda { Car.index }.should raise_error(Ricordami::InvalidIndexDefinition)
+    end
+
+    describe "declaring a value index" do
+      it "can declare a value index with #index" do
+        index = Car.index :value => :model
+        Car.indices[:model].should be_a(Ricordami::ValueIndex)
+        Car.indices[:model].should == index
+      end
+    end
+
+    describe "declaring a unique index" do
+      it "can declare a unique index with #index" do
+        index = Car.index :unique => :model
+        Car.indices[:model].should be_a(Ricordami::UniqueIndex)
+        Car.indices[:model].should == index
+      end
+
+      it "discards the subsequent declarations if the same index is created more than once" do
+        Car.index :unique => :model, :get_by => true
+        Car.indices[:model].need_get_by.should be_true
+        Car.index :unique => :model, :get_by => false
+        Car.indices[:model].need_get_by.should be_true
+      end
+
+      it "saves the values of the unique attributes into the indices" do
+        Car.index :unique => :name
+        car = Car.new(:name => "Prius")
+        car.save
+        Car.indices[:name].all.should == ["Prius"]
+      end
+
+      it "replaces old values with new ones into the indices" do
+        Car.index :unique => :name
+        car = Car.new(:name => "Prius")
+        car.save
+        Car.indices[:name].all.should == ["Prius"]
+        car.name = "Rav4"
+        car.save
+        Car.indices[:name].all.should == ["Rav4"]
+      end
+
+      it "deletes the values of the unique attributes from the indices" do
+        Car.index :unique => :name
+        car = Car.create(:name => "Prius")
+        car.delete.should be_true
+        Car.indices[:name].all.should be_empty
+      end
+
+      it "adds a get_by_xxx method for each unique index xxx declared if :get_by is true" do
+        Car.index :unique => :name, :get_by => true
+        %w(il etait un petit navire).each { |n| Car.create(:name => n) }
+        Car.get_by_name("petit").name.should == "petit"
+      end
+
+      it "doesn't add the get_by_xxx method if :get_by is not true" do
+        Car.index :unique => :name
+        Car.should_not respond_to(:get_by_name)
+      end
+    end
+  end
+end

data/spec/ricordami/is_lockable_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Ricordami::IsLockable do
+  uses_constants("Client")
+
+  it "can get only one model lock at a time" do
+    5.times do
+      ts1 = ts2 = nil
+      client = Client.create
+      t1 = Thread.new do
+        client.lock! { sleep(0.01); ts1 = Time.now }
+      end
+      t2 = Thread.new do
+        sleep(0.01)
+        client.lock! { ts2 = Time.now }
+      end
+      t1.join
+      t2.join
+      ts2.should >= ts1
+    end
+  end
+
+  it "can get one lock per instance" do
+    5.times do
+      c1ok, c2ok = false, false
+      client = Client.create
+      other = Client.create
+      t1 = Thread.new do
+        client.lock! do
+          c1ok = true
+          sleep 0.05 until c2ok
+        end
+      end
+      t2 = Thread.new do
+        other.lock! do
+          c2ok = true
+          sleep 0.05 until c1ok
+        end
+      end
+      t1.join
+      t2.join
+      c2ok.should be_true
+    end
+  end
+end

data/spec/ricordami/is_persisted_spec.rb

@@ -0,0 +1,186 @@
+require "spec_helper"
+
+describe Ricordami::IsPersisted do
+  uses_constants("Tenant")
+
+  it "is not persisted and is a new record after it's just been initialized" do
+    tenant = Tenant.new
+    tenant.should_not be_persisted
+    tenant.should be_a_new_record
+  end
+
+  it "is persisted and not a new record after it's been successfully saved with #save" do
+    tenant = Tenant.new
+    tenant.save
+    tenant.should be_persisted
+    tenant.should_not be_a_new_record
+  end
+
+  it "returns the redis driver instance with #redis" do
+    Tenant.redis.should == Ricordami.driver
+    Tenant.new.redis.should == Ricordami.driver
+  end
+
+  describe "#save & #create" do
+    shared_examples_for "a persister" do
+      it "persists a new model" do
+        Tenant.attribute :balance
+        persister_action.call
+        attributes = Ricordami.driver.hgetall("Tenant:att:jojo")
+        attributes["id"].should == "jojo"
+        attributes["balance"].should == "-$99.98"
+      end
+    end
+
+    describe "#save" do
+      let(:persister_action) {
+        Proc.new {
+          tenant = Tenant.new(:id => "jojo", :balance => "-$99.98")
+          tenant.save.should be_true
+        }
+      }
+      it_should_behave_like "a persister"
+      it "returns false if saving failed" do
+        switch_db_to_error
+        Tenant.new.save.should be_false
+        switch_db_to_ok
+      end
+    end
+
+    describe "#create" do
+      let(:persister_action) {
+        Proc.new {
+          tenant = Tenant.create(:id => "jojo", :balance => "-$99.98")
+          tenant.should be_a(Tenant)
+          tenant.should be_persisted
+        }
+      }
+      it_should_behave_like "a persister"
+      it "returns an instance not persisted if creating failed" do
+        switch_db_to_error
+        tenant = Tenant.create(:id => "jojo", :balance => "-$99.98")
+        tenant.should be_a(Tenant)
+        tenant.should_not be_persisted
+        switch_db_to_ok
+      end
+    end
+  end
+
+  describe "#reload and #update_attributes" do
+    it "reloads the attribute values from the DB with #reload" do
+      Tenant.attribute :name
+      tenant = Tenant.create(:name => "gainsbourg")
+      tenant.name = "updated"
+      tenant.name.should == "updated"
+      tenant.reload
+      tenant.name.should == "gainsbourg"
+    end
+
+    it "updates passed attribute values and saves the model with #update_attributes" do
+      [:first, :last].each { |a| Tenant.attribute a }
+      tenant = Tenant.create(:first => "serge", :last => "gainsbourg")
+      tenant.update_attributes(:first => "SERGE").should be_true
+      tenant.reload
+      tenant.first.should == "SERGE"
+      tenant.last.should == "gainsbourg"
+    end
+
+    it "raise an error if #update_attributes can't save the changes" do
+      tenant = Tenant.create(:id => "gainsbare")  # id is read-only
+      lambda {
+        tenant.update_attributes(:id => "gainsbourg")
+      }.should raise_error(Ricordami::ReadOnlyAttribute)
+    end
+  end
+
+  describe "grouping DB operations with #queue_saving_operations" do
+    it "raises an error if no block is passed" do
+      lambda {
+        Tenant.queue_saving_operations
+      }.should raise_error(ArgumentError)
+    end
+
+    it "raises an error if the block passed doesn't take 2 arguments" do
+      lambda {
+        Tenant.queue_saving_operations { |one| [one] }
+      }.should raise_error(ArgumentError)
+    end
+
+    it "allows to queue DB operations that will run when instance is saved" do
+      logs = []
+      Tenant.attribute :name
+      Tenant.queue_saving_operations do |obj, session|
+        logs << if obj.persisted?
+          "ALREADY persisted"
+        else
+          "NOT persisted"
+        end
+      end
+      tenant = Tenant.new
+      tenant.save
+      tenant.update_attributes(:name => "blah")
+      logs.should == ["NOT persisted", "ALREADY persisted"]
+    end
+  end
+
+  describe "grouping DB operations with #queue_deleting_operations" do
+    it "raises an error if no block is passed" do
+      lambda {
+        Tenant.queue_deleting_operations
+      }.should raise_error(ArgumentError)
+    end
+
+    it "raises an error if the block passed doesn't take 2 arguments" do
+      lambda {
+        Tenant.queue_deleting_operations { |one| [one] }
+      }.should raise_error(ArgumentError)
+    end
+
+    it "allows to queue DB operations that will run when instance is deleted" do
+      logs = []
+      Tenant.attribute :name
+      Tenant.queue_deleting_operations { |obj, session| logs << "Tenant deleted #1" }
+      Tenant.queue_deleting_operations { |obj, session| logs << "Tenant deleted #2" }
+      tenant = Tenant.create
+      tenant.delete
+      logs.should == ["Tenant deleted #2", "Tenant deleted #1"]
+    end
+  end
+
+  describe "#delete" do
+    before(:each) { Tenant.attribute :name }
+    let(:tenant) { Tenant.create(:id => "myid") }
+
+    it "deletes the attributes from the DB" do
+      tenant.delete.should be_true
+      from_db = Ricordami.driver.hgetall("Tenant:att:myid")
+      from_db.should be_empty
+    end
+
+    it "knows when a model has been deleted" do
+      tenant.should_not be_deleted
+      tenant.delete
+      tenant.should be_deleted
+    end
+
+    it "freezes the model after deleting it" do
+      tenant.delete
+      tenant.should be_frozen
+    end
+
+    it "can't save a model that was deleted" do
+      tenant.delete
+      lambda { tenant.save }.should raise_error(Ricordami::ModelHasBeenDeleted)
+    end
+
+    it "can't update the attributes of a model that was deleted" do
+      tenant.delete
+      lambda {
+        tenant.update_attributes(:name => "titi")
+      }.should raise_error(Ricordami::ModelHasBeenDeleted)
+    end
+
+    it "can't delete a model that was deleted" do
+    end
+  end
+end

data/spec/ricordami/is_retrievable_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Ricordami::IsRetrievable do
+  uses_constants("Tenant")
+
+  describe "#get & #[]" do
+    it "loads a model with #get when it exists" do
+      Tenant.attribute :language
+      Tenant.new(:id => "Francois", :language => "French").save
+      tenant = Tenant.get("Francois")
+      tenant.attributes.should == {
+        "id" => "Francois",
+        "language" => "French"
+      }
+      tenant.should be_persisted
+    end
+
+    it "#get raises an error if the model is not found" do
+      lambda {
+        Tenant.get("doesn't exist")
+      }.should raise_error(Ricordami::NotFound)
+    end
+
+    it "#[] is an alias for get" do
+      Tenant.new(:id => "myid").save
+      Tenant["myid"].attributes["id"].should == "myid"
+      lambda { Tenant["nope"] }.should raise_error(Ricordami::NotFound)
+    end
+  end
+
+  describe "#all & #count" do
+    it "saves the ids of new instances when saved" do
+      Tenant.attribute :name
+      instance = Tenant.new(:id => "hi")
+      instance.save
+      Tenant.indices[:id].all.should == ["hi"]
+      instance.name = "john"
+      instance.save
+      Tenant.indices[:id].all.should == ["hi"]
+    end
+
+    it "returns all the instances with #all" do
+      %w(allo la terre).each { |n| Tenant.create(:id => n) }
+      Tenant.all.map(&:id).should =~ ["allo", "la", "terre"]
+    end
+
+    it "returns the number of instances with #count" do
+      Tenant.count.should == 0
+      Tenant.create(:id => "blah")
+      Tenant.count.should == 1
+      %w(allo la terre).each { |n| Tenant.create(:id => n) }
+      Tenant.count.should == 4
+    end
+  end
+end

data/spec/ricordami/key_namer_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Ricordami::KeyNamer do
+  subject { Ricordami::KeyNamer }
+  uses_constants("Call", "Leg", "Boat")
+
+  it "returns a key name for a sequence with #sequence" do
+    name = subject.sequence(Boat, :type => "id")
+    name.should == "Boat:seq:id"
+  end
+
+  it "returns a key name for model attributes with #attributes" do
+    name = subject.attributes(Boat, :id => "42")
+    name.should == "Boat:att:42"
+  end
+
+  it "returns a key name for a unique index with #unique_index" do
+    name = subject.unique_index(Call, :name => "ani")
+    name.should == "Call:udx:ani"
+  end
+
+  it "returns a key name for a hash reference with #hash_ref" do
+    name = subject.hash_ref(Call, :fields=> ["ani", "dnis"])
+    name.should == "Call:hsh:ani_dnis_to_id"
+  end
+
+  it "returns a key name for the value of a field of a model with #index" do
+    name = subject.index(Leg, :field => :direction, :value => "inout")
+    name.should == "Leg:idx:direction:aW5vdXQ="
+  end
+
+  it "returns a volatile key name for a set with #volatile_set" do
+    kn1 = subject.volatile_set(Call, :key => nil, :info => [:and, "username", "sex"])
+    kn1.should == "~:Call:set:and(username,sex)"
+    kn2 = subject.volatile_set(Call, :key => "~:Call:set:and(username,sex)",
+                                     :info => [:or, "country"])
+    kn2.should == "~:Call:set:and(username,sex):or(country)"
+  end
+
+  it "returns a temporary key name for a model with #temporary" do
+    5.times do |i|
+      name = subject.temporary(Leg)
+      name.should == "Leg:val:_tmp:#{i + 1}"
+    end
+  end
+
+  it "returns a key name for the model lock with #lock" do
+    name = subject.lock(Leg, :id => 3)
+    name.should == "Leg:val:3:_lock"
+  end
+
+  it "returns a key name for sort an attribute with #sort" do
+    name = subject.sort("Student", :sort_by => :name)
+    name.should == "Student:att:*->name"
+  end
+end

data/spec/ricordami/model_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Ricordami::Model do
+  uses_constants('User')
+
+  it "uses ActiveSupport::Concern for a simple module structure" do
+    Ricordami::Model.should be_a_kind_of(ActiveSupport::Concern)
+  end
+
+  it "includes the modules listed with #model_can" do
+    User.model_can :be_queried, :be_validated, :have_relationships
+    user = User.new
+    user.should be_a_kind_of(Ricordami::CanBeQueried)
+    user.should be_a_kind_of(Ricordami::CanBeValidated)
+    user.should be_a_kind_of(Ricordami::CanHaveRelationships)
+  end
+
+  describe "when being included" do
+    it "adds model naming" do
+      model_name = User.model_name
+      model_name.should == "User"
+      model_name.singular.should == "user"
+      model_name.plural.should == "users"
+    end
+
+    it "adds to_model for use with Rails" do
+      user = User.new
+      user.to_model.should == user
+    end
+
+    describe "#to_key" do
+      before(:each) do
+        @user = User.new
+        def @user.id; "some_id" end
+      end
+
+      it "returns [id] if persisted" do
+        def @user.persisted?; true end
+        @user.to_key.should == [@user.id]
+      end
+
+      it "returns nil if not persisted" do
+        def @user.persisted?; false end
+        @user.to_key.should be_nil
+      end
+    end
+
+    describe "#to_param" do
+      before(:each) do
+        @user = User.new
+        def @user.persisted?; true end
+      end
+
+      it "returns key joined by - if to_key present" do
+        def @user.to_key; ["some", "id", "here"] end
+        @user.to_param.should == "some-id-here"
+      end
+
+      it "returns nil if to_key nil" do
+        def @user.persisted?; false end
+        @user.to_param.should be_nil
+      end
+    end
+  end
+end

data/spec/ricordami/query_spec.rb

@@ -0,0 +1,156 @@
+require "spec_helper"
+require "ricordami/query"
+
+describe Ricordami::Query do
+  uses_constants("Instrument")
+  let(:query) { Ricordami::Query.new(Instrument) }
+
+  it "has expressions" do
+    query.expressions.should == []
+  end
+
+  describe "#and" do
+    it "saves :and expressions" do
+      query.and(:allo => "la terre")
+      query.expressions.pop.should == [:and, {:allo => "la terre"}]
+    end
+
+    it "uses :where as an alias for :and" do
+      query.where(:allo => "la terre")
+      query.expressions.pop.should == [:and, {:allo => "la terre"}]
+    end
+
+    it "returns self" do
+      query.and.should == query
+    end
+  end
+
+  describe "#not" do
+    it "saves :not expressions" do
+      query.not(:allo => "la terre")
+      query.expressions.pop.should == [:not, {:allo => "la terre"}]
+    end
+
+    it "returns self" do
+      query.not.should == query
+    end
+  end
+
+  describe "#any" do
+    it "saves :any expressions" do
+      query.any(:allo => "la terre")
+      query.expressions.pop.should == [:any, {:allo => "la terre"}]
+    end
+
+    it "returns self" do
+      query.any.should == query
+    end
+  end
+
+  describe "running the query" do
+    it "delegates #all to the runner" do
+      Instrument.should_receive(:all).with(:expressions => [[:and, {:key => "val"}]])
+      query.and(:key => "val").all
+    end
+
+    it "delegates #paginate to the runner" do
+      Instrument.should_receive(:paginate).with(:expressions => [[:and, {:key => "val"}]], :page => 3, :per_page => 18)
+      query.and(:key => "val").paginate(:page => 3, :per_page => 18)
+    end
+
+    it "delegates #first to the runner" do
+      Instrument.should_receive(:first).with(:expressions => [[:and, {:key => "val"}]],
+                                             :sort_by => :key,
+                                             :order => "ALPHA ASC")
+      query.and(:key => "val").sort(:key).first
+    end
+
+    it "delegates #last to the runner" do
+      Instrument.should_receive(:last).with(:expressions => [[:and, {:key => "val"}]],
+                                            :sort_by => :key,
+                                            :order => "ALPHA DESC")
+      query.and(:key => "val").sort(:key, :desc_alpha).last
+    end
+
+    it "delegates #rand to the runner" do
+      Instrument.should_receive(:respond_to?).with(:rand).and_return(true)
+      Instrument.should_receive(:rand).with(:expressions => [[:and, {:key => "val"}]],
+                                            :sort_by => :key,
+                                            :order => "ALPHA ASC")
+      query.and(:key => "val").sort(:key).rand
+    end
+
+    it "returns the runner if it can't delegate to the runner" do
+      Ricordami::Query.new([]).all.should == []
+      Ricordami::Query.new([]).paginate.should == []
+    end
+
+    it "accepts any unknown method and delegate it to the result of #all" do
+      instruments = %w(guitar bass drums).map { |value| Struct.new(:name).new(value) }
+      Instrument.should_receive(:all).
+        with(:expressions => [[:and, {:key => "val"}]]).
+        and_return(instruments)
+      query.and(:key => "val").map(&:name).should =~ ["guitar", "bass", "drums"]
+    end
+  end
+
+  describe "sorting the query" do
+    it "remembers the sorting attribute with #sort" do
+      query.sort(:username)
+      query.sort_by.should == :username
+    end
+
+    it "remembers the sorting direction with #sort" do
+      query.sort(:username)
+      query.sort_dir.should == :asc_alpha
+      query.sort(:username, :desc_alpha)
+      query.sort_dir.should == :desc_alpha
+    end
+
+    it "raises an error if the sorting order is not :asc_alpha, :asc_num, desc_alpha or :desc_num" do
+      lambda {
+        [:asc_alpha, :asc_num, :desc_alpha, :desc_num].each do |dir|
+          query.sort(:username, dir)
+        end
+      }.should_not raise_error(ArgumentError)
+      lambda {
+        query.sort(:username, :blah)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "creating new objects" do
+    before(:each) do
+      Instrument.attribute :name
+      Instrument.attribute :instrument_type
+      Instrument.attribute :difficulty
+    end
+
+    it "builds a new object with #build" do
+      query.and(:instrument_type => "wind", :name => "flute")
+      obj = query.build
+      obj.should be_an(Instrument)
+      obj.should_not be_persisted
+      obj.name.should == "flute"
+      obj.instrument_type.should == "wind"
+    end
+
+    it "can pass new attributes to #build" do
+      query.and(:instrument_type => "wind", :name => "flute")
+      obj = query.build(:name => "tuba", :difficulty => "hard")
+      obj.instrument_type.should == "wind"
+      obj.name.should == "tuba"
+      obj.difficulty.should == "hard"
+    end
+
+    it "creates a new object with #create" do
+      query.and(:instrument_type => "wind", :name => "flute")
+      obj = query.create(:name => "tuba", :difficulty => "hard")
+      obj.should be_an(Instrument)
+      obj.should be_persisted
+      obj.instrument_type.should == "wind"
+      obj.name.should == "tuba"
+      obj.difficulty.should == "hard"
+    end
+  end
+end