drudgery 0.1.0 → 0.2.0

data/spec/drudgery/loaders/active_record_import_loader_spec.rb

@@ -1,67 +1,43 @@
 require 'spec_helper'
-require 'active_record'
-require 'activerecord-import'
 
-describe Drudgery::Loaders::ActiveRecordImportLoader do
-  class Record < ActiveRecord::Base; end
+class Record < ActiveRecord::Base; end
 
-  def mock_model
-    stub('model', :name => 'Record')
-  end
-
-  describe '#initialize' do
-    it 'sets model to provided argument' do
-      model = mock_model
-
-      loader = Drudgery::Loaders::ActiveRecordImportLoader.new(model)
-      loader.instance_variable_get('@model').must_equal model
-    end
-
-    it 'sets name to active_record_import:<model name>' do
-      loader = Drudgery::Loaders::ActiveRecordImportLoader.new(mock_model)
-      loader.name.must_equal 'active_record_import:Record'
-    end
-  end
-
-  describe '#load' do
-    it 'write records using model.import' do
-      record1 = { :a => 1, :b => 2 }
-      record2 = { :a => 3, :b => 4 }
+module Drudgery
+  module Loaders
+    describe ActiveRecordImportLoader do
+      before do
+        ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+        ActiveRecord::Base.connection.create_table(:records) do |t|
+          t.integer :a
+          t.integer :b
+        end
 
-      model = mock_model
-      model.expects(:import).with([:a, :b], [[1, 2], [3, 4]], :validate => false)
-
-      loader = Drudgery::Loaders::ActiveRecordImportLoader.new(model)
-      loader.load([record1, record2])
-    end
-  end
+        @loader = ActiveRecordImportLoader.new(Record)
+      end
 
-  describe 'without stubs' do
-    before(:each) do
-      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-      ActiveRecord::Base.connection.create_table(:records) do |t|
-        t.integer :a
-        t.integer :b
+      after do
+        ActiveRecord::Base.clear_active_connections!
       end
-    end
 
-    after(:each) do
-      ActiveRecord::Base.clear_active_connections!
-    end
+      describe '#name' do
+        it 'returns active_record_import:<model name>' do
+          @loader.name.must_equal 'active_record_import:Record'
+        end
+      end
 
-    describe '#load' do
-      it 'writes records using model.import' do
-        record1 = { :a => 1, :b => 2 }
-        record2 = { :a => 3, :b => 4 }
+      describe '#load' do
+        it 'writes records using model.import' do
+          record1 = { :a => 1, :b => 2 }
+          record2 = { :a => 3, :b => 4 }
 
-        loader = Drudgery::Loaders::ActiveRecordImportLoader.new(Record)
-        loader.load([record1, record2])
+          @loader.load([record1, record2])
 
-        records = Record.all.map(&:attributes)
-        records.must_equal([
-          { 'id' => 1, 'a' => 1, 'b' => 2 },
-          { 'id' => 2, 'a' => 3, 'b' => 4 }
-        ])
+          records = Record.all.map(&:attributes)
+          records.must_equal([
+            { 'id' => 1, 'a' => 1, 'b' => 2 },
+            { 'id' => 2, 'a' => 3, 'b' => 4 }
+          ])
+        end
       end
     end
   end

data/spec/drudgery/loaders/active_record_loader_spec.rb

@@ -1,73 +1,43 @@
 require 'spec_helper'
-require 'active_record'
 
-describe Drudgery::Loaders::ActiveRecordLoader do
-  class Record < ActiveRecord::Base; end
+class Record < ActiveRecord::Base; end
 
-  def mock_model
-    stub('model', :name => 'Record')
-  end
-
-  describe '#initialize' do
-    it 'sets model to provided argument' do
-      model = mock_model
-
-      loader = Drudgery::Loaders::ActiveRecordLoader.new(model)
-      loader.instance_variable_get('@model').must_equal model
-    end
-
-    it 'sets name to active_record:<model name>' do
-      loader = Drudgery::Loaders::ActiveRecordLoader.new(mock_model)
-      loader.name.must_equal 'active_record:Record'
-    end
-  end
-
-  describe '#load' do
-    it 'write records using model.create' do
-      record1 = { :a => 1 }
-      record2 = { :a => 2 }
-
-      obj1 = mock('obj1')
-      obj2 = mock('obj2')
+module Drudgery
+  module Loaders
+    describe ActiveRecordLoader do
+      before do
+        ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+        ActiveRecord::Base.connection.create_table(:records) do |t|
+          t.integer :a
+          t.integer :b
+        end
 
-      model = mock_model
-      model.expects(:new).with(record1).returns(obj1)
-      model.expects(:new).with(record2).returns(obj2)
-
-      obj1.expects(:save).with(:validate => false)
-      obj2.expects(:save).with(:validate => false)
-
-      loader = Drudgery::Loaders::ActiveRecordLoader.new(model)
-      loader.load([record1, record2])
-    end
-  end
+        @loader = ActiveRecordLoader.new(Record)
+      end
 
-  describe 'without stubs' do
-    before(:each) do
-      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-      ActiveRecord::Base.connection.create_table(:records) do |t|
-        t.integer :a
-        t.integer :b
+      after do
+        ActiveRecord::Base.clear_active_connections!
       end
-    end
 
-    after(:each) do
-      ActiveRecord::Base.clear_active_connections!
-    end
+      describe '#name' do
+        it 'returns active_record:<model name>' do
+          @loader.name.must_equal 'active_record:Record'
+        end
+      end
 
-    describe '#load' do
-      it 'writes records using model.create' do
-        record1 = { :a => 1, :b => 2 }
-        record2 = { :a => 3, :b => 4 }
+      describe '#load' do
+        it 'writes records using model.create' do
+          record1 = { :a => 1, :b => 2 }
+          record2 = { :a => 3, :b => 4 }
 
-        loader = Drudgery::Loaders::ActiveRecordLoader.new(Record)
-        loader.load([record1, record2])
+          @loader.load([record1, record2])
 
-        records = Record.all.map(&:attributes)
-        records.must_equal([
-          { 'id' => 1, 'a' => 1, 'b' => 2 },
-          { 'id' => 2, 'a' => 3, 'b' => 4 }
-        ])
+          records = Record.all.map(&:attributes)
+          records.must_equal([
+            { 'id' => 1, 'a' => 1, 'b' => 2 },
+            { 'id' => 2, 'a' => 3, 'b' => 4 }
+          ])
+        end
       end
     end
   end

data/spec/drudgery/loaders/csv_loader_spec.rb

@@ -1,78 +1,67 @@
 require 'spec_helper'
 
-describe Drudgery::Loaders::CSVLoader do
-  describe '#initialize' do
-    it 'sets filepath to provided filepath' do
-      loader = Drudgery::Loaders::CSVLoader.new('file.csv')
-      loader.instance_variable_get('@filepath').must_equal 'file.csv'
-    end
-
-    it 'initializes write_headers boolean' do
-      loader = Drudgery::Loaders::CSVLoader.new('file.csv')
-      loader.instance_variable_get('@write_headers').must_equal true
-    end
-
-    it 'sets options to provided options' do
-      options = { :col_sep => '|' }
-
-      loader = Drudgery::Loaders::CSVLoader.new('file.csv', options)
-      loader.instance_variable_get('@options').must_equal({ :col_sep => '|' })
-    end
-
-    it 'sets name to csv:<file base name>' do
-      loader = Drudgery::Loaders::CSVLoader.new('tmp/file.csv')
-      loader.name.must_equal 'csv:file.csv'
-    end
-  end
-
-  describe '#load' do
-    it 'opens CSV file to append records' do
-      CSV.expects(:open).with('file.csv', 'a', :col_sep => '|')
-
-      loader = Drudgery::Loaders::CSVLoader.new('file.csv', :col_sep => '|')
-      loader.load([{}])
-    end
-
-    it 'writes hash keys as header and records as rows' do
-      record1 = { :a => 1, :b => 2 }
-      record2 = { :a => 3, :b => 4 }
-      record3 = { :a => 5, :b => 6 }
-
-      csv = mock('csv')
-      csv.expects(:<<).with([:a, :b])
-      csv.expects(:<<).with([1, 2])
-      csv.expects(:<<).with([3, 4])
-      csv.expects(:<<).with([5, 6])
-
-      CSV.expects(:open).with('file.csv', 'a', {}).yields(csv).times(2)
-
-      loader = Drudgery::Loaders::CSVLoader.new('file.csv')
-      loader.load([record1, record2])
-      loader.load([record3])
-    end
-  end
-
-  describe 'without stubs' do
-    before(:each) do
-      File.delete('file.csv') if File.exists?('file.csv')
-    end
-
-    after(:each) do
-      File.delete('file.csv') if File.exists?('file.csv')
-    end
+module Drudgery
+  module Loaders
+    describe CSVLoader do
+      describe '#name' do
+        it 'returns csv:<file base name>' do
+          loader = CSVLoader.new('tmp/people.csv')
+          loader.name.must_equal 'csv:people.csv'
+        end
+      end
 
-    describe '#load' do
-      it 'writes hash keys as header and records as rows' do
-        record1 = { :a => 1, :b => 2 }
-        record2 = { :a => 3, :b => 4 }
-        record3 = { :a => 5, :b => 6 }
+      describe '#col_sep' do
+        it 'returns col_sep option' do
+          loader = CSVLoader.new('tmp/people.csv', :col_sep => '|')
+          loader.col_sep.must_equal '|'
+        end
+      end
 
-        loader = Drudgery::Loaders::CSVLoader.new('file.csv')
-        loader.load([record1, record2])
-        loader.load([record3])
+      describe '#col_sep=' do
+        it 'sets col_sep to provided character' do
+          loader = CSVLoader.new('tmp/people.csv')
+          loader.col_sep = '|'
+          loader.col_sep.must_equal '|'
+        end
+      end
 
-        records = File.readlines('file.csv').map { |line| line.strip.split(',') }
-        records.must_equal [%w[a b], %w[1 2], %w[3 4], %w[5 6]]
+      describe '#load' do
+        before do
+          @file = 'tmp/test.csv'
+          File.delete(@file) if File.exists?(@file)
+        end
+
+        after do
+          File.delete(@file) if File.exists?(@file)
+        end
+
+        describe 'when columns separated by |' do
+          it 'writes hash keys as header and records as rows' do
+            record1 = { :a => 1, :b => 2 }
+            record2 = { :a => 3, :b => 4 }
+            record3 = { :a => 5, :b => 6 }
+
+            loader = CSVLoader.new(@file, :col_sep => '|')
+            loader.load([record1, record2])
+            loader.load([record3])
+
+            records = File.readlines(@file).map { |line| line.strip.split('|') }
+            records.must_equal [%w[a b], %w[1 2], %w[3 4], %w[5 6]]
+          end
+        end
+
+        it 'writes hash keys as header and records as rows' do
+          record1 = { :a => 1, :b => 2 }
+          record2 = { :a => 3, :b => 4 }
+          record3 = { :a => 5, :b => 6 }
+
+          loader = CSVLoader.new(@file)
+          loader.load([record1, record2])
+          loader.load([record3])
+
+          records = File.readlines(@file).map { |line| line.strip.split(',') }
+          records.must_equal [%w[a b], %w[1 2], %w[3 4], %w[5 6]]
+        end
       end
     end
   end

data/spec/drudgery/loaders/sqlite3_loader_spec.rb

@@ -1,88 +1,53 @@
 require 'spec_helper'
-require 'sqlite3'
 
-describe Drudgery::Loaders::SQLite3Loader do
-
-  def mock_db
-    stub('db', :database_list => [{ 'name' => 'main', 'file' => '' }], :results_as_hash= => nil, :type_translation= => nil)
-  end
-
-  describe '#initialize' do
-    it 'sets db to SQLite3 database using provided db name and table to provided table name' do
-      db = mock_db
-
-      loader = Drudgery::Loaders::SQLite3Loader.new(db, 'tablename')
-      loader.instance_variable_get('@db').must_equal db
-      loader.instance_variable_get('@table').must_equal 'tablename'
-    end
-
-    describe 'with in memory db' do
-      it 'sets name to sqlite3:memory:<table name>' do
-        loader = Drudgery::Loaders::SQLite3Loader.new(mock_db, 'tablename')
-        loader.name.must_equal 'sqlite3:memory.tablename'
+module Drudgery
+  module Loaders
+    describe SQLite3Loader do
+      before do
+        @db = SQLite3::Database.new(':memory:')
+        @db.execute('CREATE TABLE records (a INTEGER, b INTEGER)')
       end
-    end
-
-    describe 'with file based db' do
-      it 'sets name to sqlite3:<main db name>:<table name>' do
-        db = mock_db
-        db.expects(:database_list).returns([{ 'name' => 'main', 'file' => 'db/test.sqlite3.db' }])
 
-        loader = Drudgery::Loaders::SQLite3Loader.new(db, 'tablename')
-        loader.name.must_equal 'sqlite3:test.tablename'
+      after do
+        @db.close
       end
-    end
-  end
-
-  describe '#load' do
-    it 'writes each record in single transaction' do
-      record1 = { :a => 1, :b => 2 }
-      record2 = { :a => 3, :b => 4 }
 
-      db = mock_db
-      db.expects(:transaction).yields(db)
-      db.expects(:execute).with('INSERT INTO tablename (a, b) VALUES (?, ?)', [1, 2])
-      db.expects(:execute).with('INSERT INTO tablename (a, b) VALUES (?, ?)', [3, 4])
+      describe '#name' do
+        describe 'with file based db' do
+          it 'returns sqlite3:<main db name>:<table name>' do
+            db = SQLite3::Database.new('tmp/test.sqlite3')
 
-      loader = Drudgery::Loaders::SQLite3Loader.new(db, 'tablename')
-      loader.load([record1, record2])
-    end
-  end
-
-  describe 'without stubs' do
-    before(:each) do
-      @db = SQLite3::Database.new(':memory:')
-      @db.execute('CREATE TABLE records (a INTEGER, b INTEGER)')
-    end
+            loader = SQLite3Loader.new(db, 'people')
+            loader.name.must_equal 'sqlite3:test.people'
+          end
+        end
 
-    after(:each) do
-      @db.close
-    end
+        describe 'with in memory db' do
+          it 'returns sqlite3:memory:<table name>' do
+            loader = SQLite3Loader.new(@db, 'cities')
+            loader.name.must_equal 'sqlite3:memory.cities'
+          end
+        end
 
-    describe '#initialize' do
-      it 'sets name to sqlite3:memory:records' do
-        loader = Drudgery::Loaders::SQLite3Loader.new(@db, 'records')
-        loader.name.must_equal 'sqlite3:memory.records'
-      end
-    end
+        describe '#load' do
+          it 'writes each record in single transaction' do
+            record1 = { :a => 1, :b => 2 }
+            record2 = { :a => 3, :b => 4 }
 
-    describe '#load' do
-      it 'writes each record in single transaction' do
-        record1 = { :a => 1, :b => 2 }
-        record2 = { :a => 3, :b => 4 }
+            loader = SQLite3Loader.new(@db, 'records')
+            loader.load([record1, record2])
 
-        loader = Drudgery::Loaders::SQLite3Loader.new(@db, 'records')
-        loader.load([record1, record2])
+            results = []
+            @db.execute('SELECT * FROM records') do |result|
+              results << result
+            end
 
-        results = []
-        @db.execute('SELECT * FROM records') do |result|
-          results << result
+            results.must_equal([
+              { 'a' => 1, 'b' => 2, 0 => 1, 1 => 2 },
+              { 'a' => 3, 'b' => 4, 0 => 3, 1 => 4}
+            ])
+          end
         end
-
-        results.must_equal([
-          { 'a' => 1, 'b' => 2, 0 => 1, 1 => 2 },
-          { 'a' => 3, 'b' => 4, 0 => 3, 1 => 4}
-        ])
       end
     end
   end

data/spec/drudgery/manager_spec.rb

@@ -1,35 +1,39 @@
 require 'spec_helper'
 
-describe Drudgery::Manager do
-  before(:each) do
-    @manager = Drudgery::Manager.new
-  end
-
-  describe '#initialize' do
-    it 'initializes jobs array' do
-      @manager.instance_variable_get('@jobs').must_equal []
+module Drudgery
+  describe Manager do
+    before do
+      @manager = Manager.new
     end
-  end
 
-  describe '#prepare' do
-    it 'adds obj to jobs array' do
-      job = stub('job')
+    describe '#prepare' do
+      it 'accepts job as an argument' do
+        job = Job.new
 
-      @manager.prepare(job)
-      @manager.instance_variable_get('@jobs').must_include job
+       @manager.prepare(job)
+      end
+
+      it 'allows configuration of job via block' do
+        @manager.prepare do |job|
+          job.extract :csv, 'records.csv'
+        end
+      end
     end
-  end
 
-  describe '#run' do
-    it 'performs each job' do
-      job1 = mock('job1', :perform => nil)
-      job2 = mock('job2', :perform => nil)
-      job3 = mock('job3')
-      job3.expects(:perform).never
+    describe '#run' do
+      it 'performs each prepared job' do
+        job1 = Job.new
+        job2 = Job.new
+        job3 = Job.new
+
+        job1.expects(:perform)
+        job2.expects(:perform)
+        job3.expects(:perform).never
 
-      @manager.prepare(job1)
-      @manager.prepare(job2)
-      @manager.run
+        @manager.prepare(job1)
+        @manager.prepare(job2)
+        @manager.run
+      end
     end
   end
 end

data/spec/drudgery/transformer_spec.rb

@@ -1,57 +1,51 @@
 require 'spec_helper'
 
-describe Drudgery::Transformer do
-  before(:each) do
-    @transformer = Drudgery::Transformer.new
-  end
-
-  describe '#initialize' do
-    it 'initializes cache hash' do
-      @transformer.instance_variable_get('@cache').must_equal({})
+module Drudgery
+  describe Transformer do
+    before do
+      @transformer = Transformer.new
     end
-  end
-
-  describe '#register' do
-    it 'sets processor with provided proc' do
-      processor = Proc.new { |data, cache| data }
 
-      @transformer.register(processor)
+    describe '#register' do
+      it 'accepts processor as an argument' do
+        processor = Proc.new { |data, cache| data }
 
-      # must_equal bug with comparing procs, so use assert_equal instead
-      assert_equal @transformer.instance_variable_get('@processor'), processor
-    end
-  end
-
-  describe '#transform' do
-    it 'symbolizes data keys' do
-      @transformer.transform({ 'a' => 1 }).must_equal({ :a => 1 })
+        @transformer.register(processor)
+      end
     end
 
-    it 'processes data with processor' do
-      processor = Proc.new { |data, cache| data[:b] = 2; data }
+    describe '#transform' do
+      it 'symbolizes data keys' do
+        @transformer.transform({ 'a' => 1 }).must_equal({ :a => 1 })
+      end
 
-      @transformer.register(processor)
-      @transformer.transform({ 'a' => 1 }).must_equal({ :a => 1, :b => 2 })
-    end
+      it 'processes data with processor' do
+        processor = Proc.new { |data, cache| data[:b] = 2; data }
 
-    it 'allows processor to use cache' do
-      processor = Proc.new do |data, cache|
-        cache[:a] ||= 0
-        cache[:a] += data[:a]
+        @transformer.register(processor)
+        @transformer.transform({ 'a' => 1 }).must_equal({ :a => 1, :b => 2 })
       end
 
-      @transformer.register(processor)
-      @transformer.transform({ 'a' => 1 })
-      @transformer.transform({ 'a' => 2 })
-      @transformer.transform({ 'a' => 3 })
-      @transformer.instance_variable_get('@cache').must_equal({ :a => 6 })
-    end
+      it 'allows processor to use cache' do
+        processor = Proc.new do |data, cache|
+          cache[:a] ||= 0
+          cache[:a] += data[:a]
 
-    it 'returns nil if any processor returns nil' do
-      processor = Proc.new { |data, cache| nil }
+          { :a => data[:a], :cached_a => cache[:a] }
+        end
 
-      @transformer.register(processor)
-      @transformer.transform({ 'a' => 1 }).must_be_nil
+        @transformer.register(processor)
+        @transformer.transform({ 'a' => 1 }).must_equal({ :a => 1, :cached_a => 1 })
+        @transformer.transform({ 'a' => 2 }).must_equal({ :a => 2, :cached_a => 3 })
+        @transformer.transform({ 'a' => 3 }).must_equal({ :a => 3, :cached_a => 6 })
+      end
+
+      it 'returns nil if any processor returns nil' do
+        processor = Proc.new { |data, cache| nil }
+
+        @transformer.register(processor)
+        @transformer.transform({ 'a' => 1 }).must_be_nil
+      end
     end
   end
 end