workarea-core 3.4.12

data/test/models/workarea/shipping/location_query_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Workarea
+  class Shipping
+    class LocationQueryTest < TestCase
+      def test_location_services
+        pa_service = create_shipping_service(country: 'US', regions: ['PA'])
+        generic = create_shipping_service
+        methods = [pa_service, generic]
+
+
+        location_services = Workarea::Shipping::LocationQuery.new(
+          methods,
+          Country['US'],
+          'PA'
+        ).location_services
+
+        refute_includes(location_services.map(&:id), generic.id)
+        assert_includes(location_services.map(&:id), pa_service.id)
+
+        location_services = Workarea::Shipping::LocationQuery.new(
+          methods,
+          Country['US'],
+          'CA'
+        ).location_services
+
+        assert_includes(location_services.map(&:id), generic.id)
+        refute_includes(location_services.map(&:id), pa_service.id)
+      end
+
+      def test_initialize_with_different_country_types
+        pa_service = create_shipping_service(country: 'US', regions: ['PA'])
+        ca_service = create_shipping_service(country: 'US', regions: ['CA'])
+        services = [pa_service, ca_service]
+
+        as_string = Workarea::Shipping::LocationQuery.new(
+          services,
+          'US',
+          'PA'
+        ).country
+
+        as_country = Workarea::Shipping::LocationQuery.new(
+          services,
+          Country['US'],
+          'PA'
+        ).country
+
+        as_active_utils = Workarea::Shipping::LocationQuery.new(
+          services,
+          ActiveUtils::Country.find('US'),
+          'PA'
+        ).country
+
+        assert_equal(Country['US'], as_string)
+        assert_equal(Country['US'], as_country)
+        assert_equal(Country['US'], as_active_utils)
+      end
+    end
+  end
+end

data/test/models/workarea/shipping/rate_lookup_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module Workarea
+  class Shipping
+    class RateLookupTest < TestCase
+
+      setup :set_shipping_services
+
+      def address
+        @address ||= Address.new
+      end
+
+      def sku
+        @sku ||= create_shipping_sku
+      end
+
+      def packages
+        @packages ||= [
+          ActiveShipping::Package.new(sku.weight, sku.dimensions)
+        ]
+      end
+
+      def set_shipping_services
+        @shipping_services = [
+          create_shipping_service(rates: [{ price: 1 }]),
+          create_shipping_service(rates: [{ price: 2 }])
+        ]
+      end
+
+      def test_response
+        response = RateLookup.new(address, address, packages).response
+        first_rate = response.rates.first
+
+        assert_equal(@shipping_services.first.name, first_rate.service_name)
+        assert_equal(100, first_rate.price) # ActiveShipping works in cents
+      end
+
+      def test_restriction_by_location
+        create_shipping_service(name: 'US', country: 'US')
+        create_shipping_service(name: 'PA', country: 'US', regions: ['PA'])
+
+        address = Address.new(country: 'CA')
+        response = RateLookup.new(address, address, packages).response
+        refute_includes(response.rates.map(&:service_name), 'US')
+
+        address = Address.new(country: 'US', region: 'NJ')
+        response = RateLookup.new(address, address, packages).response
+        refute_includes(response.rates.map(&:service_name), 'PA')
+      end
+
+      def test_restriction_by_subtotal
+        packages = [
+          ActiveShipping::Package.new(sku.weight, sku.dimensions, value: 4.to_m)
+        ]
+        create_shipping_service(name: 'Unavailable', subtotal_min: 5.to_m)
+
+        response = RateLookup.new(address, address, packages).response
+        refute_includes(response.rates.map(&:service_name), 'Unavailable')
+      end
+
+      def test_restriction_by_tiered_pricing
+        packages = [
+          ActiveShipping::Package.new(sku.weight, sku.dimensions, value: 4.to_m)
+        ]
+
+        create_shipping_service(
+          name: 'Unavailable',
+          rates: [{ price: 1, tier_min: 5.to_m }]
+        )
+
+        response = RateLookup.new(address, address, packages).response
+        refute_includes(response.rates.map(&:service_name), 'Unavailable')
+      end
+    end
+  end
+end

data/test/models/workarea/shipping/rate_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Workarea
+  class Shipping
+    class RateTest < TestCase
+      def test_tiered?
+        rate = Workarea::Shipping::Rate.new
+        refute(rate.tiered?)
+
+        rate.tier_min = 4
+        assert(rate.tiered?)
+
+        rate.tier_min = nil
+        rate.tier_max = 4
+        assert(rate.tiered?)
+      end
+    end
+  end
+end

data/test/models/workarea/shipping/service_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Workarea
+  class Shipping
+    class ServiceTest < TestCase
+      def test_rate_tier_validation
+        method = create_shipping_service
+        method.rates = [{ price: 1.to_m }, { price: 5.to_m }]
+
+        refute(method.valid?)
+        assert(method.errors[:rates].present?)
+      end
+
+      def test_find_rate
+        shipping_service = create_shipping_service
+
+        rate = shipping_service.rates.first
+        assert_equal(rate.id, shipping_service.find_rate.id)
+        assert_equal(rate.id, shipping_service.find_rate(3.to_m).id)
+
+        shipping_service =
+          create_shipping_service.tap do |method|
+            method.rates = []
+            method.rates.build(price: 4.to_m, tier_min: 0, tier_max: 5)
+            method.rates.build(price: 3.to_m, tier_min: 5, tier_max: 7)
+            method.rates.build(price: 2.to_m, tier_min: 7, tier_max: nil)
+            method.save!
+          end
+
+        assert_equal(4.to_m, shipping_service.find_rate.price)
+        assert_equal(4.to_m, shipping_service.find_rate(2.to_m).price)
+        assert_equal(4.to_m, shipping_service.find_rate(5.to_m).price)
+
+        assert_equal(3.to_m, shipping_service.find_rate(6.to_m).price)
+        assert_equal(3.to_m, shipping_service.find_rate(7.to_m).price)
+        assert_equal(2.to_m, shipping_service.find_rate(10.to_m).price)
+      end
+    end
+  end
+end

data/test/models/workarea/shipping/sku_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Workarea
+  class Shipping
+    class SkuTest < Workarea::TestCase
+      def test_length_units
+        sku = create_shipping_sku
+
+        Workarea.with_config do |config|
+          config.shipping_options = { units: :imperial }
+          assert_equal(:inches, sku.length_units)
+
+          config.shipping_options = { units: :metric }
+          assert_equal(:centimeters, sku.length_units)
+        end
+      end
+
+      def test_weight_units
+        sku = create_shipping_sku
+
+        Workarea.with_config do |config|
+          config.shipping_options = { units: :imperial }
+          assert_equal(:ounces, sku.weight_units)
+
+          config.shipping_options = { units: :metric }
+          assert_equal(:grams, sku.weight_units)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/shipping_option_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Workarea
+  class ShippingOptionTest < TestCase
+    def test_from_rate_estimate
+      rate_estimate = ActiveShipping::RateEstimate.new(
+        Address.new,
+        Address.new,
+        'UPS',
+        'Ground',
+        service_code: '03',
+        total_price: 700,
+        currency: 'USD'
+      )
+
+      create_shipping_service(carrier: 'UPS', name: 'Ground', tax_code: '001')
+      create_shipping_service(carrier: 'UPS', name: '2 Day', tax_code: '002')
+
+      result = ShippingOption.from_rate_estimate(rate_estimate)
+      assert_equal('UPS', result.carrier)
+      assert_equal('Ground', result.name)
+      assert_equal('03', result.service_code)
+      assert_equal('001', result.tax_code)
+      assert_equal(7.to_m, result.price)
+    end
+
+    def test_price
+      shipping_service = create_shipping_service(rates: [{ price: 3.to_m }])
+
+      adjustment = PriceAdjustment.new(amount: -1.to_m)
+      option = ShippingOption.new(
+        shipping_service.attributes.merge(price: 3.to_m)
+      )
+
+      option.price_adjustments = [adjustment]
+
+      assert_equal(2.to_m, option.price)
+    end
+
+    def test_price_guards_against_price_adjustments
+      shipping_service = create_shipping_service(rates: [{ price: 3.to_m }])
+
+      adjustment = PriceAdjustment.new(amount: -10.to_m)
+      option = ShippingOption.new(shipping_service.attributes)
+      option.price_adjustments = [adjustment]
+
+      assert_equal(0.to_m, option.price)
+    end
+  end
+end

data/test/models/workarea/shipping_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+module Workarea
+  class ShippingTest < TestCase
+    def test_shippable
+      shipping = Shipping.new
+      shipping.shipping_service = nil
+      shipping.set_address(
+        first_name: 'Ben',
+        last_name: 'Crouse',
+        street: '22 S. 3rd St.',
+        street_2: 'Second Floor',
+        city: 'Philadelphia',
+        region: 'PA',
+        postal_code: '19106',
+        country: 'US'
+      )
+
+      refute(shipping.shippable?)
+
+      shipping.address = nil
+      shipping.set_shipping_service(name: 'Test Method')
+      refute(shipping.shippable?)
+
+      shipping.set_address(
+        last_name: 'Crouse',
+        street: '22 S. 3rd St.',
+        street_2: 'Second Floor',
+        city: 'Philadelphia',
+        region: 'PA',
+        postal_code: '19106',
+        country: 'US'
+      )
+
+      refute(shipping.shippable?)
+
+      shipping.set_address(
+        first_name: 'Ben',
+        last_name: 'Crouse',
+        street: '22 S. 3rd St.',
+        street_2: 'Second Floor',
+        city: 'Philadelphia',
+        region: 'PA',
+        postal_code: '19106',
+        country: 'US'
+      )
+
+      assert(shipping.shippable?)
+    end
+
+    def test_set_address
+      shipping = Shipping.new
+
+      shipping.set_address(
+        first_name: 'Ben',
+        last_name: 'Crouse',
+        street: '22 S. 3rd St.',
+        street_2: 'Second Floor',
+        city: 'Philadelphia',
+        region: 'PA',
+        postal_code: '19106',
+        country: 'US'
+      )
+
+      assert_equal('Ben', shipping.address.first_name)
+      assert_equal('Crouse', shipping.address.last_name)
+      assert_equal('22 S. 3rd St.', shipping.address.street)
+      assert_equal('Second Floor', shipping.address.street_2)
+      assert_equal('Philadelphia', shipping.address.city)
+      assert_equal('PA', shipping.address.region)
+      assert_equal('19106', shipping.address.postal_code)
+      assert_equal(Country['US'], shipping.address.country)
+    end
+
+    def test_set_shipping_service
+      shipping = Shipping.new
+      shipping.set_shipping_service(name: 'Test Method')
+      assert_equal('Test Method', shipping.shipping_service.name)
+    end
+
+    def test_find_method_options
+      create_shipping_service(name: '2 Day', rates: [{ price: 2 }])
+      create_shipping_service(name: 'Ground', rates: [{ price: 1 }])
+
+      shipping = Shipping.new
+      shipping.set_address(
+        first_name: 'Ben',
+        last_name: 'Crouse',
+        street: '22 S. 3rd St.',
+        street_2: 'Second Floor',
+        city: 'Philadelphia',
+        region: 'PA',
+        postal_code: '19106',
+        country: 'US'
+      )
+
+      results = shipping.find_method_options(
+        [ActiveShipping::Package.new(3, [1, 2, 3], value: 4.to_m)]
+      )
+
+      assert_equal(2, results.length)
+      assert_equal('Ground', results.first.name)
+      assert_equal('2 Day', results.second.name)
+    end
+  end
+end

data/test/models/workarea/tax/category_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module Workarea
+  module Tax
+    class CategoryTest < TestCase
+      def test_find_by_code
+        category = create_tax_category(code: '001')
+        assert_equal(category, Workarea::Tax::Category.find_by_code('001'))
+      end
+
+      def test_tiered?
+        category = create_tax_category(rates: [])
+        refute(category.tiered?)
+
+        category.rates.create!(country: 'US')
+        refute(category.tiered?)
+        category.rates.delete_all
+
+        category.rates.create!(country: 'US', tier_min: 0, tier_max: 5)
+        category.rates.create!(country: 'US', tier_min: 5, tier_max: 7)
+        category.rates.create!(country: 'US', tier_min: 7, tier_max: nil)
+
+        assert(category.tiered?)
+      end
+
+      def test_find_rate_when_tiered
+        category = create_tax_category(rates: [{ country: 'US' }])
+        assert_equal(category.rates.first, category.find_rate(3.to_m, 'US', nil, nil))
+
+        category = create_tax_category(code: '002', rates: [])
+        first = category.rates.create!(country: 'US', tier_min: 0, tier_max: 4.99)
+        second = category.rates.create!(country: 'US', tier_min: 5, tier_max: 6.99)
+        third = category.rates.create!(country: 'US', tier_min: 7, tier_max: nil)
+
+        assert_equal(first, category.find_rate(2.to_m, 'US', nil, nil))
+        assert_equal(second, category.find_rate(6.to_m, 'US', nil, nil))
+        assert_equal(third, category.find_rate(10.to_m, 'US', nil, nil))
+      end
+
+      def test_find_rate_location_specific
+        category = create_tax_category(code: '002', rates: [])
+
+        philly = category.rates.create!(country: 'US', region: 'PA', postal_code: '19106')
+        alberta = category.rates.create!(country: 'CA', region: 'AB')
+        british_columbia = category.rates.create!(country: 'CA', region: 'BC')
+        _uk = category.rates.create!(country: 'UK')
+
+        assert_nil(category.find_rate(0.to_m, nil, nil, nil))
+        assert_nil(category.find_rate(0.to_m, 'CA', nil, nil))
+        assert_equal(alberta, category.find_rate(0.to_m, 'CA', 'AB', nil))
+        assert_equal(british_columbia, category.find_rate(0.to_m, 'CA', 'BC', nil))
+        assert_equal(philly, category.find_rate(0.to_m, 'US', 'PA', '19106'))
+        assert_equal(alberta, category.find_rate(0.to_m, 'CA', 'AB', '19106'))
+      end
+    end
+  end
+end