solidus_importer 0.1.0

data/spec/factories/solidus_importer_imports.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :solidus_importer_import_customers, class: 'SolidusImporter::Import' do
+    import_type { :customers }
+
+    after(:build) do |import|
+      import.import_file = solidus_importer_fixture_path('customers.csv')
+    end
+  end
+
+  factory :solidus_importer_import_orders, class: 'SolidusImporter::Import' do
+    import_type { :orders }
+
+    after(:build) do |import|
+      import.import_file = solidus_importer_fixture_path('orders.csv')
+    end
+  end
+
+  factory :solidus_importer_import_products, class: 'SolidusImporter::Import' do
+    import_type { :products }
+
+    after(:build) do |import|
+      import.import_file = solidus_importer_fixture_path('products.csv')
+    end
+  end
+end

data/spec/factories/solidus_importer_rows.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :solidus_importer_row_address, class: 'SolidusImporter::Row' do
+    data do
+      {
+        'First Name' => 'John',
+        'Last Name' => 'Doe',
+        'Address1' => 'My Cool Address, n.1',
+        'Address2' => '',
+        'City' => 'My beautiful City',
+        'Zip' => '12345',
+        'Phone' => '(555)-123123123',
+        'Country Code' => 'US',
+        'Province Code' => 'WA'
+      }
+    end
+
+    trait :with_import do
+      after(:build) do |row|
+        row.import = build_stubbed(:solidus_importer_import_orders)
+      end
+    end
+  end
+
+  factory :solidus_importer_row_customer, class: 'SolidusImporter::Row' do
+    data do
+      { 'Email' => 'an_email@example.com' }.merge(build(:solidus_importer_row_address).data)
+    end
+
+    trait :with_import do
+      after(:build) do |row|
+        row.import = build_stubbed(:solidus_importer_import_customers)
+      end
+    end
+  end
+
+  factory :solidus_importer_row_order, class: 'SolidusImporter::Row' do
+    data { { 'Name' => 'R123456789', 'Email' => 'an_email@example.com', 'Currency' => 'USD', 'Note' => nil } }
+
+    trait :with_import do
+      after(:build) do |row|
+        row.import = build_stubbed(:solidus_importer_import_orders)
+      end
+    end
+  end
+
+  factory :solidus_importer_row_product, class: 'SolidusImporter::Row' do
+    data { { 'Handle' => 'a-product-slug', 'Title' => 'A product name' } }
+
+    trait :with_import do
+      after(:build) do |row|
+        row.import = build_stubbed(:solidus_importer_import_products)
+      end
+    end
+
+    trait :with_tags do
+      after(:build) { |row| row.data.merge!('Tags' => 'Tag1,Tag2, Tag3') }
+    end
+
+    trait :with_type do
+      after(:build) { |row| row.data.merge!('Type' => 'Type1') }
+    end
+  end
+
+  factory :solidus_importer_row_variant, class: 'SolidusImporter::Row' do
+    data do
+      {
+        'Handle' => 'a-product-slug-2',
+        'Variant SKU' => 'a-variant-sku',
+        'Variant Weight' => 20.0,
+        'Variant Price' => 60.5
+      }
+    end
+
+    trait :with_import do
+      after(:build) do |row|
+        row.import = build_stubbed(:solidus_importer_import_products)
+      end
+    end
+  end
+end

data/spec/features/admin/solidus_importer/import_rows_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Import rows', type: :feature do
+  stub_authorization!
+
+  describe 'Imports show' do
+    subject(:described_path) do
+      spree.admin_solidus_importer_import_import_row_path(import_id: import.id, id: row.id)
+    end
+
+    let(:import) { build_stubbed(:solidus_importer_import_products) }
+    let(:row) { build_stubbed(:solidus_importer_row_product, import: import) }
+    let(:log_details) { '{"success":true,"id":2,"class_name":"Spree::Order","new_record":true}' }
+    let(:log_entry) { instance_double(Spree::LogEntry, source: row, details: log_details) }
+
+    before do
+      allow(SolidusImporter::Row).to receive(:find_by!).and_return(row)
+      allow(Spree::LogEntry).to receive(:find_by).and_return(log_entry)
+      visit described_path
+    end
+
+    it 'loads the import row details' do
+      expect(page).to have_css('[data-hook="admin_solidus_importer_import_rows_show"]')
+      expect(page).to have_css('.import_row_attribute', count: row.data.keys.size)
+      expect(page.body).to include(row.state)
+    end
+  end
+end

data/spec/features/admin/solidus_importer/imports_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Imports', type: :feature do
+  stub_authorization!
+
+  describe 'New import form' do
+    subject(:described_path) { spree.new_admin_solidus_importer_import_path }
+
+    before { visit described_path }
+
+    let(:import_file) { page.find 'input[name="solidus_importer_import[file]"]' }
+    let(:import_button) { page.find '[type="submit"]' }
+
+    it 'display import form with available types and "import!" button' do
+      expect(import_file).to be_visible
+      expect(page).to have_css('select[name="solidus_importer_import[import_type]"] > option', count: 4)
+      expect(import_button).to be_visible
+    end
+  end
+
+  describe 'Import create' do
+    subject(:described_path) { spree.new_admin_solidus_importer_import_path }
+
+    let!(:shipping_method) { create :shipping_method }
+
+    let(:import_file) { page.find 'input[name="solidus_importer_import[file]"]' }
+    let(:import_button) { page.find '[type="submit"]' }
+    let(:products_csv_file) { solidus_importer_fixture_path('products.csv') }
+    let(:import_type) { "products" }
+
+    before do
+      allow(::SolidusImporter::ImportJob).to receive(:perform_later)
+
+      visit described_path
+      import_file.set products_csv_file
+      select import_type, from: :solidus_importer_import_import_type if import_type
+      import_button.click
+    end
+
+    it 'creates a new import' do
+      expect(::SolidusImporter::ImportJob).to have_received(:perform_later)
+      expect(page).to have_content('Import has been successfully created!')
+    end
+
+    context 'when no import type is selected' do
+      let(:import_type) { nil }
+
+      it 'fails creating a new import' do
+        expect(page).to have_content("Import type can't be blank")
+      end
+    end
+
+    context 'when the wrong import type is selected', skip: 'Not implemented yet' do
+      let(:import_type) { "orders" }
+
+      it 'fails creating a new import' do
+        expect(page).to have_content('Import failed!')
+      end
+    end
+
+    context 'when an invalid CSV file is selected', skip: 'Not implemented yet' do
+      let(:products_csv_file) { 'unknow-file.csv' }
+
+      it 'fails creating a new import' do
+        expect(page).to have_content('Import failed!')
+      end
+    end
+  end
+
+  describe 'Imports index' do
+    subject(:described_path) { spree.admin_solidus_importer_imports_path }
+
+    let(:imports) {}
+
+    before do
+      imports
+      visit described_path
+    end
+
+    it 'loads the imports listing' do
+      expect(page.body).to include('No Import found')
+    end
+
+    context 'with some imports' do
+      let(:imports) do
+        [
+          create(:solidus_importer_import_customers),
+          create(:solidus_importer_import_orders),
+          create(:solidus_importer_import_products)
+        ]
+      end
+
+      it { expect(page).to have_css('.solidus_importer_import', count: imports.size) }
+    end
+  end
+
+  describe 'Imports show' do
+    subject(:described_path) { spree.admin_solidus_importer_import_path(import) }
+
+    let(:import) { create(:solidus_importer_import_customers) }
+    let(:rows) { [] }
+
+    before do
+      rows
+      visit described_path
+    end
+
+    it 'loads the imports details' do
+      expect(page).to have_css('[data-hook="admin_solidus_importer_imports_show"]')
+      expect(page.body).to include('No Row found')
+    end
+
+    context 'with some rows' do
+      let(:rows) { create_list(:solidus_importer_row_customer, 3, import: import) }
+
+      it { expect(page).to have_css('.solidus_importer_import_row', count: rows.size) }
+    end
+  end
+end

data/spec/features/solidus_importer/import_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Import from CSV files' do # rubocop:disable RSpec/DescribeClass
+  subject(:import) { SolidusImporter::ProcessImport.import_from_file(import_file, import_type) }
+
+  let(:import_file) {}
+  let(:import_type) {}
+
+  before { allow(Spree::LogEntry).to receive(:create!) }
+
+  context 'with a customers source file' do
+    let(:import_file) { solidus_importer_fixture_path('customers.csv') }
+    let(:import_type) { :customers }
+    let(:csv_file_rows) { 2 }
+    let(:user_emails) { ['jane.doe01520022060@example.com', 'jane.doe11520022060@example.com'] }
+
+    it 'imports some customers' do
+      expect { import }.to change(Spree::User, :count).by(2)
+      expect(Spree::User.where(email: user_emails).count).to eq(2)
+      expect(import.state).to eq('completed')
+      expect(Spree::LogEntry).to have_received(:create!).exactly(csv_file_rows).times
+    end
+  end
+
+  context 'with a products file' do
+    let(:import_file) { solidus_importer_fixture_path('products.csv') }
+    let(:import_type) { :products }
+    let(:csv_file_rows) { 7 }
+    let(:product_slug) { 'hightop-sports-sneaker' }
+    let(:image_url) { 'https://cdn.shopify.com/shopify-marketing_assets/static/tobias-lutke-shopify.jpg' }
+    let!(:shipping_category) { create(:shipping_category) }
+
+    before do
+      allow(URI).to receive(:open).and_call_original
+      allow(URI).to receive(:open).with(image_url) do
+        File.open(solidus_importer_fixture_path('thinking-cat.jpg'))
+      end
+    end
+
+    it 'imports some products' do # rubocop:disable RSpec/MultipleExpectations
+      expect { import }.to change(Spree::Product, :count).by(1)
+      product = Spree::Product.last
+      expect(product.variants.count).to eq(3)
+      expect(product.slug).to eq(product_slug)
+      expect(import.state).to eq('completed')
+      expect(product.images).not_to be_empty
+      expect(product.option_types.count).to eq 2
+      expect(product.variants.sample.option_values.count).to eq 2
+      expect(product.variants.sample.images).not_to be_empty
+      expect(Spree::Product.last.images).not_to be_empty
+      expect(Spree::Variant.last.images).not_to be_empty
+      expect(Spree::LogEntry).to have_received(:create!).exactly(csv_file_rows).times
+    end
+  end
+
+  context 'with an invalid products file' do
+    let(:import_file) { solidus_importer_fixture_path('invalid_product.csv') }
+    let(:import_type) { :products }
+    let!(:shipping_category) { create(:shipping_category) }
+
+    it 'fails to import the product' do
+      expect { import }.not_to change(Spree::Product, :count)
+      expect(import.rows.first.messages).to eq("Validation failed: Name can't be blank")
+    end
+  end
+
+  context 'with Shopify Product CSVs' do
+    before do
+      allow(URI).to receive(:open)
+    end
+
+    context 'with the export from Shopify Product CSVs - Apparel' do
+      let(:import_file) { solidus_importer_fixture_path('apparel.csv') }
+      let(:import_type) { :products }
+      let!(:shipping_category) { create(:shipping_category) }
+
+      it 'imports a some products and a blue shirt with no variants' do
+        expect { import }.to change(Spree::Product, :count).from(0)
+        expect(import.state).to eq('completed')
+
+        product = Spree::Product.find_by(slug: 'ocean-blue-shirt')
+
+        expect(product.variants.count).to be_zero
+      end
+    end
+
+    context 'with the export from Shopify Product CSVs - Jewelry' do
+      let(:import_file) { solidus_importer_fixture_path('jewelery.csv') }
+      let(:import_type) { :products }
+      let!(:shipping_category) { create(:shipping_category) }
+
+      it 'imports a some products and a clay pot with two variants' do
+        expect { import }.to change(Spree::Product, :count).from(0)
+        expect(import.state).to eq('completed')
+
+        product = Spree::Product.find_by(slug: 'gemstone')
+
+        expect(product.variants.count).to eq 2
+        expect(product.variants.find_by(sku: 'gemstone-blue')).to be_present
+        expect(product.variants.find_by(sku: 'gemstone-purple')).to be_present
+      end
+    end
+
+    context 'with the export from Shopify Product CSVs - Home and Garden' do
+      let(:import_file) { solidus_importer_fixture_path('home-and-garden.csv') }
+      let(:import_type) { :products }
+      let!(:shipping_category) { create(:shipping_category) }
+
+      it 'imports a some products' do
+        expect { import }.to change(Spree::Product, :count).from(0)
+        expect(import.state).to eq('completed')
+
+        product = Spree::Product.find_by(slug: 'clay-plant-pot')
+
+        expect(product.variants.count).to eq 2
+        expect(product.variants.find_by(sku: 'clay-plant-pot-large')).to be_present
+        expect(product.variants.find_by(sku: 'clay-plant-pot-regular')).to be_present
+      end
+    end
+  end
+
+  context 'with a orders file' do
+    let(:import_file) { solidus_importer_fixture_path('orders.csv') }
+    let(:import_type) { :orders }
+    let(:csv_file_rows) { 4 }
+    let(:order_numbers) { ['#MA-1097', '#MA-1098'] }
+    let!(:store) { create(:store) }
+
+    it 'imports some orders' do
+      expect { import }.to change(Spree::Order, :count).by(2)
+      expect(Spree::Order.where(number: order_numbers).count).to eq(2)
+      expect(import.state).to eq('completed')
+      expect(Spree::LogEntry).to have_received(:create!).exactly(csv_file_rows).times
+    end
+  end
+end

data/spec/features/solidus_importer/processors_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Set up a some processors' do # rubocop:disable RSpec/DescribeClass
+  subject(:process_import) do
+    SolidusImporter::ProcessImport.new(
+      import_source,
+      importer_options: importer_options
+    ).process
+  end
+
+  let(:processor_create_user) do
+    ->(context) {
+      user = Spree::User.new(email: context[:data]['Email'])
+      user.password = 'a very secure password'
+      context.merge!(success: user.save, user: user)
+    }
+  end
+  let(:processor_check_domain) do
+    ->(context) {
+      user = context[:user].reload
+      (context[:importer].checks ||= []) << user.email.end_with?('@example.com')
+    }
+  end
+  let(:import_source) { create(:solidus_importer_import_customers) }
+  let(:importer_options) do
+    {
+      importer: CustomImporter,
+      processors: [processor_create_user, processor_check_domain]
+    }
+  end
+  let(:importer) { CustomImporter.new(importer_options) }
+
+  before do
+    stub_const('CustomImporter', SolidusImporter::BaseImporter)
+    CustomImporter.class_eval do
+      attr_accessor :checks
+
+      def after_import(ending_context)
+        ending_context[:importer].checks
+      end
+    end
+    importer
+    allow(CustomImporter).to receive(:new).and_return(importer)
+    allow(importer).to receive(:after_import).and_call_original
+  end
+
+  it 'creates 2 users and check the result' do
+    expect { process_import }.to change(Spree::User, :count).from(0).to(2)
+    expect(importer).to have_received(:after_import)
+  end
+end