topographer 0.0.7 → 0.0.8

data/lib/topographer/version.rb

@@ -1,3 +1,3 @@
 module Topographer
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/assets/test_files/a_csv.csv

@@ -0,0 +1,3 @@
+header 1,header 2
+1,2
+3,foo

data/spec/topographer/importer/helpers/write_log_to_csv_spec.rb

@@ -55,14 +55,14 @@ describe Topographer::Importer::Helpers::WriteLogToCSV do
   describe '#write_log_to_csv' do
     it 'should write a passed logger instance to a CSV file' do
       file = double('file')
-      CSV.should_receive(:open).with('fake_file_path', 'wb').and_yield(file)
-      file.should_receive(:<<).exactly(12).times
+      expect(CSV).to receive(:open).with('fake_file_path', 'wb').and_yield(file)
+      expect(file).to receive(:<<).exactly(12).times
       Topographer::Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: true)
     end
     it 'should only write failures and fatal errors if write_all is false' do
       file = double('file')
-      CSV.should_receive(:open).with('fake_file_path', 'wb').and_yield(file)
-      file.should_receive(:<<).exactly(10).times
+      expect(CSV).to receive(:open).with('fake_file_path', 'wb').and_yield(file)
+      expect(file).to receive(:<<).exactly(10).times
       Topographer::Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: false)
     end
   end

data/spec/topographer/importer/importer_spec.rb

@@ -108,28 +108,44 @@ describe Topographer::Importer do
     end
 
     it 'logs invalid data' do
-      expect(import_log.errors?).to be_true
+      expect(import_log.errors?).to be_truthy
       expect(import_log.failed_imports).to be 1
     end
 
     it 'does not import data with an invalid header' do
       import_log = Topographer::Importer.import_data(bad_header_input, model_class, strategy_class, simple_logger)
-      expect(import_log.errors?).to be_true
-      expect(import_log.fatal_error?).to be_true
+      expect(import_log.errors?).to be_truthy
+      expect(import_log.fatal_error?).to be_truthy
       expect(import_log.fatal_errors.first.message).
         to match(/Invalid Input Header.+Missing Columns:\s+Field2.+Invalid Columns:\s+BadCol1.+BadCol2/)
     end
 
     it 'does import data with umapped columns when ignoring unmapped columns' do
       extra_column_input = input
-      extra_column_input.stub(:get_header) { %w(Field1 Field2 Field3 UnknownField1) }
+      allow(extra_column_input).to receive(:get_header) { %w(Field1 Field2 Field3 UnknownField1) }
 
       import_log = Topographer::Importer.import_data(extra_column_input, model_class, strategy_class, simple_logger, ignore_unmapped_columns: true)
 
-      expect(import_log.fatal_error?).to be_false
+      expect(import_log.fatal_error?).to be_falsey
       expect(import_log.total_imports).to be 4
       expect(import_log.successful_imports).to be 3
     end
+    context 'using an instance of a strategy class' do
+      let(:hash_strategy) do
+        HashImportStrategy.new(nil)
+      end
+      before do
+        allow(hash_strategy).to receive(:mapper=).and_call_original
+      end
+      it 'sets the mapper of the strategy class' do
+        Topographer::Importer.import_data(input, model_class, hash_strategy, simple_logger)
+        expect(hash_strategy).to have_received(:mapper=)
+      end
+      it 'imports data from valid import objects' do
+        import_log = Topographer::Importer.import_data(input, model_class, hash_strategy, simple_logger)
+        expect(import_log.total_imports).to be 4
+      end
+    end
   end
   describe '.build_mapper' do
     it 'returns a mapper with the defined mappings' do

data/spec/topographer/importer/input/delimited_spreadsheet_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Topographer::Importer::Input::DelimitedSpreadsheet do
+  let(:csv_path) do
+    File.expand_path(File.join(__dir__, '../../../assets/test_files/a_csv.csv'))
+  end
+  let(:csv_object) do
+    file = File.open(csv_path, 'r')
+    CSV.new(file, headers: true)
+  end
+  let(:name) do
+    'csv_name'
+  end
+
+  subject do
+    described_class.new(name, csv_object)
+  end
+
+  describe '#get_header' do
+    context 'headers read before input created' do
+      let(:csv_object) do
+        CSV.read(csv_path, headers: true)
+      end
+      it 'returns the headers that were previously read' do
+        expect(subject.get_header).to eql ['header 1', 'header 2']
+      end
+    end
+    context 'headers not read yet' do
+      let(:csv_object) do
+        file = File.open(csv_path, 'r')
+        CSV.new(file, headers: true)
+      end
+      it 'returns the headers that were previously read' do
+        expect(subject.get_header).to eql ['header 1', 'header 2']
+      end
+    end
+    context 'headers will never be read' do
+      let(:csv_object) do
+        file = File.open(csv_path, 'r')
+        CSV.new(file)
+      end
+      it 'returns an empty array' do
+        expect(subject.get_header).to eql []
+      end
+    end
+  end
+
+  describe '#input_identifier' do
+    it 'returns the csv name passed in' do
+      expect(subject.input_identifier).to eql name
+    end
+  end
+
+  describe '#each' do
+    it 'yields a SourceData object for each row in the sheet' do
+      expected_data = [
+        {
+          'header 1' => '1',
+          'header 2' => '2',
+        },
+        {
+          'header 1' => '3',
+          'header 2' => 'foo'
+        }
+      ]
+      subject.each_with_index do |source_data, index|
+        expect(source_data.data).to eql expected_data[index]
+      end
+    end
+    it 'yields the same data with multiple calls' do
+      expected_data = [
+        {
+          'header 1' => '1',
+          'header 2' => '2',
+        },
+        {
+          'header 1' => '3',
+          'header 2' => 'foo'
+        }
+      ]
+      subject.each_with_index do |source_data, index|
+        expect(source_data.data).to eql expected_data[index]
+      end
+      subject.each_with_index do |source_data, index|
+        expect(source_data.data).to eql expected_data[index]
+      end
+    end
+  end
+
+end

data/spec/topographer/importer/input/source_data_spec.rb

@@ -12,10 +12,10 @@ describe Topographer::Importer::Input::SourceData do
 
   describe '#empty?' do
     it 'should return true if there is no data' do
-      expect(with_no_data.empty?).to be_true
+      expect(with_no_data.empty?).to be_truthy
     end
     it 'should return false if there is data' do
-      expect(with_data.empty?).to be_false
+      expect(with_data.empty?).to be_falsey
     end
   end
 

data/spec/topographer/importer/logger/base_spec.rb

@@ -9,4 +9,23 @@ describe Topographer::Importer::Logger::Base do
       expect(logger.fatal_errors.first)
     end
   end
+  describe '#success?' do
+    context 'no errors' do
+      before do
+        allow(subject).to receive(:errors?).and_return false
+      end
+      it 'returns true' do
+        expect(subject.success?).to be_truthy
+      end
+    end
+    context 'errors' do
+      before do
+        allow(subject).to receive(:errors?).and_return true
+      end
+      it 'returns false' do
+        expect(subject.success?).to be_falsey
+      end
+    end
+  end
+
 end

data/spec/topographer/importer/logger/fatal_error_entry_spec.rb

@@ -4,12 +4,12 @@ describe Topographer::Importer::Logger::FatalErrorEntry do
   let(:entry) { Topographer::Importer::Logger::FatalErrorEntry.new('test-input', 'failure message') }
   describe '#failure?' do
     it 'should return true' do
-      expect(entry.failure?).to be_true
+      expect(entry.failure?).to be_truthy
     end
   end
   describe '#success?' do
     it 'should return false' do
-      expect(entry.success?).to be_false
+      expect(entry.success?).to be_falsey
     end
   end
   describe '#source_identifier' do

data/spec/topographer/importer/logger/simple_spec.rb

@@ -37,17 +37,17 @@ describe Topographer::Importer::Logger::Simple do
   describe '#errors?' do
     it 'returns true if there are fatal errors' do
       logger.log_fatal('input', 'FATAL ERROR')
-      expect(logger.errors?).to be_true
+      expect(logger.errors?).to be_truthy
     end
     it 'returns true if there are import errors' do
       logger.log_failure({record_id: 2,
                           message: 'failure'})
-      expect(logger.errors?).to be_true
+      expect(logger.errors?).to be_truthy
     end
     it 'returns false if there are no errors' do
       logger.log_success({record_id: 2,
                           message: 'failure'})
-      expect(logger.errors?).to be_false
+      expect(logger.errors?).to be_falsey
     end
   end
 end

data/spec/topographer/importer/mapper/default_field_mapping_spec.rb

@@ -23,12 +23,12 @@ describe Topographer::Importer::Mapper::DefaultFieldMapping do
   describe '#process_input' do
     it 'should return the result of the behavior block' do
       static_mapping.process_input({}, result)
-      expect(result.errors?).to be_false
+      expect(result.errors?).to be_falsey
       expect(result.data['field1']).to be 15
     end
     it 'should record any exceptions that occur within the block as errors' do
       failed_static_mapping.process_input({}, result)
-      expect(result.errors?).to be_true
+      expect(result.errors?).to be_truthy
       expect(result.errors.values).to include('FAILURE')
     end
     it 'should not rescue Exceptions that do not inherit from standard error' do

data/spec/topographer/importer/mapper/field_mapping_spec.rb

@@ -37,82 +37,82 @@ describe Topographer::Importer::Mapper::FieldMapping do
     context 'required mappings' do
       it 'maps required simple mappings when input is valid' do
         required_simple_mapping.process_input(valid_input, result)
-        expect(result.errors?).to be_false
+        expect(result.errors?).to be_falsey
         expect(result.data['output_column']).to eql(4)
       end
       it 'maps required complex mappings when input is valid' do
         required_complex_mapping.process_input(valid_input, result)
-        expect(result.errors?).to be_false
+        expect(result.errors?).to be_falsey
         expect(result.data['output_column']).to eql(15)
       end
       it 'returns an error for required simple mappings when the input key is missing' do
         required_simple_mapping.process_input({}, result)
-        expect(result.errors?).to be_true
+        expect(result.errors?).to be_truthy
         expect(result.errors.values).to include('Missing required input(s): `field1` for `output_column`')
-        expect(result.data.empty?).to be_true
+        expect(result.data.empty?).to be_truthy
       end
       it 'returns an error for required simple mappings when the input data is blank' do
         required_simple_mapping.process_input({'field1' => nil}, result)
-        expect(result.errors?).to be_true
+        expect(result.errors?).to be_truthy
         expect(result.errors.values).to include('Missing required input(s): `field1` for `output_column`')
         expect(result.data['output_column']).to be_nil
       end
       it 'returns an error for required simple mappings when the mapping block raises an exception' do
         required_simple_mapping_with_validation.process_input({'field1' => 3}, result)
-        expect(result.errors?).to be_true
+        expect(result.errors?).to be_truthy
         expect(result.errors.values).to include('Field1 MUST BE 4')
-        expect(result.data.empty?).to be_true
+        expect(result.data.empty?).to be_truthy
       end
       it 'returns an error for required complex mappings when the input key is missing' do
         required_complex_mapping.process_input({'field1' => 4}, result)
-        expect(result.errors?).to be_true
+        expect(result.errors?).to be_truthy
         expect(result.errors.values).to include('Missing required input(s): `field2, field3` for `output_column`')
-        expect(result.data.empty?).to be_true
+        expect(result.data.empty?).to be_truthy
       end
       it 'returns an error for required complex mappings when the mapping block raises an exception' do
         required_complex_mapping.process_input(invalid_complex_input, result)
-        expect(result.errors?).to be_true
+        expect(result.errors?).to be_truthy
         expect(result.errors.values).to include('Field1 MUST BE 4')
-        expect(result.data.empty?).to be_true
+        expect(result.data.empty?).to be_truthy
       end
     end
     context 'optional mappings' do
       it 'maps optional simple mappings when input is valid' do
         optional_simple_mapping.process_input(valid_input, result)
-        expect(result.errors?).to be_false
+        expect(result.errors?).to be_falsey
         expect(result.data['output_column']).to eql(4)
       end
       it 'maps optional complex mappings when input is valid' do
         optional_complex_mapping.process_input(valid_input, result)
-        expect(result.errors?).to be_false
+        expect(result.errors?).to be_falsey
         expect(result.data['output_column']).to eql(15)
       end
       it 'does not return an error for optional simple mappings when the input key is missing' do
         optional_simple_mapping.process_input({}, result)
-        expect(result.errors?).to be_false
-        expect(result.data.empty?).to be_true
+        expect(result.errors?).to be_falsey
+        expect(result.data.empty?).to be_truthy
       end
       it 'does not return an error for optional simple mappings when the input data is blank' do
         optional_simple_mapping.process_input({'field1' => nil}, result)
-        expect(result.errors?).to be_false
+        expect(result.errors?).to be_falsey
         expect(result.data['output_column']).to be_nil
       end
       it 'does not return an error for optional complex mappings when an input key is missing' do
         optional_complex_mapping.process_input({'field1' => 4}, result)
-        expect(result.errors?).to be_false
-        expect(result.data.empty?).to be_true
+        expect(result.errors?).to be_falsey
+        expect(result.data.empty?).to be_truthy
       end
       it 'returns an error for optional complex mappings when the mapping block raises an exception' do
         optional_complex_mapping.process_input(invalid_complex_input, result)
-        expect(result.errors?).to be_true
+        expect(result.errors?).to be_truthy
         expect(result.errors.values).to include('Field1 MUST BE 4')
-        expect(result.data.empty?).to be_true
+        expect(result.data.empty?).to be_truthy
       end
     end
     it 'maps data when the result of the mapping is a false value' do
       #required_simple_mapping.stub(:apply_mapping).and_return(false)
       required_simple_mapping.process_input({'field1' => false}, result)
-      expect(result.errors?).to be_false
+      expect(result.errors?).to be_falsey
       expect(result.data['output_column']).to eql(false)
     end
     it 'should not rescue Exceptions that do not inherit from standard error' do

data/spec/topographer/importer/mapper/mapper_builder_spec.rb

@@ -21,7 +21,7 @@ describe Topographer::Importer::Mapper::MapperBuilder do
       builder.required_mapping('input_column1', 'output_field1')
       expect{
         builder.required_mapping('input_column2', 'output_field1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -42,7 +42,7 @@ describe Topographer::Importer::Mapper::MapperBuilder do
       builder.optional_mapping('input_column1', 'output_field1')
       expect{
         builder.optional_mapping('input_column2', 'output_field1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -57,7 +57,7 @@ describe Topographer::Importer::Mapper::MapperBuilder do
     it 'should raise an error if there is no behavior block provided' do
       expect {
         builder.validation_field('validation_1', 'input_column1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
     it 'should raise an error if a validation mapping already exists with a given name' do
       builder.validation_field('validation_1', 'input_column1') do
@@ -67,7 +67,7 @@ describe Topographer::Importer::Mapper::MapperBuilder do
         builder.validation_field('validation_1', 'input_column1') do
           return true
         end
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -82,7 +82,7 @@ describe Topographer::Importer::Mapper::MapperBuilder do
     it 'should raise an error if there is no behavior block provided' do
       expect {
         builder.default_value('output_field1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
     it 'should raise an error if a default value mapping already exists for a column' do
       builder.default_value('output_field1') do
@@ -92,7 +92,7 @@ describe Topographer::Importer::Mapper::MapperBuilder do
         builder.default_value('output_field1') do
           return true
         end
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -107,7 +107,7 @@ describe Topographer::Importer::Mapper::MapperBuilder do
       expect {
 
         builder.key_field('output_field1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -122,10 +122,10 @@ describe Topographer::Importer::Mapper::MapperBuilder do
       builder.required_mapping('column2', 'field1')
       expect {
         builder.ignored_column('column1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
       expect {
         builder.ignored_column('column2')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 end

data/spec/topographer/importer/mapper/mapping_validator_spec.rb

@@ -35,7 +35,7 @@ describe Topographer::Importer::Mapper::MappingValidator do
     it 'should raise an error if a name is in the validation list' do
       expect {
         validator.validate_unique_validation_name('Field1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -48,7 +48,7 @@ describe Topographer::Importer::Mapper::MappingValidator do
     it 'should raise an error if a field is already an output field' do
       expect {
         validator.validate_unique_output_mapping('output_field2')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -66,15 +66,15 @@ describe Topographer::Importer::Mapper::MappingValidator do
     it 'should raise an error if a field is already ignored' do
       expect {
         validator.validate_unique_column_mapping_type('ignored_column1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
     it 'should raise an error when validating an ignored column that has already been mapped' do
       expect {
         validator.validate_unique_column_mapping_type('input_column1', ignored: true)
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
       expect {
         validator.validate_unique_column_mapping_type('ignored_column1', ignored: true)
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
 
@@ -87,30 +87,30 @@ describe Topographer::Importer::Mapper::MappingValidator do
     it 'should raise an error if a new mapping does not have a unique output field' do
       expect {
         validator.validate_unique_mapping('input_column2', 'output_field2')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
     it 'should raise an error if a new mapping includes an already ignored column' do
       expect {
         validator.validate_unique_mapping('ignored_column2', 'output_field2')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
   end
   it 'should raise an error if a new mapping includes many output fields' do
     expect {
       validator.validate_unique_mapping('ignored_column2', %w(output_field2 output_field3))
-    }.to raise_error
+    }.to raise_error Topographer::InvalidMappingError
   end
 
   describe '#validate_key_field' do
     it 'should raise an error if a new key field includes multiple fields' do
       expect {
         validator.validate_key_field(%w(output_field2 output_field3))
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
     it 'should raise an error if a key field is duplicated' do
       expect {
         validator.validate_key_field('key_field1')
-      }.to raise_error
+      }.to raise_error Topographer::InvalidMappingError
     end
     it 'should not raise an error if a key field is not already mapped' do
       expect {