importu 0.1.0 → 0.2.0

data/spec/lib/importu/backends/active_record_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+require "importu/backends/active_record"
+require "importu/importer"
+require "importu/sources/csv"
+
+RSpec.describe "ActiveRecord Backend", :active_record do
+  let(:source) { Importu::Sources::CSV.new(infile("books-valid", :csv)) }
+  subject(:importer) { importer_class.new(source) }
+
+  let!(:model) do
+    stub_const("Book", Class.new(ActiveRecord::Base) do
+      serialize :authors, type: Array
+      validates :title, :authors, :isbn10, :release_date, presence: true
+      validates :isbn10, length: { is: 10 }, uniqueness: true
+    end)
+  end
+
+  let(:importer_class) do
+    Class.new(BookImporter) do
+      model "Book"
+    end
+  end
+
+  around(:each) do |example|
+    require "database_cleaner-active_record"
+    DatabaseCleaner.cleaning { example.run }
+  end
+
+  describe "#import!" do
+    let(:models_json) do
+      serialized = Book.all.to_json(except: [:id, :created_at, :updated_at])
+      JSON.parse(serialized)
+    end
+
+    it "imports new book records" do
+      expect { importer.import! }.to change { Book.count }.by(3)
+    end
+
+    it "correctly summarizes import statistics" do
+      summary = importer.import!
+      expected_summary_json!("books-valid", summary)
+    end
+
+    it "correctly saves imported data in the model" do
+      importer.import!
+      expect(models_json).to match_array expected_model_json("books-valid")
+    end
+
+    context "when definition includes non-abstract fields not on model" do
+      let(:importer_class) { Class.new(super()) { fields(:foo, :bar) { "blah" } } }
+
+      it "raises an UnassignableFields error" do
+        expect { importer.import! }.to raise_error(Importu::UnassignableFields)
+      end
+    end
+
+    context "when model has validation errors" do
+      let(:importer_class) { Class.new(super()) { field(:isbn10) { "foo" } } }
+
+      it "marks each record creation as invalid" do
+        summary = importer.import!
+        expect(summary.created).to eq 0
+        expect(summary.invalid).to eq 3
+      end
+
+      it "includes validation errors in summary" do
+        summary = importer.import!
+        expect(summary.validation_errors.any? {|msg, _| msg =~ /isbn10/i }).to be true
+      end
+    end
+
+    context "when creating records" do
+      context "when create actions are not allowed" do
+        let(:importer_class) { Class.new(super()) { allow_actions :update } }
+
+        it "marks each record creation as inavlid" do
+          summary = importer.import!
+          expect(summary.created).to eq 0
+          expect(summary.invalid).to eq 3
+        end
+      end
+
+      context "when duplicate records in source file" do
+        let(:source) { Importu::Sources::CSV.new(infile("books-duplicates", :csv)) }
+
+        it "marks the three duplicate records as invalid" do
+          summary = importer.import!
+          expected_summary_json!("books-duplicates", summary)
+        end
+      end
+    end
+
+    context "when updating records" do
+      before { importer.import! }
+
+      context "and there are no changes" do
+        it "marks each record as unchanged" do
+          summary = importer.import!
+          expect(summary.unchanged).to eq 3
+        end
+      end
+
+      context "when updates actions are not allowed" do
+        let(:importer_class) { Class.new(super()) { allow_actions :create } }
+
+        it "marks each record update as inavlid" do
+          summary = importer.import!
+          expect(summary.updated).to eq 0
+          expect(summary.invalid).to eq 3
+        end
+      end
+
+      context "when a find_by block is used" do
+        let(:importer_class) do
+          Class.new(super()) do
+            find_by do |record|
+              find_by(title: record[:title])
+            end
+          end
+        end
+
+        it "executes the find_by block in context of the model" do
+          expect(Book)
+            .to receive(:find_by).with(title: anything)
+            .at_least(3).times
+            .and_call_original
+
+          summary = importer.import!
+          expect(summary.unchanged).to eq 3
+        end
+      end
+    end
+
+    context "when a before_save callback is defined" do
+      let(:importer_class) do
+        Class.new(super()) do
+          before_save { object.title = object.title.upcase }
+        end
+      end
+
+      it "runs callback before saving" do
+        importer.import!
+        Book.first.title == Book.first.title.upcase
+      end
+    end
+  end
+
+end

data/spec/lib/importu/backends/middleware/duplicate_manager_proxy_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+require "importu/backends/middleware/duplicate_manager_proxy"
+require "importu/definition"
+
+RSpec.describe Importu::Backends::Middleware::DuplicateManagerProxy do
+  subject(:middleware) { described_class.new(dummy_backend, **backend_config) }
+
+  let(:dummy_backend) { DummyBackend.new(**backend_config) }
+  let(:backend_config) { definition.config[:backend] }
+
+  let(:definition) do
+    Class.new(Importu::Definition) do
+      fields :foo, :bar, :baz
+      find_by :foo, :bar
+    end
+  end
+
+  describe "#create" do
+    it "returns the status and object from the backend" do
+      status, object = middleware.create(foo: 1, bar: 1, baz: 1)
+      expect(status).to eq :created
+      expect(object).to include(foo: 1, bar: 1, baz: 1)
+    end
+
+    it "perform duplicate detection on the record" do
+      middleware.create(foo: 1, bar: 1, baz: 1)
+      expect { middleware.create(foo: 2, bar: 1, baz: 2) } # :baz is a dupe find_by
+        .to raise_error(Importu::DuplicateRecord)
+    end
+
+    it "records created object for subsequent dupe detection" do
+      middleware.create(foo: 1, bar: 1, baz: 1)
+      expect { middleware.create(foo: 2, bar: 1, baz: 2) }
+        .to raise_error(Importu::DuplicateRecord)
+    end
+  end
+
+  describe "#update" do
+    it "returns the status and object from the backend" do
+      _, object = dummy_backend.create(foo: 1, bar: 1, baz: 1)
+      status, new_object = middleware.update({foo: 2, bar: 2, baz: 2}, object)
+
+      expect(status).to eq :updated
+      expect(new_object).to include(foo: 2, bar: 2, baz: 2)
+    end
+
+    it "perform duplicate detection on the record" do
+      _status, object = middleware.create(foo: 1, bar: 1, baz: 1)
+
+      expect(dummy_backend).to_not receive(:update)
+      expect { middleware.update({foo: 1, bar: 2, baz: 2}, object) } # :foo is a dupe
+        .to raise_error(Importu::DuplicateRecord)
+    end
+
+    it "performs duplicate detection on object" do
+      # Existing db record, never accessed through dupe detector
+      _status, object = dummy_backend.create(foo: 1, bar: 1, baz: 1)
+
+      # Update via :foo, first encounter of k/v and first encounter of object
+      expect { middleware.update({foo: 1, bar: 2, baz: 3}, object) }.to_not raise_error
+
+      # Update via :bar, first encounter of k/v, but second encounter of object
+      expect { middleware.update({foo: 2, bar: 1, baz: 3}, object) }
+        .to raise_error(Importu::DuplicateRecord)
+    end
+  end
+
+end

data/spec/lib/importu/backends/middleware/enforce_allowed_actions_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+require "importu/backends/middleware/enforce_allowed_actions"
+require "importu/definition"
+
+RSpec.describe Importu::Backends::Middleware::EnforceAllowedActions do
+  subject(:middleware) { described_class.new(dummy_backend, **backend_config) }
+
+  let(:dummy_backend) { DummyBackend.new(**backend_config) }
+  let(:backend_config) { definition.config[:backend] }
+
+  let(:definition) do
+    Class.new(Importu::Definition) do
+      allow_actions nil
+      fields :foo, :bar, :baz
+    end
+  end
+
+  describe "#create" do
+    context "when :create action is allowed" do
+      let(:definition) { Class.new(super()) { allow_actions :create } }
+
+      it "returns the status and object from the backend" do
+        status, object = middleware.create(foo: 1, bar: 1, baz: 1)
+        expect(status).to eq :created
+        expect(object).to include(foo: 1, bar: 1, baz: 1)
+      end
+    end
+
+    context "when :create action is not allowed" do
+      it "raises an InvalidError exception" do
+        expect { middleware.create(foo: 1, bar: 1, baz: 1) }
+          .to raise_error(Importu::InvalidRecord)
+      end
+
+      it "includes guidance in the error message" do
+        expect { middleware.create(foo: 1, bar: 1, baz: 1) }
+          .to raise_error(/allow_actions :create/)
+      end
+    end
+  end
+
+  describe "#update" do
+    let(:object) { _, object = dummy_backend.create(foo: 1, bar: 1, baz: 1); object }
+
+    context "when :update action is allowed" do
+      let(:definition) { Class.new(super()) { allow_actions :update } }
+
+      it "returns the status and object from the backend" do
+        status, new_object = middleware.update({foo: 2, bar: 2, baz: 2}, object)
+        expect(status).to eq :updated
+        expect(new_object).to include(foo: 2, bar: 2, baz: 2)
+      end
+    end
+
+    context "when :update action is not allowed" do
+      it "raises an InvalidError exception" do
+        expect { middleware.update({foo: 2}, object) }
+          .to raise_error(Importu::InvalidRecord)
+      end
+
+      it "includes guidance in the error message" do
+        expect { middleware.update({foo: 2}, object) }
+          .to raise_error(/allow_actions :create, :update/)
+      end
+    end
+  end
+
+end

data/spec/lib/importu/backends_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+require "importu/backends"
+require "importu/definition"
+
+RSpec.describe Importu::Backends do
+  subject(:registry) { described_class.new }
+
+  describe ".registry" do
+    it "returns a registry singleton" do
+      expect(described_class.registry).to be described_class.registry
+    end
+
+    it "returns a registry-like object" do
+      expect(described_class.registry).to respond_to("register")
+      expect(described_class.registry).to respond_to("lookup")
+    end
+  end
+
+  describe "#from_config!" do
+    let!(:model) { stub_const("MyModelGuest", Class.new) }
+    let(:config) { definition.config[:backend] }
+
+    context "when a model backend is specified" do
+      let(:definition) do
+        Class.new(Importu::Definition) do
+          model "MyModelGuest", backend: :cherry_scones
+        end
+      end
+
+      context "and the backend is registered" do
+        let!(:backend) { registry.register(:cherry_scones, Class.new) }
+
+        it "returns the backend" do
+          expect(registry.from_config!(**config)).to eq backend
+        end
+      end
+
+      context "and the backend is not registered" do
+        it "raises a BackendNotRegistered error" do
+          expect { registry.from_config!(**config) }
+            .to raise_error(Importu::BackendNotRegistered)
+        end
+      end
+    end
+
+    context "when backend is :auto" do
+      let(:supported) { Class.new { def self.supported_by_model?(*); true; end } }
+
+      let(:definition) do
+        Class.new(Importu::Definition) do
+          model "MyModelGuest", backend: :auto
+        end
+      end
+
+      before { registry.register(:backend1, supported) }
+
+      it "auto-detects the backend" do
+        expect(registry.from_config!(**config)).to eq supported
+      end
+    end
+
+    context "when a model backend is not specified" do
+      let(:supported) { Class.new { def self.supported_by_model?(*); true; end } }
+      let(:unsupported) { Class.new { def self.supported_by_model?(*); false; end } }
+
+      let(:definition) do
+        Class.new(Importu::Definition) do
+          model "MyModelGuest"
+        end
+      end
+
+      context "and no backends support the model" do
+        before { registry.register(:backend1, unsupported) }
+
+        it "raises a BackendMatch error" do
+          expect { registry.from_config!(**config) }
+            .to raise_error(Importu::BackendMatchError)
+        end
+      end
+
+      context "and exactly one backend supports the model" do
+        before do
+          registry.register(:backend1, unsupported)
+          registry.register(:backend2, supported)
+        end
+
+        it "returns the supported backend" do
+          expect(registry.from_config!(**config)).to eq supported
+        end
+      end
+
+      context "and multiple backends support the model" do
+        before do
+          registry.register(:backend1, unsupported)
+          registry.register(:backend2, supported)
+          registry.register(:backend3, supported)
+        end
+
+        it "raises a BackendMatch error" do
+          expect { registry.from_config!(**config) }
+            .to raise_error(Importu::BackendMatchError)
+        end
+      end
+
+      context "and a backend raises an exception during checking" do
+        let(:broken) { Class.new { def self.supported_by_model?(*); raise :hell; end } }
+
+        before do
+          registry.register(:backend1, broken)
+          registry.register(:backend2, unsupported)
+          registry.register(:backend3, supported)
+        end
+
+        it "ignores the backend" do
+          expect(registry.from_config!(**config)).to eq supported
+        end
+      end
+    end
+  end
+
+  describe "#lookup" do
+    let(:marvelous_impl) { Class.new }
+    before { registry.register(:marvelous, marvelous_impl) }
+
+    it "raises a BackendNotRegistered exception if backend not found" do
+      expect { registry.lookup(:foo) }
+        .to raise_error(Importu::BackendNotRegistered)
+    end
+
+    it "supports lookups by symbol-based name" do
+      expect(registry.lookup(:marvelous)).to eq marvelous_impl
+    end
+    it "supports lookups by string-based name" do
+      expect(registry.lookup("marvelous")).to eq marvelous_impl
+    end
+  end
+
+  describe "#names" do
+    it "returns the names of all registered backends" do
+      registry.register(:backend1, Class.new)
+      registry.register(:backend2, Class.new)
+      registry.register(:backend3, Class.new)
+      expect(registry.names).to include(:backend1, :backend2, :backend3)
+    end
+  end
+
+  describe "#register" do
+    let(:backend1) { Class.new }
+    let(:backend2) { Class.new }
+
+    it "registers the backend" do
+      registry.register(:backend1, backend1)
+      expect(registry.lookup(:backend1)).to eq backend1
+    end
+
+    it "returns the backend that was registered" do
+      expect(registry.register(:backend1, backend1)).to eq backend1
+    end
+
+    it "allows registering multiple backends" do
+      registry.register(:backend1, backend1)
+      registry.register(:backend2, backend2)
+      expect(registry.lookup(:backend1)).to eq backend1
+      expect(registry.lookup(:backend2)).to eq backend2
+    end
+  end
+
+end