data_maps 0.1.0

data/spec/data_maps/converter/affixes_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe DataMaps::Converter::Prefix do
+  subject { DataMaps::Converter::Prefix.new('PREFIX') }
+
+  describe '#execute' do
+    describe 'for Arrays' do
+      it 'cast all values to strings' do
+        data = [double(Object), double(Object)]
+
+        expect(data[0]).to receive(:to_s).and_return(String.new)
+        expect(data[1]).to receive(:to_s).and_return(String.new)
+
+        expect(
+          subject.execute(data).all?{ |x| x.is_a?(String) }
+        ).to be_truthy
+      end
+
+      it 'prefixes all values' do
+        expect(
+          subject.execute(%w[ a b c ])
+        ).to eq %w[ PREFIXa PREFIXb PREFIXc ]
+      end
+    end
+
+    describe 'for Hashes' do
+      it 'cast all values to strings' do
+        data = { a: double(Object), b: double(Object) }
+
+        expect(data[:a]).to receive(:to_s).and_return(String.new)
+        expect(data[:b]).to receive(:to_s).and_return(String.new)
+
+        expect(
+          subject.execute(data).all?{ |k,v| v.is_a?(String) }
+        ).to be_truthy
+      end
+
+      it 'prefixes all values' do
+        expect(
+          subject.execute({ a: 'a', b: 'b', c: 'c' })
+        ).to eq({ a: 'PREFIXa', b: 'PREFIXb', c: 'PREFIXc' })
+      end
+    end
+
+    describe 'for flat values' do
+      it 'cast value to string' do
+        data = double(Object)
+
+        expect(data).to receive(:to_s).and_return(String.new)
+        expect(subject.execute(data)).to be_a String
+      end
+
+      it 'prefixes the value' do
+        expect(
+          subject.execute('a')
+        ).to eq 'PREFIXa'
+      end
+    end
+  end
+end
+
+describe DataMaps::Converter::Postfix do
+  subject { DataMaps::Converter::Postfix.new('POSTFIX') }
+
+  describe '#execute' do
+    describe 'for Arrays' do
+      it 'cast all values to strings' do
+        data = [double(Object), double(Object)]
+
+        expect(data[0]).to receive(:to_s).and_return(String.new)
+        expect(data[1]).to receive(:to_s).and_return(String.new)
+
+        expect(
+          subject.execute(data).all?{ |x| x.is_a?(String) }
+        ).to be_truthy
+      end
+
+      it 'postfixes all values' do
+        expect(
+          subject.execute(%w[ a b c ])
+        ).to eq %w[ aPOSTFIX bPOSTFIX cPOSTFIX ]
+      end
+    end
+
+    describe 'for Hashes' do
+      it 'cast all values to strings' do
+        data = { a: double(Object), b: double(Object) }
+
+        expect(data[:a]).to receive(:to_s).and_return(String.new)
+        expect(data[:b]).to receive(:to_s).and_return(String.new)
+
+        expect(
+          subject.execute(data).all?{ |k,v| v.is_a?(String) }
+        ).to be_truthy
+      end
+
+      it 'postfixes all values' do
+        expect(
+          subject.execute({ a: 'a', b: 'b', c: 'c' })
+        ).to eq({ a: 'aPOSTFIX', b: 'bPOSTFIX', c: 'cPOSTFIX' })
+      end
+    end
+
+    describe 'for flat values' do
+      it 'cast value to string' do
+        data = double(Object)
+
+        expect(data).to receive(:to_s).and_return(String.new)
+        expect(subject.execute(data)).to be_a String
+      end
+
+      it 'postfixes the value' do
+        expect(
+          subject.execute('a')
+        ).to eq 'aPOSTFIX'
+      end
+    end
+  end
+end

data/spec/data_maps/converter/base_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe DataMaps::Converter do
+  describe '::create_from_map' do
+    it 'creates new converter' do
+      mapping = { ruby: :upcase }
+
+      expect(DataMaps::Converter).to receive(:factory).with(:ruby, :upcase).and_call_original
+
+      DataMaps::Converter.create_from_map(mapping)
+    end
+  end
+end
+
+describe DataMaps::Converter::Base do
+  subject { DataMaps::Converter::Base.new('muh') }
+
+  it 'is an executable' do
+    expect(subject).to be_a DataMaps::Executable
+  end
+end

data/spec/data_maps/converter/bool_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe DataMaps::Converter::Bool do
+  describe '#execute' do
+    subject { DataMaps::Converter::Bool.new(true) }
+
+    it 'returns true or false' do
+      expect([true, false]).to include subject.execute('something')
+    end
+  end
+end

data/spec/data_maps/converter/keys_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe DataMaps::Converter::Keys do
+  describe '#execute' do
+    subject { DataMaps::Converter::Keys.new({ a: 'x', b: 'y', c: 'z' }) }
+
+    it 'converts the keys' do
+      expect(
+        subject.execute({ a: 1, b: 2, c: 3 })
+      ).to eq({ 'x' => 1, 'y' => 2, 'z' => 3 })
+    end
+
+    it 'does nothing with keys that doesn\'t exist in mapping' do
+      expect(
+        subject.execute({ d: 4, e: 5, f: 6 })
+      ).to eq({ d: 4, e: 5, f: 6 })
+    end
+
+    it 'does nothing with data when data isn\'t a hash' do
+      expect(
+        subject.execute('something')
+      ).to eq 'something'
+    end
+  end
+end

data/spec/data_maps/converter/map_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe DataMaps::Converter::Map do
+  describe '#execute' do
+    subject { DataMaps::Converter::Map.new({ a: 'x', b: 'y', c: 'z' }) }
+
+    describe 'for arrays' do
+      it 'converts an array of data' do
+        expect(
+          subject.execute(%w[ a b c ])
+        ).to eq %w[ x y z ]
+      end
+
+      it 'returns nil when a value doesn\'t exists in map' do
+        expect(
+          subject.execute(%w[ a b c d ])
+        ).to eq [ 'x', 'y', 'z', nil ]
+      end
+    end
+
+    describe 'for hashes' do
+      it 'converts values in a data hash' do
+        expect(
+          subject.execute({ x: 'a', y: 'b', z: 'c' })
+        ).to eq({ x: 'x', y: 'y', z: 'z' })
+      end
+
+      it 'returns nil when a value doesn\'t exists in map' do
+        expect(
+          subject.execute({ x: 'a', y: 'b', z: 'c', w: 'd' })
+        ).to eq({ x: 'x', y: 'y', z: 'z', w: nil })
+      end
+    end
+
+    describe 'for flat values' do
+      it 'converts the value' do
+        expect(subject.execute('a')).to eq 'x'
+      end
+
+      it 'returns original value when value doesn\'t exists in map' do
+        expect(subject.execute('d')).to eq 'd'
+      end
+    end
+  end
+end

data/spec/data_maps/converter/numeric_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe DataMaps::Converter::Numeric do
+  describe '#execute' do
+    describe 'Integer' do
+      subject { DataMaps::Converter::Numeric.new('Integer') }
+
+      it 'converts a float' do
+        expect(subject.execute(5.5)).to eq 5
+      end
+
+      it 'converts a float string' do
+        expect(subject.execute('5.5')).to eq 5
+      end
+
+      it 'converts a string' do
+        expect(subject.execute('5')).to eq 5
+      end
+
+      it 'raise an error if the string is not a numeric string' do
+        expect{ subject.execute('5,50€') }.to raise_error DataMaps::Errors::InvalidDataError
+      end
+    end
+
+    describe 'Float' do
+      subject { DataMaps::Converter::Numeric.new('Float') }
+
+      it 'converts an integer' do
+        expect(subject.execute(5)).to eq 5.0
+      end
+
+      it 'converts a float string' do
+        expect(subject.execute('5.5')).to eq 5.5
+      end
+
+      it 'converts a string' do
+        expect(subject.execute('5')).to eq 5.0
+      end
+    end
+
+    describe 'precision' do
+      subject { DataMaps::Converter::Numeric.new(2) }
+
+      it 'converts an integer' do
+        expect(subject.execute(5)).to eq 5.0
+      end
+
+      it 'converts a float' do
+        expect(subject.execute(5.128)).to eq 5.13
+      end
+
+      it 'converts a float string' do
+        expect(subject.execute('5.128')).to eq 5.13
+      end
+
+      it 'converts a string' do
+        expect(subject.execute('5')).to eq 5.0
+      end
+    end
+
+    describe 'no options' do
+      subject { DataMaps::Converter::Numeric.new(nil) }
+
+      it 'returns the given numeric data without any modification' do
+        expect(subject.execute(5)). to eq 5
+      end
+
+      it 'returns the given float data without any modification' do
+        expect(subject.execute(5.5)). to eq 5.5
+      end
+
+      it 'returns the given string data without any modification' do
+        expect(subject.execute('5')). to eq '5'
+      end
+
+      it 'raise an error for invalid data' do
+        expect{ subject.execute({ something: 'huh' }) }.to raise_error DataMaps::Errors::InvalidDataError
+      end
+    end
+  end
+end

data/spec/data_maps/converter/ruby_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe DataMaps::Converter::Ruby do
+  describe '#execute' do
+    subject { DataMaps::Converter::Ruby.new([:my_method, 'option1', 'option2']) }
+
+    it 'applies the given method on the data' do
+      data = double(Object)
+
+      expect(data).to receive(:my_method).with('option1', 'option2')
+
+      subject.execute(data)
+    end
+  end
+end

data/spec/data_maps/converter/string_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe DataMaps::Converter::String do
+  describe '#execute' do
+    subject { DataMaps::Converter::String.new(true) }
+
+    it 'calls to_s on data' do
+      data = double(Object)
+
+      expect(data).to receive(:to_s).and_return(String.new)
+      expect(subject.execute(data)).to be_a String
+    end
+  end
+end

data/spec/data_maps/executable_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe DataMaps::Executable do
+  subject { DataMaps::Executable.new('option') }
+
+  describe 'initialization' do
+    it 'first argument is available via option attribute reader' do
+      expect(subject.option).to eq 'option'
+    end
+
+    it 'calls the after_initialize callback' do
+      expect_any_instance_of(DataMaps::Executable).to receive(:after_initialize)
+
+      DataMaps::Executable.new('option')
+    end
+  end
+
+  describe '#execute' do
+    it 'raise an NotImplementedError' do
+      expect{ subject.execute('something') }.to raise_error NotImplementedError
+    end
+  end
+end

data/spec/data_maps/filtered_value_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe DataMaps::FilteredValue do
+  describe 'initialisation' do
+    it 'sets value' do
+      data = 'something'
+      value = DataMaps::FilteredValue.new(data)
+
+      expect(value.value).to be data
+    end
+  end
+end

data/spec/data_maps/mapper_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe DataMaps::Mapper do
+  it 'cant\'t be initialized without a mapping' do
+    expect{ DataMaps::Mapper.new }.to raise_error ArgumentError
+  end
+
+  it 'cant\t be initialized with an invalid mapping' do
+    expect{ DataMaps::Mapper.new('something') }.to raise_error ArgumentError
+  end
+
+  describe 'initialisation' do
+    it 'sets mapping' do
+      mapping = DataMaps::Mapping.new({})
+      mapper = DataMaps::Mapper.new(mapping)
+
+      expect(mapper.mapping).to be_a DataMaps::Mapping
+      expect(mapper.mapping).to eq mapping
+    end
+  end
+
+  describe '#convert' do
+    let(:mapping) { DataMaps::Mapping.new({ 'b' => 'a' }) }
+    let(:mapper) { DataMaps::Mapper.new(mapping) }
+
+    it 'executes mapping' do
+      data = { 'a' => 'x' }
+      expect(mapping).to receive(:execute).with(data).and_call_original
+      expect(mapper.convert(data)).to eq({ 'b' => 'x' })
+    end
+
+    it 'converts keys of the data to string keys' do
+      data = { a: 'x' }
+      expect(data).to receive(:stringify_keys).and_call_original
+      expect(mapper.convert(data)).to eq({ 'b' => 'x' })
+    end
+  end
+end

data/spec/data_maps/mapping_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe DataMaps::Mapping do
+  let(:simple_mapping_hash) do
+    {
+      'destination1' => 'source1',
+      'destination2' => 'source2'
+    }
+  end
+
+  let(:conditional_mapping_hash) do
+    {
+      'destination1' => {
+        from: 'source1',
+        conditions: [
+          { when: { empty: true }, then: { filter: true } },
+          { when: { regex: /[a-z]/ }, then: { convert: { ruby: :upcase } } },
+        ]
+      }
+    }
+  end
+
+  let(:converter_mapping_hash) do
+    {
+      'destination2' => {
+        from: %w[ source2 source3 ],
+        converter: {
+          ruby: [:join, ', '],
+        }
+      }
+    }
+  end
+
+  let(:complex_mapping_hash) do
+    conditional_mapping_hash.merge converter_mapping_hash
+  end
+
+  let(:invalid_mapping_hash) do
+    {
+      'destination3' => {
+        from: 'source3',
+        condition: { when: 'this', then: 'that' },
+        converter: 'something invalid'
+      }
+    }
+  end
+
+  it 'cant\t be initialized without a valid mapping_hash' do
+    expect{ DataMaps::Mapping.new('something') }.to raise_error ArgumentError
+  end
+
+  describe 'compile' do
+    describe 'lazy compilation' do
+      subject{ DataMaps::Mapping.new(simple_mapping_hash) }
+
+      it 'compiles nothing if mapping is initialized' do
+        expect(subject.mapping).to be_empty
+      end
+
+      it 'compiles if calling get_statement_for' do
+        expect{ subject.get_statement_for('destination1') }.to change{ subject.mapping.length }.from(0).to(2)
+      end
+
+      it 'compiles if calling each_statement' do
+        expect{ subject.each_statement { |d,s| } }.to change{ subject.mapping.length }.from(0).to(2)
+      end
+    end
+
+    # Test mapping generation of a simple destination => source mapping without any conditions or converter
+    describe 'simple mapping hash' do
+      subject{ DataMaps::Mapping.new(simple_mapping_hash) }
+
+      it 'has correct destination key' do
+        expect{ subject.get_statement_for('destination1') }.not_to raise_error
+      end
+      it 'is a MappingStatement' do
+        expect(subject.get_statement_for('destination1')).to be_a DataMaps::Statement
+      end
+      it 'has the correct statement options' do
+        statement = subject.get_statement_for('destination1')
+
+        expect(statement.from).to eq 'source1'
+        expect(statement.to).to eq 'destination1'
+        expect(statement.conditions).to be_a Array
+        expect(statement.conditions).to be_empty
+        expect(statement.converter).to be_a Array
+        expect(statement.converter).to be_empty
+      end
+    end
+
+    # Test mapping generation of a mapping hash with conditions
+    describe 'conditional mapping hash' do
+      subject{ DataMaps::Mapping.new(conditional_mapping_hash) }
+
+      it 'has correct destination key' do
+        expect{ subject.get_statement_for('destination1') }.not_to raise_error
+      end
+      it 'is a MappingStatement' do
+        expect(subject.get_statement_for('destination1')).to be_a DataMaps::Statement
+      end
+      it 'has the correct statement options' do
+        statement = subject.get_statement_for('destination1')
+
+        expect(statement.from).to eq 'source1'
+        expect(statement.to).to eq 'destination1'
+        expect(statement.conditions).to be_a Array
+        expect(statement.conditions.length).to eq 2
+        expect(statement.conditions.all?{ |c| c.is_a?(DataMaps::Condition) }).to be_truthy
+        expect(statement.converter).to be_a Array
+        expect(statement.converter).to be_empty
+      end
+    end
+
+    # Test mapping generation of a mapping hash with converter
+    describe 'conditional mapping hash' do
+      subject{ DataMaps::Mapping.new(converter_mapping_hash) }
+
+      it 'has correct destination key' do
+        expect{ subject.get_statement_for('destination2') }.not_to raise_error
+      end
+      it 'is a MappingStatement' do
+        expect(subject.get_statement_for('destination2')).to be_a DataMaps::Statement
+      end
+      it 'has the correct statement options' do
+        statement = subject.get_statement_for('destination2')
+
+        expect(statement.from).to eq %w[ source2 source3 ]
+        expect(statement.to).to eq 'destination2'
+        expect(statement.conditions).to be_a Array
+        expect(statement.conditions).to be_empty
+
+        expect(statement.converter.length).to eq 1
+        expect(statement.converter.all?{ |c| c.is_a?(DataMaps::Converter::Base) }).to be_truthy
+      end
+    end
+  end
+
+  describe 'validation' do
+    it 'valid? returns true for complex_mapping_hash' do
+      mapping = DataMaps::Mapping.new(complex_mapping_hash)
+      expect(mapping.valid?).to be_truthy
+    end
+
+    it 'valid? returns false for invalid_mapping_hash' do
+      mapping = DataMaps::Mapping.new(invalid_mapping_hash)
+      expect(mapping.valid?).to be_falsey
+    end
+  end
+
+  describe '#each_statement' do
+    subject{ DataMaps::Mapping.new(simple_mapping_hash) }
+
+    it 'return an Enumerator if no block given' do
+      expect(subject.each_statement).to be_a Enumerator
+    end
+
+    it 'calls the given block with destination field name and statement' do
+      expect do |block|
+        subject.each_statement(&block)
+      end.to yield_successive_args(
+        ['destination1', DataMaps::Statement],
+        ['destination2', DataMaps::Statement]
+      )
+    end
+  end
+
+  describe '#execute' do
+    subject{ DataMaps::Mapping.new(complex_mapping_hash) }
+
+    it 'executes each statement' do
+      data = {}
+
+      subject.compile
+
+      expect(subject.mapping['destination1']).to receive(:execute).with(data).and_return(['destination1', 'value 1'])
+      expect(subject.mapping['destination2']).to receive(:execute).with(data).and_return(['destination2', 'value 2'])
+
+      expect(subject.execute(data)).to eq({ 'destination1' => 'value 1', 'destination2' => 'value 2' })
+    end
+
+    it 'filters FilteredValue from result' do
+      data = {}
+
+      subject.compile
+
+      expect(subject.mapping['destination1']).to receive(:execute).with(data).and_return(['destination1', 'value 1'])
+      expect(subject.mapping['destination2']).to receive(:execute).with(data).and_return(['destination2', DataMaps::FilteredValue.new('value 2')])
+
+      expect(subject.execute(data)).to eq({ 'destination1' => 'value 1' })
+    end
+  end
+end