hash_engine 0.3.0

data/spec/hash_engine/extract_spec.rb

@@ -0,0 +1,144 @@
+require 'hash_engine'
+
+describe HashEngine do
+  describe 'extract' do
+    describe 'should return errors' do
+      it 'when instructions is empty' do
+        HashEngine.extract(nil, {}).should ==
+          {:error => ['Missing instructions']}
+      end
+
+      it 'when instructions are nil' do
+        HashEngine.extract(nil, nil).should ==
+          {:error => ['Missing instructions']}
+      end
+
+      it 'when object is mil' do
+        HashEngine.extract(nil, {'person' => 'person'}).should ==
+          {:error => ['Missing object(s)']}
+      end
+
+      it 'when number of objects dont match instructions' do
+        objects = mock 'Person'
+        instructions = {'person' => 'person', 'company' => 'company'}
+        HashEngine.extract(objects, instructions).should ==
+          {:error => ['Instructions given for company, person but only 1 object given']}
+      end
+
+      it 'when instructions wants a missing object' do
+        objects = {'person' => 'person', 'address' => 'address'}
+        instructions = {'person' => 'person', 'company' => 'company'}
+        HashEngine.extract(objects, instructions).should ==
+          {:error => ['Missing object(s): company']}
+      end
+    end
+
+    describe 'return values' do
+      before :each do
+        @instructions = {'person' => {'first_name' => nil,
+                                      'name' => nil,
+                                      'military' => nil,
+                                      'dob' => {'method' => 'date_of_birth'}
+                                     }
+                        }
+        @person = mock 'Person', :first_name => 'Mark',
+                                # :name => 'Mark',
+                                 :military? => false,
+                                 :date_of_birth => Time.at(0)
+        @output = HashEngine.extract(@person,@instructions)
+      end
+
+      it 'should get "Mark" for first_name' do
+        @output['first_name'].should == 'Mark'
+      end
+
+      it 'should get "false" for military' do
+        @output['military'].should == false
+      end
+
+      it 'should get "" for dob' do
+        @output['dob'].should == Time.at(0)
+      end
+
+      it 'should not have name' do
+        @output['name'].should == nil
+        @output.has_key?('name').should == false
+      end
+
+      it 'should have error for missing name' do
+        @output[:error].should == ["person does not respond to any of: name, name?"]
+      end
+    end
+  end
+
+ 
+  it 'fetch_objects'
+
+  describe 'fetch_attributes' do
+    it 'should check each field'
+    it 'should not fetch_value for reserved keys'
+  end
+
+  describe 'fetch_value' do
+    it 'should call a method on the object'
+    it 'should add an error if the object doesnt respond to the method'
+  end
+
+  describe 'set_result_or_recurse' do
+    it 'should set result'
+    it 'should append error'
+    it 'should recurse'
+  end
+
+  describe 'fetch_method_array' do
+    it 'should return 3 elements' do
+      HashEngine.fetch_method_array('field', {'method' => 'other_field'}).should == ['other_field', 'field', 'field?']
+    end
+
+    it 'should return 2 elements' do
+      HashEngine.fetch_method_array('field', nil).should == ['field', 'field?']
+    end
+  end
+
+  describe 'fetch_method' do
+    it 'should return method' do
+      object = mock 'Object', :other_field => :foo
+      HashEngine.fetch_method(object, 'field', {'method' => 'other_field'}).should == 'other_field'
+    end
+
+    it 'should return field' do
+      object = mock 'Object', :field => :foo
+      HashEngine.fetch_method(object, 'field', nil).should == 'field'
+    end
+
+    it 'should return field?' do
+      object = mock 'Object', :field? => :foo
+      HashEngine.fetch_method(object, 'field', nil).should == 'field?'
+    end
+
+    it 'should return nil' do
+      object = mock 'Object', :other_field => :foo
+      HashEngine.fetch_method(object, 'field', nil).should == nil
+    end
+  end
+
+  describe 'fetch_method_args' do
+    it 'should return [] when no field_instructions' do
+      HashEngine.fetch_method_args(nil, nil).should == []
+    end
+
+    it 'should return [] when no args' do
+      HashEngine.fetch_method_args(nil, {'method' => 'foo'}).should == []
+    end
+
+    it 'should return args unmodified if already an array' do
+      HashEngine.fetch_method_args(nil, {'method_args' => ['foo']}).should == ['foo']
+    end
+
+    it 'should convert to an array' do
+      HashEngine.fetch_method_args(nil, {'method_args' => 'foo'}).should == ['foo']
+    end
+  end
+
+  it 'append_error_for_required_fields'
+end

data/spec/hash_engine/fetchers_spec.rb

@@ -0,0 +1,30 @@
+require 'hash_engine'
+
+describe HashEngine do
+  describe 'valid_fetcher?' do
+    it 'returns true when key exists' do
+      HashEngine.valid_fetcher?('input').should be_true
+    end
+
+    it 'returns false when key does not exist' do
+      HashEngine.valid_fetcher?('foo').should be_false
+    end
+  end
+
+  describe 'fetcher' do
+    it 'returns the input field from customer_data' do
+      HashEngine.fetcher('input', 'foo', {'foo' => 'bar'}).should == 'bar'
+    end
+
+    it 'returns the literal' do
+      HashEngine.fetcher('literal', 'foo', {'foo' => 'bar'}).should == 'foo'
+    end
+
+    it 'returns multiple data fields' do
+      customer_data = {:field1 => :value1, :field2 => :value2}
+      field_data = [:field1, :field2]
+      expected = [:value1, :value2]
+      HashEngine.fetcher('data', field_data, customer_data).should == expected
+    end
+  end
+end

data/spec/hash_engine/format_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+require 'hash_engine'
+
+describe HashEngine do
+  describe 'format' do
+    # data,                       format_type,              output
+    [['sample',                   'string',                 'sample'],
+     ['  sample',                 'string',                 'sample'],
+     ['sample  ',                 'string',                 'sample'],
+     ['  sample  ',               'string',                 'sample'],
+     [55,                         'string',                 '55'],
+     [:sample,                    'string',                 'sample'],
+     ['sample',                   'first',                  's'],
+     ['ÑAlaman',                  'first',                  'Ñ'],
+     [55,                         'first',                  '5'],
+     ['sample',                   'alphanumeric',           'sample'],
+     ['s_a+m=p%l-e',              'alphanumeric',           'sample'],
+     [55,                         'alphanumeric',           '55'],
+     ['sample',                   'no_whitespace',          'sample'],
+     ['sam-ple',                  'no_whitespace',          'sam-ple'],
+     ['s_a+m=p%le',               'no_whitespace',          'sample'],
+     [55,                         'no_whitespace',          '55'],
+     ['123sample',                'alpha',                  'sample'],
+     ['s_a45m=p%l-e',             'alpha',                  'sample'],
+     ['123sample',                'numeric',                '123'],
+     ['682-59-7267',              'numeric',                '682597267'],
+     ['ext 99',                   'numeric',                '99'],
+     ['2000.99',                  'float',                  2000.99],
+     ['sample',                   'integer',                0],
+     ['123sample',                'integer',                123],
+     [55,                         'integer',                55],
+     [true,                       'integer',                1],
+     [false,                      'integer',                0],
+     [nil,                        'integer',                0],
+     [Date.parse('2009-07-14'),   {'strftime'=>"%Y-%m-%d"}, '2009-07-14'],
+     ['2009-07-14',               'date',                   Date.parse('2009-07-14')],
+     ['true',                     'boolean',                true],
+     ['TrUe',                     'boolean',                true],
+     ['t',                        'boolean',                true],
+     ['T',                        'boolean',                true],
+     [1,                          'boolean',                true],
+     ['yes',                      'boolean',                true],
+     ['Y',                        'boolean',                true],
+     [2,                          'boolean',                false],
+     ['false',                    'boolean',                false],
+     ['no',                       'boolean',                false],
+     ['sample',                   'gibberish',              'sample'],
+     ['sample',                   nil,                      'sample']
+    ].each {|data, format_type, output|
+      it "#{data.class} #{data.inspect} should be cast as #{format_type} #{output.inspect}" do
+        HashEngine.action('format', format_type, data).should == output
+      end
+    }
+  end
+end

data/spec/hash_engine/transform_spec.rb

@@ -0,0 +1,365 @@
+require 'hash_engine'
+require 'yaml'
+
+describe HashEngine do
+  describe 'nil_check' do
+    it { HashEngine.nil_check({'allow_nil' => false}, nil).should be_true }
+    it { HashEngine.nil_check({'allow_nil' => true}, nil).should be_false }
+    it { HashEngine.nil_check({'allow_nil' => false}, :ll).should be_false }
+  end
+
+  describe 'blank_check' do
+    it { HashEngine.blank_check({'allow_blank' => false}, '').should be_true }
+    it { HashEngine.blank_check({'allow_blank' => false}, '  ').should be_true }
+    it { HashEngine.blank_check({'allow_blank' => true}, '').should be_false }
+    it { HashEngine.blank_check({'allow_blank' => false}, 'string').should be_false }
+  end
+
+  describe 'required_check' do
+    it { HashEngine.required_check({'optional' => true}).should be_false }
+    it { HashEngine.required_check({}).should be_true }
+    it { HashEngine.required_check({'optional' => false}).should be_true }
+  end
+
+  describe 'suppress_nil' do
+    it { HashEngine.suppress_nil({'suppress_nil' => true}, nil).should be_true }
+    it { HashEngine.suppress_nil({'suppress_nil' => false}, nil).should be_false }
+    it { HashEngine.suppress_nil({'suppress_nil' => true}, :ll).should be_false }
+  end
+
+  describe 'suppress_blank' do
+    it { HashEngine.suppress_blank({'suppress_blank' => true}, '').should be_true }
+    it { HashEngine.suppress_blank({'suppress_blank' => true}, '  ').should be_true }
+    it { HashEngine.suppress_blank({'suppress_blank' => false}, '').should be_false }
+    it { HashEngine.suppress_blank({'suppress_blank' => true}, 'string').should be_false }
+  end
+
+  it 'default_or_supress'
+
+  it 'transform'
+
+  it 'simple_instructions'
+
+  describe 'concat' do
+    it 'returns arg2 if arg1 is nil' do
+      HashEngine.concat(nil, :arg).should == :arg
+    end
+
+    it 'combines arg1 + arg2 when both are arrays' do
+      arg1 = [:arg1_1, :arg1_2]
+      arg2 = [:arg2_1, :arg2_2]
+      HashEngine.concat(arg1, arg2).should == [:arg1_1, :arg1_2, :arg2_1, :arg2_2]
+    end
+
+    it 'adds arg2 to the end when arg1 is an array' do
+      arg1 = [:arg1_1, :arg1_2]
+      HashEngine.concat(arg1, :arg2).should == [:arg1_1, :arg1_2, :arg2]
+    end
+
+    it 'puts arg1 at the front when arg2 is an array' do
+      arg2 = [:arg2_1, :arg2_2]
+      HashEngine.concat(:arg1, arg2).should == [:arg1, :arg2_1, :arg2_2]
+    end
+
+    it 'creates an array when niether arg1 or arg2 is' do
+      HashEngine.concat(:arg1, :arg2).should == [:arg1, :arg2]
+    end
+  end
+
+  it 'process_instructions'
+
+  it 'get_value'
+
+# output_2:
+#   conditional_input:
+#     left_operand
+#       input: data_key_1
+#     operator: eq
+#     right_operand:
+#       input: data_key_4
+#     true_instructions:
+#       data:
+#         - data_key_2
+#         - data_key_3
+#       join: '#'
+#     false_instructions:
+#       data:
+#         - data_key_1
+#         - data_key_4
+#       join: '#'
+#   When data_value_1 is the same as data_value_4 the result would be => data_value_2#data_value_3
+#   When data_value_1 is not the same as data_value_4 the result would be => data_value_1#data_value_4
+  describe 'conditional_eval' do
+    let(:data) do
+      {'data_key_1' => 'data_value_1',
+       'data_key_2' => 'data_value_2',
+       'data_key_3' => 'data_value_3',
+       'data_key_4' => 'data_value_4',
+       'data_key_5' => 'data_value_5'}
+    end
+
+    context 'specified in an array' do
+      it 'handles trivial case' do
+        yaml =<<EOYAML
+fields:
+  status:
+    - conditional_eval:
+        left_operand:
+          input: data_key_1
+        operator: eq
+        right_operand:
+          input: data_key_4
+        true_instructions:
+          input: data_key_2
+        false_instructions:
+          input: data_key_3
+EOYAML
+        instructions = YAML.load yaml
+        results = HashEngine.transform(data, instructions)
+        results[:error].should == []
+        results['status'].should == 'data_value_3'
+      end
+
+      it 'handles complex operand' do
+        yaml =<<EOYAML
+fields:
+  status:
+    - conditional_eval:
+        left_operand:
+          data:
+            - data_key_2
+            - data_key_3
+          join: '#'
+        operator: eq
+        right_operand:
+          input: data_key_4
+        true_instructions:
+          input: data_key_2
+        false_instructions:
+          input: data_key_3
+EOYAML
+        instructions = YAML.load yaml
+        results = HashEngine.transform(data, instructions)
+        results[:error].should == []
+        results['status'].should == 'data_value_3'
+      end
+
+      it 'handles complex result instructions' do
+        yaml =<<EOYAML
+fields:
+  status:
+    - conditional_eval:
+        left_operand:
+          input: data_key_1
+        operator: eq
+        right_operand:
+          input: data_key_4
+        true_instructions:
+          data:
+            - data_key_2
+            - data_key_3
+          join: '#'
+        false_instructions:
+          data:
+            - data_key_1
+            - data_key_4
+          join: '#'
+EOYAML
+        instructions = YAML.load yaml
+        results = HashEngine.transform(data, instructions)
+        results[:error].should == []
+        results['status'].should == 'data_value_1#data_value_4'
+      end
+    end
+
+    context 'specified in a hash' do
+      it 'handles trivial case' do
+        yaml =<<EOYAML
+fields:
+  status:
+    conditional_eval:
+      left_operand:
+        input: data_key_1
+      operator: eq
+      right_operand:
+        input: data_key_4
+      true_instructions:
+        input: data_key_2
+      false_instructions:
+        input: data_key_3
+EOYAML
+        instructions = YAML.load yaml
+        results = HashEngine.transform(data, instructions)
+        results[:error].should == []
+        results['status'].should == 'data_value_3'
+      end
+
+      it 'handles complex operand' do
+        yaml =<<EOYAML
+fields:
+  status:
+    conditional_eval:
+      left_operand:
+        data:
+          - data_key_2
+          - data_key_3
+        join: '#'
+      operator: eq
+      right_operand:
+        input: data_key_4
+      true_instructions:
+        input: data_key_2
+      false_instructions:
+        input: data_key_3
+EOYAML
+        instructions = YAML.load yaml
+        results = HashEngine.transform(data, instructions)
+        results[:error].should == []
+        results['status'].should == 'data_value_3'
+      end
+
+      it 'handles complex result instructions' do
+        yaml =<<EOYAML
+fields:
+  status:
+    conditional_eval:
+      left_operand:
+        input: data_key_1
+      operator: eq
+      right_operand:
+        input: data_key_4
+      true_instructions:
+        data:
+          - data_key_2
+          - data_key_3
+        join: '#'
+      false_instructions:
+        data:
+          - data_key_1
+          - data_key_4
+        join: '#'
+EOYAML
+        instructions = YAML.load yaml
+        results = HashEngine.transform(data, instructions)
+        results[:error].should == []
+        results['status'].should == 'data_value_1#data_value_4'
+      end
+    end
+  end
+
+  describe 'transformation' do
+    let(:data) do
+      {'vendor_status' => 'ok',
+       'vendor_payload' => 'http://www.domain.com',
+       'vendor_uuid' => '1234ABCD'}
+    end
+
+    it 'trivial case' do
+      yaml =<<EOYAML
+fields:
+  payload: vendor_payload
+EOYAML
+      instructions = YAML.load yaml
+      results = HashEngine.transform(data, instructions)
+      results[:error].should be_empty
+      results['payload'].should == 'http://www.domain.com'
+    end
+
+    it 'simple case' do
+      yaml =<<EOYAML
+fields:
+  payload:
+    input: vendor_payload
+EOYAML
+      instructions = YAML.load yaml
+      results = HashEngine.transform(data, instructions)
+      results[:error].should be_empty
+      results['payload'].should == 'http://www.domain.com'
+    end
+
+    it 'simple formatting' do
+      yaml =<<EOYAML
+fields:
+  uuid:
+    input: vendor_uuid
+    format: numeric
+EOYAML
+      instructions = YAML.load yaml
+      results = HashEngine.transform(data, instructions)
+      results[:error].should be_empty
+      results['uuid'].should == '1234'
+    end
+
+    it 'lookup map case' do
+      yaml =<<EOYAML
+fields:
+  status:
+    input: vendor_status
+    lookup_map:
+      ok: accepted
+      decline: reject
+      default: error
+EOYAML
+      instructions = YAML.load yaml
+      results = HashEngine.transform(data, instructions)
+      results[:error].should be_empty
+      results['status'].should == 'accepted'
+    end
+
+    it 'copied source case' do
+      yaml =<<EOYAML
+copy_source: true
+fields:
+  status:
+    input: vendor_status
+    lookup_map:
+      ok: accepted
+      decline: reject
+      default: error
+EOYAML
+      instructions = YAML.load yaml
+      results = HashEngine.transform(data, instructions)
+      expected = {'vendor_status' => 'ok',
+                   'vendor_payload' => 'http://www.domain.com',
+                   'vendor_uuid' => '1234ABCD',
+                   :error => [],
+                   'status' => 'accepted'}
+      results.should == expected
+    end
+
+    it 'multiple data case' do
+      yaml =<<EOYAML
+fields:
+  status:
+    - input: vendor_status
+    - data:
+       - vendor_status
+       - vendor_status
+    - join: ', '
+EOYAML
+      instructions = YAML.load yaml
+      results = HashEngine.transform(data, instructions)
+      results[:error].should be_empty
+      results['status'].should == 'ok, ok, ok'
+    end
+
+    it 'multiple data case with an action in the middle' do
+      yaml =<<EOYAML
+fields:
+  status:
+    - input: vendor_status
+    - subgroup:
+        input: vendor_status
+        lookup_map:
+          ok: accepted
+          decline: reject
+          default: error
+    - join: ', '
+EOYAML
+      instructions = YAML.load yaml
+      results = HashEngine.transform(data, instructions)
+      results[:error].should be_empty
+      results['status'].should == 'ok, accepted'
+    end
+  end
+end