migratrix 0.0.9 → 0.8.1

data/spec/lib/migratrix/migratrix_spec.rb

@@ -1,106 +1,83 @@
 require 'spec_helper'
 
-describe Migratrix::Migratrix do
-  let (:migratrix) { Migratrix::Migratrix.new }
-
-  it "exists (sanity check)" do
-    Migratrix.should_not be_nil
-    Migratrix.class.should == Module
-    Migratrix.class.should_not == Class
-    Migratrix::Migratrix.class.should_not == Module
-    Migratrix::Migratrix.class.should == Class
-    Migratrix.const_defined?("Migratrix").should be_true
-  end
-
-  describe "MigrationRegistry (needs to be extracted)" do
-    before do
-      reset_migratrix! migratrix
-      Migratrix.class_eval("class PantsMigration < Migration; end")
-      migratrix.register_migration "PantsMigration", Migratrix::PantsMigration
-    end
-
-    it "can register migrations by name" do
-      migratrix.loaded?("PantsMigration").should be_true
-      Migratrix.const_defined?("PantsMigration").should be_true
-    end
+class TestExtraction < Migratrix::Extractions::Extraction
+end
 
-    it "can fetch registered migration class" do
-      migratrix.fetch_migration("PantsMigration").should == Migratrix::PantsMigration
-    end
+class TestTransform < Migratrix::Transforms::Transform
+end
 
-    it "raises fetch error when fetching unregistered migration" do
-      lambda { migratrix.fetch_migration("arglebargle") }.should raise_error(KeyError)
-    end
-  end
+class TestLoad < Migratrix::Loads::Load
+end
 
-  describe ".migrations_path" do
-    it "uses ./db/legacy by default" do
-      migratrix.migrations_path.should == ROOT + "db/legacy"
-    end
+describe Migratrix::Migratrix do
+  let (:migratrix) { Migratrix::Migratrix.new }
 
-    it "can be overridden" do
-      migratrix.migrations_path = Pathname.new('/tmp')
-      migratrix.migrations_path.should == Pathname.new("/tmp")
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix.should_not be_nil
+      Migratrix.class.should == Module
+      Migratrix.class.should_not == Class
+      Migratrix::Migratrix.class.should_not == Module
+      Migratrix::Migratrix.class.should == Class
+      Migratrix.const_defined?("Migratrix").should be_true
     end
   end
 
-  describe "#valid_options" do
-    it "returns the valid set of option keys" do
-      migratrix.valid_options.should == ["limit", "offset", "order", "where"]
-    end
-  end
+  describe "Migration Component Registry" do
+    describe ".register_extraction" do
+      before do
+        Migratrix::Migratrix.register_extraction :test_extraction, TestExtraction, { :source => Object }
+      end
 
-  describe "#filter_options" do
-    it "filters out invalid options" do
-      options = migratrix.filter_options({ "pants" => 42, "limit" => 3})
-      options["limit"].should == 3
-      options.should_not have_key("pants")
-    end
-  end
+      it "registers the extraction" do
+        Migratrix::Migratrix.extractions.registered?(:test_extraction).should be_true
+        Migratrix::Migratrix.extractions.class_for(:test_extraction).should == TestExtraction
+      end
 
-  describe "#migration_name" do
-    it "classifies the name and adds Migration" do
-      migratrix.migration_name("shirt").should == "ShirtMigration"
+      it "creates the extraction with given options" do
+        extraction = TestExtraction.new :test
+        Migratrix::Migratrix.extractions.registered?(:test_extraction).should be_true
+        Migratrix::Migratrix.extractions.class_for(:test_extraction).should == TestExtraction
+      end
     end
 
-    it "handles symbols" do
-      migratrix.migration_name(:socks).should == "SocksMigration"
-    end
+    describe ".register_transform" do
+      before do
+        Migratrix::Migratrix.register_transform :test_transform, TestTransform, { :source => Object }
+      end
 
-    it "preserves pluralization" do
-      migratrix.migration_name(:pants).should == "PantsMigration"
-      migratrix.migration_name(:shirts).should == "ShirtsMigration"
-    end
-  end
+      it "registers the transform" do
+        Migratrix::Migratrix.transforms.registered?(:test_transform).should be_true
+        Migratrix::Migratrix.transforms.class_for(:test_transform).should == TestTransform
+      end
 
-  describe "#create_migration" do
-    before do
-      reset_migratrix! migratrix
-      migratrix.migrations_path = SPEC + "fixtures/migrations"
+      it "creates the transform with given options" do
+        transform = TestTransform.new :monkeys
+        Migratrix::Migratrix.transforms.registered?(:test_transform).should be_true
+        Migratrix::Migratrix.transforms.class_for(:test_transform).should == TestTransform
+      end
     end
 
-    it "creates new migration by name with filtered options" do
-      migration = migratrix.create_migration :marbles, { "cheese" => 42, "where" => "id > 100", "limit" => "100" }
-      migration.class.should == Migratrix::MarblesMigration
-      Migratrix::MarblesMigration.should_not be_migrated
-      migration.options.should == { "where" => "id > 100", "limit" => "100" }
-    end
-  end
+    describe ".register_load" do
+      before do
+        Migratrix::Migratrix.register_load :test_load, TestLoad
+      end
 
-  describe ".migrate" do
-    before do
-      reset_migratrix! migratrix
-      migratrix.migrations_path = SPEC + "fixtures/migrations"
-    end
+      it "registers the load" do
+        Migratrix::Migratrix.loads.registered?(:test_load).should be_true
+        Migratrix::Migratrix.loads.class_for(:test_load).should == TestLoad
+      end
 
-    it "loads migration and migrates it" do
-      Migratrix::Migratrix.stub!(:new).and_return(migratrix)
-      Migratrix::Migratrix.migrate :marbles
+      it "creates the load with given options" do
+        load = TestLoad.new :monkeys
+        Migratrix::Migratrix.loads.registered?(:test_load).should be_true
+        Migratrix::Migratrix.loads.class_for(:test_load).should == TestLoad
+      end
     end
   end
 
   describe "with logger as a singleton" do
-    let (:migration) { migratrix.create_migration :marbles }
+    let (:migration) { Migratrix::MarblesMigration.new }
     let (:buffer) { StringIO.new }
 
     def spec_all_loggers_are(this_logger)
@@ -111,11 +88,6 @@ describe Migratrix::Migratrix do
       Migratrix::MarblesMigration.logger.should == this_logger
     end
 
-    before do
-      reset_migratrix! migratrix
-      migratrix.migrations_path = SPEC + "fixtures/migrations"
-    end
-
     describe ".logger=" do
       it "sets logger globally across all Migratrices, the Migratrix module, Migrators and Models" do
         logger = Migratrix::Migratrix.create_logger(buffer)

data/spec/lib/migratrix/registry_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Migratrix::Registry do
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      ::Migratrix::Registry.should_not be_nil
+    end
+  end
+
+  describe "#register" do
+    let(:registry) { ::Migratrix::Registry.new }
+    before do
+      registry.register(:test, Array, 3)
+    end
+
+    it "registers the class by name" do
+      registry.registered?(:test).should be_true
+    end
+
+    describe "#class_for" do
+      it "returns the registered class" do
+        registry.class_for(:test).should == Array
+      end
+    end
+  end
+end
+
+

data/spec/lib/migratrix/transforms/map_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+class TestMap < Migratrix::Transforms::Map
+end
+
+describe Migratrix::Transforms::Map do
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix::Transforms::Map.should_not be_nil
+      TestMap.should_not be_nil
+    end
+  end
+
+  let(:loggable) { TestMap.new(:loggable) }
+  it_should_behave_like "loggable"
+
+  describe ".local_valid_options" do
+    it "returns the valid set of option keys" do
+      Migratrix::Transforms::Map.local_valid_options.should == []
+    end
+  end
+
+  describe ".valid_options" do
+    it "returns the valide set of options plus those of the superclass" do
+      Migratrix::Transforms::Map.valid_options.should == Migratrix::Transforms::Transform.local_valid_options
+    end
+  end
+
+  describe "with pet types fixture" do
+    let(:extracted_pets) {
+      [
+        { :pet_type_id => 42, :pet_species => 'Dog' },
+        { :pet_type_id => 43, :pet_species => 'Cat' },
+        { :pet_type_id => 44, :pet_species => 'Rat' },
+        { :pet_type_id => 45, :pet_species => 'Parrot' }
+      ]
+    }
+    let(:map) {  { :id => :pet_type_id, :name => :pet_species } }
+    let(:expected_transform) { {
+        42 => { :id => 42, :name => 'Dog' },
+        43 => { :id => 43, :name => 'Cat' },
+        44 => { :id => 44, :name => 'Rat' },
+        45 => { :id => 45, :name => 'Parrot' }
+      }
+    }
+    let(:transform) { Migratrix::Transforms::Map.new(:pet_types, :transform => map) }
+
+    it "transforms data correctly" do
+      with_logging_to(StringIO.new) do
+        transform.transform(extracted_pets).should == expected_transform
+      end
+    end
+  end
+end
+

data/spec/lib/migratrix/transforms/transform_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+class TestTransform < Migratrix::Transforms::Transform
+  include Migratrix::Loggable
+end
+
+describe Migratrix::Transforms::Transform do
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix::Transforms::Transform.should_not be_nil
+      TestTransform.should_not be_nil
+    end
+  end
+
+  let(:loggable) { TestTransform.new(:loggable) }
+  it_should_behave_like "loggable"
+
+  describe ".local_valid_options" do
+    it "returns the valid set of option keys" do
+      Migratrix::Transforms::Transform.local_valid_options.should == [:apply_attribute, :extract_attribute, :extraction, :final_class, :finalize_object, :store_transform, :target, :transform, :transform_class, :transform_collection]
+    end
+  end
+
+
+  describe "#extraction" do
+    it "returns extraction name when set" do
+      transform = Migratrix::Transforms::Transform.new(:pants_transform, { extraction: :pants_extraction })
+      transform.extraction.should == :pants_extraction
+    end
+
+    it "#returns transform name when no extraction name is set" do
+      transform = Migratrix::Transforms::Transform.new(:pants_transform)
+      transform.extraction.should == :pants_transform
+    end
+  end
+
+  describe "unimplemented methods:" do
+    [ [:create_transformed_collection, []],
+      [:create_new_object, [:extracted_row]],
+      [:apply_attribute, [:object, :value, :attribute_or_apply]],
+      [:extract_attribute, [:object, :attribute_or_extract]],
+      [:store_transformed_object, [:object, :collection]] ].each do |method, args|
+      describe "#{method}(#{args.map(&:inspect)*','})" do
+        let(:object_with_not_implemented_methods) { Migratrix::Transforms::Transform.new(:brain_damaged_transform) }
+        it "raises NotImplementedError" do
+          lambda { object_with_not_implemented_methods.send(method, *args) }.should raise_error(NotImplementedError)
+        end
+      end
+    end
+  end
+
+  describe "TypeError methods" do
+    [:transform_collection, :transform_class, :extract_attribute, :apply_attribute, :final_class, :finalize_object, :store_transformed_object].each do |method|
+      describe "With #{method} set to a string" do
+        let(:transform_options) { {
+            extraction: :test_stream,
+            transform: { id: :src_id, name: :src_name },
+            transform_collection: Array,
+            transform_class:  Hash,
+            extract_attribute:  ->(object, attribute) { object[attribute] },
+            apply_attribute: ->(object, attribute, value) { object[attribute] = value },
+            final_class: Set,
+            finalize_object: ->(object) { object.to_a },
+            store_transformed_object: :<<
+          }.merge( method => "cheese")
+        }
+        let(:transform) { TestTransform.new :test, transform_options }
+        let(:test_stream) { [{src_id: 42, src_name: "Alice"}, {src_id: 43, src_name: "Bob"} ] }
+        let(:extractions) { { test_stream: mock("extraction", name: "test_stream", extract: test_stream )}}
+
+        it "should raise TypeError" do
+          lambda { transform.transform(test_stream) }.should raise_error(TypeError)
+        end
+      end
+    end
+  end
+
+  describe "with Proc options" do
+    let(:transform) { TestTransform.new :test, {
+        extraction: :test_stream,
+        transform: { id: :src_id, name: :src_name },
+        transform_collection: ->{ Array.new },
+        transform_class:  ->(row) { Hash.new },
+        extract_attribute:  ->(object, attribute) { object[attribute] },
+        apply_attribute: ->(object, attribute, value) { object[attribute] = value },
+        final_class: Set,
+        finalize_object: ->(object) { object.to_a },
+        store_transformed_object: ->(object, collection) { collection << object }
+      }
+    }
+
+    let(:test_stream) { [{src_id: 42, src_name: "Alice"}, {src_id: 43, src_name: "Bob"} ] }
+    let(:extractions) { { test_stream: mock("extraction", name: "test_stream", extract: test_stream )}}
+
+    before do
+      TestTransform.stub!(:extractions).and_return(extractions)
+    end
+
+    it "should delegate to procs" do
+      transform.transform(test_stream).should == [
+        Set.new([[:id, 42], [:name, "Alice"]]),
+        Set.new([[:id, 43], [:name, "Bob"]])
+      ]
+    end
+  end
+
+  describe "with symbol and class options" do
+    let(:transform) { TestTransform.new :test, {
+        extraction: :test_stream,
+        transform: { id: :src_id, name: :src_name },
+        transform_collection: Array,
+        transform_class:  Hash,
+        extract_attribute:  :[],
+        apply_attribute: :[]=,
+        store_transformed_object: :<<
+      }
+    }
+
+    let(:test_stream) { [{src_id: 42, src_name: "Alice"}, {src_id: 43, src_name: "Bob"} ] }
+    let(:extractions) { { test_stream: mock("extraction", name: "test_stream", extract: test_stream )}}
+
+    before do
+      TestTransform.stub!(:extractions).and_return(extractions)
+    end
+
+    it "should delegate to procs" do
+      transform.transform(test_stream).should == [
+        {id: 42, name: "Alice"},
+        {id: 43, name: "Bob"}
+      ]
+    end
+  end
+end
+

data/spec/lib/migratrix_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Migratrix do
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix.should_not be_nil
+      Migratrix.class.should == Module
+    end
+  end
+
+  describe "convenience delegator methods" do
+    def spec_delegates_to_migratrix_class(method, *args)
+      if args.size > 0
+        Migratrix::Migratrix.should_receive(method).with(*args).once
+      else
+        Migratrix::Migratrix.should_receive(method).once
+      end
+      Migratrix.send(method, *args)
+    end
+
+    describe ".logger" do
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :logger
+      end
+    end
+
+    describe ".logger=" do
+      let (:logger) { Logger.new(StringIO.new) }
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :logger=, logger
+      end
+    end
+
+    describe ".log_to" do
+      let (:buffer) { StringIO.new }
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :log_to, buffer
+      end
+    end
+
+    describe ".register_extraction" do
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :register_extraction, :marbles, Array, 3
+      end
+    end
+
+    describe ".extractions" do
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :extractions
+      end
+    end
+
+    describe ".register_transform" do
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :register_transform, :marbles, Array, 3
+      end
+    end
+
+    describe ".transforms" do
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :transforms
+      end
+    end
+
+    describe ".register_load" do
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :register_load, :marbles, Array, 3
+      end
+    end
+
+    describe ".loads" do
+      it "delegates to Migratrix::Migratrix" do
+        spec_delegates_to_migratrix_class :loads
+      end
+    end
+  end
+
+  describe "gem-installed components:" do
+    describe "extractions" do
+      it ":active_record is registered" do
+        Migratrix.extractions.class_for(:active_record).should == ::Migratrix::Extractions::ActiveRecord
+      end
+    end
+
+    describe "transforms" do
+      it ":transform is registered" do
+        Migratrix.transforms.class_for(:transform).should == ::Migratrix::Transforms::Transform
+      end
+
+      it ":map is registered" do
+        Migratrix.transforms.class_for(:map).should == ::Migratrix::Transforms::Map
+      end
+    end
+
+    # transforms: map, transform
+  end
+end
+