solidus_core 2.1.1 → 2.2.0.beta1

data/config/initializers/premailer_assets.rb

@@ -1 +0,0 @@
-Rails.application.config.assets.precompile += %w( ink.css )

data/lib/spree/core/unreturned_item_charger.rb

@@ -1,106 +0,0 @@
-module Spree
-  class UnreturnedItemCharger
-    class ChargeFailure < StandardError
-      attr_accessor :new_order
-      def initialize(message, new_order)
-        @new_order = new_order
-        super(message)
-      end
-    end
-
-    class_attribute :failure_handler
-
-    attr_reader :original_order, :new_order
-
-    def initialize(shipment, return_items)
-      @shipment = shipment
-      @original_order = @shipment.order
-      @return_items = return_items
-    end
-
-    def charge_for_items
-      self.new_order = Spree::Order.create!(exchange_order_attributes)
-
-      new_order.associate_user!(@original_order.user) if @original_order.user
-
-      add_exchange_variants_to_order
-      set_shipment_for_new_order
-
-      new_order.update!
-      set_order_payment
-
-      # There are several checks in the order state machine to skip
-      # certain transitions when an order is an unreturned exchange
-      if !new_order.unreturned_exchange?
-        raise ChargeFailure.new('order is not an unreturned exchange', new_order)
-      end
-
-      # Transitions will call update_totals on the order
-      until new_order.can_complete?
-        new_order.next!
-      end
-
-      new_order.contents.approve(name: self.class.name)
-      new_order.complete!
-      Spree::OrderCapturing.new(new_order).capture_payments if Spree::Config[:auto_capture_exchanges] && !Spree::Config[:auto_capture]
-
-      @return_items.each(&:expired!)
-      create_new_rma if Spree::Config[:create_rma_for_unreturned_exchange]
-
-      if !new_order.completed?
-        raise ChargeFailure.new('order not complete', new_order)
-      elsif !new_order.valid?
-        raise ChargeFailure.new('order not valid', new_order)
-      end
-    end
-
-    private
-
-    attr_writer :new_order
-
-    def add_exchange_variants_to_order
-      @return_items.group_by(&:exchange_variant).map do |variant, variant_return_items|
-        variant_inventory_units = variant_return_items.map(&:exchange_inventory_unit)
-        line_item = Spree::LineItem.create!(variant: variant, quantity: variant_return_items.count, order: new_order)
-        variant_inventory_units.each { |i| i.update_attributes!(line_item_id: line_item.id, order_id: new_order.id) }
-      end
-    end
-
-    def set_shipment_for_new_order
-      @shipment.update_attributes!(order_id: new_order.id)
-      new_order.shipments.reset
-    end
-
-    def set_order_payment
-      unless new_order.payments.present?
-        card_to_reuse = @original_order.valid_credit_cards.first
-        card_to_reuse = @original_order.user.credit_cards.default.first if !card_to_reuse && @original_order.user
-        new_order.payments.create!(
-          payment_method_id: card_to_reuse.try(:payment_method_id),
-          source: card_to_reuse,
-          amount: new_order.total
-        )
-      end
-    end
-
-    def create_new_rma
-      @return_items.group_by(&:return_authorization).each do |rma, return_items|
-        new_return_items = return_items.map { |ri| Spree::ReturnItem.create!(inventory_unit: ri.inventory_unit) }
-        Spree::ReturnAuthorization.create!(order: rma.order,
-                                           reason: rma.reason,
-                                           stock_location: rma.stock_location,
-                                           return_items: new_return_items)
-      end
-    end
-
-    def exchange_order_attributes
-      {
-        bill_address: @original_order.bill_address,
-        ship_address: @original_order.ship_address,
-        email: @original_order.email,
-        store_id: @original_order.store_id,
-        frontend_viewable: false
-      }
-    end
-  end
-end

data/lib/tasks/exchanges.rake

@@ -1,47 +0,0 @@
-namespace :exchanges do
-  desc 'Takes unreturned exchanged items and creates a new order to charge
-  the customer for not returning them'
-  task charge_unreturned_items: :environment do
-    unreturned_return_items = Spree::ReturnItem.expecting_return.exchange_processed.joins(:exchange_inventory_unit).where([
-      "spree_inventory_units.created_at < :days_ago AND spree_inventory_units.state = :iu_state",
-      days_ago: Spree::Config[:expedited_exchanges_days_window].days.ago, iu_state: "shipped"
-    ]).preload(:exchange_inventory_unit).to_a
-
-    # Determine that a return item has already been deemed unreturned and therefore charged
-    # by the fact that its exchange inventory unit has popped off to a different order
-    unreturned_return_items.select! { |ri| ri.inventory_unit.order_id == ri.exchange_inventory_unit.order_id }
-
-    failures = []
-
-    unreturned_return_items.group_by(&:exchange_shipment).each do |shipment, return_items|
-      item_charger = Spree::UnreturnedItemCharger.new(shipment, return_items)
-
-      begin
-        item_charger.charge_for_items
-      rescue Spree::UnreturnedItemCharger::ChargeFailure => e
-        failure = { message: e.message }
-      rescue => e
-        failure = { message: "#{e.class}: #{e.message}" }
-      end
-
-      next unless failure
-      failure[:new_order] = item_charger.new_order.number if item_charger.new_order
-      failures << failure.merge({
-        order: item_charger.original_order.number,
-        shipment: shipment.number,
-        return_items: return_items.map(&:id),
-        order_errors: item_charger.original_order.errors.full_messages
-      })
-    end
-
-    if failures.any?
-      if Spree::UnreturnedItemCharger.failure_handler
-        Spree::UnreturnedItemCharger.failure_handler.call(failures)
-      else
-        raise Spree::ChargeUnreturnedItemsFailures.new(failures.to_json)
-      end
-    end
-  end
-end
-
-class Spree::ChargeUnreturnedItemsFailures < StandardError; end

data/spec/lib/spree/core/unreturned_item_charger_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-describe Spree::UnreturnedItemCharger do
-  let(:ship_address) { create(:address) }
-  let(:shipped_order) { create(:shipped_order, ship_address: ship_address, line_items_count: 1, with_cartons: false) }
-  let(:original_shipment) { shipped_order.shipments.first }
-  let(:original_stock_location) { original_shipment.stock_location }
-  let(:original_inventory_unit) { shipped_order.inventory_units.first }
-  let(:original_variant) { original_inventory_unit.variant }
-  let(:shipping_method) { create(:shipping_method, tax_category: original_variant.tax_category) }
-
-  let(:exchange_shipment) do
-    create(:shipment,
-           order: shipped_order,
-           state: 'shipped',
-           stock_location: original_stock_location,
-           created_at: 5.days.ago,
-           shipping_method: shipping_method)
-  end
-  let(:exchange_inventory_unit) { exchange_shipment.inventory_units.first }
-  let(:return_item) do
-    create(:exchange_return_item,
-           inventory_unit: original_inventory_unit,
-           exchange_inventory_unit: exchange_inventory_unit)
-  end
-
-  let!(:unreturned_item_charger) { Spree::UnreturnedItemCharger.new(exchange_shipment, [return_item]) }
-
-  before do
-    exchange_shipment.finalize!
-    exchange_inventory_unit.ship!
-  end
-
-  shared_examples 'charge_for_items success' do
-    let(:new_order) do
-      subject
-      exchange_inventory_unit.shipment.order.reload
-    end
-
-    it "reuses the same inventory unit" do
-      expect { subject }.not_to change { Spree::InventoryUnit.count }
-    end
-
-    it "reuses the same shipment" do
-      expect { subject }.not_to change { Spree::Shipment.count }
-      expect(new_order.shipments.count).to eq 1
-    end
-
-    context 'in tax zone' do
-      let!(:tax_zone) { create(:zone, countries: [ship_address.country]) }
-      let!(:tax_rate) { create(:tax_rate, zone: tax_zone, tax_category: original_variant.tax_category) }
-
-      it "applies tax" do
-        exchange_order = exchange_shipment.order
-        exchange_order.update!
-        subject
-        expect(new_order.additional_tax_total).to be > 0
-        expect(new_order.line_items[0].additional_tax_total).to be > 0
-        expect(new_order.shipments[0].additional_tax_total).to be > 0
-      end
-    end
-
-    it "creates a new completed order" do
-      expect { subject }.to change { Spree::Order.count }.by(1)
-      expect(new_order).to_not eq(shipped_order)
-      expect(new_order).to be_completed
-    end
-
-    it "authorizes payment" do
-      expect { subject }.to change { Spree::Payment.count }.by(1)
-      expect(new_order.payments.count).to eq 1
-      expect(new_order.payments.first).to be_pending
-      expect(new_order.payments.first.response_code).to be_present
-    end
-
-    it "delivers confirmation email" do
-      expect { subject }.to change { ActionMailer::Base.deliveries.count }.by(1)
-    end
-
-    context 'with auto_capture_exchanges' do
-      before { Spree::Config[:auto_capture_exchanges] = true }
-
-      it "captures payment" do
-        expect { subject }.to change { Spree::Payment.count }.by(1)
-        expect(new_order.payments.count).to eq 1
-        expect(new_order.payments.first).to be_completed
-        expect(new_order.payment_state).to eq "paid"
-      end
-    end
-  end
-
-  describe "#charge_for_items" do
-    before do
-      original_variant.update_attributes!(track_inventory: true)
-      original_variant.stock_items.update_all(backorderable: false)
-    end
-
-    subject { unreturned_item_charger.charge_for_items }
-
-    context "new order is not an unreturned exchange" do
-      before do
-        allow_any_instance_of(Spree::Shipment).to receive(:update_attributes!)
-      end
-
-      it "raises an error" do
-        expect { subject }.to raise_error(Spree::UnreturnedItemCharger::ChargeFailure, 'order is not an unreturned exchange')
-      end
-    end
-
-    context "item is in stock" do
-      before do
-        original_variant.stock_items.map { |si| si.set_count_on_hand(10) }
-      end
-
-      include_examples 'charge_for_items success'
-    end
-
-    context "item is now out of stock" do
-      before do
-        original_variant.stock_items.map { |si| si.set_count_on_hand(0) }
-      end
-
-      include_examples 'charge_for_items success'
-    end
-  end
-end

data/spec/lib/tasks/exchanges_spec.rb

@@ -1,220 +0,0 @@
-require 'spec_helper'
-
-describe "exchanges:charge_unreturned_items" do
-  include_context(
-    'rake',
-    task_name: 'exchanges:charge_unreturned_items',
-    task_path: Spree::Core::Engine.root.join('lib/tasks/exchanges.rake'),
-  )
-
-  subject { task }
-
-  describe '#prerequisites' do
-    it { expect(subject.prerequisites).to include("environment") }
-  end
-
-  before do
-    Spree::Config[:expedited_exchanges] = true
-    Spree::StockItem.update_all(count_on_hand: 10)
-  end
-
-  context "there are no unreturned items" do
-    it { expect { subject.invoke }.not_to change { Spree::Order.count } }
-  end
-
-  context "there are return items in an intermediate return status" do
-    let!(:order) { create(:shipped_order, line_items_count: 2) }
-    let(:return_item_1) { build(:exchange_return_item, inventory_unit: order.inventory_units.first) }
-    let(:return_item_2) { build(:exchange_return_item, inventory_unit: order.inventory_units.last) }
-    let!(:rma) { create(:return_authorization, order: order, return_items: [return_item_1, return_item_2]) }
-    let(:zone) { create(:zone, countries: [order.tax_address.country])}
-    let!(:tax_rate) { create(:tax_rate, zone: zone, tax_category: return_item_2.exchange_variant.tax_category) }
-    before do
-      rma.save!
-      Spree::Shipment.last.ship!
-      return_item_1.lost!
-      return_item_2.give!
-      Timecop.travel((Spree::Config[:expedited_exchanges_days_window] + 1).days)
-    end
-    after { Timecop.return }
-    it { expect { subject.invoke }.not_to change { Spree::Order.count } }
-  end
-
-  context "there are unreturned items" do
-    let!(:order) { create(:shipped_order, line_items_count: 2) }
-    let(:return_item_1) { build(:exchange_return_item, inventory_unit: order.inventory_units.first) }
-    let(:return_item_2) { build(:exchange_return_item, inventory_unit: order.inventory_units.last) }
-    let!(:rma) { create(:return_authorization, order: order, return_items: [return_item_1, return_item_2]) }
-    let(:zone) { create(:zone, countries: [order.tax_address.country])}
-    let!(:tax_rate) { create(:tax_rate, zone: zone, tax_category: return_item_2.exchange_variant.tax_category) }
-
-    before do
-      rma.save!
-      Spree::Shipment.last.ship!
-      return_item_1.receive!
-      Timecop.travel travel_time
-    end
-
-    after { Timecop.return }
-
-    context "fewer than the config allowed days have passed" do
-      let(:travel_time) { (Spree::Config[:expedited_exchanges_days_window] - 1).days }
-
-      it "does not create a new order" do
-        expect { subject.invoke }.not_to change { Spree::Order.count }
-      end
-    end
-
-    context "more than the config allowed days have passed" do
-      let(:travel_time) { (Spree::Config[:expedited_exchanges_days_window] + 1).days }
-
-      it "creates a new completed order" do
-        expect { subject.invoke }.to change { Spree::Order.count }
-        expect(Spree::Order.last).to be_completed
-      end
-
-      it "sets frontend_viewable to false" do
-        subject.invoke
-        expect(Spree::Order.last).not_to be_frontend_viewable
-      end
-
-      it "moves the shipment for the unreturned items to the new order" do
-        subject.invoke
-        new_order = Spree::Order.last
-        expect(new_order.shipments.count).to eq 1
-        expect(return_item_2.reload.exchange_shipment.order).to eq Spree::Order.last
-      end
-
-      it "creates line items on the order for the unreturned items" do
-        subject.invoke
-        expect(Spree::Order.last.line_items.map(&:variant)).to eq [return_item_2.exchange_variant]
-      end
-
-      it "associates the exchanges inventory units with the new line items" do
-        subject.invoke
-        expect(return_item_2.reload.exchange_inventory_unit.try(:line_item).try(:order)).to eq Spree::Order.last
-      end
-
-      it "uses the credit card from the previous order" do
-        subject.invoke
-        new_order = Spree::Order.last
-        expect(new_order.credit_cards).to be_present
-        expect(new_order.credit_cards.first).to eq order.valid_credit_cards.first
-      end
-
-      context "payments" do
-        it "authorizes the order for the full amount of the unreturned items including taxes" do
-          expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
-          new_order = Spree::Order.last
-          expected_amount = return_item_2.reload.exchange_variant.price + new_order.additional_tax_total + new_order.included_tax_total + new_order.shipment_total
-          expect(new_order.total).to eq expected_amount
-          payment = new_order.payments.first
-          expect(payment.amount).to eq expected_amount
-          expect(new_order.item_total).to eq return_item_2.reload.exchange_variant.price
-        end
-
-        context "auto_capture_exchanges is true" do
-          before do
-            Spree::Config[:auto_capture_exchanges] = true
-          end
-
-          it 'creates a pending payment' do
-            expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
-            payment = Spree::Payment.last
-            expect(payment).to be_completed
-          end
-        end
-
-        context "auto_capture_exchanges is false" do
-          before do
-            Spree::Config[:auto_capture_exchanges] = false
-          end
-
-          it 'captures payment' do
-            expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
-            payment = Spree::Payment.last
-            expect(payment).to be_pending
-          end
-        end
-      end
-
-      it "does not attempt to create a new order for the item more than once" do
-        subject.invoke
-        subject.reenable
-        expect { subject.invoke }.not_to change { Spree::Order.count }
-      end
-
-      it "associates the store of the original order with the exchange order" do
-        store = order.store
-        expect(Spree::Order).to receive(:create!).once.with(hash_including({ store_id: store.id })).and_call_original
-        subject.invoke
-      end
-
-      it 'approves the order' do
-        subject.invoke
-        new_order = Spree::Order.last
-        expect(new_order).to be_approved
-        expect(new_order.is_risky?).to eq false
-        expect(new_order.approver_name).to eq "Spree::UnreturnedItemCharger"
-        expect(new_order.approver).to be nil
-      end
-
-      context "there is no card from the previous order" do
-        let!(:credit_card) { create(:credit_card, user: order.user, default: true, gateway_customer_profile_id: "BGS-123") }
-        before { allow_any_instance_of(Spree::Order).to receive(:valid_credit_cards) { [] } }
-
-        it "attempts to use the user's default card" do
-          expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
-          new_order = Spree::Order.last
-          expect(new_order.credit_cards).to be_present
-          expect(new_order.credit_cards.first).to eq credit_card
-        end
-      end
-
-      context "it is unable to authorize the credit card" do
-        before { allow_any_instance_of(Spree::Payment).to receive(:authorize!).and_raise(RuntimeError) }
-
-        it "raises an error with the order" do
-          expect { subject.invoke }.to raise_error(Spree::ChargeUnreturnedItemsFailures)
-        end
-      end
-
-      context "the exchange inventory unit is not shipped" do
-        before { return_item_2.reload.exchange_inventory_unit.update_columns(state: "on hand") }
-        it "does not create a new order" do
-          expect { subject.invoke }.not_to change { Spree::Order.count }
-        end
-      end
-
-      context "the exchange inventory unit has been returned" do
-        before { return_item_2.reload.exchange_inventory_unit.update_columns(state: "returned") }
-        it "does not create a new order" do
-          expect { subject.invoke }.not_to change { Spree::Order.count }
-        end
-      end
-
-      context 'rma for unreturned exchanges' do
-        context 'config to not create' do
-          before { Spree::Config[:create_rma_for_unreturned_exchange] = false }
-
-          it 'does not create rma' do
-            expect { subject.invoke }.not_to change { Spree::ReturnAuthorization.count }
-          end
-        end
-
-        context 'config to create' do
-          before do
-            Spree::Config[:create_rma_for_unreturned_exchange] = true
-          end
-
-          it 'creates with return items' do
-            expect { subject.invoke }.to change { Spree::ReturnAuthorization.count }
-            rma = Spree::ReturnAuthorization.last
-
-            expect(rma.return_items.all?(&:awaiting?)).to be true
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/promotion_builder_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PromotionBuilder do
-  let(:promotion) { build(:promotion) }
-  let(:base_code) { 'abc' }
-  let(:number_of_codes) { 1 }
-  let(:promotion_attrs) { { name: 'some promo' } }
-  let(:builder) {
-    Spree::PromotionBuilder.new(
-      {
-        base_code: base_code,
-        number_of_codes: number_of_codes
-      },
-    promotion_attrs
-  )
-  }
-
-  describe '#initialize' do
-    subject { builder }
-    it 'has the right base code' do
-      expect(subject.base_code).to eq 'abc'
-    end
-
-    it 'has the right base code' do
-      expect(subject.number_of_codes).to eq 1
-    end
-  end
-
-  describe '#valid?' do
-    subject { builder.valid? }
-
-    it 'is true' do
-      expect(subject).to be
-    end
-
-    context 'promotion is not valid' do
-      let(:promotion_attrs) { { name: nil } }
-
-      it 'is true' do
-        expect(subject).to_not be
-      end
-
-      it 'has errors on the promotion' do
-        subject
-        expect(builder.errors).to_not be_empty
-      end
-    end
-
-    context 'number of codes is invalid' do
-      let(:number_of_codes) { -1 }
-
-      it 'is false ' do
-        expect(subject).to_not be
-      end
-
-      it 'validates numericality' do
-        subject
-        expect(builder.errors.full_messages).to eq ["Number of codes must be greater than 0"]
-      end
-    end
-  end
-
-  describe '#number_of_codes=' do
-    it 'coerces a string' do
-      builder.number_of_codes = '3'
-      expect(builder.number_of_codes).to eq 3
-    end
-
-    it 'is nil for empty string' do
-      builder.number_of_codes = ''
-      expect(builder.number_of_codes).to be_nil
-    end
-  end
-
-  describe "#perform" do
-    subject { builder.perform }
-
-    context 'when the builder is invalid' do
-      let(:number_of_codes) { 'sups' }
-
-      it 'returns false' do
-        expect(subject).to_not be
-      end
-    end
-
-    context "when the builder is valid" do
-      context "when the builder cant build promotion codes" do
-        let(:number_of_codes) { nil }
-
-        it "doesn't create any new codes" do
-          subject
-          expect(builder.promotion.codes).to be_empty
-        end
-      end
-
-      context "when the builder can build promotion codes" do
-        let(:number_of_codes) { 1 }
-
-        it "creates the correct number of codes" do
-          subject
-          expect(builder.promotion.codes.length).to eq number_of_codes
-        end
-
-        it "creates the promotion with the correct code" do
-          subject
-          expect(builder.promotion.codes.first.value).to eq base_code
-        end
-      end
-
-      it "saves the promotion" do
-        subject
-        expect(builder.promotion).to be_persisted
-      end
-
-      it "returns true on success" do
-        expect(subject).to be true
-      end
-    end
-  end
-end

data/spec/models/spree/promotion_code/code_builder_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PromotionCode::CodeBuilder do
-  let(:promotion) { build_stubbed :promotion }
-  let(:base_code) { "abc" }
-  let(:builder) do
-    described_class.new promotion, base_code, num_codes
-  end
-
-  describe "#build_promotion_codes" do
-    subject { builder.build_promotion_codes }
-
-    context "with one code" do
-      let(:num_codes) { 1 }
-
-      it "builds a single promotion code" do
-        subject
-        expect(builder.promotion.codes.size).to eq(num_codes)
-      end
-
-      it "creates the promotion code with the correct value" do
-        subject
-        expect(builder.promotion.codes.first.value).to eq base_code
-      end
-    end
-
-    context "with more than one code" do
-      let(:num_codes) { 2 }
-
-      it "builds the correct number of codes" do
-        subject
-        expect(builder.promotion.codes.size).to eq(num_codes)
-      end
-
-      it "builds codes with distinct values" do
-        subject
-        expect(builder.promotion.codes.map(&:value).uniq.size).to eq(num_codes)
-      end
-
-      it "builds codes with the same base prefix" do
-        subject
-        values = builder.promotion.codes.map(&:value)
-        expect(values.all? { |val| val.starts_with?("#{base_code}_") }).to be true
-      end
-
-      context 'when every possible code must be used' do
-        before do
-          @old_length = described_class.random_code_length
-          described_class.random_code_length = 1
-        end
-        after { described_class.random_code_length = @old_length }
-
-        let(:num_codes) { 26 }
-
-        it "resolves the collision" do
-          subject
-          expect(builder.promotion.codes.map(&:value).uniq.size).to eq(num_codes)
-        end
-      end
-
-      context "when collisions occur" do
-        before do
-          @old_length = described_class.random_code_length
-          described_class.random_code_length = 1
-        end
-        after { described_class.random_code_length = @old_length }
-
-        let(:num_codes) { 25 } # every possible code except 1
-
-        it "resolves the collisions and returns the correct number of codes" do
-          subject
-          expect(builder.promotion.codes.map(&:value).uniq.size).to eq(num_codes)
-        end
-      end
-    end
-  end
-end