massive_record 0.1.0

data/spec/orm/cases/callbacks_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+require 'orm/models/person'
+require 'orm/models/address'
+
+#
+# Some basic tests
+#
+shared_examples_for "Massive Record with callbacks" do
+  it "should include ActiveModel::Callbacks" do
+    @model.class.should respond_to :define_model_callbacks
+  end
+
+  it "should include ActiveModell::Validations::Callback" do
+    @model.class.included_modules.should include(ActiveModel::Validations::Callbacks)
+  end
+end
+
+{
+  "MassiveRecord::Base::Table" => Person,
+  "MassiveRecord::Base::Column" => Address
+}.each do |orm_class, inherited_by_test_class|
+  describe orm_class do
+    before do
+      @model = inherited_by_test_class.new
+    end
+
+    it_should_behave_like "Massive Record with callbacks"
+  end
+end
+
+
+#
+# Some real life object tests
+#
+class CallbackDeveloper < MassiveRecord::ORM::Table
+  class << self
+    def callback_string(callback_method)
+      "history << [#{callback_method.to_sym.inspect}, :string]"
+    end
+
+    def callback_proc(callback_method)
+      Proc.new { |model| model.history << [callback_method, :proc] }
+    end
+
+    def define_callback_method(callback_method)
+      define_method(callback_method) do
+        self.history << [callback_method, :method]
+      end
+      send(callback_method, :"#{callback_method}")
+    end
+
+    def callback_object(callback_method)
+      klass = Class.new
+      klass.send(:define_method, callback_method) do |model|
+        model.history << [callback_method, :object]
+      end
+      klass.new
+    end
+  end
+
+  MassiveRecord::ORM::Callbacks::CALLBACKS.each do |callback_method|
+    next if callback_method.to_s =~ /^around_/
+    define_callback_method(callback_method)
+    send(callback_method, callback_string(callback_method))
+    send(callback_method, callback_proc(callback_method))
+    send(callback_method, callback_object(callback_method))
+    send(callback_method) { |model| model.history << [callback_method, :block] }
+  end
+
+  def history
+    @history ||= []
+  end
+end
+
+
+describe "callbacks for" do
+  include MockMassiveRecordConnection
+
+  it "initialize should run in correct order" do
+    thorbjorn = CallbackDeveloper.new
+    thorbjorn.history.should == [
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc],
+      [:after_initialize, :object],
+      [:after_initialize, :block]
+    ]
+  end
+
+  it "find should run in correct order" do
+    thorbjorn = CallbackDeveloper.find(1)
+    thorbjorn.history.should == [
+      [:after_find, :method],
+      [:after_find, :string],
+      [:after_find, :proc],
+      [:after_find, :object],
+      [:after_find, :block],
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc],
+      [:after_initialize, :object],
+      [:after_initialize, :block]
+    ]
+  end
+
+  it "touch should run in correct order" do
+    thorbjorn = CallbackDeveloper.find(1)
+    thorbjorn.touch
+    thorbjorn.history.should == [
+      [:after_find, :method],
+      [:after_find, :string],
+      [:after_find, :proc],
+      [:after_find, :object],
+      [:after_find, :block],
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc],
+      [:after_initialize, :object],
+      [:after_initialize, :block],
+      [:after_touch, :method],
+      [:after_touch, :string],
+      [:after_touch, :proc],
+      [:after_touch, :object],
+      [:after_touch, :block]
+    ]
+  end
+  
+  it "valid for new record should run in correct order" do
+    thorbjorn = CallbackDeveloper.new
+    thorbjorn.valid?
+    thorbjorn.history.should == [
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc],
+      [:after_initialize, :object],
+      [:after_initialize, :block],
+      [:before_validation, :method],
+      [:before_validation, :string],
+      [:before_validation, :proc],
+      [:before_validation, :object],
+      [:before_validation, :block],
+      [:after_validation, :method],
+      [:after_validation, :string],
+      [:after_validation, :proc],
+      [:after_validation, :object],
+      [:after_validation, :block]
+    ]
+  end
+
+  it "valid for exiting record should run in correct order" do
+    thorbjorn = CallbackDeveloper.find(1)
+    thorbjorn.valid?
+    thorbjorn.history.should == [
+      [:after_find, :method],
+      [:after_find, :string],
+      [:after_find, :proc],
+      [:after_find, :object],
+      [:after_find, :block],
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc],
+      [:after_initialize, :object],
+      [:after_initialize, :block],
+      [:before_validation, :method],
+      [:before_validation, :string],
+      [:before_validation, :proc],
+      [:before_validation, :object],
+      [:before_validation, :block],
+      [:after_validation, :method],
+      [:after_validation, :string],
+      [:after_validation, :proc],
+      [:after_validation, :object],
+      [:after_validation, :block]
+    ]
+  end
+
+  it "create should run in correct order" do
+    thorbjorn = CallbackDeveloper.create :id => "dummy"
+    thorbjorn.history.should == [
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc  ],
+      [:after_initialize, :object],
+      [:after_initialize, :block ],
+      [:before_validation, :method],
+      [:before_validation, :string],
+      [:before_validation, :proc  ],
+      [:before_validation, :object],
+      [:before_validation, :block ],
+      [:after_validation, :method],
+      [:after_validation, :string],
+      [:after_validation, :proc  ],
+      [:after_validation, :object],
+      [:after_validation, :block ],
+      [:before_save, :method],
+      [:before_save, :string],
+      [:before_save, :proc  ],
+      [:before_save, :object],
+      [:before_save, :block ],
+      [:before_create, :method],
+      [:before_create, :string],
+      [:before_create, :proc  ],
+      [:before_create, :object],
+      [:before_create, :block ],
+      [:after_create, :method],
+      [:after_create, :string],
+      [:after_create, :proc  ],
+      [:after_create, :object],
+      [:after_create, :block ],
+      [:after_save, :method],
+      [:after_save, :string],
+      [:after_save, :proc  ],
+      [:after_save, :object],
+      [:after_save, :block ]
+    ]
+  end
+
+  it "update should run in correct order" do
+    thorbjorn = CallbackDeveloper.find(1)
+    thorbjorn.save
+    thorbjorn.history.should == [
+      [:after_find, :method],
+      [:after_find, :string],
+      [:after_find, :proc],
+      [:after_find, :object],
+      [:after_find, :block],
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc  ],
+      [:after_initialize, :object],
+      [:after_initialize, :block ],
+      [:before_validation, :method],
+      [:before_validation, :string],
+      [:before_validation, :proc  ],
+      [:before_validation, :object],
+      [:before_validation, :block ],
+      [:after_validation, :method],
+      [:after_validation, :string],
+      [:after_validation, :proc  ],
+      [:after_validation, :object],
+      [:after_validation, :block ],
+      [:before_save, :method],
+      [:before_save, :string],
+      [:before_save, :proc  ],
+      [:before_save, :object],
+      [:before_save, :block ],
+      [:before_update, :method],
+      [:before_update, :string],
+      [:before_update, :proc  ],
+      [:before_update, :object],
+      [:before_update, :block ],
+      [:after_update, :method],
+      [:after_update, :string],
+      [:after_update, :proc  ],
+      [:after_update, :object],
+      [:after_update, :block ],
+      [:after_save, :method],
+      [:after_save, :string],
+      [:after_save, :proc  ],
+      [:after_save, :object],
+      [:after_save, :block ]
+    ]
+  end
+
+  it "destroy should run in correct order" do
+    thorbjorn = CallbackDeveloper.find(1) 
+    thorbjorn.destroy
+    thorbjorn.history.should == [
+      [:after_find, :method],
+      [:after_find, :string],
+      [:after_find, :proc],
+      [:after_find, :object],
+      [:after_find, :block],
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc  ],
+      [:after_initialize, :object],
+      [:after_initialize, :block ],
+      [:before_destroy, :method],
+      [:before_destroy, :string],
+      [:before_destroy, :proc  ],
+      [:before_destroy, :object],
+      [:before_destroy, :block ],
+      [:after_destroy, :method],
+      [:after_destroy, :string],
+      [:after_destroy, :proc  ],
+      [:after_destroy, :object],
+      [:after_destroy, :block ]
+    ]
+  end
+
+  it "should not run callbacks for destroy on delete" do
+    thorbjorn = CallbackDeveloper.find(1) 
+    thorbjorn.delete
+    thorbjorn.should be_destroyed
+    thorbjorn.history.should == [
+      [:after_find, :method],
+      [:after_find, :string],
+      [:after_find, :proc],
+      [:after_find, :object],
+      [:after_find, :block],
+      [:after_initialize, :method],
+      [:after_initialize, :string],
+      [:after_initialize, :proc  ],
+      [:after_initialize, :object],
+      [:after_initialize, :block ]
+    ]
+  end
+end

data/spec/orm/cases/column_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'orm/models/address'
+
+describe "column classes" do
+  before do
+    @address = Address.new(:street => "Asker", :number => 5)
+  end
+
+  it "should have known_attribute_names" do
+    Address.should have(3).known_attribute_names
+    Address.known_attribute_names.should include("street", "number", "nice_place")
+  end
+
+  it "should have default_attributes_from_schema" do
+    Address.default_attributes_from_schema["street"].should be_nil
+    Address.default_attributes_from_schema["number"].should be_nil
+    Address.default_attributes_from_schema["nice_place"].should be_true
+  end
+
+  it "should have attributes_schema" do
+    Address.attributes_schema["street"].should be_instance_of MassiveRecord::ORM::Schema::Field
+  end
+
+  it "should have a default value set" do
+    @address.nice_place.should be_true
+  end
+
+
+  # TODO  We might want to remove this when we have implemented
+  #       associations correctly. Since Columns are contained within
+  #       tables, calling save should do something on it's owner object.
+  describe "not be possible to persist (at least for now...)" do
+    %w(first last all exists? destroy_all).each do |method|
+      it "should not respond to class method #{method}" do
+        Address.should_not respond_to method
+      end
+    end
+
+    %w(
+      create! create reload save save!
+      update_attribute update_attributes update_attributes! touch destroy
+      delete increment! atomic_increment! decrement!
+    ).each do |method|
+      it "should not respond to instance method #{method}" do
+        @address.should_not respond_to method
+      end
+    end
+  end
+end

data/spec/orm/cases/config_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'orm/models/test_class'
+require 'orm/models/person'
+
+describe "configuration" do
+  include MockMassiveRecordConnection
+
+  before do
+    @mock_connection = mock(MassiveRecord::Wrapper::Connection, :open => true)
+    MassiveRecord::Wrapper::Connection.stub(:new).and_return(@mock_connection)
+  end
+
+  describe "connection" do
+    it "should use connection_configuration if present" do
+      TestClass.reset_connection!
+      MassiveRecord::Wrapper::Connection.should_receive(:new).with(TestClass.connection_configuration)
+      TestClass.connection
+    end
+
+    it "should not ask Wrapper::Base for a connection when Rails is not defined" do
+      MassiveRecord::Wrapper::Base.should_not_receive(:connection)
+      TestClass.connection
+    end
+
+    it "should use the same connection if asked twice" do
+      TestClass.connection_configuration = {:host => "foo", :port => 9001}
+      MassiveRecord::Wrapper::Connection.should_receive(:new).once.and_return(@mock_connection)
+      2.times { TestClass.connection }
+    end
+
+    it "should use the same connection for different sub classes" do
+      TestClass.connection_configuration = {:host => "foo", :port => 9001}
+      MassiveRecord::Wrapper::Connection.should_receive(:new).and_return(@mock_connection)
+      TestClass.connection.should == Person.connection
+    end
+
+    it "should raise an error if connection configuration is missing" do
+      TestClass.connection_configuration = {}
+      lambda { TestClass.connection }.should raise_error MassiveRecord::ORM::ConnectionConfigurationMissing
+    end
+
+    it "should return an opened connection" do
+      @mock_connection = mock(MassiveRecord::Wrapper::Connection)
+      @mock_connection.should_receive(:open)
+      MassiveRecord::Wrapper::Connection.should_receive(:new).and_return(@mock_connection)
+
+      TestClass.connection
+    end
+
+
+    describe "under Rails" do
+      before do
+        TestClass.connection_configuration = {}
+        module Rails; end
+        MassiveRecord::Wrapper::Base.stub!(:connection).and_return(@mock_connection)
+      end
+      
+      after do
+        Object.send(:remove_const, :Rails)
+      end
+
+      it "should simply call Wrapper::Base" do
+        MassiveRecord::Wrapper::Base.should_receive(:connection).and_return(@mock_connection)
+        TestClass.connection.should == @mock_connection
+      end
+
+      it "should use connection_configuration if defined" do
+        TestClass.connection_configuration = {:host => "foo", :port => 9001}
+        MassiveRecord::Wrapper::Connection.should_receive(:new).with(TestClass.connection_configuration)
+        TestClass.connection
+      end
+    end
+  end
+
+
+
+  describe "table" do
+    it "should create a new wrapper table instance" do
+      table_name = "TestClasss"
+      connection = "dummy_connection"
+
+      TestClass.should_receive(:table_name).and_return(table_name)
+      TestClass.should_receive(:connection).and_return(connection)
+      MassiveRecord::Wrapper::Table.should_receive(:new).with(connection, table_name)
+
+      TestClass.table
+    end
+
+    it "should not reinitialize the same table twice" do
+      MassiveRecord::Wrapper::Table.should_receive(:new).twice
+      2.times { TestClass.table }
+      2.times { Person.table }
+    end
+
+    it "should not return the same table for two different sub classes" do
+      TestClass.table.should_not == Person.table
+    end
+
+    it "should use the same conncetion for two tables" do
+      TestClass.table.connection.should == Person.table.connection
+    end
+  end
+end