importu 0.1.0 → 0.2.0

data/spec/lib/importu/converters_spec.rb

@@ -1,274 +1,317 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
-require 'active_support/core_ext/time/calculations'
+require "importu/converter_context"
+require "importu/definition"
 
-describe Importu::Importer do
-  subject(:record) { build(:importer_record) }
+RSpec.describe "Importu Converters" do
+  subject(:context) { Importu::ConverterContext.with_config(**definition.config).new(data) }
+  let(:definition) { Class.new(Importu::Definition) }
+
+  let(:data) { { "field1" => " value1 ", "field2" => "value2" } }
 
   describe ":raw converter" do
+    let(:definition) { Class.new(super()) { fields :field1, :field3 } }
+    let(:data) { { "field1" => " value1 ", "field2" => "value2" } }
+
     it "uses definition's label as key when looking up data" do
-      record.stub(:definitions => { :field1 => { :label => "field1", :required => true } })
-      record.stub(:data => { "field1" => " value1 ", "field2" => "value2" })
-      record.convert(:field1, :raw).should eq " value1 "
+      expect(context.raw(:field1)).to eq " value1 "
     end
 
     it "raises an exception if field definition is not defined" do
-      expect { record.convert(:field1, :raw) }.to raise_error
-    end
-
-    it "raises MissingField if field data not defined" do
-      record.stub(:definitions => { :field1 => { :required => true } })
-      expect { record.convert(:field1, :raw) }.to raise_error(Importu::MissingField)
+      expect { context.raw(:field2) }.to raise_error(Importu::InvalidDefinition)
     end
   end
 
-  describe ":clean converter" do
-    it "returns nil if raw data is nil" do
-      record.converters[:raw] = proc { nil }
-      record.convert(:field1, :clean).should be nil
+  describe ":trimmed converter" do
+    it "returns nil if raw value is nil" do
+      allow(context).to receive(:raw_value).and_return(nil)
+      expect(context.trimmed(:field1)).to be nil
     end
 
     it "returns nil if a blank string" do
-      record.converters[:raw] = proc { "" }
-      record.convert(:field1, :clean).should be nil
+      allow(context).to receive(:raw_value).and_return("")
+      expect(context.trimmed(:field1)).to be nil
     end
 
     it "returns stripped value if a string" do
-      record.converters[:raw] = proc { "  abc  123 " }
-      record.convert(:field1, :clean).should eq "abc  123"
+      allow(context).to receive(:raw_value).and_return("  abc  123 ")
+      expect(context.trimmed(:field1)).to eq "abc  123"
     end
 
     it "returns original value if not a string" do
       raw_val = Time.now
-      record.converters[:raw] = proc { raw_val }
-      record.convert(:field1, :clean).should eq raw_val
+      allow(context).to receive(:raw_value).and_return(raw_val)
+      expect(context.trimmed(:field1)).to eq raw_val
+    end
+
+    it "handles unicode strings with leading/trailing whitespace" do
+      allow(context).to receive(:raw_value).and_return("  \u00e9l\u00e8ve  ")
+      expect(context.trimmed(:field1)).to eq "\u00e9l\u00e8ve"
+    end
+
+    # NOTE: Ruby's String#strip only handles ASCII whitespace. Unicode whitespace
+    # characters like ideographic space (U+3000) or non-breaking space (U+00A0)
+    # are not stripped. This documents the current behavior.
+    it "does not strip unicode whitespace characters (uses String#strip)" do
+      allow(context).to receive(:raw_value).and_return("\u00a0test\u3000")
+      expect(context.trimmed(:field1)).to eq "\u00a0test\u3000"
     end
   end
 
   describe ":string converter" do
-    it "returns nil if clean value is nil" do
-      record.converters[:clean] = proc { nil }
-      record.convert(:field1, :string).should be nil
+    it "returns nil if trimmed value is nil" do
+      definition.converter(:trimmed) {|*| nil }
+      expect(context.string(:field1)).to be nil
+    end
+
+    it "returns string if trimmed value is a string" do
+      definition.converter(:trimmed) {|*| "six pence" }
+      expect(context.string(:field1)).to eq "six pence"
     end
 
-    it "returns string if clean value is a string" do
-      record.converters[:clean] = proc { "six pence" }
-      record.convert(:field1, :string).should eq "six pence"
+    it "converts trimmed value to string if not a string" do
+      trimmed_val = Time.now
+      definition.converter(:trimmed) {|*| trimmed_val }
+      expect(context.string(:field1)).to eq trimmed_val.to_s
     end
 
-    it "converts clean value to string if not a string" do
-      clean_val = Time.now
-      record.converters[:clean] = proc { clean_val }
-      record.convert(:field1, :string).should eq clean_val.to_s
+    it "preserves unicode characters in string" do
+      definition.converter(:trimmed) {|*| "\u00e9l\u00e8ve \u4e2d\u6587" }
+      expect(context.string(:field1)).to eq "\u00e9l\u00e8ve \u4e2d\u6587"
     end
   end
 
   describe ":integer converter" do
-    it "returns nil if clean value is nil" do
-      record.converters[:clean] = proc { nil }
-      record.convert(:field1, :integer).should be nil
+    it "returns nil if trimmed value is nil" do
+      definition.converter(:trimmed) {|*| nil }
+      expect(context.integer(:field1)).to be nil
+    end
+
+    it "returns integer if trimmed value returns an integer" do
+      definition.converter(:trimmed) {|*| 92 }
+      expect(context.integer(:field1)).to eq 92
     end
 
-    it "returns integer if clean value returns an integer" do
-      record.converters[:clean] = proc { 92 }
-      record.convert(:field1, :integer).should eq 92
+    it "converts trimmed value to integer if not an integer type" do
+      definition.converter(:trimmed) {|*| "29" }
+      expect(context.integer(:field1)).to eq 29
     end
 
-    it "converts clean value to integer if not an integer type" do
-      record.converters[:clean] = proc { "29" }
-      record.convert(:field1, :integer).should eq 29
+    it "handles values with a leading 0 as a decimal (not octal)" do
+      definition.converter(:trimmed) {|*| "044" }
+      expect(context.integer(:field1)).to eq 44
     end
 
-    it "raises an exception if clean value is not a valid integer" do
-      record.converters[:clean] = proc { "4.25" }
-      expect { record.convert(:field1, :integer) }.to raise_error(Importu::FieldParseError)
+    it "raises an ArgumentError if trimmed value is not a valid integer" do
+      definition.converter(:trimmed) {|*| "4.25" }
+      expect { context.integer(:field1) }.to raise_error(ArgumentError)
     end
   end
 
   describe ":float converter" do
-    it "returns nil if clean value is nil" do
-      record.converters[:clean] = proc { nil }
-      record.convert(:field1, :float).should be nil
+    it "returns nil if trimmed value is nil" do
+      definition.converter(:trimmed) {|*| nil }
+      expect(context.float(:field1)).to be nil
     end
 
-    it "returns float if clean value returns an float" do
-      record.converters[:clean] = proc { 92.25 }
-      record.convert(:field1, :float).should eq 92.25
+    it "returns float if trimmed value returns an float" do
+      definition.converter(:trimmed) {|*| 92.25 }
+      expect(context.float(:field1)).to eq 92.25
     end
 
-    it "converts clean value to float if not an float type" do
-      record.converters[:clean] = proc { "29.4" }
-      record.convert(:field1, :float).should eq 29.4
+    it "converts trimmed value to float if not an float type" do
+      definition.converter(:trimmed) {|*| "29.4" }
+      expect(context.float(:field1)).to eq 29.4
     end
 
     it "converts whole values to float" do
-      record.converters[:clean] = proc { "77" }
-      record.convert(:field1, :float).should eq 77.0
+      definition.converter(:trimmed) {|*| "77" }
+      expect(context.float(:field1)).to eq 77.0
     end
 
-    it "raises an exception if clean value is not a valid float" do
-      record.converters[:clean] = proc { "4d6point3" }
-      expect { record.convert(:field1, :float) }.to raise_error(Importu::FieldParseError)
+    it "raises an ArgumentError if trimmed value is not a valid float" do
+      definition.converter(:trimmed) {|*| "4d6point3" }
+      expect { context.float(:field1) }.to raise_error(ArgumentError)
     end
   end
 
   describe ":decimal converter" do
-    it "returns nil if clean value is nil" do
-      record.converters[:clean] = proc { nil }
-      record.convert(:field1, :decimal).should be nil
+    it "returns nil if trimmed value is nil" do
+      definition.converter(:trimmed) {|*| nil }
+      expect(context.decimal(:field1)).to be nil
     end
 
-    it "returns decimal if clean value returns an decimal" do
-      clean_val = BigDecimal("92.25")
-      record.converters[:clean] = proc { clean_val }
-      record.convert(:field1, :decimal).should eq clean_val
+    it "returns decimal if trimmed value returns an decimal" do
+      trimmed_val = BigDecimal("92.25")
+      definition.converter(:trimmed) {|*| trimmed_val }
+      expect(context.decimal(:field1)).to eq trimmed_val
     end
 
-    it "converts clean value to decimal if not an decimal type" do
-      record.converters[:clean] = proc { "29.4" }
-      record.convert(:field1, :decimal).should eq BigDecimal("29.4")
+    it "converts trimmed value to decimal if not an decimal type" do
+      definition.converter(:trimmed) {|*| "29.4" }
+      expect(context.decimal(:field1)).to eq BigDecimal("29.4")
     end
 
     it "converts whole values to decimal" do
-      record.converters[:clean] = proc { "77" }
-      record.convert(:field1, :decimal).should eq BigDecimal("77.0")
+      definition.converter(:trimmed) {|*| "77" }
+      expect(context.decimal(:field1)).to eq BigDecimal("77.0")
     end
 
-    it "raises an exception if clean value is not a valid decimal" do
-      record.converters[:clean] = proc { "4d6point3" }
-      expect { record.convert(:field1, :decimal) }.to raise_error(Importu::FieldParseError)
+    it "raises an ArgumentError if trimmed value is not a valid decimal" do
+      definition.converter(:trimmed) {|*| "4d6point3" }
+      expect { context.decimal(:field1) }.to raise_error(ArgumentError)
     end
   end
 
   describe ":boolean converter" do
-    it "returns nil if clean value is nil" do
-      record.converters[:clean] = proc { nil }
-      record.convert(:field1, :boolean).should be nil
+    it "returns nil if trimmed value is nil" do
+      definition.converter(:trimmed) {|*| nil }
+      expect(context.boolean(:field1)).to be nil
+    end
+
+    it "returns true if trimmed value is true" do
+      definition.converter(:trimmed) {|*| true }
+      expect(context.boolean(:field1)).to eq true
+    end
+
+    it "returns true if trimmed value is 'true'" do
+      definition.converter(:trimmed) {|*| "true" }
+      expect(context.boolean(:field1)).to eq true
+    end
+
+    it "returns true if trimmed value is 'yes'" do
+      definition.converter(:trimmed) {|*| "yes" }
+      expect(context.boolean(:field1)).to eq true
     end
 
-    it "returns true if clean value is true" do
-      record.converters[:clean] = proc { true }
-      record.convert(:field1, :boolean).should eq true
+    it "returns true if trimmed value is '1'" do
+      definition.converter(:trimmed) {|*| "1" }
+      expect(context.boolean(:field1)).to eq true
     end
 
-    it "returns true if clean value is 'true'" do
-      record.converters[:clean] = proc { "true" }
-      record.convert(:field1, :boolean).should eq true
+    it "returns true if trimmed value is 1" do
+      definition.converter(:trimmed) {|*| 1 }
+      expect(context.boolean(:field1)).to eq true
     end
 
-    it "returns true if clean value is 'yes'" do
-      record.converters[:clean] = proc { "yes" }
-      record.convert(:field1, :boolean).should eq true
+    it "returns false if trimmed value is false" do
+      definition.converter(:trimmed) {|*| false }
+      expect(context.boolean(:field1)).to eq false
     end
 
-    it "returns true if clean value is '1'" do
-      record.converters[:clean] = proc { "1" }
-      record.convert(:field1, :boolean).should eq true
+    it "returns false if trimmed value is 'false'" do
+      definition.converter(:trimmed) {|*| "false" }
+      expect(context.boolean(:field1)).to eq false
     end
 
-    it "returns true if clean value is 1" do
-      record.converters[:clean] = proc { 1 }
-      record.convert(:field1, :boolean).should eq true
+    it "returns false if trimmed value is 'no'" do
+      definition.converter(:trimmed) {|*| "no" }
+      expect(context.boolean(:field1)).to eq false
     end
 
-    it "returns false if clean value is false" do
-      record.converters[:clean] = proc { false }
-      record.convert(:field1, :boolean).should eq false
+    it "returns false if trimmed value is '0'" do
+      definition.converter(:trimmed) {|*| "0" }
+      expect(context.boolean(:field1)).to eq false
     end
 
-    it "returns false if clean value is 'false'" do
-      record.converters[:clean] = proc { "false" }
-      record.convert(:field1, :boolean).should eq false
+    it "returns false if trimmed value is 0" do
+      definition.converter(:trimmed) {|*| 0 }
+      expect(context.boolean(:field1)).to eq false
     end
 
-    it "returns false if clean value is 'no'" do
-      record.converters[:clean] = proc { "no" }
-      record.convert(:field1, :boolean).should eq false
+    it "raises an ArgumentError if the value is invalid" do
+      definition.converter(:trimmed) {|*| "why-not-both" }
+      expect { context.boolean(:field1) }.to raise_error(ArgumentError)
     end
 
-    it "returns false if clean value is '0'" do
-      record.converters[:clean] = proc { "0" }
-      record.convert(:field1, :boolean).should eq false
+    it "treats values as case-insensitive" do
+      definition.converter(:trimmed) {|*| "TrUE" }
+      expect(context.boolean(:field1)).to eq true
     end
 
-    it "returns false if clean value is 0" do
-      record.converters[:clean] = proc { 0 }
-      record.convert(:field1, :boolean).should eq false
+    # NOTE: The boolean converter receives values AFTER trimming, so whitespace
+    # around boolean values should already be stripped. If raw values with
+    # whitespace need to work, they should use the :trimmed converter first.
+    # This test documents that behavior - " true " without trimming will fail.
+    it "does not handle whitespace (expects trimmed input)" do
+      definition.converter(:trimmed) {|*| " true " }
+      expect { context.boolean(:field1) }.to raise_error(ArgumentError)
     end
   end
 
   describe ":date converter" do
-    it "returns nil if clean value is nil" do
-      record.converters[:clean] = proc { nil }
-      record.convert(:field1, :date).should be nil
+    it "returns nil if trimmed value is nil" do
+      definition.converter(:trimmed) {|*| nil }
+      expect(context.date(:field1)).to be nil
     end
 
     context "when a format is not specified" do
       it "tries to guess the date format (DD/MM/YYYY is default?)" do
         expected = Date.new(2012, 10, 3)
-        record.converters[:clean] = proc { "03/10/2012" }
-        record.convert(:field1, :date).should eq expected
+        definition.converter(:trimmed) {|*| "03/10/2012" }
+        expect(context.date(:field1)).to eq expected
       end
 
-      it "raises an exception if the date is invaild" do
-        record.converters[:clean] = proc { "2012-04-32" }
-        expect { record.convert(:field1, :date) }.to raise_error(Importu::FieldParseError)
+      it "raises an ArgumentError if the date is invaild" do
+        definition.converter(:trimmed) {|*| "2012-04-32" }
+        expect { context.date(:field1) }.to raise_error(ArgumentError)
       end
     end
 
     context "when a format is specified" do
       it "parses dates that match the format" do
         expected = Date.new(2012, 4, 18)
-        record.converters[:clean] = proc { "04/18/2012" }
-        record.convert(:field1, :date, :format => "%m/%d/%Y").should eq expected
+        definition.converter(:trimmed) {|*| "04/18/2012" }
+        expect(context.date(:field1, format: "%m/%d/%Y")).to eq expected
       end
 
-      it "raises exception if date doesn't match the format" do
-        record.converters[:clean] = proc { "04-18-2012" }
-        expect { record.convert(:field1, :date) }.to raise_error(Importu::FieldParseError)
+      it "raises an ArgumentError if date doesn't match the format" do
+        definition.converter(:trimmed) {|*| "04-18-2012" }
+        expect { context.date(:field1) }.to raise_error(ArgumentError)
       end
 
-      it "raises an exception if the date is invalid" do
-        record.converters[:clean] = proc { "04/32/2012" }
-        expect { record.convert(:field1, :date) }.to raise_error(Importu::FieldParseError)
+      it "raises an ArgumentError if the date is invalid" do
+        definition.converter(:trimmed) {|*| "04/32/2012" }
+        expect { context.date(:field1) }.to raise_error(ArgumentError)
       end
     end
   end
 
   describe ":datetime converter" do
-    it "returns nil if clean value is nil" do
-      record.converters[:clean] = proc { nil }
-      record.convert(:field1, :datetime).should be nil
+    it "returns nil if trimmed value is nil" do
+      definition.converter(:trimmed) {|*| nil }
+      expect(context.datetime(:field1)).to be nil
     end
 
     context "when a format is not specified" do
       it "tries to guess the date format (DD/MM/YYYY is default?)" do
-        expected = DateTime.parse("2012-10-03 04:37:29")
-        record.converters[:clean] = proc { "03/10/2012 04:37:29" }
-        record.convert(:field1, :datetime).should eq expected
+        expected = Time.parse("2012-10-03 04:37:29Z")
+        definition.converter(:trimmed) {|*| "03/10/2012 04:37:29" }
+        expect(context.datetime(:field1)).to eq expected
       end
 
-      it "raises an exception if the datetime is invaild" do
-        record.converters[:clean] = proc { "2012-04-32 15:41:22" }
-        expect { record.convert(:field1, :datetime) }.to raise_error(Importu::FieldParseError)
+      it "raises an ArgumentError if the datetime is invaild" do
+        definition.converter(:trimmed) {|*| "2012-04-32 15:41:22" }
+        expect { context.datetime(:field1) }.to raise_error(ArgumentError)
       end
     end
 
     context "when a format is specified" do
       it "parses datetimes that match the format" do
-        expected = DateTime.parse("2012-04-18 16:37:00")
-        record.converters[:clean] = proc { "04/18/2012 16:37" }
-        record.convert(:field1, :datetime, :format => "%m/%d/%Y %H:%M").should eq expected
+        expected = Time.parse("2012-04-18 16:37:00Z")
+        definition.converter(:trimmed) {|*| "04/18/2012 16:37" }
+        expect(context.datetime(:field1, format: "%m/%d/%Y %H:%M")).to eq expected
       end
 
-      it "raises exception if datetime doesn't match the format" do
-        record.converters[:clean] = proc { "04-18-2012 15:22:19" }
-        expect { record.convert(:field1, :datetime) }.to raise_error(Importu::FieldParseError)
+      it "raises an ArgumentError if datetime doesn't match the format" do
+        definition.converter(:trimmed) {|*| "04-18-2012 15:22:19" }
+        expect { context.datetime(:field1) }.to raise_error(ArgumentError)
       end
 
-      it "raises an exception if the datetime is invalid" do
-        record.converters[:clean] = proc { "04/32/2012 00:00:00" }
-        expect { record.convert(:field1, :datetime) }.to raise_error(Importu::FieldParseError)
+      it "raises an ArgumentError if the datetime is invalid" do
+        definition.converter(:trimmed) {|*| "04/32/2012 00:00:00" }
+        expect { context.datetime(:field1) }.to raise_error(ArgumentError)
       end
     end
   end