solidus_related_products 1.0.0

data/spec/controllers/spree/admin/relations_controller_spec.rb

@@ -0,0 +1,96 @@
+RSpec.describe Spree::Admin::RelationsController, type: :controller do
+  stub_authorization!
+
+  let(:user)     { create(:user) }
+  let!(:product) { create(:product) }
+  let!(:other1)  { create(:product) }
+
+  let!(:relation_type) { create(:relation_type) }
+  let!(:relation) do
+    create(
+      :relation,
+      relatable: product,
+      related_to: other1,
+      relation_type: relation_type,
+      position: 0
+    )
+  end
+
+  before { stub_authentication! }
+  after  { Spree::Admin::ProductsController.clear_overrides! }
+
+  context '.model_class' do
+    it 'responds to model_class as Spree::Relation' do
+      expect(controller.send(:model_class)).to eq Spree::Relation
+    end
+  end
+
+  describe 'with JS' do
+    sign_in_as_admin!
+
+    let(:valid_params) do
+      {
+        format: :js,
+        product_id: product.id,
+        relation: {
+          related_to_id: other1.id,
+          relation_type_id: relation_type.id
+        }
+      }
+    end
+
+    context '#create' do
+      it 'is not routable' do
+        spree_post :create, valid_params
+        expect(response.status).to be(200)
+      end
+
+      it 'returns success with valid params' do
+        expect {
+          spree_post :create, valid_params
+        }.to change(Spree::Relation, :count).by(1)
+      end
+
+      it 'raises error with invalid params' do
+        expect {
+          spree_post :create, format: :js
+        }.to raise_error
+      end
+    end
+
+    context '#update' do
+      it 'redirects to product/related url' do
+        spree_put :update, product_id: product.id, id: 1, relation: { discount_amount: 2.0 }
+        expect(response).to redirect_to(spree.admin_product_path(relation.relatable) + '/related')
+      end
+    end
+
+    context '#destroy' do
+      it 'records successfully' do
+        expect {
+          spree_delete :destroy, id: 1, product_id: product.id, format: :js
+        }.to change(Spree::Relation, :count).by(-1)
+      end
+    end
+
+    context '#update_positions' do
+      it 'returns the correct position of the related products' do
+        other2    = create(:product)
+        relation2 = create(
+          :relation, relatable: product, related_to: other2, relation_type: relation_type, position: 1
+        )
+
+        expect {
+          params = {
+            product_id: product.id,
+            id: relation.id,
+            positions: { relation.id => '1', relation2.id => '0' },
+            format: :js
+          }
+          spree_post :update_positions, params
+          relation.reload
+        }.to change(relation, :position).from(0).to(1)
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/relations_controller_spec.rb

@@ -0,0 +1,98 @@
+RSpec.describe Spree::Api::RelationsController, type: :controller do
+  stub_authorization!
+  render_views
+
+  let(:user)     { create(:user) }
+  let!(:product) { create(:product) }
+  let!(:other1)  { create(:product) }
+
+  let!(:relation_type) { create(:relation_type) }
+  let!(:relation) do
+    create(
+      :relation,
+      relatable: product,
+      related_to: other1,
+      relation_type: relation_type,
+      position: 0
+    )
+  end
+
+  before { stub_authentication! }
+  after  { Spree::Admin::ProductsController.clear_overrides! }
+
+  context 'model_class' do
+    it 'responds to model_class as Spree::Relation' do
+      expect(controller.send(:model_class)).to eq Spree::Relation
+    end
+  end
+
+  describe 'with JSON' do
+    sign_in_as_admin!
+
+    let(:valid_params) do
+      {
+        format: :json,
+        product_id: product.id,
+        relation: {
+          related_to_id: other1.id,
+          relation_type_id: relation_type.id
+        },
+        token: user.spree_api_key
+      }
+    end
+
+    context '#create' do
+      it 'creates the relation' do
+        spree_post :create, valid_params
+        expect(response.status).to eq(201)
+      end
+
+      it 'responds 422 error with invalid params' do
+        spree_post :create, format: :json, product_id: product.id, token: user.spree_api_key
+        expect(response.status).to eq(422)
+      end
+    end
+
+    context '#update' do
+      it 'succesfully updates the relation ' do
+        params = {
+          format: :json,
+          product_id: product.id,
+          id: relation.id,
+          relation: { discount_amount: 2.0 }
+        }
+        expect {
+          spree_put :update, params
+        }.to change { relation.reload.discount_amount.to_s }.from('0.0').to('2.0')
+      end
+    end
+
+    context '#destroy with' do
+      it 'records successfully' do
+        expect {
+          spree_delete :destroy, id: 1, product_id: product.id, format: :json, token: user.spree_api_key
+        }.to change(Spree::Relation, :count).by(-1)
+      end
+    end
+
+    context '#update_positions' do
+      it 'returns the correct position of the related products' do
+        other2    = create(:product)
+        relation2 = create(
+          :relation, relatable: product, related_to: other2, relation_type: relation_type, position: 1
+        )
+
+        expect {
+          params = {
+            product_id: product.id,
+            id: relation.id,
+            positions: { relation.id => '1', relation2.id => '0' },
+            format: :json
+          }
+          spree_post :update_positions, params
+          relation.reload
+        }.to change(relation, :position).from(0).to(1)
+      end
+    end
+  end
+end

data/spec/factories/relation_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :relation, class: Spree::Relation do
+    association :relatable, factory: :product
+    association :related_to, factory: :product
+    relation_type 'Spree::Product'
+  end
+end

data/spec/factories/relation_type_factory.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :relation_type, class: Spree::RelationType do
+    name       { generate(:random_string) }
+    applies_to 'Spree::Product'
+  end
+end

data/spec/features/spree/admin/product_relation_spec.rb

@@ -0,0 +1,86 @@
+RSpec.feature 'Admin Product Relation', :js do
+  stub_authorization!
+
+  given!(:product) { create(:product) }
+  given!(:other)   { create(:product) }
+
+  given!(:relation_type) { create(:relation_type, name: 'Gears') }
+
+  background do
+    visit spree.edit_admin_product_path(product)
+    click_link 'Related Products'
+  end
+
+  scenario 'create relation' do
+    expect(page).to have_text 'ADD RELATED PRODUCT'
+    expect(page).to have_text product.name
+
+    within('#add-line-item') do
+      select2_search other.name, from: 'Name or SKU'
+      select2_search relation_type.name, from: 'Type'
+      fill_in 'add_discount', with: '0.8'
+      click_link 'Add'
+    end
+
+    wait_for_ajax
+
+    within_row(1) do
+      expect(page).to have_field('relation_discount_amount', with: '0.8')
+      expect(column_text(2)).to eq other.name
+      expect(column_text(3)).to eq relation_type.name
+    end
+  end
+
+  context 'with relations' do
+    given!(:relation) do
+      create(
+        :relation,
+        relatable: product,
+        related_to: other,
+        relation_type: relation_type,
+        discount_amount: 0.5
+      )
+    end
+
+    background do
+      visit spree.edit_admin_product_path(product)
+      click_link 'Related Products'
+    end
+
+    scenario 'ensure content exist' do
+      expect(page).to have_text 'ADD RELATED PRODUCT'
+      expect(page).to have_text product.name
+      expect(page).to have_text other.name
+
+      within_row(1) do
+        expect(page).to have_field('relation_discount_amount', with: '0.5')
+        expect(column_text(2)).to eq other.name
+        expect(column_text(3)).to eq relation_type.name
+      end
+    end
+
+    scenario 'update discount' do
+      within_row(1) do
+        fill_in 'relation_discount_amount', with: '0.9'
+        click_on 'Update'
+      end
+      wait_for_ajax
+      within_row(1) do
+        expect(page).to have_field('relation_discount_amount', with: '0.9')
+      end
+    end
+
+    context 'delete' do
+      scenario 'can remove records' do
+        expect(page).to have_text other.name
+        within_row(1) do
+          expect(column_text(2)).to eq other.name
+          click_icon :trash
+        end
+        page.driver.browser.switch_to.alert.accept unless Capybara.javascript_driver == :poltergeist
+        wait_for_ajax
+        expect(page).not_to have_text other.name
+      end
+    end
+  end
+end

data/spec/features/spree/admin/relation_types_spec.rb

@@ -0,0 +1,97 @@
+RSpec.feature 'Admin Relation Types', :js do
+  stub_authorization!
+
+  background do
+    visit spree.admin_relation_types_path
+  end
+
+  scenario 'when no relation types exists' do
+    expect(page).to have_text 'NO RELATION TYPES FOUND, ADD ONE!'
+  end
+
+  context 'create' do
+    scenario 'can create a new relation type' do
+      click_link 'New Relation Type'
+      expect(current_path).to eq spree.new_admin_relation_type_path
+
+      fill_in 'Name', with: 'Gears'
+      fill_in 'Applies To', with: 'Spree:Products'
+
+      click_button 'Create'
+
+      expect(page).to have_text 'successfully created!'
+      expect(current_path).to eq spree.admin_relation_types_path
+    end
+
+    scenario 'shows validation errors with blank :name' do
+      click_link 'New Relation Type'
+      expect(current_path).to eq spree.new_admin_relation_type_path
+
+      fill_in 'Name', with: ''
+      click_button 'Create'
+
+      expect(page).to have_text 'Name can\'t be blank'
+    end
+
+    scenario 'shows validation errors with blank :applies_to' do
+      click_link 'New Relation Type'
+      expect(current_path).to eq spree.new_admin_relation_type_path
+
+      fill_in 'Name', with: 'Gears'
+      fill_in 'Applies To', with: ''
+      click_button 'Create'
+
+      expect(page).to have_text 'Applies to can\'t be blank'
+    end
+  end
+
+  context 'with records' do
+    background do
+      %w(Gears Equipments).each do |name|
+        create(:relation_type, name: name)
+      end
+      visit spree.admin_relation_types_path
+    end
+
+    context 'show' do
+      scenario 'displays existing relation types' do
+        within_row(1) do
+          expect(column_text(1)).to eq 'Gears'
+          expect(column_text(2)).to eq 'Spree::Product'
+          expect(column_text(3)).to eq ''
+        end
+      end
+    end
+
+    context 'edit' do
+      background do
+        within_row(1) { click_icon :edit }
+        expect(current_path).to eq spree.edit_admin_relation_type_path(1)
+      end
+
+      scenario 'can update an existing relation type' do
+        fill_in 'Name', with: 'Gadgets'
+        click_button 'Update'
+        expect(page).to have_text 'successfully updated!'
+        expect(page).to have_text 'Gadgets'
+      end
+
+      scenario 'shows validation errors with blank :name' do
+        fill_in 'Name', with: ''
+        click_button 'Update'
+        expect(page).to have_text 'Name can\'t be blank'
+      end
+    end
+
+    context 'delete' do
+      scenario 'can remove records' do
+        within_row(1) do
+          expect(column_text(1)).to eq 'Gears'
+          click_icon :trash
+        end
+        page.driver.browser.switch_to.alert.accept unless Capybara.javascript_driver == :poltergeist
+        expect(page).to have_text 'successfully removed!'
+      end
+    end
+  end
+end

data/spec/models/spree/calculator/related_product_discount_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe Spree::Calculator::RelatedProductDiscount, type: :model do
+  subject { described_class.new }
+
+  context '.description' do
+    it 'outputs relation product discount' do
+      expect(subject.description).to eq Spree.t(:related_product_discount)
+    end
+  end
+
+  describe '.compute(object)' do
+    it 'returns nil with empty Array' do
+      expect(subject.compute([])).to be_nil
+    end
+
+    it 'returns nil unless order is eligible' do
+      empty_order = double('Spree::Order')
+      allow(empty_order).to receive(:line_items).and_return([])
+      expect(subject.compute(empty_order)).to be_nil
+    end
+
+    context 'with order' do
+      before do
+        @order    = double('Spree::Order')
+        product   = build_stubbed(:product)
+        variant   = double('Spree::Variant', product: product)
+        price     = double('Spree::Price', variant: variant, amount: 5.00)
+        line_item = double('Spree::LineItem', variant: variant, order: @order, quantity: 1, price: 4.99)
+
+        allow(variant).to receive(:default_price).and_return(price)
+        allow(@order).to receive(:line_items).and_return([line_item])
+
+        related_product = create(:product)
+        relation_type   = create(:relation_type)
+
+        create(:relation, relatable: product, related_to: related_product, relation_type: relation_type, discount_amount: 1.0)
+      end
+
+      it 'returns total count of Array' do
+        objects = Array.new { @order }
+        expect(subject.compute(objects)).to be_nil
+      end
+
+      it 'returns total count' do
+        expect(subject.compute(@order)).to be_zero
+      end
+    end
+  end
+end

data/spec/models/spree/product_spec.rb

@@ -0,0 +1,129 @@
+RSpec.describe Spree::Product, type: :model do
+  context 'class' do
+    describe '.relation_types' do
+      it 'returns all the RelationTypes in use for this Product' do
+        relation_type = create(:relation_type)
+        expect(described_class.relation_types).to include(relation_type)
+      end
+    end
+  end
+
+  context 'relations' do
+    it { is_expected.to have_many(:relations) }
+  end
+
+  context 'instance' do
+    let(:other1) { create(:product) }
+    let(:other2) { create(:product) }
+
+    before do
+      @product = create(:product)
+      @relation_type = create(:relation_type, name: 'Related Products')
+    end
+
+    describe '.relations' do
+      it 'has many relations' do
+        relation1 = create(:relation, relatable: @product, related_to: other1, relation_type: @relation_type)
+        relation2 = create(:relation, relatable: @product, related_to: other2, relation_type: @relation_type)
+
+        @product.reload
+        expect(@product.relations).to include(relation1)
+        expect(@product.relations).to include(relation2)
+      end
+
+      it 'has many relations for different RelationTypes' do
+        other_relation_type = Spree::RelationType.new(name: 'Recommended Products')
+
+        relation1 = create(:relation, relatable: @product, related_to: other1, relation_type: @relation_type)
+        relation2 = create(:relation, relatable: @product, related_to: other1, relation_type: other_relation_type)
+
+        @product.reload
+        expect(@product.relations).to include(relation1)
+        expect(@product.relations).to include(relation2)
+      end
+    end
+
+    describe 'RelationType finders' do
+      before do
+        @relation = create(:relation, relatable: @product, related_to: other1, relation_type: @relation_type)
+        @product.reload
+      end
+
+      it 'returns the relevant relations' do
+        expect(@product.related_products).to include(other1)
+      end
+
+      it 'recognizes the method with has_related_products?(method)' do
+        expect(@product.has_related_products?('related_products')).to be_truthy
+      end
+
+      it 'does not recognize non-existent methods with has_related_products?(method)' do
+        expect(@product.has_related_products?('unrelated_products')).not_to be_truthy
+      end
+
+      it 'is the pluralised form of the RelationType name' do
+        @relation_type.update_attributes(name: 'Related Product')
+        expect(@product.related_products).to include(other1)
+      end
+
+      it 'does not return relations for another RelationType' do
+        other_relation_type = Spree::RelationType.new(name: 'Recommended Products')
+
+        create(:relation, relatable: @product, related_to: other1, relation_type: @relation_type)
+        create(:relation, relatable: @product, related_to: other2, relation_type: other_relation_type)
+
+        @product.reload
+        expect(@product.related_products).to include(other1)
+        expect(@product.related_products).not_to include(other2)
+      end
+
+      it 'does not return Products that are deleted' do
+        other1.update_attributes(deleted_at: Time.now)
+        expect(@product.related_products).to be_blank
+      end
+
+      it 'does not return Products that are not yet available' do
+        other1.update_attributes(available_on: Time.now + 1.hour)
+        expect(@product.related_products).to be_blank
+      end
+
+      it 'does not return Products where available_on are blank' do
+        other1.update_attributes(available_on: nil)
+        expect(@product.related_products).to be_blank
+      end
+
+      it 'returns all results when .relation_filter is nil' do
+        expect(described_class).to receive(:relation_filter).and_return(nil)
+        other1.update_attributes(available_on: Time.now + 1.hour)
+        expect(@product.related_products).to include(other1)
+      end
+
+      context 'with an enhanced Product.relation_filter' do
+        it 'restricts the filter' do
+          relation_filter = described_class.relation_filter
+          expect(described_class).to receive(:relation_filter).at_least(:once).and_return(relation_filter.includes(:master).where('spree_variants.cost_price > 20'))
+
+          other1.master.update_attributes(cost_price: 10)
+          other2.master.update_attributes(cost_price: 30)
+
+          create(:relation, relatable: @product, related_to: other2, relation_type: @relation_type)
+          results = @product.related_products
+          expect(results).not_to include(other1)
+          expect(results).to include(other2)
+        end
+      end
+    end
+  end
+
+  context 'instance when relation_types table is missing' do
+    it 'method missing should not throw ActiveRecord::StatementInvalid when the spree_relation_types table is missing' do
+      described_class.connection.rename_table('spree_relation_types', 'missing_relation_types')
+      begin
+        product = described_class.new
+        expect { product.foo }.to raise_error(NameError)
+      ensure
+        described_class.connection.rename_table('missing_relation_types', 'spree_relation_types')
+      end
+    end
+  end
+end