solidus_core 2.2.2 → 2.3.0.beta1

data/spec/mailers/carton_mailer_spec.rb

@@ -11,8 +11,8 @@ describe Spree::CartonMailer do
   # Regression test for https://github.com/spree/spree/issues/2196
   it "doesn't include out of stock in the email body" do
     shipment_email = Spree::CartonMailer.shipped_email(order: order, carton: carton)
-    expect(shipment_email.body).not_to include(%{Out of Stock})
-    expect(shipment_email.body).to include(%{Your order has been shipped})
+    expect(shipment_email).not_to have_body_text(%{Out of Stock})
+    expect(shipment_email).to have_body_text(%{Your order has been shipped})
     expect(shipment_email.subject).to eq "#{order.store.name} Shipment Notification ##{order.number}"
   end
 
@@ -38,7 +38,7 @@ describe Spree::CartonMailer do
 
         specify do
           shipped_email = Spree::CartonMailer.shipped_email(order: order, carton: carton)
-          expect(shipped_email.body).to include("Caro Cliente,")
+          expect(shipped_email).to have_body_text("Caro Cliente,")
         end
       end
     end

data/spec/models/spree/address_spec.rb

@@ -21,7 +21,7 @@ describe Spree::Address, type: :model do
     let(:address) { build(:address, country: country) }
 
     before do
-      allow(country.states).to receive_messages find_all_by_name_or_abbr: [state]
+      allow(country.states).to receive_messages with_name_or_abbr: [state]
     end
 
     context 'address does not require state' do
@@ -151,10 +151,10 @@ describe Spree::Address, type: :model do
     context "zipcode not required" do
       before { allow(address).to receive_messages require_zipcode?: false }
 
-      it "shows no errors when phone is blank" do
+      it "shows no errors when zipcode is blank" do
         address.zipcode = ""
         address.valid?
-        expect(address.errors[:zipcode].size).to eq 0
+        expect(address.errors[:zipcode]).to be_blank
       end
     end
   end

data/spec/models/spree/adjustment_spec.rb

@@ -79,54 +79,98 @@ describe Spree::Adjustment, type: :model do
   end
 
   context '#update!' do
-    let(:adjustment) { Spree::Adjustment.create!(label: 'Adjustment', order: order, adjustable: order, amount: 5, finalized: finalized, source: source) }
-    let(:source) { mock_model(Spree::TaxRate, compute_amount: 10) }
-
     subject { adjustment.update! }
+    let(:adjustment) do
+      line_item.adjustments.create!(
+        label: 'Adjustment',
+        order: order,
+        adjustable: order,
+        amount: 5,
+        finalized: finalized,
+        source: source,
+      )
+    end
+    let(:order) { create(:order_with_line_items, line_items_price: 100) }
+    let(:line_item) { order.line_items.to_a.first }
 
-    context "when adjustment is closed" do
+    context "when adjustment is finalized" do
       let(:finalized) { true }
 
-      it "does not update the adjustment" do
-        expect(adjustment).to_not receive(:update_column)
-        subject
+      context 'with a promotion adjustment' do
+        let(:source) { promotion.actions.first! }
+        let(:promotion) { create(:promotion, :with_line_item_adjustment, adjustment_rate: 7) }
+
+        it 'does not update the adjustment' do
+          expect { subject }.not_to change { adjustment.amount }
+        end
       end
-    end
 
-    context "when adjustment isn't finalized" do
-      let(:finalized) { false }
+      context 'with a tax adjustment' do
+        let(:source) { mock_model(Spree::TaxRate, compute_amount: 10) }
 
-      it "updates the amount" do
-        expect { subject }.to change { adjustment.amount }.to(10)
+        it 'updates the adjustment' do
+          expect { subject }.to change { adjustment.amount }.from(5).to(10)
+        end
       end
 
-      context "it is a promotion adjustment" do
-        let(:promotion) { create(:promotion, :with_order_adjustment, starts_at: promo_start_date) }
-        let(:promo_start_date) { nil }
-        let(:promotion_code) { promotion.codes.first }
-        let(:order) { create(:order_with_line_items, line_items_count: 1) }
+      context 'with a sourceless adjustment' do
+        let(:source) { nil }
 
-        let!(:adjustment) do
-          promotion.activate(order: order, promotion_code: promotion_code)
-          order.adjustments.first
+        it 'does nothing' do
+          expect { subject }.not_to change { adjustment.amount }
         end
+      end
+    end
+
+    context "when adjustment isn't finalized" do
+      let(:finalized) { false }
+
+      context 'with a promotion adjustment' do
+        let(:source) { promotion.actions.first! }
+        let(:promotion) { create(:promotion, :with_line_item_adjustment, adjustment_rate: 7) }
 
-        context "the promotion is eligible" do
-          it "sets the adjustment elgiible to true" do
+        context 'when the promotion is eligible' do
+          it 'updates the adjustment' do
+            expect { subject }.to change { adjustment.amount }.from(5).to(-7)
+          end
+
+          it 'sets the adjustment elgiible to true' do
             subject
-            expect(adjustment.eligible).to eq true
+            expect(adjustment.eligible).to eq(true)
           end
         end
 
-        context "the promotion is not eligible" do
-          let(:promo_start_date) { Date.tomorrow }
+        context 'when the promotion is not eligible' do
+          before do
+            promotion.update!(starts_at: 1.day.from_now)
+          end
 
-          it "sets the adjustment elgiible to false" do
+          it 'zeros out the adjustment' do
+            expect { subject }.to change { adjustment.amount }.from(5).to(0)
+          end
+
+          it 'sets the adjustment elgiible to false' do
             subject
-            expect(adjustment.eligible).to eq false
+            expect(adjustment.eligible).to eq(false)
           end
         end
       end
+
+      context 'with a tax adjustment' do
+        let(:source) { mock_model(Spree::TaxRate, compute_amount: 10) }
+
+        it 'updates the adjustment' do
+          expect { subject }.to change { adjustment.amount }.from(5).to(10)
+        end
+      end
+
+      context 'with a sourceless adjustment' do
+        let(:source) { nil }
+
+        it 'does nothing' do
+          expect { subject }.to_not change { adjustment.amount }
+        end
+      end
     end
   end
 

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

@@ -6,7 +6,13 @@ describe Spree::Calculator::DefaultTax, type: :model do
   let!(:zone) { create(:zone, name: "Country Zone", default_tax: default_tax, countries: [tax_rate_country]) }
   let(:tax_rate_country) { address.country }
   let(:tax_category) { create(:tax_category) }
-  let!(:rate) { create(:tax_rate, tax_category: tax_category, amount: 0.05, included_in_price: included_in_price, zone: zone) }
+  let(:starts_at) { nil }
+  let(:expires_at) { nil }
+  let!(:rate) do
+    create(:tax_rate, tax_categories: [tax_category], amount: 0.05,
+                      included_in_price: included_in_price, zone: zone,
+                      starts_at: starts_at, expires_at: expires_at)
+  end
   let(:included_in_price) { false }
   let(:default_tax) { false }
   subject(:calculator) { Spree::Calculator::DefaultTax.new(calculable: rate ) }
@@ -32,6 +38,15 @@ describe Spree::Calculator::DefaultTax, type: :model do
         it "should be equal to the sum of the item totals * rate" do
           expect(calculator.compute(order)).to eq(3)
         end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(order)).to eq(0)
+          end
+        end
       end
 
       context "when no line items match the tax category" do
@@ -52,6 +67,15 @@ describe Spree::Calculator::DefaultTax, type: :model do
           expect(calculator.compute(order)).to eq(1.5)
         end
 
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(order)).to eq(0)
+          end
+        end
+
         context "correctly rounds to within two decimal places" do
           let(:line_item_one_options) { { price: 10.333, quantity: 1 } }
 
@@ -73,6 +97,15 @@ describe Spree::Calculator::DefaultTax, type: :model do
           expect(calculator.compute(order).to_f).to eql 2.86
         end
 
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(order)).to eq(0)
+          end
+        end
+
         context "when the order's tax address is outside the default VAT zone" do
           let(:default_tax) { true }
           let(:default_vat_country) { create(:country, iso: "DE") }
@@ -86,6 +119,17 @@ describe Spree::Calculator::DefaultTax, type: :model do
               expect(subject.compute(order)).to eq(-2.86)
             end
           end
+
+          context "when rate is not in its validity period" do
+            let(:starts_at) { 1.day.from_now }
+            let(:expires_at) { 2.days.from_now }
+
+            it "should be 0" do
+              Spree::Deprecation.silence do
+                expect(calculator.compute(order)).to eq(0)
+              end
+            end
+          end
         end
       end
     end
@@ -103,6 +147,15 @@ describe Spree::Calculator::DefaultTax, type: :model do
           expect(calculator.compute(item)).to eql 1.43
         end
 
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(item)).to eq(0)
+          end
+        end
+
         context "when line item is discounted" do
           let(:promo_total) { -1 }
 
@@ -135,12 +188,30 @@ describe Spree::Calculator::DefaultTax, type: :model do
         it "should be equal to the item's pre-tax total * rate" do
           expect(calculator.compute(item)).to eq(1.45)
         end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(item)).to eq(0)
+          end
+        end
       end
 
       context "when the variant matches the tax category" do
         it "should be equal to the item pre-tax total * rate" do
           expect(calculator.compute(item)).to eq(1.50)
         end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(item)).to eq(0)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'shared_examples/calculator_shared_examples'
+
+describe Spree::Calculator::DistributedAmount, type: :model do
+  describe "#compute_line_item" do
+    subject { calculator.compute_line_item(order.line_items.first) }
+
+    let(:calculator) { Spree::Calculator::DistributedAmount.new }
+
+    let(:order) do
+      FactoryGirl.create(
+        :order_with_line_items,
+        line_items_attributes: [{ price: 50 }, { price: 50 }, { price: 50 }]
+      )
+    end
+
+    before do
+      calculator.preferred_amount = 15
+      calculator.preferred_currency = currency
+    end
+
+    context "when the order currency matches the store's currency" do
+      let(:currency) { "USD" }
+      it { is_expected.to eq 5 }
+    end
+
+    context "when the order currency does not match the store's currency" do
+      let(:currency) { "CAD" }
+      it { is_expected.to eq 0 }
+    end
+  end
+end

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

@@ -57,22 +57,41 @@ describe Spree::Calculator::TieredFlatRate, type: :model do
   end
 
   describe "#compute" do
-    let(:line_item) { mock_model Spree::LineItem, amount: amount }
+    let(:order) do
+      create(
+        :order_with_line_items,
+        line_items_count: 1,
+        line_items_price: amount
+      )
+    end
+    let(:line_item) { order.line_items.first }
+    let(:preferred_currency) { "USD" }
+
     before do
       calculator.preferred_base_amount = 10
       calculator.preferred_tiers = {
         100 => 15,
         200 => 20
       }
+      calculator.preferred_currency = preferred_currency
     end
+
     subject { calculator.compute(line_item) }
+
     context "when amount falls within the first tier" do
       let(:amount) { 50 }
       it { is_expected.to eq 10 }
     end
+
     context "when amount falls within the second tier" do
       let(:amount) { 150 }
       it { is_expected.to eq 15 }
     end
+
+    context "when the order's currency does not match the calculator" do
+      let(:preferred_currency) { "CAD" }
+      let(:amount) { 50 }
+      it { is_expected.to eq 0 }
+    end
   end
 end

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

@@ -73,8 +73,15 @@ describe Spree::Calculator::TieredPercent, type: :model do
   end
 
   describe "#compute" do
-    let(:order) { create(:order_with_line_items, line_items_count: line_item_count, line_items_price: price) }
+    let(:order) do
+      create(
+        :order_with_line_items,
+        line_items_count: line_item_count,
+        line_items_price: price
+      )
+    end
     let(:price) { 10 }
+    let(:preferred_currency) { "USD" }
 
     before do
       calculator.preferred_base_percent = 10
@@ -82,6 +89,7 @@ describe Spree::Calculator::TieredPercent, type: :model do
         20 => 15,
         30 => 20
       }
+      calculator.preferred_currency = preferred_currency
     end
 
     context "with a line item" do
@@ -123,6 +131,12 @@ describe Spree::Calculator::TieredPercent, type: :model do
           it { is_expected.to eq 6.0 }
         end
       end
+
+      context "when the order's currency does not match the calculator" do
+        let(:preferred_currency) { "CAD" }
+        let(:line_item_count) { 1 }
+        it { is_expected.to eq 0 }
+      end
     end
 
     context "with an order" do
@@ -165,6 +179,11 @@ describe Spree::Calculator::TieredPercent, type: :model do
           it { is_expected.to eq 6.0 }
         end
       end
+
+      context "when the order's currency does not match the calculator" do
+        let(:preferred_currency) { "CAD" }
+        it { is_expected.to eq 0 }
+      end
     end
   end
 end

data/spec/models/spree/distributed_amounts_handler_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+RSpec.describe Spree::DistributedAmountsHandler, type: :model do
+  let(:order) do
+    FactoryGirl.create(
+      :order_with_line_items,
+      line_items_attributes: line_items_attributes
+    )
+  end
+
+  describe "#amount" do
+    let(:total_amount) { 15 }
+
+    subject { described_class.new(line_item, total_amount).amount }
+
+    context "when there is only one line item" do
+      let(:line_items_attributes) { [{ price: 100 }] }
+      let(:line_item) { order.line_items.first }
+
+      it "applies the entire amount to the line item" do
+        expect(subject).to eq(15)
+      end
+    end
+
+    context "when there are multiple line items" do
+      let(:line_items_attributes) do
+        [{ price: 50 }, { price: 50 }, { price: 50 }]
+      end
+
+      context "and the line items are equally priced" do
+        it "evenly distributes the total amount" do
+          expect(
+            [
+              described_class.new(order.line_items[0], total_amount).amount,
+              described_class.new(order.line_items[1], total_amount).amount,
+              described_class.new(order.line_items[2], total_amount).amount
+            ]
+          ).to eq(
+            [5, 5, 5]
+          )
+        end
+
+        context "and the total amount cannot be equally distributed" do
+          let(:total_amount) { 10 }
+
+          it "applies the remainder of the total amount to the last item" do
+            expect(
+              [
+                described_class.new(order.line_items[0], total_amount).amount,
+                described_class.new(order.line_items[1], total_amount).amount,
+                described_class.new(order.line_items[2], total_amount).amount
+              ]
+            ).to eq(
+              [3.33, 3.33, 3.34]
+            )
+          end
+        end
+      end
+
+      context "and the line items are not equally priced" do
+        let(:line_items_attributes) do
+          [{ price: 150 }, { price: 50 }, { price: 100 }]
+        end
+
+        it "distributes the total amount relative to the item's price" do
+          expect(
+            [
+              described_class.new(order.line_items[0], total_amount).amount,
+              described_class.new(order.line_items[1], total_amount).amount,
+              described_class.new(order.line_items[2], total_amount).amount
+            ]
+          ).to eq(
+            [7.5, 2.5, 5]
+          )
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/gateway/bogus_simple.rb

@@ -1,18 +1,12 @@
 require 'spec_helper'
 
-describe Spree::Gateway::BogusSimple, type: :model do
-  subject { Spree::Gateway::BogusSimple.new }
-
-  # regression test for https://github.com/spree/spree/issues/3824
-  describe "#capture" do
-    it "returns success with the right response code" do
-      response = subject.capture(123, '12345', {})
-      expect(response.message).to include("success")
-    end
+describe Spree::Gateway::BogusSimple do
+  it 'is deprecated' do
+    expect(Spree::Deprecation).to receive(:warn)
+    described_class.new
+  end
 
-    it "returns failure with the wrong response code" do
-      response = subject.capture(123, 'wrong', {})
-      expect(response.message).to include("failure")
-    end
+  it 'has Spree::PaymentMethod::SimpleBogusCreditCard as superclass' do
+    expect(described_class.ancestors).to include(Spree::PaymentMethod::SimpleBogusCreditCard)
   end
 end

data/spec/models/spree/gateway/bogus_spec.rb

@@ -1,8 +1,12 @@
 require 'spec_helper'
 
-module Spree
-  describe Gateway::Bogus, type: :model do
-    let(:bogus) { create(:credit_card_payment_method) }
-    let!(:cc) { create(:credit_card, payment_method: bogus, gateway_customer_profile_id: "BGS-RERTERT") }
+describe Spree::Gateway::Bogus do
+  it 'is deprecated' do
+    expect(Spree::Deprecation).to receive(:warn)
+    described_class.new
+  end
+
+  it 'has Spree::PaymentMethod::BogusCreditCard as superclass' do
+    expect(described_class.ancestors).to include(Spree::PaymentMethod::BogusCreditCard)
   end
 end

data/spec/models/spree/gateway_spec.rb

@@ -1,111 +1,12 @@
 require 'spec_helper'
 
-describe Spree::Gateway, type: :model do
-  class Provider
-    def initialize(options)
-    end
-
-    def authorize; 'authorize'; end
-
-    def purchase; 'purchase'; end
-
-    def capture; 'capture'; end
-
-    def void; 'void'; end
-
-    def credit; 'credit'; end
-  end
-
-  class TestGateway < Spree::Gateway
-    def provider_class
-      Provider
-    end
+describe Spree::Gateway do
+  it 'is deprecated' do
+    expect(Spree::Deprecation).to receive(:warn)
+    described_class.new
   end
 
-  describe 'ActiveMerchant methods' do
-    let(:gateway) { TestGateway.new }
-
-    it "passes through authorize" do
-      expect(gateway.authorize).to eq 'authorize'
-    end
-
-    it "passes through purchase" do
-      expect(gateway.purchase).to eq 'purchase'
-    end
-
-    it "passes through capture" do
-      expect(gateway.capture).to eq 'capture'
-    end
-
-    it "passes through void" do
-      expect(gateway.void).to eq 'void'
-    end
-
-    it "passes through credit" do
-      expect(gateway.credit).to eq 'credit'
-    end
-  end
-
-  context "fetching payment sources" do
-    let(:store) { create :store }
-    let(:user) { create :user }
-    let(:order) { Spree::Order.create(user: user, completed_at: completed_at, store: store) }
-
-    let(:payment_method) { create(:credit_card_payment_method) }
-
-    let(:cc) do
-      create(:credit_card,
-             payment_method: payment_method,
-             gateway_customer_profile_id: "EFWE",
-             user: cc_user)
-    end
-
-    let(:payment) do
-      create(:payment, order: order, source: cc, payment_method: payment_method)
-    end
-
-    context 'order is not complete and credit card user is nil' do
-      let(:cc_user) { nil }
-      let(:completed_at) { nil }
-
-      it "finds no credit cards associated to the order" do
-        expect(payment_method.reusable_sources(payment.order)).to be_empty
-      end
-    end
-
-    context 'order is complete but credit card user is nil' do
-      let(:cc_user) { nil }
-      let(:completed_at) { Date.yesterday }
-
-      it "finds credit cards associated on a order completed" do
-        expect(payment_method.reusable_sources(payment.order)).to eq [cc]
-      end
-    end
-
-    context 'order is not complete but credit card has user' do
-      let(:cc_user) { user }
-      let(:completed_at) { nil }
-      before do
-        cc_user.wallet.add(cc)
-      end
-      it "finds credit cards associated to the user" do
-        expect(payment_method.reusable_sources(payment.order)).to eq [cc]
-      end
-    end
-  end
-
-  context 'using preference_source' do
-    let(:klass){ Spree::Gateway::Bogus }
-    before do
-      Spree::Config.static_model_preferences.add(klass, 'test_preference_source', server: 'bar')
-    end
-    after do
-      Spree::Config.static_model_preferences.for_class(klass).clear
-    end
-    let(:payment_method){ create(:credit_card_payment_method, preference_source: 'test_preference_source') }
-
-    it "reads static preferences" do
-      expect(payment_method.options).to eq({ server: "bar" })
-    end
+  it 'has Spree::PaymentMethod::CreditCard as superclass' do
+    expect(described_class.ancestors).to include(Spree::PaymentMethod::CreditCard)
   end
 end

data/spec/models/spree/image_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Spree::Image, type: :model do
+  context '#save' do
+    context 'invalid attachment' do
+      let(:invalid_image) { File.open(__FILE__) }
+      subject { described_class.new(attachment: invalid_image) }
+
+      it 'returns false' do
+        expect(subject.save).to be false
+      end
+    end
+
+    context 'valid attachment' do
+      let(:valid_image) { File.open(File.join('spec', 'fixtures', 'thinking-cat.jpg')) }
+      subject { described_class.new(attachment: valid_image) }
+
+      it 'returns true' do
+        expect(subject.save).to be true
+      end
+    end
+  end
+end