activerecord-model-spaces 0.2.0

data/spec/active_record/model_spaces/table_manager_spec.rb

@@ -0,0 +1,186 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'active_support/core_ext/class' # SchemaDumper needs this
+
+require 'active_record/model_spaces/table_manager'
+
+module ActiveRecord
+  module ModelSpaces
+
+    describe TableManager do
+
+      describe "initialize" do
+        it "should initialize with a model" do
+          m = double('model')
+          c = double('connection')
+          m.should_receive(:connection).and_return(c)
+          tm = TableManager.new(m)
+          tm.model.should == m
+          tm.connection.should == c
+        end
+
+        it "should initialize with a model name" do
+          c = double('connection')
+          ActiveRecord::ModelSpaces.should_receive(:connection).and_return(c)
+          tm = TableManager.new("ActiveRecord::ModelSpaces")
+          tm.model.should == ActiveRecord::ModelSpaces
+          tm.connection.should == c
+        end
+      end
+
+      def create_table_manager(model=nil)
+        model ||= double('model')
+        connection = double('connection')
+        model.stub(:connection).and_return(connection)
+        TableManager.new(model)
+      end
+
+      describe "create table" do
+        it "should extract the base_table schema, and use it to create a new table" do
+          tm = create_table_manager
+          tm.connection.should_receive(:table_exists?).with('bars')
+
+          tsc = double('table-schema-copier')
+          tm.should_receive(:get_table_schema_copier).with(tm.connection).and_return(tsc)
+
+          tsc.should_receive(:copy_table_schema).with(tm.connection, 'foos', 'bars')
+
+          tm.create_table('foos', 'bars')
+        end
+      end
+
+      describe "drop table" do
+        it "should drop the given table if it exists" do
+          tm = create_table_manager
+          tm.connection.should_receive(:table_exists?).with("foos").and_return(true)
+          tm.connection.should_receive(:execute).with("drop table foos")
+          tm.drop_table("foos")
+        end
+
+        it "should do nothing if the given table does not exist" do
+          tm = create_table_manager
+          tm.connection.should_receive(:table_exists?).with("foos").and_return(false)
+          tm.drop_table("foos")
+        end
+      end
+
+      describe "recreate table" do
+        it "should drop the table if it exists, and recreate it from the base table if the table_name is different from the base_table_name" do
+          tm = create_table_manager
+          tm.should_receive(:drop_table).with("bars")
+          tm.should_receive(:create_table).with("foos", "bars")
+          tm.recreate_table("foos", "bars")
+        end
+
+        it "should do nothing if the base_table_name is the same as the table_name" do
+          tm = create_table_manager
+          tm.recreate_table("foos", "foos")
+        end
+      end
+
+      describe "truncate table" do
+        it "should truncate the given table" do
+          tm = create_table_manager
+          tm.connection.should_receive(:execute).with("truncate table foos")
+          tm.truncate_table('foos')
+        end
+      end
+
+      describe "copy table" do
+        it "should copy data from the source to the target table if source and target are different" do
+          tm = create_table_manager
+          tm.connection.should_receive(:execute).with("insert into bars select * from foos")
+          tm.copy_table('foos', 'bars')
+        end
+
+        it "should do nothing if source and target are the same" do
+          tm = create_table_manager
+          tm.copy_table('foos', 'foos')
+        end
+      end
+
+      describe "get_table_schema_copier" do
+        it "should get a TableSchemaCopier specialised for the connection adapter, if available" do
+          c = double('connection')
+          c.stub(:adapter_name).and_return('MySQL')
+
+          tm = create_table_manager
+          tm.send(:get_table_schema_copier, c).should == MySQLTableSchemaCopier
+        end
+
+        it "should get a DefaultTableSchemaCopier if no specialised TableSchemaCopier available" do
+          c = double('connection')
+          c.stub(:adapter_name).and_return('Random')
+
+          tm = create_table_manager
+          tm.send(:get_table_schema_copier, c).should == DefaultTableSchemaCopier
+        end
+      end
+
+      describe MySQLTableSchemaCopier do
+
+        describe "copy_table_schema" do
+          it "should ask mysql for the create-table statement, modify it and execute the modified statement" do
+            c = double('connection')
+            c.should_receive(:select_rows).with("SHOW CREATE TABLE `foos`").and_return([["foos", "CREATE TABLE `foos` (blah)"]])
+            c.should_receive(:execute).with("CREATE TABLE `bars` (blah)")
+
+            MySQLTableSchemaCopier.copy_table_schema(c, "foos", "bars")
+          end
+        end
+
+        describe "table_schema" do
+          it "should ask mysql for the create-table statement for the table" do
+            c = double('connection')
+            c.should_receive(:select_rows).with("SHOW CREATE TABLE `foos`").and_return([["foos", "CREATE TABLE `foos` (blah)"]])
+            MySQLTableSchemaCopier.table_schema(c, "foos").should == "CREATE TABLE `foos` (blah)"
+          end
+        end
+
+        describe "change_table_name" do
+          it "should change the table name in the CREATE TABLE statement" do
+            MySQLTableSchemaCopier.change_table_name('foos', 'bars', "CREATE TABLE `foos` (blah)").should ==
+              "CREATE TABLE `bars` (blah)"
+          end
+        end
+
+      end
+
+      describe DefaultTableSchemaCopier do
+
+        describe "copy_table_schema" do
+          it "should extract ruby schema, modify and eval it to create a new table"  do
+            c = double('connection')
+            c.should_receive(:instance_eval).with('create_table "bars" ()')
+
+            DefaultTableSchemaCopier.should_receive(:table_schema).with(c, "foos").and_return('create_table "foos" ()')
+
+            DefaultTableSchemaCopier.copy_table_schema(c, "foos", "bars")
+          end
+        end
+
+        describe "table_schema" do
+          it "should use the schema dumper to retrieve ruby code to create a table" do
+            c = double('connection')
+
+            sd = double('schema-dumper')
+            ActiveRecord::SchemaDumper.should_receive(:new).with(c).and_return(sd)
+
+            sd.should_receive(:table).with('foos', anything).and_return(StringIO.new('create_table "foos" ()'))
+
+            DefaultTableSchemaCopier.table_schema(c, "foos").should == 'create_table "foos" ()'
+          end
+        end
+
+        describe "change_table_name" do
+          it "should alter the provided schema generating code to change the table_name" do
+            tm = create_table_manager
+            DefaultTableSchemaCopier.change_table_name( "foos", "bars", 'create_table "foos" (blahblah)\nadd_index "foos" blahblah').should ==
+              'create_table "bars" (blahblah)\nadd_index "bars" blahblah'
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/active_record/model_spaces/table_names_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'active_record/model_spaces/table_names'
+module ActiveRecord
+  module ModelSpaces
+    describe TableNames do
+
+      describe "base_table_name" do
+        it "should underscore and pluralize the classname" do
+          TableNames.base_table_name("FooBar").should == "foo_bars"
+        end
+
+        it "should remove module names" do
+          TableNames.base_table_name(ModelSpaces).should == "model_spaces"
+        end
+      end
+
+      describe "model_space_table_name" do
+        it "should return base_table_name if no model-space or model-space-key given" do
+          TableNames.model_space_table_name(nil, nil, "foo_bars").should == "foo_bars"
+        end
+
+        it "should return base_table_name if an empty model-space and model-space-key given" do
+          TableNames.model_space_table_name("", "", "foo_bars").should == "foo_bars"
+        end
+
+        it "should prefix with model-space-name if given alone" do
+          TableNames.model_space_table_name("blarghl", nil, "foo_bars").should == "blarghl__foo_bars"
+        end
+
+        it "should prefix a model-space-name and model-space-key if bothgiven" do
+          TableNames.model_space_table_name("blarghl", "one", "foo_bars").should == "blarghl__one__foo_bars"
+        end
+
+        it "should raise an error if a model-space-key is given without a model-space-name" do
+
+          expect {
+            TableNames.model_space_table_name(nil, "one", "FooBar")
+          }.to raise_error /model_space_key cannot be non-empty if model_space_name is empty/
+
+        end
+      end
+
+      describe "table_name" do
+        it "should always suffix version provided if non-nil and >0" do
+          TableNames.table_name("blarghl", "one", "foo_bars", nil, nil).should == "blarghl__one__foo_bars"
+          TableNames.table_name("blarghl", "one", "foo_bars", nil, 1).should == "blarghl__one__foo_bars__1"
+          TableNames.table_name("blarghl", "one", "foo_bars", 0, nil).should == "blarghl__one__foo_bars"
+          TableNames.table_name("blarghl", "one", "foo_bars", 0, 1).should == "blarghl__one__foo_bars__1"
+
+          TableNames.table_name("blarghl", "one", "foo_bars", 1, 0).should == "blarghl__one__foo_bars"
+          TableNames.table_name("blarghl", "one", "foo_bars", 1, 1).should == "blarghl__one__foo_bars__1"
+          TableNames.table_name("blarghl", "one", "foo_bars", 1, 2).should == "blarghl__one__foo_bars__2"
+          TableNames.table_name("blarghl", "one", "foo_bars", 1, 3).should == "blarghl__one__foo_bars__3"
+
+          TableNames.table_name("blarghl", "one", "foo_bars", 2, 0).should == "blarghl__one__foo_bars"
+          TableNames.table_name("blarghl", "one", "foo_bars", 2, 1).should == "blarghl__one__foo_bars__1"
+          TableNames.table_name("blarghl", "one", "foo_bars", 2, 2).should == "blarghl__one__foo_bars__2"
+          TableNames.table_name("blarghl", "one", "foo_bars", 2, 3).should == "blarghl__one__foo_bars__3"
+          TableNames.table_name("blarghl", "one", "foo_bars", 2, 4).should == "blarghl__one__foo_bars__4"
+        end
+      end
+
+      describe "next_version" do
+        it "should return the next version" do
+          TableNames.next_version(nil, nil).should == 0
+          TableNames.next_version(nil, 0).should == 0
+          TableNames.next_version(nil, 1).should == 0
+
+          TableNames.next_version(0, nil).should == 0
+          TableNames.next_version(0, 0).should == 0
+          TableNames.next_version(0, 1).should == 0
+
+          TableNames.next_version(1, nil).should == 1
+          TableNames.next_version(1, 0).should == 1
+          TableNames.next_version(1, 1).should == 0
+          TableNames.next_version(1, 2).should == 1
+
+          TableNames.next_version(2, nil).should == 1
+          TableNames.next_version(2, 0).should == 1
+          TableNames.next_version(2, 1).should == 2
+          TableNames.next_version(2, 2).should == 0
+          TableNames.next_version(2, 3).should == 1
+        end
+      end
+
+
+    end
+  end
+end

data/spec/active_record/model_spaces/util_spec.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'active_record'
+require 'active_record/model_spaces/util'
+
+module ActiveRecord
+  module ModelSpaces
+
+    describe Util do
+
+      describe "name_from_model" do
+        it "should stringify the model" do
+          m = double('model')
+          mk = double('model-key')
+          m.should_receive(:to_s).and_return(mk)
+          Util.name_from_model(m).should == mk
+        end
+
+      end
+
+      describe "model_from_name" do
+        it "should return the model class from the classname" do
+          Util.model_from_name("ActiveRecord::ModelSpaces").should == ActiveRecord::ModelSpaces
+        end
+
+        it "should do nothing if given a model class" do
+          Util.model_from_name(ActiveRecord::ModelSpaces).should == ActiveRecord::ModelSpaces
+        end
+      end
+
+      describe "require_for_classname" do
+        it "should require a file based on the classname then eval the classname to get the class" do
+          Kernel.should_receive(:require).with('active_record/model_spaces/foo_table_schema_copier')
+          klass = double('the-class')
+          Kernel.should_receive(:eval).with("ActiveRecord::ModelSpaces::FooTableSchemaCopier").and_return(klass)
+          Util.require_for_classname("ActiveRecord::ModelSpaces::FooTableSchemaCopier").should == klass
+        end
+
+        it "should return false in the case of any error" do
+          Kernel.should_receive(:require).with('active_record/model_spaces/foo_table_schema_copier').and_return{raise "boo"}
+          Util.require_for_classname("ActiveRecord::ModelSpaces::FooTableSchemaCopier").should == false
+        end
+      end
+
+      describe "class_for_classname" do
+        it "should eval a classname to get a class" do
+          klass = double('the-class')
+          Kernel.should_receive(:eval).with("ActiveRecord::ModelSpaces::FooTableSchemaCopier").and_return(klass)
+
+          Util.class_for_classname("ActiveRecord::ModelSpaces::FooTableSchemaCopier").should == klass
+        end
+
+        it "should return false in the case of any error" do
+          Kernel.should_receive(:eval).with("ActiveRecord::ModelSpaces::FooTableSchemaCopier").and_return{raise "boo"}
+          Util.class_for_classname("ActiveRecord::ModelSpaces::FooTableSchemaCopier").should == false
+        end
+      end
+
+      describe "class_from_classname" do
+        it "should try class_for_classname then require_for_classname to find a class" do
+          klass = double('the-class')
+
+          Kernel.should_receive(:eval).with("ActiveRecord::ModelSpaces::FooTableSchemaCopier").and_return{raise "boo"}
+
+          Kernel.should_receive(:require).with('active_record/model_spaces/foo_table_schema_copier').and_return do
+            Kernel.rspec_reset
+            Kernel.should_receive(:eval).with("ActiveRecord::ModelSpaces::FooTableSchemaCopier").and_return(klass)
+          end
+
+          Util.class_from_classname("ActiveRecord::ModelSpaces::FooTableSchemaCopier").should == klass
+        end
+      end
+
+      describe "all_model_superclasses" do
+        it "should return an ordered list of all model superclasses of a class" do
+          c1 = Class.new(ActiveRecord::Base)
+          c2 = Class.new(c1)
+          c3 = Class.new(c2)
+
+          Util.all_model_superclasses(c3).should == [c3,c2,c1]
+        end
+      end
+
+      describe "is_active_record_model?" do
+        it "should return true for direct or indirect subclasses of ActiveRecord::Base" do
+          c1 = Class.new(ActiveRecord::Base)
+          Util.is_active_record_model?(c1).should == true
+
+          c2 = Class.new(c1)
+          Util.is_active_record_model?(c2).should ==true
+        end
+
+        it "should return false for non-subclasses of ActiveRecord::Base" do
+          Util.is_active_record_model?(ActiveRecord::Base).should == false
+
+          c1 = Class.new
+          Util.is_active_record_model?(c1).should == false
+
+          c2 = Class.new
+          Util.is_active_record_model?(c2).should == false
+        end
+      end
+
+    end
+  end
+end

data/spec/active_record/model_spaces_spec.rb

@@ -0,0 +1,116 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module ActiveRecord
+  describe ModelSpaces do
+
+    describe "with_context" do
+      it "should pass with_context calls to the registry" do
+        ModelSpaces::REGISTRY.should_receive(:with_context).and_return do |model_space_name, model_space_key, &block|
+          model_space_name.should == :foo_space
+          model_space_key.should == :one
+          block.call
+        end
+
+        ModelSpaces.with_context(:foo_space, :one) do
+          :result
+        end.should == :result
+      end
+    end
+
+    describe "active_key" do
+      it "should pass active_key calls to the registry" do
+        ModelSpaces::REGISTRY.should_receive(:active_key).with(:foo_space)
+        ModelSpaces.active_key(:foo_space)
+      end
+    end
+
+    describe "kill_context" do
+      it "should pass kill_context calls to the registry" do
+        ModelSpaces::REGISTRY.should_receive(:kill_context).with(:foo_space, :one)
+        ModelSpaces.kill_context(:foo_space, :one)
+      end
+    end
+
+    describe "enforce_context" do
+      it "should pass enforce_contrext calls to the registry" do
+        ec = double('enforce-context')
+        ModelSpaces::REGISTRY.should_receive(:enforce_context).and_return(ec)
+        ModelSpaces.enforce_context.should == ec
+      end
+    end
+
+    describe "set_enforce_context" do
+      it "should pass set_enforce_context calls to the registry" do
+        ec = double('enforce-context')
+        ModelSpaces::REGISTRY.should_receive(:set_enforce_context).with(ec)
+        ModelSpaces.set_enforce_context(ec)
+      end
+    end
+
+    def create_model_spaces_class
+      klass = Class.new
+      klass.class_eval do
+        include ActiveRecord::ModelSpaces
+      end
+      klass
+    end
+
+    it "should pass set_table_name calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:set_base_table_name).with(klass, "random_models")
+      klass.set_table_name("random_models")
+    end
+
+    it "should pass table_name= calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:set_base_table_name).with(klass, "random_models")
+      klass.table_name = "random_models"
+    end
+
+    it "should pass in_model_space calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:register_model).with(klass, :foo_space, {})
+      klass.in_model_space :foo_space
+    end
+
+    it "should pass table_name calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:table_name).with(klass).and_return("foos")
+      klass.table_name.should == "foos"
+    end
+
+    it "should pass current_table_name calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:current_table_name).with(klass).and_return("foos")
+      klass.current_table_name.should == "foos"
+    end
+
+    it "should pass working_table_name calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:working_table_name).with(klass).and_return("foos")
+      klass.working_table_name.should == "foos"
+    end
+
+    it "should pass new_version calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:new_version).with(klass).and_return do |k, &proc|
+        proc.call.should == :blah
+      end
+      klass.new_version{:blah}
+    end
+
+    it "should pass updated_version calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:updated_version).with(klass).and_return do |k, &proc|
+        proc.call.should == :blah
+      end
+      klass.updated_version{:blah}
+    end
+
+    it "should pass hoover calls to the registry" do
+      klass = create_model_spaces_class
+      ModelSpaces::REGISTRY.should_receive(:hoover).with(klass).and_return(true)
+      klass.hoover
+    end
+  end
+end