tableless_model 0.0.7 → 0.0.8

data/lib/tableless_model/version.rb

@@ -1,3 +1,3 @@
 module TablelessModel
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require "active_record"
+require "timecop"
+require "tableless_model"
+

data/spec/tableless_model_spec.rb

@@ -1,246 +1,256 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+require "spec_helper"
 
-require "active_record"
-require 'minitest/autorun'
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Base.connection.execute(" create table test_models (id integer, options varchar(50)) ")
 
-require File.expand_path(File.join(File.dirname(__FILE__), "../lib/tableless_model"))
-
-
-describe "A class inheriting from ActiveRecord::TablelessModel" do
-  before do
-    class TestClass1 < ActiveRecord::TablelessModel
-    end
-  end
-  
-  it "has the accessor 'attributes', which is originally an empty hash" do
-    TestClass1.must_respond_to("attributes")
-    TestClass1.attributes.must_be_kind_of Hash
-    TestClass1.attributes.must_be_empty
-  end
-
-  it "responds to 'attribute', 'cast'" do
-    ["attribute", "cast"].each {|method_name| TestClass1.must_respond_to method_name }
-  end
+class ModelOptions < ActiveRecord::TablelessModel
+  attribute :no_default_value_no_type_attribute
+  attribute :no_default_value_typed_attribute, :type => :integer 
+  attribute :no_type_attribute, :default => 111
+  attribute :typed_attribute,   :default => 5, :type => :integer 
+  attribute :typed_attribute_no_default_value,  :type => :integer 
+  attribute :attribute_with_proc_default_value, :type => :time, :default => lambda { Time.now }  
 end
 
-describe "The 'attribute' macro" do
-  before do
-    class TestClass < ActiveRecord::TablelessModel
-      attribute :test_attribute
-    end
-  end
-
-  it "adds a key-value pair to the attributes accessor" do
-    TestClass.attributes.wont_be_empty
-    TestClass.attributes.key?("test_attribute").must_equal true, "An attribute named 'test_attribute' should have been defined"
-  end
+class TestModel < ActiveRecord::Base
+  has_tableless :options => ModelOptions
 end
 
-describe "An instance of TablelessModel" do
-  before do
-    class TestClass2 < ActiveRecord::TablelessModel
-      attribute :test_attribute
-      attribute :test_attribute_with_default_value,           :default => "default value"
-      attribute :test_attribute_with_type_and_default_value,  :default => "003xxx", :type => :integer
-    end
-    
-    @instance = TestClass2.new
-  end
-  
-  it "has a getter and a setter for each defined attribute" do
-    [:test_attribute, :test_attribute_with_default_value, :test_attribute_with_type_and_default_value].each do |attribute_name|
-      @instance.must_respond_to attribute_name,       "Getter for #{attribute_name} should have been defined"
-      @instance.must_respond_to "#{attribute_name}=", "Setter for #{attribute_name} should have been defined"
-    end
-  end
-  
-  it "assigns the default value to an attribute that has not yet been set, if a default value has been specified" do
-    @instance.test_attribute_with_default_value.must_equal "default value"
-    @instance.test_attribute_with_type_and_default_value.must_equal 3
-  end
-  
-  it "should allow overriding the default values" do
-    instance = TestClass2.new( :test_attribute_with_default_value => "changed value" )
-    instance.test_attribute_with_default_value.must_equal "changed value"
+describe TestModel do
+  let(:test_model)  { subject }
+  let(:options)     { test_model.options }  
+  let(:frozen_time) { Time.local(2011, 7, 24, 18, 47, 0).in_time_zone("Europe/London") }
+  let(:test_values) do
+    {
+      :no_default_value_no_type_attribute => "no_default_value_no_type_attribute",
+      :no_default_value_typed_attribute   => 4567,
+      :no_type_attribute                  => "no_type_attribute",
+      :typed_attribute                    => 8765,
+      :typed_attribute_no_default_value   => 34,
+      :attribute_with_proc_default_value => frozen_time
+    }
   end
   
-  it "assumes an attribute's data type is string if the type has not been specified" do
-    @instance.test_attribute.must_be_kind_of String
-  end
-
-  it "assigns the expected not-nil value to an attribute if a default value hasn't been specified" do
-    @instance.test_attribute.must_equal ""
+  it "is not in a changed state if no properties have changed" do
+    test_model.changed?.should == false
+    test_model.changes.should == {}
   end
   
-  it "does not allow access to undefined attributes" do
-    @instance.wont_respond_to "unknown_attribute"
-    @instance.wont_respond_to "unknown_attribute="
+  context "when setting all (or more than one of) the tableless model's attributes at once" do
+    before(:each) do
+      test_model.options = test_values
+    end
     
-    proc { @instance["unknown_attribute"] }.must_raise(NoMethodError)
-    proc { @instance["unknown_attribute="] }.must_raise(NoMethodError)
-  end
-  
-  it "shows the expected output on inspect" do
-    @instance.inspect.must_equal "<#TestClass2 test_attribute=\"\" test_attribute_with_default_value=\"default value\" test_attribute_with_type_and_default_value=3>"
-  end
-
-
-  it "should not allow merging" do
-    proc { @instance.merge(:new_symbol_key => "new_symbol_key") }.must_raise NoMethodError
-  end
-  
-end
-
-
-describe "An instance of TablelessModel" do
-  before do
-    class TestClass3 < ActiveRecord::TablelessModel
-      attribute :typed_test_attribute,  :type => :integer
+    after(:each) do
+      TestModel.delete_all
     end
-  end
-
-  describe "instance" do
-    before do
-      @instance = TestClass3.new
+    
+    it "the attributes have the expected values" do
+      test_model.options.no_default_value_no_type_attribute.should == "no_default_value_no_type_attribute"
+      test_model.options.no_default_value_typed_attribute.should == 4567
+      test_model.options.no_type_attribute.should == "no_type_attribute"
+      test_model.options.typed_attribute.should == 8765
+      test_model.options.typed_attribute_no_default_value.should == 34
+      test_model.options.attribute_with_proc_default_value.should == frozen_time
     end
     
-    it "has rw the accessor __owner_object" do
-      @instance.must_respond_to "__owner_object"
-      @instance.must_respond_to "__owner_object="
+    it "forces the owner model to a changed state with partial_updates on" do
+      test_model.changed?.should == true
+      test_model.changes.keys.should include "options"
+      test_model.changes[:options][0].should be_nil
+      test_model.changes[:options][1].should == test_values
     end
+    
+    context "and saving the parent model" do
+      before(:each) do
+        test_model.save!
+      end
+      
+      it "correctly initialises the attributes with their expected values when reading from database" do
+        # Not sure if these are really needed, but I am leaving them just in case Identity Map
+        # prevents the record from being actually loaded from the database for this test.
+        options    = nil
+        test_model = nil
+        
+        instance   = TestModel.first
 
-    it "has rw the accessor __serialized_attribute" do
-      @instance.must_respond_to "__serialized_attribute"
-      @instance.must_respond_to "__serialized_attribute="
+        instance.options.no_default_value_no_type_attribute.should == "no_default_value_no_type_attribute"
+        instance.options.no_default_value_typed_attribute.should == 4567
+        instance.options.no_type_attribute.should == "no_type_attribute"
+        instance.options.typed_attribute.should == 8765
+        instance.options.typed_attribute_no_default_value.should == 34
+        instance.options.attribute_with_proc_default_value.should == frozen_time
+      end
     end
   end
-  
-  it "tries to enforce type casting if a type has been specified for an attribute" do
 
-    test_values = [ "test", 1234, true, "1234.12", "2011-01-02 15:23" ]
+  context "when receives a message with the name of an attribute in the tableless model" do
+    before(:each) do
+      test_model.options = test_values
+    end
     
-    [ :string, :integer, :float, :decimal, :time, :date, :datetime, :boolean ].each do |type|
-
-      # temporarily changing type
-      TestClass3.attributes["typed_test_attribute"][:type] = type
-
-      instance = TestClass3.new
-      
-      type_name = case type
-      when :datetime then :date_time
-      when :decimal then :big_decimal
-      else type
-      end
-        
-        
-      # excluding some test values that would always fail depending on the type
-      exclude_test_values = case type
-      when :decimal then [ "test", true ]
-      when :time then [ "test", 1234, true ]
-      when :date then [ "test", 1234, true, "1234.12" ]
-      when :datetime then [ "test", 1234, true ]
-      else []
+    context "and it doesn't have a method of its own by that name" do
+      it "delegates the method call to the tableless model" do
+        test_values.each do |k, v|
+          test_model.send(k).should == v
+        end
       end
+
+      it "delegates setters too" do
+        instance = TestModel.new
         
-      (test_values - exclude_test_values).each do |value|
-        instance.typed_test_attribute = value
-        
-        if type == :boolean
-          [true, false].include?(instance.typed_test_attribute).must_equal true, "Expected #{instance.typed_test_attribute.inspect} to be boolean, not #{type.class}"
-        else
-          instance.typed_test_attribute.must_be_kind_of type_name.to_s.classify.constantize
+        test_values.each do |k, v|
+          instance.send("#{k}=", v)
+          instance.options.send(k).should == v
         end
       end
 
+      it "can delegate calls to attribute_name?" do
+        test_values.each do |k, v|
+          test_model.send("#{k}?").should == !!v
+        end
+      end
     end
   end
-end
-
-describe "An ActiveRecord::Base model" do
-  before do
-    class ModelOptions < ActiveRecord::TablelessModel
-      attribute :aaa, :default => 111
-      attribute :bbb, :default => "bbb"
+  
+  describe "#options" do
+    it "is an instance of the tableless model" do
+      options.should be_instance_of ModelOptions
     end
-
-    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-    ActiveRecord::Base.connection.execute(" create table test_models (options varchar(50)) ")
-
-    class TestModel < ActiveRecord::Base
-      has_tableless :options => ModelOptions
+    
+    it "sets the attributes to the expected default values" do
+      Timecop.freeze(frozen_time) do
+        test_model.options.no_default_value_no_type_attribute.should == ""
+        test_model.options.no_default_value_typed_attribute.should == 0
+        test_model.options.no_type_attribute.should == "111"
+        test_model.options.typed_attribute.should == 5
+        test_model.options.typed_attribute_no_default_value.should == 0
+        test_model.options.attribute_with_proc_default_value.should == frozen_time
+      end
+    end
+    
+    it "honours the type of the attribute, when specified" do
+      options.typed_attribute.should == 5
     end
-  end
 
-  it "responds to default_value_for, has_tableless" do
-    TestModel.must_respond_to(:has_tableless)
-  end
-  
-  
-  describe "instance" do
-    before do
-      @instance = TestModel.new
+    it "assumes the default type of an attribute is :string, if no type has been specified" do
+      options.no_type_attribute.should == "111"
     end
     
-    it "must respond to changed?" do
-      @instance.must_respond_to "changed?"
-      @instance.changed?.must_equal false
-      @instance.changes.must_equal({})
+    it "assigns a non-nil string value to an attribute with no type nor default value" do
+      options.no_default_value_no_type_attribute.should == ""
+    end
+  
+    it "assigns a non-nil value of the expected type to an attribute with type but no default value" do
+      options.no_default_value_typed_attribute.should == 0
     end
     
-    it "sets the accessor __owner_object to self in the tableless model instance" do
-      @instance.options.__owner_object.must_equal @instance
+    it "allows setting the value of a known attribute" do
+      expect {
+        options.typed_attribute = 1234
+        test_model.options.typed_attribute.should == 1234
+      }.to_not raise_error
     end
     
-    it "sets the accessor __serialized_attribute to the name of its column that stored the tableless model instance, serialized" do
-      @instance.options.__serialized_attribute.must_equal :options
+    it "doesn't recognise undefined attributes" do
+      expect {
+        options.unknown_attribute
+      }.to raise_error NoMethodError
     end
     
+    it "doesn't allow setting undefined attributes" do
+      expect {
+        options.unknown_attribute = "whatever"
+      }.to raise_error NoMethodError
+    end    
     
-    it "has a getter and a setter for :options" do
-      %w(options options=).each{|m| @instance.must_respond_to m }
-      @instance.options.must_be_kind_of ModelOptions
-      @instance.options.wont_be_nil
-      @instance.options.aaa.must_equal "111"
-      @instance.options.bbb.must_equal "bbb"
-      proc { @instance.options = "test" }.must_raise NoMethodError, "should not accept other values than a hash or ModelOptions instance"
+    it "does not allow merging, since the tableless mode is supposed to be used like a normal model, not a hash" do
+      expect { 
+        options.merge(:some_new_attribute => "whatever") 
+      }.should raise_error NoMethodError
     end
-
-    describe "setter" do
-      before do
-        @return_value = @instance.send("options=", { :aaa => "CCC", :bbb => "DDD"  })
+    
+    it "shows the expected object-like output on inspect" do
+      Timecop.freeze(frozen_time) do
+        instance = TestModel.new
+        instance.options.inspect.should == "<#ModelOptions attribute_with_proc_default_value=2011-07-24 18:47:00 BST no_default_value_no_type_attribute=\"\" no_default_value_typed_attribute=0 no_type_attribute=\"111\" typed_attribute=5 typed_attribute_no_default_value=0>"
       end
-
-      it "correctly sets the serialized column" do
-        @return_value.must_be_kind_of ModelOptions
-        %w(aaa bbb).each{|m| @return_value.must_respond_to m}
-        @instance.options.aaa.must_equal "CCC"
-        @instance.options.bbb.must_equal "DDD"
+    end
+    
+    it "tries to enforce type casting if a type has been specified for an attribute" do
+      test_values = [ "test", 1234, true, "1234.12", "2011-01-02 15:23" ]
+      
+      [ :string, :integer, :float, :decimal, :time, :date, :datetime, :boolean ].each do |type|
+  
+        # temporarily changing type
+        ModelOptions.attributes[:typed_attribute_no_default_value][:type] = type
+  
+        instance = ModelOptions.new
+        
+        type_name = case type
+        when :datetime then :date_time
+        when :decimal then :big_decimal
+        else type
+        end
+          
+          
+        # excluding some test values that would always fail depending on the type
+        exclude_test_values = case type
+        when :decimal then [ "test", true ]
+        when :time then [ "test", 1234, true ]
+        when :date then [ "test", 1234, true, "1234.12" ]
+        when :datetime then [ "test", 1234, true ]
+        else []
+        end
+          
+        (test_values - exclude_test_values).each do |value|
+          instance.typed_attribute_no_default_value = value
+          
+          if type == :boolean
+            [true, false].include?(instance.typed_attribute_no_default_value).should == true
+          else
+            instance.typed_attribute_no_default_value.should be_kind_of type_name.to_s.classify.constantize
+          end
+        end
       end
       
-      it "forces the owner object to a changed state with partial_updates on" do
-        @instance.options.aaa = "changed aaa"
-        @instance.options.bbb = "changed bbb"
+      # restoring original type
+      ModelOptions.attributes[:typed_attribute_no_default_value][:type] = :integer
+    end
 
-        @instance.options.aaa.must_equal "changed aaa"
-        @instance.changes.keys.include?("options").must_equal true
+    it "remembers who is the owner model, so that it can be forced to a changed state when any attributes change" do
+      options.__owner_object.should == test_model
+      options.__serialized_attribute.should == :options
+    end
 
-        @instance.changes[:options][0].must_equal nil
-        @instance.changes[:options][1].must_equal({"aaa"=>"changed aaa", "bbb"=>"changed bbb"})
+    context "when a proc is passed to define the default value of an attribute" do
+      context "and a new instance of the parent model is being created" do
+        it "allows passing a Proc/lambda to define a default value at runtime" do
+          Timecop.freeze(frozen_time) do
+            TestModel.new.options.attribute_with_proc_default_value.should == frozen_time
+          end
+        end
       end
-
-      it "should save the serialized column correctly" do
-        @instance.save!
       
-        instance = TestModel.first
+      context "and an existing instance of the parent model is read from database" do
+        let(:some_other_time) { Time.local(2011, 6, 30, 15, 22, 0).in_time_zone("Europe/London") }
         
-        instance.options.aaa.must_equal "CCC"
-        instance.options.bbb.must_equal "DDD"
+        before(:each) do
+          Timecop.freeze(frozen_time) { TestModel.create({ :options => test_values }) }
+        end
         
-         # Ensuring the serialize macro is used
-        instance.options.must_be_kind_of ModelOptions
+        after(:each) do
+          TestModel.delete_all
+        end
+
+        it "does not execute the proc, but sets the attribute to the expected value from database" do
+          Timecop.freeze(some_other_time) do
+            TestModel.first.options.attribute_with_proc_default_value.should == frozen_time
+          end
+        end
       end
     end
+
   end
-end
 
-  
+end