solidus_core 1.2.3 → 1.3.0.beta1

data/spec/lib/spree/core/importer/order_spec.rb

@@ -3,39 +3,44 @@ require 'spec_helper'
 module Spree
   module Core
     describe Importer::Order do
-
+      let!(:store) { create(:store) }
       let!(:country) { create(:country) }
-      let!(:state) { country.states.first || create(:state, :country => country) }
+      let!(:state) { country.states.first || create(:state, country: country) }
       let!(:stock_location) { create(:stock_location, admin_name: 'Admin Name') }
 
-      let(:user) { stub_model(LegacyUser, :email => 'fox@mudler.com') }
+      let(:user) { stub_model(LegacyUser, email: 'fox@mudler.com') }
       let(:shipping_method) { create(:shipping_method) }
       let(:payment_method) { create(:check_payment_method) }
 
-      let(:product) { product = Spree::Product.create(:name => 'Test',
-                                             :sku => 'TEST-1',
-                                             :price => 33.22)
-                      product.shipping_category = create(:shipping_category)
-                      product.save
-                      product }
-
-      let(:variant) { variant = product.master
-                      variant.stock_items.each { |si| si.update_attribute(:count_on_hand, 10) }
-                      variant }
+      let(:product) {
+        product = Spree::Product.create(name: 'Test',
+                                             sku: 'TEST-1',
+                                             price: 33.22)
+        product.shipping_category = create(:shipping_category)
+        product.save
+        product
+      }
+
+      let(:variant) {
+        variant = product.master
+        variant.stock_items.each { |si| si.set_count_on_hand(10) }
+        variant
+      }
 
       let(:sku) { variant.sku }
       let(:variant_id) { variant.id }
 
-      let(:line_items) {{ "0" => { :variant_id => variant.id, :quantity => 5 }}}
-      let(:ship_address) {{
-         :address1 => '123 Testable Way',
-         :firstname => 'Fox',
-         :lastname => 'Mulder',
-         :city => 'Washington',
-         :country_id => country.id,
-         :state_id => state.id,
-         :zipcode => '66666',
-         :phone => '666-666-6666'
+      let(:line_items) { { "0" => { variant_id: variant.id, quantity: 5 } } }
+      let(:ship_address) {
+        {
+         address1: '123 Testable Way',
+         firstname: 'Fox',
+         lastname: 'Mulder',
+         city: 'Washington',
+         country_id: country.id,
+         state_id: state.id,
+         zipcode: '66666',
+         phone: '666-666-6666'
       }}
 
       it 'can import an order number' do
@@ -48,22 +53,22 @@ module Spree
         params = { email: 'test@test.com',
                    completed_at: Time.current,
                    line_items_attributes: line_items }
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order).to be_completed
         expect(order.state).to eq 'complete'
       end
 
       it "assigns order[email] over user email to order" do
         params = { email: 'wooowww@test.com' }
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.email).to eq params[:email]
       end
 
       context "assigning a user to an order" do
-        let(:other_user) { stub_model(LegacyUser, :email => 'dana@scully.com') }
+        let(:other_user) { stub_model(LegacyUser, email: 'dana@scully.com') }
 
         context "as an admin" do
-          before { allow(user).to receive_messages :has_spree_role? => true }
+          before { allow(user).to receive_messages has_spree_role?: true }
 
           context "a user's id is not provided" do
             context "nil user id is provided" do
@@ -85,7 +90,7 @@ module Spree
 
           context "a user's id is not provided" do
             it "doesn't unassociate the admin from the order" do
-              params = { }
+              params = {}
               order = Importer::Order.import(user, params)
               expect(order.user_id).to eq(user.id)
             end
@@ -93,7 +98,7 @@ module Spree
         end
 
         context "as a user" do
-          before { allow(user).to receive_messages :has_spree_role? => false }
+          before { allow(user).to receive_messages has_spree_role?: false }
           it "does not assign the order to the other user" do
             params = { user_id: other_user.id }
             order = Importer::Order.import(user, params)
@@ -103,10 +108,10 @@ module Spree
       end
 
       it 'can build an order from API with just line items' do
-        params = { :line_items_attributes => line_items }
+        params = { line_items_attributes: line_items }
 
-        expect(Importer::Order).to receive(:ensure_variant_id_from_params).and_return({variant_id: variant.id, quantity: 5})
-        order = Importer::Order.import(user,params)
+        expect(Importer::Order).to receive(:ensure_variant_id_from_params).and_return({ variant_id: variant.id, quantity: 5 })
+        order = Importer::Order.import(user, params)
         expect(order.user).to eq(nil)
         line_item = order.line_items.first
         expect(line_item.quantity).to eq(5)
@@ -115,18 +120,18 @@ module Spree
 
       it 'handles line_item updating exceptions' do
         line_items['0'][:currency] = 'GBP'
-        params = { :line_items_attributes => line_items }
+        params = { line_items_attributes: line_items }
 
         expect {
-          order = Importer::Order.import(user, params)
+          Importer::Order.import(user, params)
         }.to raise_error /Validation failed/
       end
 
       it 'can build an order from API with variant sku' do
-        params = { :line_items_attributes => {
-                     "0" => { :sku => sku, :quantity => 5 } }}
+        params = { line_items_attributes: {
+                     "0" => { sku: sku, quantity: 5 } } }
 
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
 
         line_item = order.line_items.first
         expect(line_item.variant_id).to eq(variant_id)
@@ -134,41 +139,41 @@ module Spree
       end
 
       it 'can build an order from API shipping address' do
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
+        params = { ship_address_attributes: ship_address,
+                   line_items_attributes: line_items }
 
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.ship_address.address1).to eq '123 Testable Way'
       end
 
       it 'can build an order from API with country attributes' do
         ship_address.delete(:country_id)
         ship_address[:country] = { 'iso' => 'US' }
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
+        params = { ship_address_attributes: ship_address,
+                   line_items_attributes: line_items }
 
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.ship_address.country.iso).to eq 'US'
       end
 
       it 'can build an order from API with state attributes' do
         ship_address.delete(:state_id)
         ship_address[:state] = { 'name' => state.name }
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
+        params = { ship_address_attributes: ship_address,
+                   line_items_attributes: line_items }
 
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.ship_address.state.name).to eq 'Alabama'
       end
 
       context "with a different currency" do
-        before { variant.price_in("GBP").update_attribute(:price, 18.99) }
+        before { variant.prices.create(currency: "GBP", amount: 18.99) }
 
         it "sets the order currency" do
           params = {
             currency: "GBP"
           }
-          order = Importer::Order.import(user,params)
+          order = Importer::Order.import(user, params)
           expect(order.currency).to eq "GBP"
         end
 
@@ -187,8 +192,10 @@ module Spree
 
       context "state passed is not associated with country" do
         let(:params) do
-          params = { :ship_address_attributes => ship_address,
-                     :line_items_attributes => line_items }
+          {
+            ship_address_attributes: ship_address,
+            line_items_attributes: line_items
+          }
         end
 
         let(:other_state) { create(:state, name: "Uhuhuh", country: create(:country)) }
@@ -199,7 +206,7 @@ module Spree
         end
 
         it 'sets states name instead of state id' do
-          order = Importer::Order.import(user,params)
+          order = Importer::Order.import(user, params)
           expect(order.ship_address.state_name).to eq other_state.name
         end
       end
@@ -207,10 +214,10 @@ module Spree
       it 'sets state name if state record not found' do
         ship_address.delete(:state_id)
         ship_address[:state] = { 'name' => 'XXX' }
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
+        params = { ship_address_attributes: ship_address,
+                   line_items_attributes: line_items }
 
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.ship_address.state_name).to eq 'XXX'
       end
 
@@ -234,14 +241,14 @@ module Spree
 
       it 'ensures_country_id for country fields' do
         [:name, :iso, :iso_name, :iso3].each do |field|
-          address = { :country => { field => country.send(field) }}
+          address = { country: { field => country.send(field) } }
           Importer::Order.ensure_country_id_from_params(address)
           expect(address[:country_id]).to eq country.id
         end
       end
 
       it "raises with proper message when cant find country" do
-        address = { :country => { "name" => "NoNoCountry" } }
+        address = { country: { "name" => "NoNoCountry" } }
         expect {
           Importer::Order.ensure_country_id_from_params(address)
         }.to raise_error ActiveRecord::RecordNotFound
@@ -249,7 +256,7 @@ module Spree
 
       it 'ensures_state_id for state fields' do
         [:name, :abbr].each do |field|
-          address = { country_id: country.id, :state => { field => state.send(field) }}
+          address = { country_id: country.id, state: { field => state.send(field) } }
           Importer::Order.ensure_state_id_from_params(address)
           expect(address[:state_id]).to eq state.id
         end
@@ -257,19 +264,19 @@ module Spree
 
       context "shipments" do
         let(:params) do
-          { :shipments_attributes => [
-              { :tracking => '123456789',
-                :cost => '14.99',
-                :shipping_method => shipping_method.name,
-                :stock_location => stock_location.name,
-                :inventory_units => [{ :sku => sku }]
+          { shipments_attributes: [
+              { tracking: '123456789',
+                cost: '14.99',
+                shipping_method: shipping_method.name,
+                stock_location: stock_location.name,
+                inventory_units: [{ sku: sku }]
               }
           ] }
         end
 
         it 'ensures variant exists and is not deleted' do
           expect(Importer::Order).to receive(:ensure_variant_id_from_params).and_call_original
-          order = Importer::Order.import(user,params)
+          Importer::Order.import(user, params)
         end
 
         it 'builds them properly' do
@@ -296,21 +303,21 @@ module Spree
         it "raises if cant find stock location" do
           params[:shipments_attributes][0][:stock_location] = "doesnt exist"
           expect {
-            order = Importer::Order.import(user,params)
+            Importer::Order.import(user, params)
           }.to raise_error ActiveRecord::RecordNotFound
         end
 
         context 'when completed_at and shipped_at present' do
           let(:params) do
             {
-              :completed_at => 2.days.ago,
-              :shipments_attributes => [
-                { :tracking => '123456789',
-                  :cost => '4.99',
-                  :shipped_at => 1.day.ago,
-                  :shipping_method => shipping_method.name,
-                  :stock_location => stock_location.name,
-                  :inventory_units => [{ :sku => sku }]
+              completed_at: 2.days.ago,
+              shipments_attributes: [
+                { tracking: '123456789',
+                  cost: '4.99',
+                  shipped_at: 1.day.ago,
+                  shipping_method: shipping_method.name,
+                  stock_location: stock_location.name,
+                  inventory_units: [{ sku: sku }]
                 }
               ]
             }
@@ -336,14 +343,14 @@ module Spree
       end
 
       it 'adds adjustments' do
-        params = { :adjustments_attributes => [
+        params = { adjustments_attributes: [
             { label: 'Shipping Discount', amount: -4.99 },
             { label: 'Promotion Discount', amount: -3.00 }] }
 
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.adjustments.all?(&:finalized?)).to be true
         expect(order.adjustments.first.label).to eq 'Shipping Discount'
-        expect(order.adjustments.first.amount).to eq -4.99
+        expect(order.adjustments.first.amount).to eq(-4.99)
       end
 
       it "calculates final order total correctly" do
@@ -359,30 +366,29 @@ module Spree
           }
         }
 
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.item_total).to eq(166.1)
         expect(order.total).to eq(163.1) # = item_total (166.1) - adjustment_total (3.00)
-
       end
 
       it 'builds a payment using state' do
-        params = { :payments_attributes => [{ amount: '4.99',
+        params = { payments_attributes: [{ amount: '4.99',
                                               payment_method: payment_method.name,
                                               state: 'completed' }] }
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.payments.first.amount).to eq 4.99
       end
 
       it 'builds a payment using status as fallback' do
-        params = { :payments_attributes => [{ amount: '4.99',
+        params = { payments_attributes: [{ amount: '4.99',
                                               payment_method: payment_method.name,
                                               status: 'completed' }] }
-        order = Importer::Order.import(user,params)
+        order = Importer::Order.import(user, params)
         expect(order.payments.first.amount).to eq 4.99
       end
 
       it 'build a source payment using years and month' do
-        params = { :payments_attributes => [{
+        params = { payments_attributes: [{
                                               amount: '4.99',
                                               payment_method: payment_method.name,
                                               status: 'completed',
@@ -393,14 +399,14 @@ module Spree
                                                 year: '2022',
                                                 month: "5"
                                               }
-                                            }]}
+                                            }] }
 
         order = Importer::Order.import(user, params)
         expect(order.payments.first.source.last_digits).to eq '7424'
       end
 
       it 'handles source building exceptions when do not have years and month' do
-        params = { :payments_attributes => [{
+        params = { payments_attributes: [{
                                               amount: '4.99',
                                               payment_method: payment_method.name,
                                               status: 'completed',
@@ -409,23 +415,22 @@ module Spree
                                                 last_digits: "7424",
                                                 cc_type: "visa"
                                               }
-                                            }]}
+                                            }] }
 
         expect {
-          order = Importer::Order.import(user, params)
+          Importer::Order.import(user, params)
         }.to raise_error /Validation failed: Credit card Month is not a number, Credit card Year is not a number/
       end
 
       context "raises error" do
         it "clears out order from db" do
-          params = { :payments_attributes => [{ payment_method: "XXX" }] }
+          params = { payments_attributes: [{ payment_method: "XXX" }] }
           count = Order.count
 
-          expect { order = Importer::Order.import(user,params) }.to raise_error ActiveRecord::RecordNotFound
+          expect { Importer::Order.import(user, params) }.to raise_error ActiveRecord::RecordNotFound
           expect(Order.count).to eq count
         end
       end
-
     end
   end
 end

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

@@ -29,18 +29,18 @@ describe Spree::RoleConfiguration do
 
   describe "#assign_permissions" do
     let(:name) { "thing" }
-    subject { instance.assign_permissions name, [DummyPermissionSet]}
+    subject { instance.assign_permissions name, [DummyPermissionSet] }
 
     context "when a role for the name exists" do
       before do
-        instance.roles.merge!({ name => described_class::Role.new(name, Set.new(existing_roles)) })
+        instance.roles[name] = described_class::Role.new(name, Set.new(existing_roles))
       end
 
       context "when adding duplicate permission sets" do
         let(:existing_roles) { [DummyPermissionSet] }
 
         it "does not add another role" do
-          expect{subject}.to_not change{instance.roles.count}
+          expect{ subject }.to_not change{ instance.roles.count }
         end
 
         it "does not add duplicate permission sets" do
@@ -54,7 +54,7 @@ describe Spree::RoleConfiguration do
         let(:existing_roles) { [OtherDummyPermissionSet] }
 
         it "does not add another role" do
-          expect{subject}.to_not change{instance.roles.count}
+          expect{ subject }.to_not change{ instance.roles.count }
         end
 
         it "appends the permission set to the existing role" do
@@ -67,7 +67,7 @@ describe Spree::RoleConfiguration do
 
     context "when a role for the name does not yet exist" do
       it "creates a new role" do
-        expect{subject}.to change{instance.roles.count}.from(0).to(1)
+        expect{ subject }.to change{ instance.roles.count }.from(0).to(1)
       end
 
       it "sets the roles name accordingly" do
@@ -97,27 +97,27 @@ describe Spree::RoleConfiguration do
 
     context "when the configuration has roles" do
       before do
-        instance.roles.merge!({ role_name => described_class::Role.new(role_name, [DummyPermissionSet])})
+        instance.roles[role_name] = described_class::Role.new(role_name, [DummyPermissionSet])
       end
 
       context "default_role" do
         let(:role_name) { 'default' }
 
         context "when the user has no roles" do
-          let(:user_roles) {[]}
+          let(:user_roles) { [] }
 
           it "activates the applicable permissions on the ability" do
-            expect{subject}.to change{ability.can? :manage, :things}.
+            expect{ subject }.to change{ ability.can? :manage, :things }.
               from(false).
               to(true)
           end
         end
 
         context "when the user has a different role" do
-          let(:user_roles) {[]}
+          let(:user_roles) { [] }
 
           it "activates the applicable permissions on the ability" do
-            expect{subject}.to change{ability.can? :manage, :things}.
+            expect{ subject }.to change{ ability.can? :manage, :things }.
               from(false).
               to(true)
           end
@@ -125,31 +125,31 @@ describe Spree::RoleConfiguration do
       end
 
       context "when the configuration has applicable roles" do
-        let(:user_roles) {[role_name, "someotherrandomrole"]}
+        let(:user_roles) { [role_name, "someotherrandomrole"] }
 
         it "activates the applicable permissions on the ability" do
-          expect{subject}.to change{ability.can? :manage, :things}.
+          expect{ subject }.to change{ ability.can? :manage, :things }.
             from(false).
             to(true)
         end
       end
 
       context "when the configuration does not have applicable roles" do
-        let(:user_roles) {["somerandomrole"]}
+        let(:user_roles) { ["somerandomrole"] }
 
         it "doesn't activate non matching roles" do
           subject
-          expect(ability.can? :manage, :things).to be false
+          expect(ability.can?(:manage, :things)).to be false
         end
       end
     end
 
     context "when the configuration does not have roles" do
-      let(:user_roles) {["somerandomrole"]}
+      let(:user_roles) { ["somerandomrole"] }
 
       it "doesnt activate any new permissions" do
         subject
-        expect(ability.can? :manage, :things).to be false
+        expect(ability.can?(:manage, :things)).to be false
       end
     end
   end

data/spec/lib/spree/core/testing_support/factories/address_factory_spec.rb

@@ -21,4 +21,39 @@ RSpec.describe 'address factory' do
 
     it_behaves_like 'a working factory'
   end
+
+  describe 'when passing in a country iso code' do
+    subject { build(:address, country_iso_code: "RO") }
+
+    it 'creates a valid address with actually valid data' do
+      expect(subject).to be_valid
+    end
+  end
+
+  describe 'when passing in a state and country' do
+    subject { build(:address, country_iso_code: country_iso_code, state_code: state_code) }
+
+    context 'when the country has a state with proper code' do
+      let(:country_iso_code) { "US" }
+      let(:state_code) { "NY" }
+
+      it 'works' do
+        expect(subject).to be_valid
+        expect(subject.state.abbr).to eq("NY")
+        expect(subject.country.iso).to eq("US")
+      end
+    end
+  end
+
+  describe 'creating multiple addresses' do
+    let!(:address1) { create(:address) }
+    let!(:address2) { create(:address) }
+
+    it 'shares the same country and state objects' do
+      expect(address1.country).to eq(address2.country)
+      expect(address1.state).to eq(address2.state)
+      expect(Spree::Country.count).to eq(1)
+      expect(Spree::State.count).to eq(1)
+    end
+  end
 end

data/spec/lib/spree/core/testing_support/factories/customer_return_factory_spec.rb

@@ -8,6 +8,15 @@ RSpec.describe 'customer return factory' do
     let(:factory) { :customer_return }
 
     it_behaves_like 'a working factory'
+
+    # Regression test for https://github.com/solidusio/solidus/pull/697
+    it "creates only one of dependent records" do
+      create(:customer_return, line_items_count: 2)
+      aggregate_failures "items created" do
+        expect(Spree::Order.count).to eq(1)
+        expect(Spree::ReturnAuthorization.count).to eq(1)
+      end
+    end
   end
 
   describe 'customer return with accepted items' do
@@ -20,7 +29,7 @@ RSpec.describe 'customer return factory' do
     let(:factory) { :customer_return_without_return_items }
 
     it "builds successfully" do
-      expect(build factory).to be_a(factory_class)
+      expect(build(factory)).to be_a(factory_class)
     end
 
     # No create test, because this factory is (intentionally) invalid

data/spec/lib/spree/core/testing_support/factories/order_factory_spec.rb

@@ -10,7 +10,6 @@ RSpec.describe 'order factory' do
     it_behaves_like 'a working factory'
   end
 
-
   describe 'order with totals' do
     let(:factory) { :order_with_totals }
 

data/spec/lib/spree/core/testing_support/factories/shipping_method_factory_spec.rb

@@ -8,13 +8,18 @@ RSpec.describe 'shipping method factory' do
     let(:factory) { :shipping_method }
 
     it_behaves_like 'a working factory'
+
+    it "should set calculable correctly" do
+      shipping_method = create(factory)
+      expect(shipping_method.calculator.calculable).to eq(shipping_method)
+    end
   end
 
   describe 'base shipping method' do
     let(:factory) { :base_shipping_method }
 
     it 'builds successfully' do
-      expect(build factory).to be_a(factory_class)
+      expect(build(factory)).to be_a(factory_class)
     end
 
     # No test for create, as that is not intended somehow

data/spec/lib/spree/core/testing_support/factories/state_factory_spec.rb

@@ -4,9 +4,45 @@ require 'spree/testing_support/factories/state_factory'
 RSpec.describe 'state factory' do
   let(:factory_class) { Spree::State }
 
-  describe 'plain shipping rate' do
+  describe 'plain state' do
     let(:factory) { :state }
 
     it_behaves_like 'a working factory'
+
+    it 'is Alabama' do
+      expect(build(factory).abbr).to eq('AL')
+      expect(build(factory).name).to eq('Alabama')
+    end
+  end
+
+  describe 'when given a country iso code' do
+    let(:state) { build(:state, country_iso: "DE") }
+    it 'creates the first state for that country it finds in carmen' do
+      expect(state.abbr).to eq("BW")
+      expect(state.name).to eq("Baden-Württemberg")
+    end
+
+    context 'of an existing country' do
+      let!(:country){ create(:country, iso: "DE") }
+      it 'uses the existing country in the database' do
+        expect(state.country).to eq(country)
+        expect(Spree::Country.count).to eq(1)
+      end
+    end
+  end
+
+  describe 'when given a country record' do
+    let(:country) { build(:country, iso: "DE") }
+    let(:state) { build(:state, country: country) }
+    it 'creates the first state for that country it finds in carmen' do
+      expect(state.abbr).to eq("BW")
+      expect(state.name).to eq("Baden-Württemberg")
+    end
+  end
+
+  describe 'when given an invalid country iso code' do
+    it 'raises a helpful message' do
+      expect{ build(:state, country_iso: "ZZ") }.to raise_error(RuntimeError, 'Unknown country iso code: "ZZ"')
+    end
   end
 end