data-import 0.0.1

data/spec/data-import/database_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe DataImport::Database do
+
+  subject { DataImport::Database }
+
+  class TestAdapter
+  end
+
+  describe ".connect" do
+    it "returns a connection object from the correct adapter" do
+      subject.stub(:find_adapter).and_return { TestAdapter }
+      TestAdapter.should_receive(:connect)
+      subject.connect(:sequel)
+    end
+  end
+
+  describe ".find_adapter" do
+    it "returns nil if the adapter is not supported" do
+      subject.send(:find_adapter, :abc).should be_nil
+    end
+  end
+
+end

data/spec/data-import/definition/simple_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe DataImport::Definition::Simple do
+
+  subject { DataImport::Definition::Simple.new('a', :source, :target) }
+
+  describe "#mappings" do
+    it "returns an empty hash by default" do
+      subject.mappings.should be_empty
+    end
+  end
+
+  describe "#add_id_mapping" do
+    it "adds a primary key mapping to the definition" do
+      subject.add_id_mapping 18 => 24
+      subject.id_mappings[18].should == 24
+    end
+  end
+
+  describe "#new_id_of" do
+    it "looks for the new id in the id mappings" do
+      subject.add_id_mapping 39 => 834
+      subject.new_id_of(39).should == 834
+    end
+  end
+
+  describe "#definition" do
+    it "returns the definition of the importer if nothing is passed" do
+      subject.definition.should == subject
+    end
+
+    it "looks for the definition in the registered definition list if a name is passed" do
+      DataImport.stub(:definitions).and_return { {'abc' => :def} }
+      subject.definition('abc').should == :def
+    end
+
+    it "raises an error if no definition was found" do
+      DataImport.stub(:definitions).and_return { {} }
+      lambda { subject.definition('abc') }.should raise_error
+    end
+  end
+
+  describe '#run' do
+
+    let(:source_db) { mock }
+    let(:target_db) { mock }
+    let(:source_columns) { [:name, :location, :location2] }
+    let(:source_distinct_columns) { [:name, :location] }
+
+    subject do
+      definition = DataImport::Definition::Simple.new('Houses', source_db, target_db)
+      definition.source_table_name = 'tblHouses'
+      definition.source_columns = source_columns
+      definition.source_distinct_columns = source_distinct_columns
+      definition
+    end
+
+    it 'executes the definition and displays the progress' do
+      source_db.should_receive(:count).with('tblHouses',
+                                            :columns => source_columns,
+                                            :distinct => source_distinct_columns).and_return(125)
+      Progress.should_receive(:start).with('Importing Houses', 125).and_yield
+      importer = mock
+      DataImport::Importer.should_receive(:new).with('CONTEXT', subject).and_return(importer)
+      importer.should_receive(:run)
+
+      subject.run('CONTEXT')
+    end
+  end
+
+end

data/spec/data-import/definition_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe DataImport::Definition do
+
+  subject { DataImport::Definition.new('a', :source, :target) }
+
+  describe "#dependencies" do
+    it "can have dependent definitions which must run before" do
+      subject.add_dependency 'b'
+      subject.add_dependency 'c'
+      subject.dependencies.should == ['b', 'c']
+    end
+  end
+end

data/spec/data-import/dsl/import/from_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe DataImport::Dsl::Import::From do
+
+  let(:definition) { DataImport::Definition::Simple.new('d', :source, :target) }
+  subject { DataImport::Dsl::Import::From.new(definition) }
+
+  describe "#table" do
+    it "saves the source table name to the definition" do
+      subject.table 'source_table'
+      definition.source_table_name.should == 'source_table'
+    end
+  end
+
+  describe "#primary_key" do
+    it "saves the primary key to the definition" do
+      subject.primary_key 'my_key'
+      definition.source_primary_key.should == :my_key
+    end
+  end
+
+  describe "#columns" do
+    it "saves the columns to the definition" do
+      subject.columns 'col1', 'col2'
+      definition.source_columns.should include('col1')
+      definition.source_columns.should include('col2')
+    end
+
+    it "sets the distinct flag" do
+      subject.columns 'col1', :distinct => true
+      definition.source_distinct_columns.should be_true
+    end
+  end
+
+  describe "#order" do
+    it "saves the order columns to the definition" do
+      subject.order 'col1', 'col2'
+      definition.source_order_columns.should include('col1')
+      definition.source_order_columns.should include('col2')
+    end
+  end
+
+end

data/spec/data-import/dsl/import_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe DataImport::Dsl::Import do
+
+  let(:definition) { DataImport::Definition::Simple.new('d', :source, :target) }
+  subject { DataImport::Dsl::Import.new(definition) }
+
+  describe "#from" do
+    it "saves the source table name to the definition" do
+      subject.from 'source_table'
+      definition.source_table_name.should == 'source_table'
+    end
+
+    it "saves the primary key" do
+      subject.from 'source_table', :primary_key => 'my_key'
+      definition.source_primary_key.should == :my_key
+    end
+
+    let(:block) { lambda{} }
+    it "executes the passed block" do
+      DataImport::Dsl::Import::From.any_instance.should_receive(:instance_eval).with(&block)
+      subject.from &block
+    end
+  end
+
+  describe "#to" do
+    it "saves the target table name to the definition" do
+      subject.to 'target_table'
+      definition.target_table_name.should == 'target_table'
+    end
+
+    it 'accepts a :mode option' do
+      subject.to 'target_table', :mode => :update
+      definition.mode.should == :update
+    end
+  end
+
+  describe "#dependencies" do
+    it "sets the list of definitions it depends on" do
+      subject.dependencies 'a', 'b'
+      definition.dependencies.should == ['a', 'b']
+    end
+
+    it "can be called multiple times" do
+      subject.dependencies 'a', 'b'
+      subject.dependencies 'x'
+      subject.dependencies 'y'
+      definition.dependencies.should == ['a', 'b', 'x', 'y']
+    end
+  end
+
+  describe "#mapping" do
+    it "adds a column mapping to the definition" do
+      subject.mapping :a => :b
+      definition.mappings.should include(:a)
+      definition.mappings[:a].should == :b
+    end
+
+    let(:block) { lambda{|value|} }
+    it "adds a proc to the mappings" do
+      subject.mapping :a, &block
+      definition.mappings.should include(:a)
+      definition.mappings[:a].should == block
+    end
+
+    it "adds a proc with multiple fields to the mappings" do
+      subject.mapping :a, :b, &block
+      definition.mappings.should include([:a, :b])
+      definition.mappings[[:a, :b]].should == block
+    end
+  end
+
+  describe "#after" do
+    let(:block) { lambda{} }
+    it "adds a proc to be executed after the import" do
+      subject.after &block
+      definition.after_blocks.should include(block)
+    end
+  end
+
+  it "#after_row adds a block, which is executed after every row" do
+    my_block = lambda {}
+    subject.after_row &my_block
+    definition.after_row_blocks == [my_block]
+  end
+
+end

data/spec/data-import/dsl_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe DataImport::Dsl do
+
+  let(:plan) { stub }
+
+  context "class methods" do
+    subject { DataImport::Dsl }
+
+    describe ".evaluate_import_config" do
+      it "executes the content of the config in a new DSL context" do
+        File.stub(:read).and_return do
+          <<-RUBY
+          source :sequel, 'sqlite:/'
+          target :sequel, 'sqlite:/'
+          RUBY
+        end
+        DataImport::ExecutionPlan.should_receive(:new).and_return(plan)
+        result = subject.evaluate_import_config('my_file')
+        result.should == plan
+      end
+    end
+  end
+
+  context "instance methods" do
+    subject { DataImport::Dsl.new(plan) }
+
+    describe "#source" do
+      it "creates a connection to the database" do
+        DataImport::Database.should_receive(:connect).with(:options)
+        subject.source :options
+      end
+
+      let(:source) { Object.new }
+      it "sets the source" do
+        DataImport::Database.stub(:connect).and_return { source }
+        subject.source :options
+        subject.source_database.should == source
+      end
+    end
+
+    describe "#target" do
+      it "creates a connection to the database" do
+        DataImport::Database.should_receive(:connect).with(:options)
+        subject.target :options
+      end
+
+      let(:target) { Object.new }
+      it "sets the target" do
+        DataImport::Database.stub(:connect).and_return { target }
+        subject.target :options
+        subject.target_database.should == target
+      end
+    end
+
+    describe "#import" do
+      it "adds a new import config to the import" do
+        definition = stub
+        DataImport::Definition::Simple.should_receive(:new).with('Import 5', nil, nil).and_return(definition)
+        plan.should_receive(:add_definition).with(definition)
+        subject.import 'Import 5'
+      end
+
+      it "sets the source and target database in the definition" do
+        subject.stub(:source_database).and_return { :source }
+        subject.stub(:target_database).and_return { :target }
+
+        definition = stub
+        DataImport::Definition::Simple.should_receive(:new).with('a', :source, :target).and_return(definition)
+        plan.should_receive(:add_definition).with(definition)
+
+        subject.import 'a'
+      end
+
+      it "executes the block in an import conext" do
+        my_block = lambda {}
+        import_dsl = stub
+        definition = stub
+        DataImport::Definition::Simple.should_receive(:new).with(any_args).and_return(definition)
+        plan.should_receive(:add_definition).with(definition)
+        DataImport::Dsl::Import.should_receive(:new).with(definition).and_return(import_dsl)
+
+        import_dsl.should_receive(:instance_eval).with(&my_block)
+        subject.import 'name', &my_block
+      end
+    end
+
+    describe "#before_block" do
+      it 'adds the before block to the execution plan' do
+        my_filter = lambda {}
+        plan = DataImport::Dsl.define do
+          before_filter &my_filter
+        end
+        plan.before_filter.should == my_filter
+      end
+    end
+  end
+
+end

data/spec/data-import/execution_plan_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe DataImport::ExecutionPlan do
+
+  let(:people) { DataImport::Definition.new('People', :tblPerson, :people) }
+  let(:houses) { DataImport::Definition.new('House', :tblHouse, :houses) }
+
+  it 'kann mit einem Set von Definitions erstellt werden' do
+    plan = DataImport::ExecutionPlan.new([people, houses])
+    plan.definitions.should == [people, houses]
+  end
+
+  it 'beschreibt den Ablauf anhand von definitions' do
+    subject.add_definition(people)
+    subject.add_definition(houses)
+    subject.definitions.should == [people, houses]
+  end
+
+  it 'kann einen before_filter enthalten' do
+    my_filter = lambda {}
+    subject.before_filter = my_filter
+    subject.before_filter.should == my_filter
+  end
+
+end

data/spec/data-import/importer_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe DataImport::Importer do
+
+  let(:source) { stub }
+  let(:target) { stub }
+  let(:other_definition) { DataImport::Definition::Simple.new 'C', source, target }
+  let(:definition) { DataImport::Definition::Simple.new 'A', source, target }
+  let(:context) { stub(:before_filter => nil) }
+  before { context.stub(:definition).with('C').and_return(other_definition) }
+  subject { DataImport::Importer.new(context, definition) }
+
+  describe "#run" do
+    it "runs the import in a transaction" do
+      definition.target_database.should_receive(:transaction)
+      subject.run
+    end
+
+    it "call #import_row for each row" do
+      definition.target_database.stub(:transaction).and_yield
+      definition.source_database.stub(:each_row).and_yield(:a => :b).and_yield(:c => :d)
+
+      subject.should_receive(:import_row).with(:a => :b)
+      subject.should_receive(:import_row).with(:c => :d)
+      subject.run
+    end
+
+    it 'uses the before_filter to modify the row before importing it' do
+      context.stub(:before_filter => lambda do |row|
+                     row['a'] = row['a'].upcase
+                   end)
+      definition.target_database.stub(:transaction).and_yield
+      definition.source_database.stub(:each_row).and_yield('a' => 'b').and_yield('a' => 'c')
+
+      subject.should_receive(:import_row).with('a' => 'B')
+      subject.should_receive(:import_row).with('a' => 'C')
+      subject.run
+    end
+
+    context 'after blocks' do
+      before do
+        definition.target_database.stub(:transaction).and_yield
+        definition.source_database.stub(:each_row)
+      end
+
+      it "run after the data import" do
+        executed = false
+        definition.after_blocks << Proc.new do
+          executed = true
+        end
+
+        subject.run
+        executed.should == true
+      end
+
+      it "have access to other definitions" do
+        found_definition = nil
+        definition.after_blocks << Proc.new do |context|
+          found_definition = context.definition('C')
+        end
+
+        subject.run
+        found_definition.should == other_definition
+      end
+
+      it 'have access to the definition instance' do
+        found_name = nil
+        definition.after_blocks << Proc.new do
+          found_name = name
+        end
+
+        subject.run
+        found_name.should == 'A'
+      end
+    end
+  end
+
+  context 'after row blocks' do
+    it "run after the data import" do
+      input_rows = []
+      output_rows = []
+      definition.after_row_blocks << Proc.new do |context, input_row, output_row|
+        input_rows << input_row
+        output_rows << output_row
+      end
+
+      definition.stub(:mappings).and_return { {:id => :new_id} }
+      definition.target_database.should_receive(:insert_row).any_number_of_times
+      subject.send(:import_row, :id => 1)
+      subject.send(:import_row, :id => 2)
+
+      input_rows.should == [{:id => 1}, {:id => 2}]
+      output_rows.should == [{:new_id => 1}, {:new_id => 2}]
+    end
+  end
+
+  describe "#import_row" do
+    it "executes the insertion" do
+      definition.stub(:mappings).and_return { {:id => :id} }
+      definition.stub(:target_table_name).and_return { :table }
+      definition.target_database.should_receive(:insert_row).with(:table, :id => 1)
+      subject.send(:import_row, :id => 1)
+    end
+
+    it "replaces the keys that occur in the field mapping" do
+      definition.stub(:mappings).and_return { {:personenid => :id} }
+      definition.stub(:target_table_name).and_return { :table }
+      definition.target_database.should_receive(:insert_row).with(:table, :id => 1)
+      subject.send(:import_row, :personenid => 1)
+    end
+
+    it "calls the proc if one is specified in the field mapping" do
+      definition.stub(:mappings).and_return { {:personenid => lambda{|context, value| {:id => 2}}} }
+      definition.stub(:target_table_name).and_return { :table }
+      definition.target_database.should_receive(:insert_row).with(:table, :id => 2)
+      subject.send(:import_row, :personenid => 1)
+    end
+
+    it "ignores the return value of the proc when it is nil" do
+      definition.stub(:mappings).and_return { {:personenid => lambda{|context, value| nil }} }
+      definition.stub(:target_table_name).and_return { :table }
+      definition.target_database.should_receive(:insert_row).with(:table, {})
+      subject.send(:import_row, :personenid => 1)
+    end
+
+    it "calls the proc for multiple columns" do
+      definition.stub(:mappings).and_return { {[:a, :b] => lambda{|context, a_value, b_value| {:id => 2}}} }
+      definition.stub(:target_table_name).and_return { :table }
+      definition.target_database.should_receive(:insert_row).with(:table, :id => 2)
+      subject.send(:import_row, :a => 4, :b => 9)
+    end
+
+    it "adds the generated id to the id mapping of the definition" do
+      definition.target_database.stub(:insert_row).and_return { 15 }
+      definition.stub(:source_primary_key).and_return { :id }
+      definition.should_receive(:add_id_mapping).with(1 => 15)
+      subject.send(:import_row, :id => 1)
+    end
+
+    it 'calls update_row for definitions with a mode uf :update' do
+      definition.stub(:mappings).and_return { {:id => :id} }
+      definition.target_table_name = 'target_table'
+      definition.use_mode(:update)
+      definition.target_database.should_receive(:update_row).with('target_table', {:id => 1})
+
+      subject.send(:import_row, :id => 1)
+    end
+  end
+
+end