solidus_core 1.1.0 → 1.1.1

data/spec/models/spree/concerns/ordered_property_value_list_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Spree::OrderedPropertyValueList do
+  #
+  # Using ProductProperty as a subject
+  # since it includes OrderedPropertyValueList
+  #
+  let(:product_property) { create(:product_property) }
+
+  context "validations" do
+    # Only MySQL stores or stores that were migrated prior to the Rails 4.2
+    # upgrade have length limitations on "value":
+    # > The PostgreSQL and SQLite adapters no longer add a default limit of 255
+    # > characters on string columns.
+    # http://guides.rubyonrails.org/4_2_release_notes.html#active-record-notable-changes
+    # https://github.com/rails/rails/pull/14579
+    if Spree::ProductProperty.columns_hash['value'].limit
+      it "should validate length of value" do
+        overflow_length = Spree::ProductProperty.columns_hash['value'].limit + 1
+        product_property.value = "x" * overflow_length
+        expect(product_property).not_to be_valid
+      end
+    end
+  end
+end

data/spec/models/spree/concerns/user_address_book_spec.rb

@@ -0,0 +1,332 @@
+require 'spec_helper'
+
+module Spree
+  describe UserAddressBook do
+
+    #
+    # Using LegacyUser as a subject
+    # since it uses the UserAddressBookExtension
+    #
+    let!(:user) { create(:user) }
+
+    describe "#save_in_address_book" do
+      context "saving a default address" do
+        let(:user_address) { user.user_addresses.find_first_by_address_values(address.attributes) }
+
+        subject { user.save_in_address_book(address.attributes, true) }
+
+        context "the address is a new record" do
+          let(:address) { build(:address) }
+
+          it "creates a new Address" do
+            expect { subject }.to change { Spree::Address.count }.by(1)
+          end
+
+          it "creates a UserAddress" do
+            expect { subject }.to change { Spree::UserAddress.count }.by(1)
+          end
+
+          it "sets the UserAddress default flag to true" do
+            subject
+            expect(user_address.default).to eq true
+          end
+
+          it "adds the address to the user's the associated addresses" do
+            expect { subject }.to change { user.reload.addresses.count }.by(1)
+          end
+        end
+
+        context "user already has a default address" do
+          let(:address) { create(:address) }
+          let(:original_default_address) { create(:ship_address) }
+          let(:original_user_address) { user.user_addresses.find_first_by_address_values(original_default_address.attributes) }
+
+          before do
+            user.user_addresses.create(address: original_default_address, default: true)
+          end
+
+          it "makes all the other associated addresses not be the default" do
+            expect { subject }.to change { original_user_address.reload.default }.from(true).to(false)
+          end
+
+          context "an odd flip-flop corner case discovered running backfill rake task" do
+
+            before do
+              user.save_in_address_book(original_default_address.attributes, true)
+              user.save_in_address_book(address.attributes, true)
+            end
+
+            it "handles setting 2 addresses as default without a reload of user" do
+              user.save_in_address_book(original_default_address.attributes, true)
+              user.save_in_address_book(address.attributes, true)
+              expect(user.addresses.count).to eq 2
+              expect(user.default_address.address1).to eq address.address1
+            end
+          end
+        end
+
+        context "changing existing address to default" do
+          let(:address) { create(:address) }
+
+          before do
+            user.user_addresses.create(address: address, default: false)
+          end
+
+          it "properly sets the default flag" do
+            expect(subject).to eq user.default_address
+          end
+
+          context "and changing another address field at the same time" do
+            let(:updated_address_attributes) { address.attributes.tap {|a| a[:first_name] = "Newbie"} }
+
+            subject { user.save_in_address_book(updated_address_attributes, true) }
+
+            it "changes first name" do
+              expect(subject.first_name).to eq updated_address_attributes[:first_name]
+            end
+
+            it "preserves last name" do
+              expect(subject.last_name).to eq address.last_name
+            end
+
+            it "is a new immutable address instance" do
+              expect(subject.id).to_not eq address.id
+            end
+
+            it "is the new default" do
+              expect(subject).to eq user.default_address
+            end
+          end
+        end
+      end
+
+      context "updating an address and making default at once" do
+        let(:address1) { create(:address) }
+        let(:address2) { create(:address, firstname: "Different") }
+        let(:updated_attrs) do
+          address2.attributes.tap {|a| a[:firstname] = "Johnny" }
+        end
+
+        before do
+          user.save_in_address_book(address1.attributes, true)
+          user.save_in_address_book(address2.attributes, false)
+        end
+
+        it "returns the edit as the first address" do
+          user.save_in_address_book(updated_attrs, true)
+          expect(user.user_addresses.first.address.firstname).to eq "Johnny"
+        end
+      end
+
+      context "saving a non-default address" do
+        let(:user_address) { user.user_addresses.find_first_by_address_values(address.attributes) }
+
+        subject { user.save_in_address_book(address.attributes) }
+
+        context "the address is a new record" do
+          let(:address) { build(:address) }
+
+          it "creates a new Address" do
+            expect { subject }.to change { Spree::Address.count }.by(1)
+          end
+
+          it "creates a UserAddress" do
+            expect { subject }.to change { Spree::UserAddress.count }.by(1)
+          end
+
+          context "it is not the first address" do
+            before { user.user_addresses.create!(address: create(:address)) }
+            it "sets the UserAddress default flag to false" do
+              expect { subject }.to change { Spree::UserAddress.count }.by(1)
+              expect(user_address.default).to eq false
+            end
+          end
+
+          context "it is the first address" do
+            it "sets the UserAddress default flag to true" do
+              subject
+              expect(user_address.default).to eq true
+            end
+          end
+
+          it "adds the address to the user's the associated addresses" do
+            expect { subject }.to change { user.reload.addresses.count }.by(1)
+          end
+        end
+      end
+
+      context "resurrecting a previously saved (but now archived) address" do
+        let(:address) { create(:address) }
+        before do
+          user.save_in_address_book(address.attributes, true)
+          user.remove_from_address_book(address.id)
+        end
+        subject { user.save_in_address_book(address.attributes, true) }
+
+        it "returns the address" do
+          expect(subject).to eq address
+        end
+
+        it "sets it as default" do
+          subject
+          expect(user.default_address).to eq address
+        end
+
+        context "via an edit to another address" do
+          let(:address2) { create(:address, firstname: "Different") }
+          let(:edited_attributes) do
+            # conceptually edit address2 to match the values of address
+            edited_attributes = address.attributes
+            edited_attributes[:id] = address2.id
+            edited_attributes
+          end
+
+          before { user.save_in_address_book(address2.attributes, true) }
+
+          subject { user.save_in_address_book(edited_attributes) }
+
+          it "returns the address" do
+            expect(subject).to eq address
+          end
+
+          it "archives address2" do
+            subject
+            user_address2 = user.user_addresses.all_historical.find_by(address_id: address2.id)
+            expect(user_address2.archived).to be true
+          end
+
+          context "via a new address that matches an archived one" do
+            let(:added_attributes) do
+              added_attributes = address.attributes
+              added_attributes.delete(:id)
+              added_attributes
+            end
+
+            subject { user.save_in_address_book(added_attributes) }
+
+            it "returns the address" do
+              expect(subject).to eq address
+            end
+
+            it "no longer has archived user_addresses" do
+              subject
+              expect(user.user_addresses.all_historical).to eq user.user_addresses
+            end
+          end
+        end
+      end
+    end
+
+    context "#remove_from_address_book" do
+      let(:address1) { create(:address) }
+      let(:address2) { create(:address, firstname: "Different") }
+      let(:remove_id) { address1.id}
+      subject { user.remove_from_address_book(remove_id) }
+
+      before do
+        user.save_in_address_book(address1.attributes)
+        user.save_in_address_book(address2.attributes)
+      end
+
+      it "removes the address from user_addresses" do
+        subject
+        expect(user.user_addresses.find_first_by_address_values(address1.attributes)).to be_nil
+      end
+
+      it "leaves user_address record in an archived state" do
+        subject
+        archived_user_address = user.user_addresses.all_historical.find_first_by_address_values(address1.attributes)
+        expect(archived_user_address).to be_archived
+      end
+
+      it "returns false if the addresses is not there" do
+        expect(user.remove_from_address_book(42)).to be false
+      end
+    end
+
+    context "#persist_order_address" do
+      context "when automatic_default_address preference is at a default of true" do
+        before do
+          Spree::Config.automatic_default_address = true
+          expect(user).to receive(:save_in_address_book).with(kind_of(Hash), true)
+          expect(user).to receive(:save_in_address_book).with(kind_of(Hash), false)
+        end
+
+        it "does set the default: true flag" do
+          order = build(:order)
+          user.persist_order_address(order)
+        end
+      end
+
+      context "when automatic_default_address preference is false" do
+        before do
+          Spree::Config.automatic_default_address = false
+          expect(user).to receive(:save_in_address_book).with(kind_of(Hash),false).twice
+            #and not the optional 2nd argument
+        end
+
+        it "does not set the default: true flag" do
+          order = build(:order)
+          user.persist_order_address(order)
+        end
+      end
+
+      context "when address is nil" do
+        context "when automatic_default_address preference is at a default of true" do
+          before do
+            Spree::Config.automatic_default_address = true
+            expect(user).to receive(:save_in_address_book).with(kind_of(Hash), true).once
+          end
+
+          it "does not call save_in_address_book on ship address" do
+            order = build(:order)
+            order.ship_address = nil
+
+            user.persist_order_address(order)
+          end
+
+          it "does not call save_in_address_book on bill address" do
+            order = build(:order)
+            order.bill_address = nil
+
+            user.persist_order_address(order)
+          end
+        end
+      end
+
+      context "when automatic_default_address preference is false" do
+        before do
+          Spree::Config.automatic_default_address = false
+          expect(user).to receive(:save_in_address_book).with(kind_of(Hash), false).once
+        end
+
+        it "does not call save_in_address_book on ship address" do
+          order = build(:order)
+          order.ship_address = nil
+
+          user.persist_order_address(order)
+        end
+
+          it "does not call save_in_address_book on bill address" do
+          order = build(:order)
+          order.bill_address = nil
+
+          user.persist_order_address(order)
+        end
+      end
+    end
+  end
+
+  context "generating a new user with a ship_address at once" do
+    let(:ship_address) { build(:ship_address) }
+    subject { create(:user, ship_address: ship_address) }
+
+    it "stores the ship_address" do
+      expect(subject.ship_address).to eq ship_address
+    end
+
+    it "is also available as default_address" do
+      expect(subject.default_address).to eq ship_address
+    end
+  end
+end

data/spec/models/spree/concerns/user_methods_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Spree::UserMethods do
+  let(:test_user)        { create :user }
+
+  describe '#has_spree_role?' do
+    subject { test_user.has_spree_role? name }
+
+    let(:role) { Spree::Role.create(name: name) }
+    let(:name) { 'test' }
+
+    context 'with a role' do
+      before { test_user.spree_roles << role }
+      it     { is_expected.to be_truthy }
+    end
+
+    context 'without a role' do
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe '#last_incomplete_spree_order' do
+    subject { test_user.last_incomplete_spree_order }
+
+    context 'with an incomplete order' do
+      let(:last_incomplete_order) { create :order, user: test_user }
+
+      before do
+        create(:order, user: test_user, created_at: 1.day.ago)
+        create(:order, user: create(:user))
+        last_incomplete_order
+      end
+
+      it { is_expected.to eq last_incomplete_order }
+    end
+
+    context 'without an incomplete order' do
+      it { is_expected.to be_nil }
+    end
+  end
+end

data/spec/models/spree/credit_card_spec.rb

@@ -0,0 +1,341 @@
+require 'spec_helper'
+
+describe Spree::CreditCard, type: :model do
+  let(:valid_credit_card_attributes) do
+    {
+      number: '4111111111111111',
+      verification_value: '123',
+      expiry: "12 / #{(Time.now.year + 1).to_s.last(2)}",
+      name: 'Spree Commerce'
+    }
+  end
+
+  def self.payment_states
+    Spree::Payment.state_machine.states.keys
+  end
+
+  let(:credit_card) { Spree::CreditCard.new }
+
+  before(:each) do
+
+    @order = create(:order)
+    @payment = Spree::Payment.create(:amount => 100, :order => @order)
+
+    @success_response = double('gateway_response', success?: true, authorization: '123', avs_result: { 'code' => 'avs-code' })
+    @fail_response = double('gateway_response', success?: false)
+
+    @payment_gateway = mock_model(Spree::PaymentMethod,
+      payment_profiles_supported?: true,
+      authorize: @success_response,
+      purchase: @success_response,
+      capture: @success_response,
+      void: @success_response,
+      credit: @success_response,
+    )
+
+    allow(@payment).to receive_messages payment_method: @payment_gateway
+  end
+
+  context "#can_capture?" do
+    it "should be true if payment is pending" do
+      payment = mock_model(Spree::Payment, pending?: true, created_at: Time.now)
+      expect(credit_card.can_capture?(payment)).to be true
+    end
+
+    it "should be true if payment is checkout" do
+      payment = mock_model(Spree::Payment, pending?: false, checkout?: true, created_at: Time.now)
+      expect(credit_card.can_capture?(payment)).to be true
+    end
+  end
+
+  context "#can_void?" do
+    it "should be true if payment is not void" do
+      payment = mock_model(Spree::Payment, failed?: false, void?: false)
+      expect(credit_card.can_void?(payment)).to be true
+    end
+  end
+
+  context "#can_credit?" do
+    it "should be false if payment is not completed" do
+      payment = mock_model(Spree::Payment, completed?: false)
+      expect(credit_card.can_credit?(payment)).to be false
+    end
+
+    it "should be false when credit_allowed is zero" do
+      payment = mock_model(Spree::Payment, completed?: true, credit_allowed: 0, order: mock_model(Spree::Order, payment_state: 'credit_owed'))
+      expect(credit_card.can_credit?(payment)).to be false
+    end
+  end
+
+  context "#valid?" do
+    it "should validate presence of number" do
+      credit_card.attributes = valid_credit_card_attributes.except(:number)
+      expect(credit_card).not_to be_valid
+      expect(credit_card.errors[:number]).to eq(["can't be blank"])
+    end
+
+    it "should validate presence of security code" do
+      credit_card.attributes = valid_credit_card_attributes.except(:verification_value)
+      expect(credit_card).not_to be_valid
+      expect(credit_card.errors[:verification_value]).to eq(["can't be blank"])
+    end
+
+    it "validates name presence" do
+      credit_card.valid?
+      expect(credit_card.error_on(:name).size).to eq(1)
+    end
+
+    it "should only validate on create" do
+      credit_card.attributes = valid_credit_card_attributes
+      credit_card.save
+      expect(credit_card).to be_valid
+    end
+
+    context "encrypted data is present" do
+      it "does not validate presence of number or cvv" do
+        credit_card.encrypted_data = "$fdgsfgdgfgfdg&gfdgfdgsf-"
+        credit_card.valid?
+        expect(credit_card.errors[:number]).to be_empty
+        expect(credit_card.errors[:verification_value]).to be_empty
+      end
+    end
+
+    context "imported is true" do
+      it "does not validate presence of number or cvv" do
+        credit_card.imported = true
+        credit_card.valid?
+        expect(credit_card.errors[:number]).to be_empty
+        expect(credit_card.errors[:verification_value]).to be_empty
+      end
+    end
+  end
+
+  context "#save" do
+    before do
+      credit_card.attributes = valid_credit_card_attributes
+      credit_card.save!
+    end
+
+    let!(:persisted_card) { Spree::CreditCard.find(credit_card.id) }
+    let (:valid_address_attributes) { {firstname: "Hugo", lastname: "Furst",
+                                       address1: "123 Main", city: "Somewhere",
+                                       country_id: 1, zipcode: 55555,
+                                       phone: "1234567890"} }
+
+    it "should not actually store the number" do
+      expect(persisted_card.number).to be_blank
+    end
+
+    it "should not actually store the security code" do
+      expect(persisted_card.verification_value).to be_blank
+    end
+
+    it "should save and update addresses through nested attributes" do
+      persisted_card.update_attributes({address_attributes: valid_address_attributes})
+      persisted_card.save!
+      updated_attributes = {id: persisted_card.address.id, address1: "123 Main St."}
+      persisted_card.update_attributes({address_attributes: updated_attributes})
+      expect(persisted_card.address.address1).to eq "123 Main St."
+    end
+  end
+
+  context "#number=" do
+    it "should strip non-numeric characters from card input" do
+      credit_card.number = "6011000990139424"
+      expect(credit_card.number).to eq("6011000990139424")
+
+      credit_card.number = "  6011-0009-9013-9424  "
+      expect(credit_card.number).to eq("6011000990139424")
+    end
+
+    it "should not raise an exception on non-string input" do
+      credit_card.number = Hash.new
+      expect(credit_card.number).to be_nil
+    end
+  end
+
+  # Regression test for #3847 & #3896
+  context "#expiry=" do
+    it "can set with a 2-digit month and year" do
+      credit_card.expiry = '04 / 15'
+      expect(credit_card.month).to eq('4')
+      expect(credit_card.year).to eq('2015')
+    end
+
+    it "can set with a 2-digit month and 4-digit year" do
+      credit_card.expiry = '04 / 2015'
+      expect(credit_card.month).to eq('4')
+      expect(credit_card.year).to eq('2015')
+    end
+
+    it "can set with a 2-digit month and 4-digit year without whitespace" do
+      credit_card.expiry = '04/15'
+      expect(credit_card.month).to eq('4')
+      expect(credit_card.year).to eq('2015')
+    end
+
+    it "can set with a 2-digit month and 4-digit year without whitespace" do
+      credit_card.expiry = '04/2015'
+      expect(credit_card.month).to eq('4')
+      expect(credit_card.year).to eq('2015')
+    end
+
+    it "can set with a 2-digit month and 4-digit year without whitespace and slash" do
+      credit_card.expiry = '042015'
+      expect(credit_card.month).to eq('4')
+      expect(credit_card.year).to eq('2015')
+    end
+
+    it "can set with a 2-digit month and 2-digit year without whitespace and slash" do
+      credit_card.expiry = '0415'
+      expect(credit_card.month).to eq('4')
+      expect(credit_card.year).to eq('2015')
+    end
+
+    it "does not blow up when passed an empty string" do
+      expect { credit_card.expiry = '' }.not_to raise_error
+    end
+
+    # Regression test for #4725
+    it "does not blow up when passed one number" do
+      expect { credit_card.expiry = '12' }.not_to raise_error
+    end
+
+  end
+
+  context "#cc_type=" do
+    it "converts between the different types" do
+      credit_card.cc_type = 'mastercard'
+      expect(credit_card.cc_type).to eq('master')
+
+      credit_card.cc_type = 'maestro'
+      expect(credit_card.cc_type).to eq('master')
+
+      credit_card.cc_type = 'amex'
+      expect(credit_card.cc_type).to eq('american_express')
+
+      credit_card.cc_type = 'dinersclub'
+      expect(credit_card.cc_type).to eq('diners_club')
+
+      credit_card.cc_type = 'some_outlandish_cc_type'
+      expect(credit_card.cc_type).to eq('some_outlandish_cc_type')
+    end
+
+    it "assigns the type based on card number in the event of js failure" do
+      credit_card.number = '4242424242424242'
+      credit_card.cc_type = ''
+      expect(credit_card.cc_type).to eq('visa')
+
+      credit_card.number = '5555555555554444'
+      credit_card.cc_type = ''
+      expect(credit_card.cc_type).to eq('master')
+
+      credit_card.number = '378282246310005'
+      credit_card.cc_type = ''
+      expect(credit_card.cc_type).to eq('american_express')
+
+      credit_card.number = '30569309025904'
+      credit_card.cc_type = ''
+      expect(credit_card.cc_type).to eq('diners_club')
+
+      credit_card.number = '3530111333300000'
+      credit_card.cc_type = ''
+      expect(credit_card.cc_type).to eq('jcb')
+
+      credit_card.number = ''
+      credit_card.cc_type = ''
+      expect(credit_card.cc_type).to eq('')
+
+      credit_card.number = nil
+      credit_card.cc_type = ''
+      expect(credit_card.cc_type).to eq('')
+    end
+  end
+
+  context "#associations" do
+    it "should be able to access its payments" do
+      expect { credit_card.payments.to_a }.not_to raise_error
+    end
+  end
+
+  context "#first_name" do
+    before do
+      credit_card.name = "Ludwig van Beethoven"
+    end
+
+    it "extracts the first name" do
+      expect(credit_card.first_name).to eq "Ludwig"
+    end
+  end
+
+  context "#last_name" do
+    before do
+      credit_card.name = "Ludwig van Beethoven"
+    end
+
+    it "extracts the last name" do
+      expect(credit_card.last_name).to eq "van Beethoven"
+    end
+  end
+
+  context "#to_active_merchant" do
+    before do
+      credit_card.number = "4111111111111111"
+      credit_card.year = Time.now.year
+      credit_card.month = Time.now.month
+      credit_card.name = "Ludwig van Beethoven"
+      credit_card.verification_value = 123
+    end
+
+    it "converts to an ActiveMerchant::Billing::CreditCard object" do
+      am_card = credit_card.to_active_merchant
+      expect(am_card.number).to eq("4111111111111111")
+      expect(am_card.year).to eq(Time.now.year)
+      expect(am_card.month).to eq(Time.now.month)
+      expect(am_card.first_name).to eq("Ludwig")
+      expect(am_card.last_name).to eq("van Beethoven")
+      expect(am_card.verification_value).to eq(123)
+    end
+  end
+
+  it 'ensures only one credit card per user is default at a time' do
+    user = FactoryGirl.create(:user)
+    first = FactoryGirl.create(:credit_card, user: user, default: true)
+    second = FactoryGirl.create(:credit_card, user: user, default: true)
+
+    expect(first.reload.default).to eq false
+    expect(second.reload.default).to eq true
+
+    first.default = true
+    first.save!
+
+    expect(first.reload.default).to eq true
+    expect(second.reload.default).to eq false
+  end
+
+  it 'allows default credit cards for different users' do
+    first = FactoryGirl.create(:credit_card, user: FactoryGirl.create(:user), default: true)
+    second = FactoryGirl.create(:credit_card, user: FactoryGirl.create(:user), default: true)
+
+    expect(first.reload.default).to eq true
+    expect(second.reload.default).to eq true
+  end
+
+  it 'allows this card to save even if the previously default card has expired' do
+    user = FactoryGirl.create(:user)
+    first = FactoryGirl.create(:credit_card, user: user, default: true)
+    second = FactoryGirl.create(:credit_card, user: user, default: false)
+    first.update_columns(year: DateTime.now.year, month: 1.month.ago.month)
+
+    expect { second.update_attributes!(default: true) }.not_to raise_error
+  end
+
+  it 'allows this card to save even if the previously default card has expired' do
+    user = FactoryGirl.create(:user)
+    first = FactoryGirl.create(:credit_card, user: user, default: true)
+    second = FactoryGirl.create(:credit_card, user: user, default: false)
+    first.update_columns(year: DateTime.now.year, month: 1.month.ago.month)
+
+    expect { second.update_attributes!(default: true) }.not_to raise_error
+  end
+end