topographer 0.0.1

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Importer::Mapper::DefaultFieldMapping do
+  let(:static_mapping) do
+    Importer::Mapper::DefaultFieldMapping.new('field1') do
+      10+5
+    end
+  end
+  let(:failed_static_mapping) do
+    Importer::Mapper::DefaultFieldMapping.new('field1') do
+      raise 'FAILURE'
+    end
+  end
+
+  let(:result) { Importer::Mapper::Result.new('test') }
+  let(:result2) { Importer::Mapper::Result.new('test') }
+  describe '#initialize' do
+    it 'should not create a static mapping without a behavior block' do
+      expect { Importer::Mapper::DefaultFieldMapping.new('broken mapping') }.
+          to raise_error(Topographer::InvalidMappingError)
+    end
+  end
+  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.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.values).to include('FAILURE')
+    end
+    it 'should not rescue Exceptions that do not inherit from standard error' do
+      mapper = Importer::Mapper::DefaultFieldMapping.new('output_column') do
+        raise Exception, 'Field1 MUST BE 4'
+      end
+      expect{ mapper.process_input({'field1' => false}, result) }.to raise_error(Exception)
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Importer::Mapper::FieldMapping do
+  let(:required_simple_mapping) { Importer::Mapper::FieldMapping.new(true, ['field1'], 'output_column') }
+  let(:required_simple_mapping_with_validation) do
+    Importer::Mapper::FieldMapping.new(true, ['field1'], 'output_column') do |input|
+      if input['field1'] != 4
+        raise 'Field1 MUST BE 4'
+      end
+    end
+  end
+  let(:required_complex_mapping) do
+    Importer::Mapper::FieldMapping.new(true, ['field1', 'field2', 'field3'], 'output_column') do |input|
+      if input['field1'] != 4
+        raise 'Field1 MUST BE 4'
+      end
+      input.values.flatten.inject(0) {|sum, x| sum+x}
+    end
+  end
+  let(:optional_simple_mapping) { Importer::Mapper::FieldMapping.new(false, 'field1', 'output_column') }
+  let(:optional_complex_mapping) do
+    Importer::Mapper::FieldMapping.new(false, ['field1', 'field2', 'field3'], 'output_column') do |input|
+      if input['field1'] != 4
+        raise 'Field1 MUST BE 4'
+      end
+      input.values.flatten.inject(0) {|sum, x| sum+x}
+    end
+  end
+  let(:valid_input) do
+    {'field1' => 4, 'field2' => 5, 'field3' => 6}
+  end
+  let(:invalid_complex_input) do
+    {'field1' => 3, 'field2' => 4, 'field3' => 5}
+  end
+  let(:result) { Importer::Mapper::Result.new('test') }
+  describe '#process_input' 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.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.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.values).to include('Missing required input(s): `field1` for `output_column`')
+        expect(result.data.empty?).to be_true
+      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.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.values).to include('Field1 MUST BE 4')
+        expect(result.data.empty?).to be_true
+      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.values).to include('Missing required input(s): `field2, field3` for `output_column`')
+        expect(result.data.empty?).to be_true
+      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.values).to include('Field1 MUST BE 4')
+        expect(result.data.empty?).to be_true
+      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.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.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
+      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.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
+      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.values).to include('Field1 MUST BE 4')
+        expect(result.data.empty?).to be_true
+      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.data['output_column']).to eql(false)
+    end
+    it 'should not rescue Exceptions that do not inherit from standard error' do
+      mapper = Importer::Mapper::FieldMapping.new(true, 'field1', 'output_column') do |input|
+        raise Exception, 'Field1 MUST BE 4'
+      end
+      expect{ mapper.process_input({'field1' => false}, result) }.to raise_error(Exception)
+    end
+
+  end
+end

data/spec/Cartographer/importer/mapper/validation_field_mapping_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Importer::Mapper::ValidationFieldMapping do
+  let(:validation_mapping) do
+    Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) do |input|
+      sum = input.values.flatten.inject(0) {|sum, x| sum+x}
+      raise 'Sum must be 15' if sum != 15
+    end
+  end
+  let(:valid_input) do
+    {'field1' => 4, 'field2' => 5, 'field3' => 6}
+  end
+  let(:invalid_input) do
+    {'field1' => 3, 'field2' => 4, 'field3' => 5}
+  end
+  let(:result) { Importer::Mapper::Result.new('test') }
+  describe '#initialize' do
+    it 'should not create a validation mapping without a behavior block' do
+      expect { Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) }.
+        to raise_error(Topographer::InvalidMappingError)
+    end
+  end
+  describe '#process_input' do
+    it 'should not return an error if the validation block passes' do
+      validation_mapping.process_input(valid_input, result)
+      expect(result.errors?).to be_false
+      expect(result.data.blank?).to be_true
+    end
+    it 'should return an error if the validation block raises an error' do
+      validation_mapping.process_input(invalid_input, result)
+      expect(result.errors?).to be_true
+      expect(result.errors.values).to include('Sum must be 15')
+    end
+    it 'should not rescue Exceptions that do not inherit from standard error' do
+      mapper = Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) do |input|
+        sum = input.values.flatten.inject(0) {|sum, x| sum+x}
+        raise Exception, 'Sum must be 15' if sum != 15
+      end
+      expect{ mapper.process_input(invalid_input, result) }.to raise_error(Exception)
+    end
+  end
+end

data/spec/Cartographer/importer/mapper_spec.rb

@@ -0,0 +1,318 @@
+require 'spec_helper'
+
+describe Importer::Mapper do
+  describe '.build_mapper' do
+    describe 'required mappings' do
+      it 'can require a one to one field mapping' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.required_mapping 'Field1', 'field_1'
+        end
+        mapper.required_columns.should include("Field1")
+        mapper.output_fields.should include('field_1')
+      end
+      it 'can require a many to one field mapping' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.required_mapping ['Field1', 'Field2'], 'field_1'
+        end
+        mapper.required_columns.should include("Field1", "Field2")
+        mapper.output_fields.should include('field_1')
+      end
+      it 'cannot require a one to many field mapping' do
+        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.required_mapping 'Field1', ['field_1', 'field_2']
+        end
+        }.to raise_error(Topographer::InvalidMappingError)
+      end
+    end
+    describe 'optional mappings' do
+      it 'can create an optional one to one field mapping' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.optional_mapping 'Field1', 'field_1'
+        end
+        mapper.optional_columns.should include("Field1")
+        mapper.output_fields.should include('field_1')
+      end
+      it 'can create an optional many to one field mapping' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.optional_mapping ['Field1', 'Field2'], 'field_1'
+        end
+        mapper.optional_columns.should include("Field1", "Field2")
+        mapper.output_fields.should include('field_1')
+      end
+      it 'cannot create an optional one to many field mapping' do
+        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.optional_mapping 'Field1', ['field_1', 'field_2']
+        end
+        }.to raise_error(Topographer::InvalidMappingError)
+      end
+    end
+    describe 'ignored mappings' do
+      it 'can ignore a column' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.ignored_column 'Field1'
+        end
+        mapper.ignored_columns.should include('Field1')
+        mapper.output_fields.should be_empty
+      end
+
+      it 'raises an error when adding a mapping whose output is already an output of another mapping' do
+        expect { Importer::Mapper.build_mapper(Object) do |m|
+          m.optional_mapping 'Field1', 'field_1'
+          m.required_mapping 'Field2', 'field_1'
+        end }.to raise_error(Topographer::InvalidMappingError)
+      end
+
+      it 'raises an error when adding a ignored column, which is already an input of another mapping' do
+        expect { Importer::Mapper.build_mapper(Object) do |m|
+          m.optional_mapping 'Field1', 'field_1'
+          m.ignored_column 'Field1'
+        end }.to raise_error(Topographer::InvalidMappingError)
+      end
+
+      it 'raises an error when adding a mapped column which has already been ignored' do
+        expect { Importer::Mapper.build_mapper(Object) do |m|
+          m.ignored_column 'Field1'
+          m.optional_mapping 'Field1', 'field_1'
+        end }.to raise_error(Topographer::InvalidMappingError)
+      end
+    end
+
+    describe 'validation mappings' do
+      it 'can create a single column validation' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.validation_field 'Field 1 Validation', 'Field1' do |input|
+            raise 'No Input' unless input
+          end
+        end
+        expect(mapper.validation_columns).to include('Field1')
+        expect(mapper.output_fields.empty?).to be_true
+      end
+      it 'can create a multicolumn validation' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.validation_field 'Multicolumn Validation', ['Field1', 'Field2'] do |input|
+            raise 'No Input' unless input
+          end
+        end
+        expect(mapper.validation_columns).to eql(['Field1', 'Field2'])
+        expect(mapper.output_fields.empty?).to be_true
+      end
+      it 'raises an error if a validation name is repeated' do
+        expect {
+          mapper = Importer::Mapper.build_mapper(Object) do |m|
+            m.validation_field 'Field 1 Validation', 'Field1' do |input|
+              raise 'No Input' unless input
+            end
+            m.validation_field('Field 1 Validation', 'Field1') { |input| raise 'Test Error' }
+          end
+        }.to raise_error( Topographer::InvalidMappingError )
+      end
+    end
+
+    describe 'static mappings' do
+      it 'can create a static mapping' do
+        mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.default_value 'Field1' do
+            34
+          end
+        end
+        expect(mapper.default_fields).to eql(['Field1'])
+        expect(mapper.output_fields).to eql(['Field1'])
+      end
+      it 'cannot create a static mapping to many columns' do
+        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.default_value ['Field1', 'Field2'] do
+            34
+          end
+        end }.to raise_error(Topographer::InvalidMappingError)
+      end
+      it 'cannot add a static mapping to a field that has already been mapped' do
+        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+          m.required_mapping 'Field1', 'field1'
+          m.default_value 'field1' do
+            34
+          end
+        end }.to raise_error(Topographer::InvalidMappingError)
+      end
+    end
+
+    it 'associates the model class with the mapper instance' do
+      mapper = Importer::Mapper.build_mapper(Object) do |m|
+        m.ignored_column 'Field1'
+        m.optional_mapping 'Field2', 'field_1'
+      end
+      expect(mapper.model_class).to be Object
+    end
+  end
+
+  describe '#key_field' do
+    let(:mapper) { Importer::Mapper.new(Object) }
+    it 'should add a key field to the list of key fields' do
+      mapper.key_field 'Field1'
+      expect(mapper.key_fields).to eql(['Field1'])
+    end
+    it 'should not allow multiple key fields at one time' do
+      expect {
+        mapper.key_field ['Field1', 'Field2']
+      }.to raise_error(Topographer::InvalidMappingError)
+    end
+    it 'should not allow the same key field more than once' do
+      expect {
+        mapper.key_field 'Field1'
+        mapper.key_field 'Field1'
+      }.to raise_error(Topographer::InvalidMappingError)
+    end
+  end
+
+  describe '#input_structure_valid?' do
+    let(:mapper) do
+      Importer::Mapper.build_mapper(Object) do |m|
+        m.required_mapping 'Field1', 'field1'
+        m.required_mapping 'Field2', 'field_4'
+        m.optional_mapping 'Field3', 'field_6'
+        m.validation_field('test validation', 'Field4') { |input| raise 'FAILURE' if !input }
+        m.ignored_column 'Field5'
+      end
+    end
+
+    let(:valid_input_structure_with_options) { ['Field1', 'Field2', 'Field3', 'Field4'] }
+    let(:valid_input_structure_without_options) { ['Field1', 'Field2', 'Field4'] }
+    let(:missing_required_column_structure) { ['Field1', 'Field3'] }
+    let(:missing_validation_column_structure) { ['Field1', 'Field2', 'Field3'] }
+    let(:bad_column_structure) { ['Field1', 'UnknownField', 'Field2', 'Field4'] }
+
+    it 'returns false if required fields are missing' do
+      expect(mapper.input_structure_valid?(missing_required_column_structure)).to be_false
+    end
+    it 'returns false if a validation field is missing' do
+      expect(mapper.input_structure_valid?(missing_validation_column_structure)).to be_false
+    end
+    it 'returns true if all of the required fields are present' do
+      expect(mapper.input_structure_valid?(valid_input_structure_without_options)).to be_true
+    end
+    it 'returns true if all the required and optional fields are present' do
+      expect(mapper.input_structure_valid?(valid_input_structure_with_options)).to be_true
+    end
+    it 'returns true regardless of whether ignored fields are present' do
+      expect(mapper.input_structure_valid?(valid_input_structure_with_options)).to be_true
+      expect(mapper.input_structure_valid?(valid_input_structure_with_options+['Field5'])).to be_true
+    end
+    it 'returns false if there are any extra fields that have not been ignored' do
+      mapper.input_structure_valid?(bad_column_structure).should be_false
+    end
+  end
+
+  describe '#bad_columns' do
+    let(:mapper) do
+      Importer::Mapper.build_mapper(Object) do |m|
+        m.required_mapping 'Field1', 'field1'
+        m.required_mapping 'Field2', 'field_4'
+        m.validation_field('test validation 2', 'Field2') { |input| raise 'FAILURE' if !input }
+        m.optional_mapping 'Field3', 'field_6'
+        m.validation_field('test validation', 'Field4') { |input| raise 'FAILURE' if !input }
+        m.ignored_column 'Field5'
+      end
+    end
+    let(:bad_column_structure) { ['Field1', 'Bad Field', 'Field3'] }
+
+    it 'should return bad column names' do
+      mapper.input_structure_valid?(bad_column_structure)
+      expect(mapper.bad_columns).to eql(['Bad Field'])
+    end
+  end
+
+  describe '#missing_columns' do
+    let(:mapper) do
+      Importer::Mapper.build_mapper(Object) do |m|
+        m.required_mapping 'Field1', 'field1'
+        m.required_mapping 'Field2', 'field_4'
+        m.optional_mapping 'Field3', 'field_6'
+        m.validation_field('test validation', 'Field4') { |input| raise 'FAILURE' if !input }
+        m.ignored_column 'Field5'
+      end
+    end
+    let(:missing_column_structure) { ['Field1'] }
+
+    it 'should return missing column names' do
+      mapper.input_structure_valid?(missing_column_structure)
+      expect(mapper.missing_columns).to eql(['Field2', 'Field4'])
+    end
+  end
+
+  describe '#map_input' do
+    let(:mapper) do
+      Importer::Mapper.build_mapper(Object) do |m|
+        m.required_mapping 'Field1', 'field_1'
+        m.required_mapping ['Field1', 'Field2'], 'field_2'
+        m.validation_field('Field2 Validation', 'Field2') { |input| raise 'FAILURE' if input['Field2'] != 'datum2'}
+        m.required_mapping('Field1', 'field_3') { |x| x['Field1'].length }
+        m.required_mapping(['Field1', 'Field3'], 'field_4') { |x| x['Field1'].length * x['Field3'] }
+        m.default_value('static_field') { 34 }
+        m.optional_mapping('Field4', 'field_5')
+      end
+    end
+    let(:valid_input) do
+      double 'SourceData',
+             source_identifier: 'row1',
+             data: {'Field1' => 'datum1',
+                    'Field2' => 'datum2',
+                    'Field3' => 6}
+    end
+
+    let(:invalid_data_input) do
+      double 'SourceData',
+             source_identifier: 'row1',
+             data: {'Field1' => 'datum1',
+                    'Field2' => 'bad_field2_data',
+                    'Field3' => 6}
+    end
+
+    let(:missing_field_input) do
+      double 'SourceData',
+             source_identifier: 'row1',
+             data: {'Field1' => 'datum1',
+                    'Field2' => 'datum2'}
+    end
+
+    let(:result) do
+      mapper.map_input(valid_input)
+    end
+
+
+    it 'maps one to one field information' do
+      expect(result.data['field_1']).to eql('datum1')
+    end
+
+    it 'maps many to one field information' do
+      expect(result.data['field_2']).to eql('datum1, datum2')
+    end
+
+    it 'maps one to one field information with complex behavior' do
+      expect(result.data['field_3']).to eql(6)
+    end
+
+    it 'maps many to one field information with complex behavior' do
+      expect(result.data['field_4']).to eql(36)
+    end
+
+    it 'maps static fields' do
+      expect(result.data['static_field']).to eql(34)
+    end
+
+    it 'returns an error if required field is missing in input data' do
+      invalid_field_result = mapper.map_input(missing_field_input)
+      expect(invalid_field_result.errors?).to be_true
+      expect(invalid_field_result.errors['field_4']).to include('Missing required input(s): `Field3` for `field_4`')
+    end
+
+    it 'returns an error if a validation does not pass' do
+      invalid_data_result = mapper.map_input(invalid_data_input)
+      expect(invalid_data_result.errors?).to be_true
+      expect(invalid_data_result.errors['Field2 Validation']).to include('FAILURE')
+
+    end
+
+    it 'does not return an error if an optional field is missing in the input data' do
+      expect(result.errors?).to be_false
+    end
+  end
+end