migratrix 0.0.9 → 0.8.1

data/lib/migratrix/valid_options.rb

@@ -0,0 +1,22 @@
+require 'active_support/concern'
+module Migratrix
+  module ValidOptions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def set_valid_options(*options)
+        @local_valid_options = options.map(&:to_s).sort.map(&:to_sym)
+      end
+
+      def valid_options
+        options = local_valid_options.dup
+        options += self.ancestors.map {|klass| klass.local_valid_options rescue nil }.compact.flatten
+        options.map(&:to_s).sort.uniq.map(&:to_sym)
+      end
+
+      def local_valid_options
+        @local_valid_options ||= []
+      end
+    end
+  end
+end

data/lib/patches/object_ext.rb

@@ -1,8 +1,4 @@
 class Object
-  def in?(array)
-    array.include? self
-  end
-
   def deep_copy
     Marshal::load(Marshal::dump(self))
   end

data/spec/fixtures/migrations/marbles_migration.rb

@@ -1,17 +1,19 @@
 module Migratrix
   # Fake migration fixture for "Marbles"
   class MarblesMigration < Migration
+    # :nocov: # because we play some games with file loading/unloading, SimpleCov often misses lines in this file
     def initialize(options={})
       super
-      @@migrated = false
+      @migrated = false
     end
 
     def migrate
-      @@migrated = true
+      @migrated = true
     end
 
-    def self.migrated?
-      @@migrated
+    def migrated?
+      @migrated
     end
+    # :nocov:
   end
 end

data/spec/lib/migratrix/extractions/active_record_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'active_record'
+
+class TestModel < ::ActiveRecord::Base
+end
+
+class TestActiveRecordExtraction < Migratrix::Extractions::ActiveRecord
+end
+
+describe Migratrix::Extractions::ActiveRecord do
+  let(:extraction) { TestActiveRecordExtraction.new :test }
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix::Extractions::Extraction.should_not be_nil
+      TestActiveRecordExtraction.should_not be_nil
+    end
+  end
+
+  describe ".new" do
+    it "raises TypeError unless source is Active" do
+      lambda { TestActiveRecordExtraction.new :test, :source => Object }.should raise_error(TypeError)
+    end
+  end
+
+  describe "#source=" do
+    it "raises TypeError unless source is Active" do
+      lambda { extraction.source = Object }.should raise_error(TypeError)
+    end
+  end
+
+  describe ".local_valid_options" do
+    it "returns the valid set of option keys" do
+      Migratrix::Extractions::ActiveRecord.local_valid_options.should == [:fetchall]
+    end
+  end
+
+  describe ".valid_options" do
+    it "returns the valid set of option keys" do
+      Migratrix::Extractions::ActiveRecord.valid_options.should == [:fetchall] + Migratrix::Extractions::Extraction.valid_options
+    end
+  end
+
+  describe "#obtain_source" do
+    it "raises ExtractionSourceUndefined unless source is defined" do
+      lambda { extraction.extract }.should raise_error(Migratrix::ExtractionSourceUndefined)
+    end
+
+    it "returns the legacy ActiveRecord class" do
+      extraction.source = TestModel
+      extraction.obtain_source(TestModel).should == TestModel
+    end
+  end
+
+  describe "handler functions" do
+    let(:source) { TestModel }
+    before do
+      extraction.source = source
+    end
+
+    [:where, :order, :limit, :offset].each do |handler|
+      describe "#handle_#{handler}" do
+        it "calls #{handler} on the source ActiveRelation" do
+          source.should_receive(handler).with(1).and_return(nil)
+          extraction.send("handle_#{handler}", source, 1)
+        end
+      end
+    end
+  end
+
+  describe "#to_query" do
+    let(:source) { TestModel }
+    let(:relation) { source.where(1) }
+    let(:lolquery) { 'SELECT "HAY GUYZ IM A QUARY LOL"' }
+    before do
+      extraction.source = source
+    end
+
+    describe "when source is ActiveRecord" do
+      it "converts it to ActiveRelation with where(1)" do
+        extraction.should_receive(:handle_where).with(source, 1).and_return(relation)
+        relation.should_receive(:to_sql).and_return(lolquery)
+        extraction.to_query(source).should == lolquery
+      end
+    end
+
+    describe "When source has already been converted to ActiveRelation" do
+      it "delegates to to_sql on source" do
+        relation.should_receive(:to_sql).and_return(lolquery)
+        extraction.to_query(relation).should == lolquery
+      end
+    end
+  end
+
+  describe "#execute_extract" do
+    let(:source) { TestModel }
+    let(:relation) { source.where(1) }
+    let(:lolquery) { 'SELECT "HAY GUYZ IM A QUARY LOL"' }
+
+    before do
+      TestModel.stub!(:establish_connection).and_return true
+    end
+
+    describe "with 'fetchall' option" do
+      let(:extraction) { TestActiveRecordExtraction.new :test, "fetchall" => true }
+
+      describe "and source is an ActiveRelation" do
+        it "calls all on the relation" do
+          relation.should_receive(:all).and_return([])
+          extraction.execute_extract(relation, extraction.options).should == []
+        end
+      end
+
+      describe "and source is still ActiveRecord" do
+        it "converts it to ActiveRelation with where(1)" do
+          source.should_receive(:all).and_return([])
+          extraction.execute_extract(source, extraction.options).should == []
+        end
+      end
+    end
+
+    describe "without 'fetchall' option" do
+      before do
+        # hrm, okay, this is tricky. The should == is setting off a
+        # tripwire in ActiveRecord that makes it try to connect to
+        # the database. This is AR internals dependent, but if the
+        # relation has a cached to_sql, it will return it without
+        # trying to connect.
+        relation.should_receive(:to_sql).at_least(1).times.and_return(lolquery)
+      end
+
+      describe "and source is an ActiveRelation" do
+        it "returns source unmodified" do
+          extraction.execute_extract(relation).should == relation
+        end
+      end
+
+      describe "and source is still ActiveRecord" do
+        it "converts it to ActiveRelation with where(1)" do
+          extraction.should_receive(:handle_where).with(source, 1).and_return(relation)
+          extraction.execute_extract(source).should == relation
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/migratrix/extractions/extraction_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+class TestExtraction < Migratrix::Extractions::Extraction
+end
+
+describe Migratrix::Extractions::Extraction do
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix::Extractions::Extraction.should_not be_nil
+      TestExtraction.should_not be_nil
+    end
+  end
+
+  describe ".local_valid_options" do
+    it "returns the valid set of option keys" do
+      Migratrix::Extractions::Extraction.local_valid_options.should == [:limit, :offset, :order, :where]
+    end
+  end
+
+  describe "unimplemented methods:" do
+    let(:base_extraction) { Migratrix::Extractions::Extraction.new :test }
+    [:obtain_source, :handle_where, :handle_limit, :handle_offset, :handle_order, :to_query, :execute_extract].each do |method|
+      describe "#{method}" do
+        it "raises NotImplementedError" do
+          lambda { base_extraction.send(method, nil) }.should raise_error(NotImplementedError)
+        end
+      end
+    end
+  end
+
+  describe "#extract (default strategy)" do
+    describe "with no options" do
+      let(:extraction) { TestExtraction.new :test }
+      it "should call handle_source and execute_extract only" do
+        extraction.should_receive(:obtain_source).with(nil, {}).and_return(13)
+        extraction.should_receive(:execute_extract).with(13, {}).and_return(64)
+        extraction.extract.should == 64
+      end
+    end
+
+    describe "with all options" do
+      let(:options) { { :where => 1, :order => 2, :limit => 3, :offset => 4 } }
+      let(:extraction) { TestExtraction.new :test, options }
+      it "should call entire handler chain" do
+        extraction.should_receive(:obtain_source).with(nil, options).and_return("A")
+        extraction.should_receive(:handle_where).with("A", 1).and_return("B")
+        extraction.should_receive(:handle_order).with("B", 2).and_return("C")
+        extraction.should_receive(:handle_limit).with("C", 3).and_return("D")
+        extraction.should_receive(:handle_offset).with("D", 4).and_return("E")
+        extraction.should_receive(:execute_extract).with("E", options).and_return("BONG")
+        extraction.extract.should == "BONG"
+      end
+    end
+
+    describe "with overridden options" do
+      let(:options) { { :where => 1, :order => 2, :limit => 3, :offset => 4 } }
+      let(:extraction) { TestExtraction.new :test, options }
+      let(:overrides) { {:where => 5, :order => 6, :limit => 7, :offset => 8 } }
+      it "should call entire handler chain" do
+        extraction.should_receive(:obtain_source).with(nil, overrides).and_return("A")
+        extraction.should_receive(:handle_where).with("A", 5).and_return("B")
+        extraction.should_receive(:handle_order).with("B", 6).and_return("C")
+        extraction.should_receive(:handle_limit).with("C", 7).and_return("D")
+        extraction.should_receive(:handle_offset).with("D", 8).and_return("E")
+        extraction.should_receive(:execute_extract).with("E", overrides).and_return("BONG")
+        extraction.extract(overrides).should == "BONG"
+      end
+    end
+  end
+end
+

data/spec/lib/migratrix/loads/load_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class TestLoad < Migratrix::Loads::Load
+end
+
+describe Migratrix::Loads::Load do
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix::Loads::Load.should_not be_nil
+      TestLoad.should_not be_nil
+    end
+  end
+
+  let(:loggable) { TestLoad.new(:loggable) }
+  it_should_behave_like "loggable"
+
+  # describe ".local_valid_options" do
+  #   it "returns the valid set of option keys" do
+  #     Migratrix::Extractors::Extractor.local_valid_options.should == [:limit, :offset, :order, :where]
+  #   end
+  # end
+
+  describe '#load' do
+    describe "default strategy" do
+      it "saves every transformed object" do
+        data = mock("transformed_object", :save => true)
+        load = TestLoad.new(:test_load)
+        data.should_receive(:save).exactly(3).times
+        load.load([data,data,data])
+      end
+    end
+  end
+
+  describe "#transform" do
+    it "returns transform name when set" do
+      load = Migratrix::Loads::Load.new(:pants_load, { transform: :pants_transform })
+      load.transform.should == :pants_transform
+    end
+
+    it "#returns load name when no transform name is set" do
+      load = Migratrix::Loads::Load.new(:pants_load)
+      load.transform.should == :pants_load
+    end
+  end
+
+  # describe "unimplemented methods:" do
+  #   [ [:before_load, []],
+  #     [:after_load, []] ].each do |method, args|
+  #     describe "#{method}(#{args.map(&:inspect)*','})" do
+  #       let(:object_with_not_implemented_methods) { Migratrix::Loads::Load.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
+
+end
+

data/spec/lib/migratrix/loads/yaml_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class TestYamlLoad < Migratrix::Loads::Yaml
+end
+
+describe Migratrix::Loads::Yaml do
+  describe "sanity check cat" do
+    it "is sanity checked" do
+      Migratrix::Loads::Load.should_not be_nil
+      TestYamlLoad.should_not be_nil
+    end
+  end
+
+  let(:loggable) { TestYamlLoad.new(:loggable) }
+  it_should_behave_like "loggable"
+
+  describe ".local_valid_options" do
+    it "returns the valid set of option keys" do
+      Migratrix::Loads::Yaml.local_valid_options.should == [:filename]
+    end
+  end
+
+  describe "#load" do
+    let(:input) { [1, 2, 3]}
+    let(:output) { "---\n- 1\n- 2\n- 3\n"}
+    let(:buffer) { StringIO.new }
+    let(:load) { TestYamlLoad.new(:test, filename: '/tmp/test.yml')}
+
+    before do
+      File.should_receive(:open).with('/tmp/test.yml', 'w').and_yield(buffer)
+    end
+
+    it "writes transformed_items to file as YAML" do
+      load.load(input)
+      buffer.string.should == output
+    end
+  end
+end
+

data/spec/lib/migratrix/migration_spec.rb

@@ -2,25 +2,24 @@ require 'spec_helper'
 
 # This migration is embedded in migration_spec.rb to allow testing of
 # the class methods that specialize subclasses.
-class Migratrix::TestMigration < Migratrix::Migration
+class TestMigration < Migratrix::Migration
 end
 
-describe Migratrix::Migration do
-  let(:migration) { Migratrix::TestMigration.new }
-  let(:loggable) { Migratrix::TestMigration.new }
-  it_should_behave_like "loggable"
+class ChildMigration1 < TestMigration
+end
 
-  describe ".new" do
-    it "does not modify given options hash" do
-      conditions = ["id=? AND approved=?", 42, true]
-      migration = Migratrix::TestMigration.new({ "where" => conditions })
+class ChildMigration2 < TestMigration
+end
 
-      migration.options["where"][0] += " AND pants=?"
-      migration.options["where"] << false
-      migration.options["where"].should == ["id=? AND approved=? AND pants=?", 42, true, false]
-      conditions.should == ["id=? AND approved=?", 42, true]
-    end
-  end
+class GrandchildMigration1 < ChildMigration1
+end
+
+describe Migratrix::Migration do
+  let(:migration) { TestMigration.new :cheese => 42 }
+  let(:mock_extraction) { mock("Migratrix::Extractions::ActiveRecord", :name => :pets, :extract => 43, :valid_options => ["fetchall", "limit", "offset", "order", "where"])}
+
+  let(:loggable) { TestMigration.new }
+  it_should_behave_like "loggable"
 
   describe "#migrate" do
     it "delegates to extract, transform, and load" do
@@ -31,29 +30,198 @@ describe Migratrix::Migration do
     end
   end
 
-  describe "with mock active_record extractor" do
-    let(:mock_extractor) { mock("Extractor", :extract => 43)}
+  describe "with mocked components" do
+    let(:map) { { :id => :id, :name => :name }}
+    let(:extraction) {
+      mock("Migratrix::Extractions::ActiveRecord", {
+             :extract => {:animals => [42,13,43,14]},
+             :valid_options => [:fetchall, :limit, :offset, :order, :where]
+           }
+      )
+    }
+    let(:transform1) {
+      mock("Migratrix::Transforms::Map", {
+             :name => :tame,
+             :transform => [{:id => 42, :name => "Mister Bobo"}, {:id => 43, :name => "Mrs. Bobo"}],
+             :valid_options => [:map],
+             :extraction => :animals
+           })
+    }
+    let(:transform2) {
+      mock("Migratrix::Transforms::Map", {
+             :name => :animals,
+             :extraction => :animals,
+             :transform => [{:id => 13, :name => "Sparky"}, {:id => 14, :name => "Fido"}],
+             :valid_options => [:map]
+           }
+      )
+    }
+    let(:load1) {
+      mock("Migratrix::Loads::Yaml", {
+        :name => :cute,
+        :filename => "/tmp/monkeys.yml",
+        :valid_options => [:filename],
+        :transform => :tame
+      })
+    }
+    let(:load2) {
+      mock("Migratrix::Loads::Yaml", {
+        :name => :adorable,
+        :filename => "/tmp/puppies.yml",
+        :valid_options => [:filename],
+        :transform => :animals
+      })
+    }
+
     before do
-      Migratrix::Extractors::ActiveRecord.should_receive(:new).with({ :source => Object}).and_return(mock_extractor)
-      Migratrix::TestMigration.class_eval "set_extractor :active_record, :source => Object"
+      # Clear out any named components
+      TestMigration.extractions.clear
+      TestMigration.transforms.clear
+      TestMigration.loads.clear
+
+      # Intercept the delegated component creations
+      Migratrix::Extractions::ActiveRecord.should_receive(:new).with(:animals, {:source => Object }).and_return(extraction)
+
+      Migratrix::Transforms::Map.should_receive(:new).with(:monkeys, :transform => map, :extraction => :animals).and_return(transform1)
+      Migratrix::Transforms::Map.should_receive(:new).with(:puppies, :transform => map, :extraction => :animals).and_return(transform2)
+
+      Migratrix::Loads::Yaml.should_receive(:new).with(:monkeys, :filename => '/tmp/monkeys.yml').and_return(load1)
+      Migratrix::Loads::Yaml.should_receive(:new).with(:puppies, :filename => '/tmp/puppies.yml').and_return(load2)
+
+
+      TestMigration.set_extraction :animals, :active_record, :source => Object
+      TestMigration.set_transform :monkeys, :map, :transform => map, :extraction => :animals
+      TestMigration.set_transform :puppies, :map, :transform => map, :extraction => :animals
+      TestMigration.set_load :monkeys, :yaml, :filename => '/tmp/monkeys.yml'
+      TestMigration.set_load :puppies, :yaml, :filename => '/tmp/puppies.yml'
+    end
+
+    describe ".set_extraction" do
+      it "sets the class instance variable for extraction" do
+        TestMigration.extractions[:animals].should == extraction
+      end
+
+      it "also sets convenience instance method for extraction" do
+        TestMigration.new.extractions[:animals].should == extraction
+      end
     end
 
-    describe ".set_extractor" do
-      it "sets the class accessor for extractor" do
-        Migratrix::TestMigration.extractor.should == mock_extractor
+    describe ".set_transform" do
+      it "sets the class instance variable for transforms" do
+        TestMigration.transforms.should == { :monkeys => transform1, :puppies => transform2 }
       end
 
-      it "also sets convenience instance method for extractor" do
-        Migratrix::TestMigration.new.extractor.should == mock_extractor
+      it "also sets convenience instance method for transform" do
+        TestMigration.new.transforms.should == { :monkeys => transform1, :puppies => transform2 }
+      end
+    end
+
+    describe ".set_load" do
+      it "sets the class instance variable for loads" do
+        TestMigration.loads.should == { :monkeys => load1, :puppies => load2 }
+      end
+
+      it "also sets convenience instance method for load" do
+        TestMigration.new.loads.should == { :monkeys => load1, :puppies => load2 }
       end
     end
 
     describe "#extract" do
-      it "delegates to extractor" do
-        migration.extract.should == 43
+      it "delegates to extraction" do
+        extraction.should_receive(:extract).and_return([42,13,43,14])
+        migration.extract.should == {:animals => [42,13,43,14]}
+      end
+    end
+
+    describe "#transform" do
+      it "should pass named extracted_items to each transform" do
+        transform1.should_receive(:transform).with([42,13,43,14])
+        transform2.should_receive(:transform).with([42,13,43,14])
+
+        migration = TestMigration.new
+        migration.transform(extraction.extract)
+      end
+    end
+
+    describe "#load" do
+      it "should pass named transformed_items to each load" do
+        load1.should_receive(:load).with([{:id => 42, :name => "Mister Bobo"}, {:id => 43, :name => "Mrs. Bobo"}])
+        load2.should_receive(:load).with([{:id => 13, :name => "Sparky"}, {:id => 14, :name => "Fido"}])
+
+        migration = TestMigration.new
+        extracteds = extraction.extract
+        transforms = migration.transform(extracteds)
+        migration.load(transforms)
+      end
+    end
+
+    describe ".valid_options" do
+      it "returns valid options from itself and components" do
+        TestMigration.valid_options.should == [:console, :fetchall, :limit, :map, :offset, :order, :where]
       end
     end
   end
-end
 
+  describe "extending" do
+    before do
+      [TestMigration, ChildMigration1, ChildMigration2, GrandchildMigration1].each do |klass|
+        [:extractions, :transforms, :loads].each do |kollection|
+          klass.send(kollection).send(:clear)
+        end
+      end
+      TestMigration.set_extraction :cheese, :extraction, { first_option: 'id>100' }
+      TestMigration.set_transform :cheese, :transform, { first_option: 'id>100' }
+      TestMigration.set_load :cheese, :load, { first_option: 'id>100' }
+
+    end
+
+    [:extraction, :transform, :load ].each do |component|
+      describe "#{component}" do
+        it "extends the #{component} to child class" do
+          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2 })
+          ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>100'}
+        end
+
+        it "extends the #{component} to the grandchild class" do
+          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2 })
+          GrandchildMigration1.send("extend_#{component}", :cheese, { surprise_option: 50 })
+          GrandchildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>100', surprise_option: 50 }
+        end
+
+        it "extends the #{component} to the grandchild class even if the child class does not extend" do
+          GrandchildMigration1.send("extend_#{component}", :cheese, { surprise_option: 50 })
+          GrandchildMigration1.new.send("#{component}s")[:cheese].options.should == { first_option: 'id>100', surprise_option: 50 }
+        end
+
+        it "overrides parent options" do
+          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
+          ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
+        end
+
+        it "does not affect sibling class options" do
+          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
+          ChildMigration2.send("extend_#{component}", :cheese, { zany_option: Hash, first_option: 'id>75' })
+          ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
+          ChildMigration2.new.send("#{component}s")[:cheese].options.should == { zany_option: Hash, first_option: 'id>75'}
+        end
+
+        it "does not affect parent class options" do
+          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
+          ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
+          TestMigration.new.send("#{component}s")[:cheese].options.should == { first_option: 'id>100'}
+        end
+
+        it "raises #{component.capitalize}NotDefined if no parent has that #{component}" do
+          exception = "Migratrix::#{component.capitalize}NotDefined".constantize
+          lambda { ChildMigration1.send("extend_#{component}", :blargle, { second_option: 2, first_option: 'id>50' }) }.should raise_error(exception)
+        end
+      end
+    end
+
+
+    # TODO: lambdas cannot be deep-copied, and form closures at the
+    # time of creation. Is there a way to detect if a lambda has a
+    # closure?
+  end
+end