solidus_importer 0.1.0

data/spec/lib/solidus_importer/processors/option_values_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Processors::OptionValues do
+  describe '#call' do
+    subject(:described_method) { described_class.call(context) }
+
+    let(:context) { { data: data, variant: variant } }
+    let(:variant) { create :base_variant }
+    let(:product) { variant.product }
+    let(:color) { create :option_type, presentation: 'Color' }
+    let(:size) { create :option_type, presentation: 'Size' }
+    let(:data) do
+      {
+        'Option1 Name' => 'Size',
+        'Option1 Value' => 'L',
+        'Option2 Name' => 'Color',
+        'Option2 Value' => 'Black'
+      }
+    end
+
+    before { product.option_types << size << color }
+
+    context 'when "Option(1,2,3) Value" are present' do
+      it 'create option values for variant in row' do
+        expect { described_method }.to change(variant.option_values, :count).from(0).to(2)
+        expect(variant.option_values.first.presentation).to eq 'L'
+        expect(variant.option_values.first.name).to eq 'L'
+        expect(variant.option_values.last.presentation).to eq 'Black'
+        expect(variant.option_values.last.name).to eq 'Black'
+      end
+
+      it 'creates "Black" option value for related "Color" option type' do
+        described_method
+        black = variant.option_values.find_by(presentation: 'Black')
+        l = variant.option_values.find_by(presentation: 'L')
+        expect(black.option_type).to eq color
+        expect(l.option_type).to eq size
+      end
+    end
+  end
+end

data/spec/lib/solidus_importer/processors/order_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Processors::Order do
+  describe '#call' do
+    subject(:described_method) { described_class.call(context) }
+
+    let(:context) { {} }
+
+    context 'without order number in row data' do
+      let(:context) do
+        { data: 'Some data' }
+      end
+
+      it 'raises an exception' do
+        expect { described_method }.to raise_error(SolidusImporter::Exception, 'Missing required key: "Name"')
+      end
+    end
+
+    context 'with an order row with a file entity' do
+      let(:context) do
+        { data: data }
+      end
+      let(:data) { build(:solidus_importer_row_order, :with_import).data }
+      let(:result) { context.merge(order: Spree::Order.last) }
+
+      before { allow(Spree::Store).to receive(:default).and_return(build_stubbed(:store)) }
+
+      it 'creates a new order' do
+        expect { described_method }.to change { Spree::Order.count }.by(1)
+        expect(described_method).to eq(result)
+      end
+
+      context 'with an existing valid order' do
+        let!(:order) { create(:order, number: data['Name'], email: data['Email']) }
+
+        it 'updates the order' do
+          expect { described_method }.not_to(change{ Spree::Order.count })
+          expect(described_method).to eq(result)
+          expect(order.reload.email).to eq('an_email@example.com')
+        end
+      end
+
+      context 'with an existing invalid order' do
+        let!(:order) { create(:order, number: data['Name'], email: data['Email']) }
+
+        before { order.update_column(:state, 'an invalid state') }
+
+        it 'raises an exception' do
+          expect { described_method }.to raise_error(ActiveRecord::RecordInvalid, /State is invalid/)
+        end
+      end
+    end
+  end
+end

data/spec/lib/solidus_importer/processors/product_images_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Processors::ProductImages do
+  describe '#call' do
+    subject(:described_method) { described_class.call(context) }
+
+    let(:context) { {} }
+
+    context 'without "Image Src" attribute in row data' do
+      let(:context) do
+        { data: { 'Some attr' => 'some value' }, product: build_stubbed(:product) }
+      end
+
+      it 'returns nothing' do
+        expect(described_method).to be_nil
+      end
+    end
+
+    context 'with a product and a invalid image in row data' do
+      let(:context) do
+        { data: { 'Image Src' => 'some missing image' }, product: build_stubbed(:product) }
+      end
+
+      it 'raises an exception' do
+        expect { described_method }.to raise_error(Errno::ENOENT, /No such file or directory/)
+      end
+    end
+
+    context 'with a product and a valid image in row data' do
+      let(:image_path) { solidus_importer_fixture_path('thinking-cat.jpg') }
+      let(:context) do
+        { data: { 'Image Src' => image_path }, product: build_stubbed(:product) }
+      end
+
+      it 'adds images to the product' do
+        expect { described_method }.to change(context[:product].images, :any?).from(false).to(true)
+      end
+    end
+  end
+end

data/spec/lib/solidus_importer/processors/product_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Processors::Product do
+  describe '#call' do
+    subject(:described_method) { described_class.call(context) }
+
+    let(:context) { {} }
+
+    context 'without product slug in row data' do
+      let(:context) do
+        { data: 'Some data' }
+      end
+
+      it 'raises an exception' do
+        expect { described_method }.to raise_error(SolidusImporter::Exception, 'Missing required key: "Handle"')
+      end
+    end
+
+    context 'with a product row with a file entity' do
+      let(:context) do
+        { data: data }
+      end
+      let(:data) { build(:solidus_importer_row_product, :with_import).data }
+      let(:product) { Spree::Product.last }
+      let(:result) { context.merge(product: product) }
+      let!(:shipping_category) { create(:shipping_category) }
+
+      it 'creates a new product' do
+        expect { described_method }.to change { Spree::Product.count }.by(1)
+        expect(described_method).to eq(result)
+        expect(product).not_to be_available
+      end
+
+      context 'when "Published" is "true"' do
+        before { data.merge! 'Published' => 'true' }
+
+        it 'creates an available product' do
+          described_method
+          expect(product).to be_available
+        end
+      end
+
+      context 'when "Published" is false' do
+        before { data.merge! 'Published' => 'false' }
+
+        it 'creates an available product' do
+          described_method
+          expect(product).not_to be_available
+        end
+      end
+
+      context 'with an existing valid product' do
+        let(:result) { { data: data, product: product } }
+        let!(:product) { create(:product, slug: data['Handle']) }
+
+        it 'updates the product' do
+          expect { described_method }.not_to(change { Spree::Product.count })
+          expect(described_method).to eq(result)
+          expect(product.reload.name).to eq('A product name')
+        end
+      end
+    end
+  end
+end

data/spec/lib/solidus_importer/processors/taxon_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Processors::Taxon do
+  describe '#call' do
+    subject(:described_method) { described_class.call(context) }
+
+    let!(:shipping_category) { create :shipping_category }
+    let(:context) { { data: data, product: product } }
+    let(:product) { create :product }
+    let(:data) { build(:solidus_importer_row_product, :with_import, :with_type, :with_tags).data }
+    let(:tags_taxonomy) { Spree::Taxonomy.find_by(name: 'Tags') }
+    let(:type_taxonomy) { Spree::Taxonomy.find_by(name: 'Type') }
+
+    it 'create a taxon for each tag, related to the given taxonomy' do
+      expect { described_method }.to change(product.taxons, :count).by(4)
+
+      %w[Type1 Tag1 Tag2 Tag3].each do |taxon_name|
+        expect(product.taxons.map(&:name)).to include(taxon_name)
+      end
+
+      expect(Spree::Taxon.find_by(name: 'Tag1').taxonomy).to eq tags_taxonomy
+      expect(Spree::Taxon.find_by(name: 'Type1').taxonomy).to eq type_taxonomy
+    end
+
+    it 'creates "Type" and "Tags" taxonomies' do
+      described_method
+      expect(type_taxonomy).to be_present
+      expect(tags_taxonomy).to be_present
+    end
+  end
+end

data/spec/lib/solidus_importer/processors/variant_images_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Processors::VariantImages do
+  describe '#call' do
+    subject(:described_method) { described_class.call(context) }
+
+    let(:context) { {} }
+
+    context 'without "Variant Image" attribute in row data' do
+      let(:context) do
+        { data: { 'Some attr' => 'some value' }, product: build_stubbed(:product) }
+      end
+
+      it 'returns nothing' do
+        expect(described_method).to be_nil
+      end
+    end
+
+    context 'with a variant and a invalid image in row data' do
+      let(:context) do
+        { data: { 'Variant Image' => 'some missing image' }, variant: build_stubbed(:variant) }
+      end
+
+      it 'raises an exception' do
+        expect { described_method }.to raise_error(Errno::ENOENT, /No such file or directory/)
+      end
+    end
+
+    context 'with a variant and a valid image in row data' do
+      let(:context) do
+        {
+          data: { 'Variant Image' => solidus_importer_fixture_path('thinking-cat.jpg') },
+          variant: build_stubbed(:variant)
+        }
+      end
+
+      it 'adds images to the variant' do
+        expect { described_method }.to change(context[:variant].images, :any?).from(false).to(true)
+      end
+    end
+  end
+end

data/spec/lib/solidus_importer/processors/variant_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Processors::Variant do
+  describe '#call' do
+    subject(:described_method) { described_class.call(context) }
+
+    let(:context) { {} }
+
+    context 'without a target product' do
+      let(:context) do
+        { data: { 'Variant SKU' => 'some SKU' }, product: nil }
+      end
+
+      it 'raises an exception' do
+        expect { described_method }.to raise_error(ArgumentError, 'missing :product in context')
+      end
+    end
+
+    context 'with a variant row, a product and a source file' do
+      let(:context) do
+        { data: data, product: product }
+      end
+      let(:data) { build(:solidus_importer_row_variant, :with_import).data }
+      let!(:product) { create(:product, slug: data['Handle']) }
+
+      before do
+        allow(Spree::ShippingCategory).to receive(:last).and_return(build_stubbed(:shipping_category))
+      end
+
+      context 'when "Option1 Value" is "Some value"' do
+        let(:result) { context.merge(variant: product.variants.first) }
+
+        before { data.merge! 'Option1 Value' => 'Some value' }
+
+        it 'creates a new variant' do
+          expect { described_method }.to change { Spree::Variant.count }.by(1)
+          expect(described_method).to eq(result)
+          expect(product.variants.first.weight).to eq 20.0
+          expect(product.variants.first.price).to eq 60.5
+        end
+      end
+
+      context 'when "Option1 Value" is "Default Title"' do
+        let(:result) { context.merge(variant: product.master) }
+
+        before { data.merge! 'Option1 Value' => 'Default Title' }
+
+        it 'updates master variant' do
+          expect { described_method }.not_to(change { Spree::Variant.count })
+          expect(described_method).to eq(result)
+          expect(product.master.weight).to eq 20.0
+          expect(product.master.price).to eq 60.5
+        end
+      end
+
+      context 'when "Option1 Value" is blank' do
+        let(:result) { context.merge(variant: product.master) }
+
+        before { data.merge! 'Option1 Value' => nil }
+
+        it 'updates master variant' do
+          expect { described_method }.not_to(change { Spree::Variant.count })
+          expect(described_method).to eq(result)
+          expect(product.master.weight).to eq 20.0
+          expect(product.master.price).to eq 60.5
+        end
+      end
+
+      context 'with an existing valid variant' do
+        let(:result) { context.merge(variant: variant) }
+        let!(:variant) { create(:variant, sku: data['Variant SKU'], price: 0, weight: 10.0) }
+
+        before { data.merge! 'Option1 Value' => 'Some value' }
+
+        it 'updates the variant' do
+          expect { described_method }.not_to(change { Spree::Variant.count })
+          expect(described_method).to eq(result)
+          expect(variant.reload.weight.to_f).to eq(data['Variant Weight'])
+          expect(variant.reload.price).to eq(data['Variant Price'])
+        end
+      end
+    end
+  end
+end

data/spec/lib/solidus_importer_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter do
+  describe '.import!' do
+    subject(:described_method) { described_class.import!('target-import.csv', type: 'customers') }
+
+    it 'invokes ProcessImport#import_from_file' do
+      expect(SolidusImporter::ProcessImport).to receive(:import_from_file).with('target-import.csv', :customers)
+      subject
+    end
+  end
+end

data/spec/models/solidus_importer/import_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::Import do
+  subject(:described_instance) { described_class.new }
+
+  it { expect(described_instance).not_to be_valid }
+
+  context 'with an import file and type' do
+    before do
+      described_instance.import_type = :customers
+      described_instance.import_file = solidus_importer_fixture_path('customers.csv')
+    end
+
+    it { expect(described_instance).to be_valid }
+  end
+
+  describe '#import_file=' do
+    subject(:described_method) { described_instance.import_file = some_file }
+
+    let(:some_file) { nil }
+
+    it { expect { described_method }.to raise_error(SolidusImporter::Exception) }
+
+    context 'with a file' do
+      let(:some_file) { __FILE__ }
+
+      it { expect { described_method }.to change { described_instance.file.present? }.from(false).to(true) }
+    end
+  end
+
+  describe '#finished?' do
+    subject(:described_method) { described_instance.finished? }
+
+    let(:rows) { OpenStruct.new }
+    let(:finished_rows) { [] }
+    let(:size) { 0 }
+
+    before do
+      allow(rows).to receive_messages(failed_or_completed: finished_rows, size: size)
+      allow(described_instance).to receive_messages(rows: rows)
+    end
+
+    it { is_expected.to be_truthy }
+
+    context 'with some rows' do
+      let(:finished_rows) { [1, 2] }
+      let(:size) { 3 }
+
+      it { is_expected.to be_falsey }
+
+      context 'with the size equals to the number of failed or completed rows' do
+        let(:size) { finished_rows.size }
+
+        it { is_expected.to be_truthy }
+      end
+    end
+  end
+end