transfer 0.0.1

data/spec/support/shared_examples_for_generators.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+
+shared_examples "a generator" do
+  subject { generator.new klass }
+
+  it { should respond_to :create }
+  it { should respond_to :column_present? }
+
+  describe "#column_present?" do
+    it :first_name do
+      subject.column_present?(:first_name).should be_true
+    end
+    it :last_name do
+      subject.column_present?(:last_name).should be_true
+    end
+    it :full_name do
+      subject.column_present?(:full_name).should be_true
+    end
+    it :before_save_value do
+      subject.column_present?(:before_save_value).should be_true
+    end
+    it :dynamic_value do
+      subject.column_present?(:dynamic_value).should be_true
+    end
+    it :undefined do
+      subject.column_present?(:undefined).should be_false
+    end
+  end
+
+  describe "#create" do
+    let(:attributes) {{}}
+    let(:row) {{}}
+    let(:options) {{}}
+    let(:callbacks) {{}}
+
+    def do_action
+      subject.create attributes, row, options, callbacks
+    end
+
+    it "should return correct type" do
+      do_action.should be_instance_of klass
+    end
+
+    context "with #save throws an exception" do
+      before do
+        save_failure klass
+      end
+      context ":failure_startegy=>:ignore" do
+        let(:options) { {:failure_strategy => :ignore} }
+        it "not raise exception" do
+          expect{ do_action }.to_not raise_error
+        end
+      end
+      context ":failure_startegy=>:ignore" do
+        let(:options) { {:failure_strategy => :rollback} }
+        it "raise exception" do
+          expect{ do_action }.to raise_error
+        end
+      end
+    end
+  end
+
+end

data/spec/support/shared_examples_for_transfer.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+shared_examples "a transfer johnny hollow" do
+  let!(:user) { Fabricate :johnny_hollow }
+
+  it "should change count records from 0 to 1" do
+    expect{ do_action }.to change{ klass.count }.from(0).to(1)
+  end
+
+  describe "first record" do
+    subject { klass.first }
+
+    before do
+      do_action do
+        first_name :fname
+        last_name  :lname
+        full_name  {|r| "#{r[:fname]} #{r[:lname]}" }
+        protected_value "flash"
+      end
+    end
+
+    it { should be }
+    its(:id) { should == user.id }
+    its(:first_name) { should == "Johnny" }
+    its(:last_name) { should == "Hollow" }
+    its(:full_name) { should == "Johnny Hollow" }
+    its(:protected_value) { should == "flash" }
+  end
+
+  describe "callbacks" do
+    subject { klass.first }
+
+    it "should call before_save" do
+      do_action do
+        before_save do |row|
+          self.before_save_value = row[:fname]
+        end
+      end
+      subject.before_save_value == "Johnny"
+    end
+    it "should call after_save" do
+      value = nil
+      do_action do
+        after_save do |row|
+          value = row[:fname]
+        end
+      end
+      value.should == "Johnny"
+    end
+
+    context "if #save throws an exception" do
+      include_context "stub klass model"
+      before do
+        save_failure klass
+      end
+
+      it "should call before_save" do
+        do_action do
+          before_save do |row|
+            self.dynamic_value = row[:fname]
+          end
+        end
+        model.dynamic_value == "Johnny"
+      end
+      it "should not call after_save" do
+        do_action do
+          after_save do |row|
+            self.dynamic_value = row[:fname]
+          end
+        end
+        model.dynamic_value.should be_nil
+      end
+
+    end
+  end
+end
+
+shared_examples "a not transfer johnny hollow" do
+  let!(:user) { Fabricate :johnny_hollow }
+  it "should count not changed" do
+    expect{ do_action }.to_not change{ klass.count }
+  end
+end
+
+shared_examples "a transfer" do
+  context SequelUser do
+    let!(:klass) { SequelUser }
+    it_should_behave_like "a transfer johnny hollow"
+  end
+  context ActiveRecordUser do
+    let!(:klass) { ActiveRecordUser }
+    it_should_behave_like "a transfer johnny hollow"
+  end
+  context MongoidUser do
+    let!(:klass) { MongoidUser }
+    it_should_behave_like "a transfer johnny hollow"
+  end
+end
+
+shared_examples "a not transfer" do
+  let!(:user) { Fabricate :johnny_hollow }
+
+  context SequelUser do
+    let!(:klass) { SequelUser }
+    it_should_behave_like "a not transfer johnny hollow"
+  end
+  context ActiveRecordUser do
+    let!(:klass) { ActiveRecordUser }
+    it_should_behave_like "a not transfer johnny hollow"
+  end
+  context MongoidUser do
+    let!(:klass) { MongoidUser }
+    it_should_behave_like "a not transfer johnny hollow"
+  end
+end
+
+shared_examples "a transfer with false validation" do
+  context SequelUserWithFalseValidation do
+    let!(:klass) { SequelUserWithFalseValidation }
+    it_should_behave_like "a transfer johnny hollow"
+  end
+  context ActiveRecordUserWithFalseValidation do
+    let!(:klass) { ActiveRecordUserWithFalseValidation }
+    it_should_behave_like "a transfer johnny hollow"
+  end
+  context MongoidUserWithFalseValidation do
+    let!(:klass) { MongoidUserWithFalseValidation }
+    it_should_behave_like "a transfer johnny hollow"
+  end
+end
+
+shared_examples "a not transfer with false validation" do
+  let!(:user) { Fabricate :johnny_hollow }
+
+  context SequelUserWithFalseValidation do
+    let!(:klass) { SequelUserWithFalseValidation }
+    it_should_behave_like "a not transfer johnny hollow"
+  end
+  context ActiveRecordUserWithFalseValidation do
+    let!(:klass) { ActiveRecordUserWithFalseValidation }
+    it_should_behave_like "a not transfer johnny hollow"
+  end
+  context MongoidUserWithFalseValidation do
+    let!(:klass) { MongoidUserWithFalseValidation }
+    it_should_behave_like "a not transfer johnny hollow"
+  end
+end
+
+shared_context "stub klass model" do
+  let!(:model) { klass.new }
+  before do
+    stub(klass).new { model }
+  end
+end

data/spec/support/source.rb

@@ -0,0 +1,26 @@
+require 'sequel'
+
+Sequel.extension :migration
+
+SOURCE_DB = Sequel.sqlite
+
+class SourceUserMigration < Sequel::Migration
+  def up
+    create_table! :source_users, :force => true do
+      primary_key :id
+      String :fname
+      String :lname
+    end
+  end
+  def down
+    drop_table :source_users
+  end
+end
+
+
+class SourceUser < Sequel::Model
+end
+
+
+SourceUserMigration.apply SOURCE_DB, :up
+SourceUser.db = SOURCE_DB

data/spec/transfer/config_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+
+module Transfer
+  describe Config do
+    subject { Config.new options }
+
+    describe "#process_options" do
+      context "by default" do
+        let!(:options) { {} }
+        its(:process_options) { should == { :validate => true, :failure_strategy => :ignore } }
+      end
+      context "set options" do
+        let!(:options) { { :validate => false, :failure_strategy => :rollback, :failure => lambda{} } }
+        its(:process_options) { should == options }
+      end
+    end
+
+    describe "#connection_options" do
+      context "by default" do
+        let!(:options) { {} }
+        its(:connection_options) { should be_empty }
+      end
+      context "set options" do
+        let!(:options) { { :adapter => "sqlite", :host => "localhost" } }
+        its(:connection_options) { should == options }
+      end
+    end
+
+    describe "#connection" do
+      let!(:options) { { :adapter => "sqlite", :host => "localhost" } }
+      before do
+        stub(Sequel).connect(options) { :bingo }
+      end
+      its(:connection) { should be :bingo }
+    end
+
+    describe "added new options" do
+      let!(:options) { {} }
+
+      describe "#validate" do
+        before do
+          subject.validate = false
+        end
+        its(:validate) { should be_false }
+        its(:process_options) { should include(:validate => false) }
+        its(:connection_options) { should_not include(:validate) }
+      end
+
+      describe "#failure_strategy" do
+        before do
+          subject.failure_strategy = :rollback
+        end
+        its(:failure_strategy) { should == :rollback }
+        its(:process_options) { should include(:failure_strategy => :rollback) }
+        its(:connection_options) { should_not include(:failure_strategy) }
+      end
+
+      describe "#failure" do
+        context "with block" do
+          before do
+            subject.failure {}
+          end
+          its(:failure) { should be_instance_of Proc }
+          its(:process_options) { should include(:failure) }
+          its(:connection_options) { should_not include(:failure) }
+        end
+      end
+
+      describe "#before" do
+        before do
+          subject.before {}
+        end
+        its(:before) { should be_instance_of Proc }
+        its(:process_options) { should include(:before) }
+        its(:connection_options) { should_not include(:before) }
+      end
+
+      describe "#after" do
+        before do
+          subject.after {}
+        end
+        its(:after) { should be_instance_of Proc }
+        its(:process_options) { should include(:after) }
+        its(:connection_options) { should_not include(:after) }
+      end
+
+      describe "#success" do
+        before do
+          subject.success {}
+        end
+        its(:success) { should be_instance_of Proc }
+        its(:process_options) { should include(:success) }
+        its(:connection_options) { should_not include(:success) }
+      end
+
+      describe "#other=" do
+        before do
+          subject.host = "localhost"
+        end
+        its(:host) { should == "localhost" }
+        its(:connection_options) { should include(:host => "localhost") }
+        its(:process_options) { should_not include(:host) }
+      end
+
+      describe "#other &block" do
+        before do
+          subject.host {}
+        end
+        its(:host) { should be_instance_of Proc }
+        its(:connection_options) { should include(:host) }
+        its(:process_options) { should_not include(:host) }
+      end
+    end
+  end
+end

data/spec/transfer/generators/active_record_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+
+module Transfer
+  module Generators
+    describe ActiveRecord do
+      it_should_behave_like "a generator" do
+        let!(:generator) { ActiveRecord }
+        let!(:klass) { ActiveRecordUser }
+      end
+    end
+  end
+end

data/spec/transfer/generators/mongoid_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+
+module Transfer
+  module Generators
+    describe Mongoid do
+      it_should_behave_like "a generator" do
+        let!(:generator) { Mongoid }
+        let!(:klass) { MongoidUser }
+      end
+    end
+  end
+end

data/spec/transfer/generators/sequel_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+
+module Transfer
+  module Generators
+    describe Sequel do
+      it_should_behave_like "a generator" do
+        let!(:generator) { Sequel }
+        let!(:klass) { SequelUser }
+      end
+    end
+  end
+end

data/spec/transfer/transferer_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+
+module Transfer
+  describe Transferer do
+    let!(:dataset) { SOURCE_DB[:source_users] }
+
+    describe "#columns" do
+      def do_action klass, &block
+        Transferer.new(dataset, klass, &block).columns.keys
+      end
+
+      [SequelUser, ActiveRecordUser, MongoidUser].each do |klass|
+        context klass do
+          it "with block" do
+            do_action(klass) do
+              first_name :fname
+              last_name  :lname
+            end.should == [:id, :first_name, :last_name]
+          end
+
+          it "raise error if column not exists in source" do
+            expect{ do_action(klass) { first_name :undefined } }.to raise_error(ArgumentError, "source column #undefined not exists!")
+          end
+
+          it "raise error if column not exists in destination class" do
+            expect{ do_action(klass) { undefined :fname } }.to raise_error(ArgumentError, "method #undefined in class #{klass} is not defined!")
+          end
+
+          it "filter columns with #except" do
+            do_action(klass) do
+              except :id
+            end.should == []
+          end
+
+          it "filter columns with #only" do
+            do_action(klass) do
+              first_name :fname
+              last_name  :lname
+              only :last_name
+            end.should == [:last_name]
+        end
+        end
+      end
+    end
+
+    describe "#generator" do
+      subject { Transferer.new(dataset, @klass).generator }
+
+      it Generators::Sequel do
+        @klass = SequelUser
+        should be_instance_of Generators::Sequel
+      end
+      it Generators::ActiveRecord do
+        @klass = ActiveRecordUser
+        should be_instance_of Generators::ActiveRecord
+      end
+      it Generators::Mongoid do
+        @klass = MongoidUser
+        should be_instance_of Generators::Mongoid
+      end
+    end
+
+    describe "#callbacks" do
+      subject do
+        Transferer.new dataset, klass do
+          before_save do;end
+          after_save do;end
+        end
+      end
+
+      [SequelUser, ActiveRecordUser, MongoidUser].each do |klass|
+        context klass do
+          let!(:klass) { klass }
+          its(:callbacks) { should be_include :before_save }
+          its(:callbacks) { should be_include :after_save }
+        end
+      end
+    end
+
+    describe "#process" do
+      def do_action o=options, &block
+        Transferer.new(dataset, klass, &block).process(o)
+      end
+
+      context "with empty options" do
+        let!(:options) { {} }
+        it_should_behave_like "a transfer"
+      end
+
+      context "with options :validate => true" do
+        let!(:options) { {:validate => true} }
+        it_should_behave_like "a transfer"
+      end
+
+      context "with options :validate => false" do
+        let!(:options) { {:validate => false} }
+        it_should_behave_like "a transfer with false validation"
+      end
+
+      context "if model#save throws an exception" do
+        let!(:olivia) { Fabricate :olivia_lufkin }
+        before do
+          stub.proxy(klass).new do |model|
+            save_failure(model) if model.id == olivia.id
+            model
+          end
+        end
+
+        context "with options :failure_strategy => :ignore" do
+          let!(:options) { {:failure_strategy => :ignore} }
+          it_should_behave_like "a transfer"
+        end
+        context "with options :failure_strategy => :rollback" do
+          let!(:options) { {:failure_strategy => :rollback} }
+          it_should_behave_like "a not transfer"
+        end
+      end
+
+    end
+
+  end
+end

data/spec/transfer_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+
+describe Transfer do
+  subject { Transfer }
+
+  it { should respond_to :configs }
+  it { should respond_to :configure }
+
+  before do
+    Transfer.configs.clear
+  end
+
+  describe ".configs" do
+    subject { Transfer.configs }
+
+    it { should be_instance_of Hash }
+    it "raise error if key not exists" do
+      expect{ subject[:anything] }.to raise_error
+    end
+  end
+
+  describe ".configure" do
+    context ":default" do
+      subject { Transfer.configs[:default] }
+      before do
+        Transfer.configure {|c| c.host = "default"}
+      end
+
+      it { should be_instance_of Transfer::Config }
+      its(:host) { should == "default" }
+    end
+
+    context ":named" do
+      subject { Transfer.configs[:named] }
+      before do
+        Transfer.configure(:named) {|c| c.host = "named" }
+      end
+
+      it { should be_instance_of Transfer::Config }
+      its(:host) { should == "named" }
+    end
+  end
+
+  describe "transfer" do
+    def do_action &block
+      transfer :source_users => klass, &block
+    end
+
+    before do
+      instance_of(Transfer::Config).connection { SOURCE_DB }
+    end
+
+    context "with empty" do
+      before do
+        Transfer.configure
+      end
+      it_should_behave_like "a transfer"
+    end
+
+    context "with :validate => false" do
+      before do
+        Transfer.configure do |config|
+          config.validate = false
+        end
+      end
+      it_should_behave_like "a transfer with false validation"
+    end
+
+    context "olivia_lufkin and johnny_hollow" do
+      let!(:olivia) { Fabricate :olivia_lufkin }
+      before do
+        Transfer.configure do |config|
+          config.failure_strategy = failure_strategy
+        end
+      end
+
+      context "while olivia#save throws an exception" do
+        before do
+          stub.proxy(klass).new do |model|
+            save_failure(model) if model.id == olivia.id
+            model
+          end
+        end
+
+        context "with Transfer.failure_strategy = :ignore" do
+          let!(:failure_strategy) { :ignore }
+          it_should_behave_like "a transfer"
+        end
+        context "with Transfer.failure_strategy = :rollback" do
+          let!(:failure_strategy) { :rollback }
+          it_should_behave_like "a not transfer"
+        end
+      end
+    end
+
+    context "with callbacks" do
+      include_context "stub klass model"
+      let!(:user) { Fabricate :johnny_hollow }
+      before do
+        @config = Transfer.configure do |c|
+          c.before {}
+          c.success {}
+          c.failure {}
+          c.after {}
+        end
+        @dataset = @config.connection[:source_users]
+      end
+
+      [SequelUser, ActiveRecordUser, MongoidUser].each do |klass|
+        context klass do
+          let!(:klass) { klass }
+          it "should call before" do
+            stub(@config.before).call(klass, @dataset).once
+            do_action
+          end
+          it "should call after" do
+            stub(@config.after).call(klass, @dataset).once
+            do_action
+          end
+          it "should call success" do
+            stub(@config.success).call(model, user.values).once
+            do_action
+          end
+          it "should not call failure" do
+            stub(@config.failure).call.never
+            do_action
+          end
+          context "if save failure" do
+            let!(:exception) { RuntimeError.new }
+            before do
+              save_failure klass
+              stub(RuntimeError).new { exception }
+            end
+            it "should call before" do
+              stub(@config.before).call(klass, @dataset).once
+              do_action
+            end
+            it "should call after" do
+              stub(@config.after).call(klass, @dataset).once
+              do_action
+            end
+            it "should not call success" do
+              stub(@config.success).call.never
+              do_action
+            end
+            it "should call failure" do
+              stub(@config.failure).call(model, user.values, exception).once
+              do_action
+            end
+          end
+        end
+      end
+    end
+
+    describe "override global options" do
+      before do
+        Transfer.configure do |c|
+          c.validate = true
+          c.failure_strategy = :ignore
+        end
+      end
+
+      [SequelUser, ActiveRecordUser, MongoidUser].each do |klass|
+        it "for #{klass}" do
+          instance_of(Transfer::Transferer).process(:validate => false, :failure_strategy => :rollback).once
+          transfer :source_users => klass, :validate => false, :failure_strategy => :rollback
+        end
+      end
+    end
+
+  end
+
+end