importu 0.1.0 → 0.2.0

data/spec/lib/importu/definition_spec.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+require "importu/definition"
+
+RSpec.describe Importu::Definition do
+  subject(:definition) { Class.new(ancestor) }
+  let(:ancestor) { Class.new(Importu::Definition) }
+
+  describe "#allow_actions" do
+    it "updates the [:backend][:allowed_actions] config" do
+      expect { definition.allow_actions(:create, :update) }
+        .to change { definition.config[:backend][:allowed_actions] }
+        .to([:create, :update])
+    end
+
+    it "inherits config from ancestor" do
+      ancestor.allow_actions(:update)
+      expect(definition.config[:backend][:allowed_actions]).to eq [:update]
+    end
+
+    it "does not affect ancestor config" do
+      ancestor.allow_actions(:update)
+      expect { definition.allow_actions(:create, :update) }
+        .to_not change { ancestor.config }
+    end
+  end
+
+  describe "#before_save" do
+    let(:foo_block) { Proc.new {} }
+
+    it "updates the [:backend][:before_save] config" do
+      expect { definition.before_save(&foo_block) }
+        .to change { definition.config[:backend][:before_save] }
+        .to(foo_block)
+    end
+
+    it "inherits config from ancestor" do
+      ancestor.before_save(&foo_block)
+      expect(definition.config[:backend][:before_save]).to eq foo_block
+    end
+
+    it "does not affect ancestor config" do
+      ancestor.before_save(&foo_block)
+      expect { definition.before_save {} }
+        .to_not change { ancestor.config }
+    end
+  end
+
+  describe "#config" do
+    it "returns a config hash of the definition" do
+      expect(definition.config).to include(:converters, :fields)
+    end
+
+    it "[:backend][:allowed_actions] defaults to only allow :create" do
+      expect(definition.config[:backend][:allowed_actions]).to eq [:create]
+    end
+
+    it "[:backend][:finder_fields] defaults to no fields" do
+      expect(definition.config[:backend][:finder_fields]).to eq []
+    end
+  end
+
+  describe "#convert_to" do
+    let!(:converter) do
+      definition.converter :foo do |name, **options|
+        "foo(#{name}, {#{options.map {|k, v| "#{k}:#{v}"}.join(",")}})"
+      end
+    end
+
+    it "returns a converter stub representing the converter" do
+      stub = definition.convert_to(:foo)
+      expect(stub.type).to eq :foo
+    end
+
+    it "saves converter options from definition" do
+      expect(definition.convert_to(:foo, a: 7).options).to eq({a: 7})
+      expect(definition.convert_to(:foo).options).to eq({})
+    end
+
+    it "raises an exception if converter cannot be found" do
+      expect { definition.convert_to(:bar) }.to raise_error(KeyError)
+    end
+  end
+
+  describe "#converter" do
+    let(:foo_block) { Proc.new {} }
+
+    it "updates the :converters config" do
+      expect { definition.converter(:foo, &foo_block) }
+        .to change { definition.config[:converters][:foo] }
+        .to(foo_block)
+    end
+
+    it "inherits config from ancestor" do
+      ancestor.converter(:foo, &foo_block)
+      expect(definition.config[:converters][:foo]).to eq foo_block
+    end
+
+    it "does not affect ancestor config" do
+      ancestor.converter(:foo, &foo_block)
+      expect { definition.converter(:foo) {} }
+        .to_not change { ancestor.config }
+    end
+  end
+
+  describe "#field" do
+    let(:converter) { Proc.new {} }
+
+    it "updates the :fields config and presets defaults" do
+      definition.field(:foo, required: false)
+      expect(definition.config[:fields][:foo])
+        .to eq definition.field_defaults(:foo).merge(required: false)
+    end
+
+    it "inherits config from ancestors" do
+      ancestor.field(:foo, required: false, &converter)
+      expect(definition.config[:fields][:foo]).to include(
+        required: false,
+        converter: converter,
+      )
+    end
+
+    it "does not affect ancestor config" do
+      ancestor.field(:foo, required: false, &converter)
+      expect { definition.field(:foo, abstract: true, label: "baaa") }
+        .to_not change { ancestor.config }
+      expect(definition.config[:fields][:foo]).to include(
+        required: false,
+        abstract: true,
+        label: "baaa"
+      )
+    end
+
+    it "allows partially updating the field config" do
+      ancestor.field(:foo, required: false, &converter)
+      definition.field(:foo, abstract: true, label: "baaa")
+      definition.field(:foo, create: false)
+      expect(definition.config[:fields][:foo]).to include(
+        required: false,
+        abstract: true,
+        create: false,
+        label: "baaa",
+        converter: converter,
+      )
+    end
+
+    it "defaults to using the :default converter" do
+      definition.field(:foo)
+      field_definition = definition.config[:fields][:foo]
+      expect(field_definition[:converter].type).to eq :default
+    end
+  end
+
+  describe "#fields" do
+    it "configures each field with the same properties" do
+      converter = Proc.new {}
+      expect(definition).to receive(:field).with(:foo, required: false, &converter)
+      expect(definition).to receive(:field).with(:bar, required: false, &converter)
+      expect(definition).to receive(:field).with(:baz, required: false, &converter)
+      definition.fields(:foo, :bar, :baz, required: false, &converter)
+    end
+  end
+
+  describe "#find_by" do
+    it "updates the [:backend][:finder_fields] config" do
+      expect { definition.find_by(:foo, [:bar, :baz]) }
+        .to change { definition.config[:backend][:finder_fields] }
+        .to([[:foo], [:bar, :baz]])
+    end
+
+    it "inherits config from ancestor" do
+      ancestor.find_by(:foo, [:bar, :baz])
+      expect(definition.config[:backend][:finder_fields])
+        .to eq [[:foo], [:bar, :baz]]
+    end
+
+    it "does not affect ancestor config" do
+      ancestor.find_by(:foo, [:bar, :baz])
+      expect { definition.find_by(:bar) }
+        .to_not change { ancestor.config }
+    end
+
+    it "allows setting to a block" do
+      foo_block = Proc.new {}
+      expect { definition.find_by(&foo_block) }
+        .to change { definition.config[:backend][:finder_fields] }
+        .to([foo_block])
+    end
+
+    it "allows clearing all finder fields" do
+      ancestor.find_by(:foo, [:bar, :baz])
+      expect { definition.find_by(nil) }
+        .to change { definition.config[:backend][:finder_fields] }
+        .to([])
+    end
+  end
+
+  describe "#model" do
+    it "updates the :backend config" do
+      expect { definition.model("Foo") }
+        .to change { definition.config[:backend][:model] }
+        .to("Foo")
+    end
+
+    it "inherits config from ancestor" do
+      ancestor.model("Foo")
+      expect(definition.config[:backend][:model]).to eq "Foo"
+    end
+
+    it "does not affect ancestor config" do
+      ancestor.model("Foo")
+      expect { definition.model("Bar") }
+        .to_not change { ancestor.config }
+    end
+
+    it "allows specifying a backend property" do
+      expect { definition.model("Foo", backend: :oven) }
+        .to change { definition.config[:backend][:name] }
+        .to(:oven)
+    end
+  end
+
+  describe "#source" do
+    let(:converter) { Proc.new {} }
+
+    it "updates the :sources config" do
+      definition.source(:xml, records_xpath: "//people")
+      expect(definition.config[:sources][:xml])
+        .to include(records_xpath: "//people")
+    end
+
+    it "inherits config from ancestors" do
+      ancestor.source(:xml, records_xpath: "//animals")
+      expect(definition.config[:sources][:xml])
+        .to include(records_xpath: "//animals")
+    end
+
+    it "does not affect ancestor config" do
+      ancestor.source(:xml, records_xpath: "//animals")
+      expect { definition.source(:xml, records_xpath: "//people") }
+        .to_not change { ancestor.config }
+      expect(definition.config[:sources][:xml])
+        .to include(records_xpath: "//people")
+    end
+  end
+
+end

data/spec/lib/importu/duplicate_manager_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+require "importu/exceptions"
+
+RSpec.describe Importu::DuplicateManager do
+  subject(:duplicates) { described_class.new(finder_fields: finder_fields) }
+
+  let(:finder_fields) { [] }
+
+  describe "#check_object!" do
+    it "allows different unique ids to be set without any errors" do
+      duplicates.check_object!(9164)
+      expect { duplicates.check_object!(9165) }.to_not raise_error
+    end
+
+    it "raises a DuplicateRecord when unique on subsequent encounters" do
+      duplicates.check_object!(9164)
+      expect { duplicates.check_object!(9164) }
+        .to raise_error(Importu::DuplicateRecord)
+    end
+  end
+
+  describe "#check_record!" do
+    context "when no finder fields are defined" do
+      let(:finder_fields) { [] }
+
+      it "never considers records to be duplicates" do
+        duplicates.check_record!(foo: 3, bar: 4)
+        expect { duplicates.check_record!(foo: 3, bar: 4) }.to_not raise_error
+      end
+    end
+
+    context "when a finder field is defined" do
+      let(:finder_fields) { [[:foo]] }
+
+      it "allows different values to be set without any errors" do
+        duplicates.check_record!(foo: 3, bar: 4)
+        expect { duplicates.check_record!(foo: 4, bar: 4) }.to_not raise_error
+      end
+    end
+
+    context "when multiple finder field groups are defined" do
+      let(:finder_fields) { [[:foo, :bar], [:bar, :baz], [:qux]] }
+
+      it "records and matches against all field groups" do
+        duplicates.check_record!(foo: 1, bar: 1, baz: 1, qux: 1)
+
+        # Each field group has a unique set of values from previous check
+        duplicates.check_record!(foo: 1, bar: 2, baz: 1, qux: 2)
+
+        # The second field group conflicts with values from previous check
+        expect { duplicates.check_record!(foo: 2, bar: 2, baz: 1, qux: 3) }
+          .to raise_error(Importu::DuplicateRecord)
+      end
+
+      it "adds all non-duplicate field groups, even if exception is raised" do
+        duplicates.check_record!(foo: 1, bar: 1, baz: 1, qux: 1)
+
+        # Only first field group is duplicate, but others should still get added
+        expect { duplicates.check_record!(foo: 1, bar: 1, baz: 2, qux: 2) }
+          .to raise_error(Importu::DuplicateRecord)
+
+        expect { duplicates.check_record!(bar: 1, baz: 2) }
+          .to raise_error(Importu::DuplicateRecord)
+        expect { duplicates.check_record!(qux: 2) }
+          .to raise_error(Importu::DuplicateRecord)
+      end
+    end
+
+    context "when a proc-based finder field is defined" do
+      let(:finder_fields) { [Proc.new { raise :bleep }, [:foo]] }
+
+      it "ignores proc-based field groups" do
+        duplicates.check_record!(foo: 3, bar: 4)
+        duplicates.check_record!(foo: 4, bar: 4)
+        expect { duplicates.check_record!(foo: 3, bar: 5) }
+          .to raise_error(Importu::DuplicateRecord)
+      end
+    end
+
+    context "when a field in a finder field group is does not exist on the record" do
+      let(:finder_fields) { [[:foo, :baz]] }
+
+      it "ignores the field group when doing duplicate checking" do
+        duplicates.check_record!(foo: 3, bar: 4)
+        expect { duplicates.check_record!(foo: 3, bar: 4) }.to_not raise_error
+      end
+    end
+  end
+
+end

data/spec/lib/importu/exceptions_spec.rb

@@ -1,10 +1,13 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
-describe Importu::ImportuException do
+require "importu/exceptions"
+
+RSpec.describe Importu::ImportuException do
   subject(:exception) { Importu::ImportuException.new }
 
   it "#name should return 'ImportuException" do
-    exception.name.should eq "ImportuException"
+    expect(exception.name).to eq "ImportuException"
   end
 
   describe Importu::InvalidInput do
@@ -15,7 +18,7 @@ describe Importu::ImportuException do
     end
 
     it "#name should return 'InvalidInput'" do
-      exception.name.should eq "InvalidInput"
+      expect(exception.name).to eq "InvalidInput"
     end
   end
 
@@ -27,24 +30,48 @@ describe Importu::ImportuException do
     end
 
     it "#name should return 'InvalidRecord'" do
-      exception.name.should eq "InvalidRecord"
+      expect(exception.name).to eq "InvalidRecord"
+    end
+
+    describe "#normalized_message" do
+      context "when not provided" do
+        it "returns nil" do
+          expect(exception.normalized_message).to be_nil
+        end
+      end
+
+      context "when provided" do
+        subject(:exception) do
+          Importu::InvalidRecord.new(
+            "isbn too short (was: abc)", nil, normalized_message: "isbn too short"
+          )
+        end
+
+        it "returns the normalized message" do
+          expect(exception.normalized_message).to eq "isbn too short"
+        end
+
+        it "preserves the full message" do
+          expect(exception.message).to eq "isbn too short (was: abc)"
+        end
+      end
     end
   end
 
   describe Importu::FieldParseError do
-    subject(:exception) { Importu::FieldParseError.new }
+    subject(:exception) { Importu::FieldParseError.new(:foo, "is invalid") }
 
     it "should be a subclass of Importu::InvalidRecord" do
       exception.class.ancestors.include?(Importu::InvalidRecord)
     end
 
     it "#name should return 'FieldParseError'" do
-      exception.name.should eq "FieldParseError"
+      expect(exception.name).to eq "FieldParseError"
     end
   end
 
   describe Importu::MissingField do
-    let(:definition) { { :name => "foo_field_1", :label => "Field 1" } }
+    let(:definition) { { name: "foo_field_1", label: "Field 1" } }
     subject(:exception) { Importu::MissingField.new(definition) }
 
     it "should be a subclass of Importu::InvalidRecord" do
@@ -52,30 +79,56 @@ describe Importu::ImportuException do
     end
 
     it "#name should return 'MissingField'" do
-      exception.name.should eq "MissingField"
+      expect(exception.name).to eq "MissingField"
     end
 
     it "#definition should return the definition passed during construction" do
-      exception.definition.should eq definition
+      expect(exception.definition).to eq definition
     end
 
     describe "#message" do
       it "should mention a missing field" do
-        exception.message.should match(/missing field/i)
+        expect(exception.message).to match(/missing field/i)
       end
 
       context "field definition has a label" do
-        let(:definition) { { :label => "Field 2" } }
+        let(:definition) { { label: "Field 2" } }
         it "mentions missing field's label" do
-          exception.message.should match(/Field 2/)
+          expect(exception.message).to match(/Field 2/)
         end
       end
 
       context "field definition is missing a label" do
-        let(:definition) { { :name => "foo_field_2" } }
+        let(:definition) { { name: "foo_field_2" } }
 
         it "mentions missing field's name" do
-          exception.message.should match(/foo_field_2/)
+          expect(exception.message).to match(/foo_field_2/)
+        end
+      end
+
+      context "when available_fields is provided" do
+        subject(:exception) do
+          Importu::MissingField.new(definition, available_fields: ["name", "email", "phone"])
+        end
+
+        it "lists available fields" do
+          expect(exception.message).to match(/available fields: name, email, phone/)
+        end
+      end
+
+      context "when available_fields is empty" do
+        subject(:exception) do
+          Importu::MissingField.new(definition, available_fields: [])
+        end
+
+        it "does not include available fields section" do
+          expect(exception.message).not_to match(/available fields/)
+        end
+      end
+
+      context "when available_fields is not provided" do
+        it "does not include available fields section" do
+          expect(exception.message).not_to match(/available fields/)
         end
       end
     end
@@ -89,7 +142,7 @@ describe Importu::ImportuException do
     end
 
     it "#name should return 'DuplicateRecord'" do
-      exception.name.should eq "DuplicateRecord"
+      expect(exception.name).to eq "DuplicateRecord"
     end
   end
 

data/spec/lib/importu/import_context_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+require "importu/converter_context"
+require "importu/definition"
+require "importu/exceptions"
+
+RSpec.describe Importu::ConverterContext do
+  subject(:context) do
+    described_class.with_config(**definition.config).new(data)
+  end
+
+  let(:definition) { Class.new(Importu::Definition) }
+
+  let(:data) { {} }
+
+  describe "#field_value" do
+    let(:definition) do
+      Class.new(super()) do
+        field :field1, required: true, &convert_to(:integer)
+      end
+    end
+
+    let(:data) { { "field1" => "73" } }
+
+    it "returns the field value after applying the converter" do
+      expect(context.field_value(:field1)).to eq 73
+    end
+
+    context "when a definition doesn't exist for the field" do
+      it "raises an InvalidDefinition error" do
+        expect { context.field_value(:nonexistent_field) }
+          .to raise_error(Importu::InvalidDefinition)
+      end
+    end
+
+    context "when the converted value is nil" do
+      let(:data) { { "field1" => nil } }
+
+      context "and the field is required" do
+        let(:definition) { Class.new(super()) { field :field1, required: true } }
+
+        it "raises a MissingField error" do
+          expect { context.field_value(:field1) }
+            .to raise_error(Importu::MissingField)
+        end
+
+        context "and a default is defined on the field" do
+          let(:definition) { Class.new(super()) { field :field1, default: :beep } }
+
+          it "raises a MissingField error" do
+            expect { context.field_value(:field1) }
+              .to raise_error(Importu::MissingField)
+          end
+        end
+      end
+
+      context "and the field is not required" do
+        let(:definition) { Class.new(super()) { field :field1, required: false } }
+
+        it "returns nil" do
+          expect(context.field_value(:field1)).to be nil
+        end
+
+        context "annd a default is defined on the field" do
+          let(:definition) { Class.new(super()) { field :field1, default: :beep } }
+
+          it "returns the default value" do
+            expect(context.field_value(:field1)).to eq :beep
+          end
+        end
+      end
+    end
+
+    context "when converter raises an ArgumentError" do
+      let(:definition) do
+        Class.new(super()) do
+          converter(:ash) {|*| raise ArgumentError, "sawdust" }
+          field :field1, &convert_to(:ash)
+        end
+      end
+
+      it "raises a FieldParseError error" do
+        expect { context.field_value(:field1) }
+          .to raise_error(Importu::FieldParseError)
+      end
+
+      it "includes the original error message" do
+        expect { context.field_value(:field1) }
+          .to raise_error(Importu::FieldParseError)
+          .with_message(/sawdust/)
+      end
+    end
+
+    context "when converter raises an unexpected error" do
+      let(:definition) do
+        Class.new(super()) do
+          converter(:rubble) {|*| raise StandardError, "you did what?!" }
+          field :field1, &convert_to(:rubble)
+        end
+      end
+
+      it "raises the unexpected exception" do
+        expect { context.field_value(:field1) }
+          .to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe "field cross-references" do
+    context "when a field converter references another field" do
+      let(:definition) do
+        Class.new(super()) do
+          field :first_name
+          field :last_name
+          field :full_name, abstract: true do
+            "#{field_value(:first_name)} #{field_value(:last_name)}"
+          end
+        end
+      end
+
+      let(:data) { { "first_name" => "Arthur", "last_name" => "Dent" } }
+
+      it "can access other field values" do
+        expect(context.field_value(:full_name)).to eq "Arthur Dent"
+      end
+    end
+
+    context "when a field references a field with a converter" do
+      let(:definition) do
+        Class.new(super()) do
+          field :price, &convert_to(:decimal)
+          field :quantity, &convert_to(:integer)
+          field :total, abstract: true do
+            field_value(:price) * field_value(:quantity)
+          end
+        end
+      end
+
+      let(:data) { { "price" => "19.99", "quantity" => "3" } }
+
+      it "receives the converted value, not raw" do
+        expect(context.field_value(:total)).to eq BigDecimal("59.97")
+      end
+    end
+
+    context "when a referenced field is missing" do
+      let(:definition) do
+        Class.new(super()) do
+          field :first_name
+          field :last_name
+          field :full_name, abstract: true do
+            "#{field_value(:first_name)} #{field_value(:last_name)}"
+          end
+        end
+      end
+
+      let(:data) { { "first_name" => "Arthur" } }
+
+      it "raises MissingField for the referenced field" do
+        expect { context.field_value(:full_name) }
+          .to raise_error(Importu::MissingField)
+      end
+    end
+  end
+
+  describe "#raw_value" do
+    let(:definition) { Class.new(super()) { field :field1 } }
+    let(:data) { { "field1" => "zippy" } }
+
+    it "returns the data associated with the field" do
+      expect(context.raw_value(:field1)).to eq data["field1"]
+    end
+
+    context "when a definition doesn't exist for the field" do
+      it "raises an InvalidDefinition error" do
+        expect { context.raw_value(:nonexistent_field) }
+          .to raise_error(Importu::InvalidDefinition)
+      end
+    end
+
+    context "when data is nil for the field" do
+      let(:data) { { "field1" => nil } }
+
+      it "returns nil" do
+        expect(context.raw_value(:field1)).to be nil
+      end
+    end
+
+    context "when the field does not exist in data hash" do
+      let(:data) { {} }
+
+      it "returns nil" do
+        expect(context.raw_value(:field1)).to be nil
+      end
+    end
+  end
+
+end