active_shipping 1.14.2 → 2.0.0

data/test/unit/location_test.rb

@@ -1,135 +1,231 @@
 require 'test_helper'
 
-class LocationTest < Minitest::Test
+class LocationTest < ActiveSupport::TestCase
   include ActiveShipping::Test::Fixtures
 
-  def test_countries
-    assert_instance_of ActiveUtils::Country, location_fixtures[:ottawa].country
-    assert_equal 'CA', location_fixtures[:ottawa].country_code(:alpha2)
-  end
-
-  def test_location_from_strange_hash
-    hash = {  :country => 'CA',
-              :zip => '90210',
-              :territory_code => 'QC',
-              :town => 'Perth',
-              :address => '66 Gregory Ave.',
-              :phone => '515-555-1212',
-              :fax_number => 'none to speak of',
-              :address_type => :commercial
-            }
-    location = Location.from(hash)
-
-    assert_equal hash[:country], location.country_code(:alpha2)
-    assert_equal hash[:zip], location.zip
-    assert_equal hash[:territory_code], location.province
-    assert_equal hash[:town], location.city
-    assert_equal hash[:address], location.address1
-    assert_equal hash[:phone], location.phone
-    assert_equal hash[:fax_number], location.fax
-    assert_equal hash[:address_type].to_s, location.address_type
-  end
-
-  def test_pretty_print
-    expected = "110 Laurier Avenue West\nOttawa, ON, K1P 1J1\nCanada"
-    assert_equal expected, location_fixtures[:ottawa].prettyprint
+  setup do
+    @location = location_fixtures[:ottawa]
+    @address2 = 'Apt 613'
+    @address3 = 'Victory Lane'
+    @attributes_hash = {
+      country: 'CA',
+      zip: '90210',
+      territory_code: 'QC',
+      town: 'Perth',
+      address: '66 Gregory Ave.',
+      phone: '515-555-1212',
+      fax_number: 'none to speak of',
+      address_type: :commercial,
+      name: "Bob Bobsen",
+    }
+  end
+
+  test "#initialize sets a country object" do
+    assert_instance_of ActiveUtils::Country, @location.country
+    assert_equal 'CA', @location.country_code(:alpha2)
+  end
+
+  test ".from sets up the location from a hash" do
+    location = Location.from(@attributes_hash)
+
+    assert_equal @attributes_hash[:country], location.country_code(:alpha2)
+    assert_equal @attributes_hash[:zip], location.zip
+    assert_equal @attributes_hash[:territory_code], location.province
+    assert_equal @attributes_hash[:town], location.city
+    assert_equal @attributes_hash[:address], location.address1
+    assert_equal @attributes_hash[:phone], location.phone
+    assert_equal @attributes_hash[:fax_number], location.fax
+    assert_equal @attributes_hash[:address_type].to_s, location.address_type
+    assert_equal @attributes_hash[:name], location.name
+  end
+
+  test ".from sets from an object with properties" do
+    object = Class.new do
+      def initialize(hash)
+        @hash = hash
+      end
+      def method_missing(method)
+        @hash[method]
+      end
+      def respond_to?(method)
+        return false if method == :[]
+        true
+      end
+    end.new(@attributes_hash)
+
+    location = Location.from(object)
+
+    assert_equal @attributes_hash[:country], location.country_code(:alpha2)
+    assert_equal @attributes_hash[:zip], location.zip
+    assert_equal @attributes_hash[:territory_code], location.province
+    assert_equal @attributes_hash[:town], location.city
+    assert_equal @attributes_hash[:address], location.address1
+    assert_equal @attributes_hash[:phone], location.phone
+    assert_equal @attributes_hash[:fax_number], location.fax
+    assert_equal @attributes_hash[:address_type].to_s, location.address_type
+    assert_equal @attributes_hash[:name], location.name
+  end
+
+  test ".from adheres to propery order even if hash access is available" do
+    object = Class.new do
+      def [](index)
+        { province: "California" }[index]
+      end
+
+      def province_code
+        "CA"
+      end
+    end.new
+    assert_equal "CA", Location.from(object).province
+  end
+
+  test ".from sets the name to nil if it is not provided" do
+    location = Location.from({})
+    assert_nil location.name
   end
 
-  def test_to_s
-    expected = "110 Laurier Avenue West Ottawa, ON, K1P 1J1 Canada"
-    assert_equal expected, location_fixtures[:ottawa].to_s
+  test ".from sets company and company_name from company" do
+    location = Location.from(company: "Mine")
+
+    assert_equal "Mine", location.company
+    assert_equal "Mine", location.company_name
   end
 
-  def test_inspect
-    expected = "110 Laurier Avenue West\nOttawa, ON, K1P 1J1\nCanada\nPhone: 1-613-580-2400\nFax: 1-613-580-2495"
-    assert_equal expected, location_fixtures[:ottawa].inspect
+  test ".from sets company and company_name from company_name" do
+    location = Location.from(company_name: "Mine")
+
+    assert_equal "Mine", location.company
+    assert_equal "Mine", location.company_name
   end
 
-  def test_includes_name
-    location = Location.from(:name => "Bob Bobsen")
-    assert_equal "Bob Bobsen", location.name
+  test ".from prioritizes company" do
+    location = Location.from(company_name: "from company_name", company: "from company")
+
+    assert_equal "from company", location.company
+    assert_equal "from company", location.company_name
   end
 
-  def test_name_is_nil_if_not_provided
-    location = Location.from({})
-    assert_nil location.name
+  test "#prettyprint outputs a readable string" do
+    expected = "110 Laurier Avenue West\nOttawa, ON, K1P 1J1\nCanada"
+    assert_equal expected, @location.prettyprint
   end
 
-  def test_location_with_company_name
-    location = Location.from(:company => "Mine")
-    assert_equal "Mine", location.company_name
+  test "#to_s outputs a readable string without newlines" do
+    expected = "110 Laurier Avenue West Ottawa, ON, K1P 1J1 Canada"
+    assert_equal expected, @location.to_s
+  end
 
-    location = Location.from(:company_name => "Mine")
-    assert_equal "Mine", location.company_name
+  test "#inspect returns a readable string" do
+    expected = "110 Laurier Avenue West\nOttawa, ON, K1P 1J1\nCanada\nPhone: 1-613-580-2400\nFax: 1-613-580-2495"
+    assert_equal expected, @location.inspect
   end
 
-  def test_set_address_type
-    location = location_fixtures[:ottawa]
-    assert !location.commercial?
+  test "#address_type= assigns a type of address as commercial" do
+    refute @location.commercial?
 
-    location.address_type = :commercial
-    assert location.commercial?
+    @location.address_type = :commercial
+    assert @location.commercial?
+    refute @location.residential?
+    assert_equal "commercial", @location.address_type
   end
 
-  def test_set_address_type_invalid
-    location = location_fixtures[:ottawa]
+  test "#address_type= assigns a type of address as residential" do
+    refute @location.residential?
 
+    @location.address_type = :residential
+    assert @location.residential?
+    refute @location.commercial?
+    assert_equal "residential", @location.address_type
+  end
+
+  test "#address_type= raises on an invalid assignment" do
     assert_raises(ArgumentError) do
-      location.address_type = :new_address_type
+      @location.address_type = :new_address_type
     end
 
-    refute_equal "new_address_type", location.address_type
+    assert_nil @location.address_type
   end
 
-  def test_to_hash_attributes
-    assert_equal %w(address1 address2 address3 address_type city company_name country fax name phone postal_code province), location_fixtures[:ottawa].to_hash.stringify_keys.keys.sort
+  test "#address_type= cannot blank out the value as nil" do
+    @location.address_type = :residential
+    assert @location.residential?
+
+    @location.address_type = nil
+    assert @location.residential?
+    assert_equal "residential", @location.address_type
   end
 
-  def test_to_json
-    location_json = location_fixtures[:ottawa].to_json
-    assert_equal location_fixtures[:ottawa].to_hash, JSON.parse(location_json).symbolize_keys
+  test "#address_type= cannot blank out the value as empty string" do
+    @location.address_type = :residential
+    assert @location.residential?
+
+    @location.address_type = ""
+    assert @location.residential?
+    assert_equal "residential", @location.address_type
   end
 
-  def test_zip_plus_4_with_no_dash
-    zip = "33333"
-    plus_4 = "1234"
-    zip_plus_4 = "#{zip}-#{plus_4}"
-    location = Location.from(:zip => "#{zip}#{plus_4}")
-    assert_equal zip_plus_4, location.zip_plus_4
+  test "#to_hash has the expected attributes" do
+    expected = %w(address1 address2 address3 address_type city company_name country fax name phone postal_code province)
+
+    assert_equal expected, @location.to_hash.stringify_keys.keys.sort
   end
 
-  def test_zip_plus_4_with_dash
-    zip = "33333"
-    plus_4 = "1234"
-    zip_plus_4 = "#{zip}-#{plus_4}"
-    location = Location.from(:zip => zip_plus_4)
-    assert_equal zip_plus_4, location.zip_plus_4
+  test "#to_json returns the JSON values" do
+    expected = JSON.parse(@location.to_json).symbolize_keys
+
+    assert_equal @location.to_hash, expected
   end
 
-  def test_address2_and_3_is_nil
-    location = location_fixtures[:ottawa]
-    assert_nil location.address2
-    assert_nil location.address3
-    assert location.address2_and_3.blank?
+  test "#zip_plus_4 nil without the extra four" do
+    zip = "12345"
+    location = Location.from(zip: zip)
+
+    assert_nil location.zip_plus_4
+    assert_equal zip, location.zip
   end
 
-  def test_address2_and_3
-    address2 = 'Apt 613'
-    address3 = 'Victory Lane'
-    location = Location.from(:address2 => address2)
+  test "#zip_plus_4 parses without the dash" do
+    zip = "12345-9999"
+    zip_without_dash = "123459999"
+    location = Location.from(zip: zip_without_dash)
+
+    assert_equal zip, location.zip_plus_4
+    assert_equal zip_without_dash, location.zip
+  end
+
+  test "#zip_plus_4 parses with the dash" do
+    zip = "12345-9999"
+    location = Location.from(zip: zip)
+
+    assert_equal zip, location.zip_plus_4
+    assert_equal zip, location.zip
+  end
+
+  test "#address2_and_3 shows just address2" do
+    location = Location.from(address2: @address2)
     assert_equal 'Apt 613', location.address2_and_3
+  end
+
+  test "#address2_and_3 shows just address3" do
+    location = Location.from(address3: @address3)
+    assert_equal @address3, location.address2_and_3
+  end
 
-    location = Location.from(:address2 => address2, :address3 => address3)
-    assert_equal 'Apt 613, Victory Lane', location.address2_and_3
+  test "#address2_and_3 shows both address2 and address3" do
+    location = Location.from(address2: @address2, address3: @address3)
+    assert_equal "#{@address2}, #{@address3}", location.address2_and_3
+  end
 
-    location = Location.from(:address3 => address3)
-    assert_equal 'Victory Lane', location.address2_and_3
+  test "#address2_and_3 shows an empty string when address2 and address3 are both blank" do
+    assert_nil @location.address2
+    assert_nil @location.address3
+    assert_equal "", @location.address2_and_3
   end
 
-  def test_equality
-    location_1 = location_fixtures[:ottawa]
-    location_2 = Location.from(location_1.to_hash)
+  test "#== compares locations by attributes" do
+    another_location = Location.from(@location.to_hash)
 
-    assert_equal location_1, location_2
+    assert_equal @location, another_location
+    refute_equal @location, Location.new({})
   end
 end

data/test/unit/package_item_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
-class PackageItemTest < Minitest::Test
-  def setup
+class PackageItemTest < ActiveSupport::TestCase
+  setup do
     @name = "Fancy Pants"
     @weight = 100
     @value = 1299
@@ -16,10 +16,10 @@ class PackageItemTest < Minitest::Test
     }
 
     @item = PackageItem.new(@name, @weight, @value, @quantity, @options)
-    @mass = ::Quantified::Mass.new(@weight, :grams)
+    @mass = Measured::Weight.new(@weight, :grams)
   end
 
-  def test_initialize_with_all_attributes
+  test "#initialize with all attributes" do
     assert_equal @name, @item.name
     assert_equal @options, @item.options
     assert_equal @hs_code, @item.hs_code
@@ -28,7 +28,7 @@ class PackageItemTest < Minitest::Test
     assert_equal @quantity, @item.quantity
   end
 
-  def test_initialize_assumes_symbol_keys
+  test "#initialize assumes symbol keys" do
     options = {
       "units" => :imperial,
       "sku" => @sku,
@@ -42,98 +42,93 @@ class PackageItemTest < Minitest::Test
     assert_equal @weight, @item.grams
   end
 
-  def test_initialize_negative_quantity
+  test "#initialize with a negative quantity" do
     assert_equal 1, PackageItem.new(@name, @weight, @value, -1).quantity
     assert_equal 1, PackageItem.new(@name, @weight, @value, 0).quantity
   end
 
-  def test_initialize_weight_mass_object
-    begin
-      @item = PackageItem.new(@name, @mass, @value, @quantity, @options)
-      assert_equal @mass, @item.weight
-      flunk "This code path is broken but passed unexpectedly"
-    rescue NameError
-      skip "This code path is broken"
-    end
+  test "#initialize weight mass object" do
+    @item = PackageItem.new(@name, @mass, @value, @quantity, @options)
+    assert_equal @mass, @item.weight
   end
 
-  def test_initialize_weight_default_metric
+  test "#initialize weight default metric" do
     assert_equal @weight, @item.grams
     refute_equal @weight, @item.ounces
   end
 
-  def test_initialize_weight_accepts_imperial
+  test "#initialize weight accepts imperial" do
     @item = PackageItem.new(@name, @weight, @value, @quantity, @options.merge(units: :imperial))
 
     assert_equal @weight, @item.ounces
     refute_equal @weight, @item.grams
   end
 
-  def test_initialize_weight_accepts_metric
+  test "#initialize_weight accepts metric" do
     @item = PackageItem.new(@name, @weight, @value, @quantity, @options.merge(units: :metric))
 
     assert_equal @weight, @item.grams
     refute_equal @weight, @item.ounces
   end
 
-  def test_initialize_weight_does_not_accept_strings
+  test "#initialize weight does not accept strings" do
     @item = PackageItem.new(@name, @weight, @value, @quantity, @options.merge(units: "imperial"))
 
     assert_equal @weight, @item.grams
     refute_equal @weight, @item.ounces
   end
 
-  def test_initialize_value_from_cents
+  test "#initialize value from cents" do
     @item = PackageItem.new(@name, @weight, "1.23", @quantity, @options)
 
     assert_equal 123, @item.value
   end
 
-  def test_weight
+  test "#weight default lookup" do
     assert_equal @mass, @item.weight
-    assert_instance_of ::Quantified::Mass, @item.weight
+    assert_instance_of Measured::Weight, @item.weight
   end
 
-  def test_weight_actual
+  test "#weight type: actual" do
     assert_equal @mass, @item.weight(type: :actual)
-    assert_instance_of ::Quantified::Mass, @item.weight(type: :actual)
+    assert_instance_of Measured::Weight, @item.weight(type: :actual)
   end
 
-  def test_weight_volumetric
+  test "#weight type: volumetric" do
     begin
       assert_equal :todo, @item.weight(type: :volumetric)
-      assert_instance_of ::Quantified::Mass, @item.weight(type: :volumetric)
+      assert_instance_of Measured::Weight, @item.weight(type: :volumetric)
       flunk "This code path is broken but passed unexpectedly"
     rescue NoMethodError
       skip "This code path is broken"
     end
   end
 
-  def test_weight_dimensional
+  test "#weight type: dimensional" do
     begin
       assert_equal :todo, @item.weight(type: :dimensional)
-      assert_instance_of ::Quantified::Mass, @item.weight(type: :dimensional)
+      assert_instance_of Measured::Weight, @item.weight(type: :dimensional)
       flunk "This code path is broken but passed unexpectedly"
     rescue NoMethodError
       skip "This code path is broken"
     end
   end
 
-  def test_weight_billable_max_weight_and_volumetric
+  test "#weight type: billable is the max of weight and volumetric" do
     begin
       assert_equal :todo, @item.weight(type: :billable)
-      assert_instance_of ::Quantified::Mass, @item.weight(type: :billable)
+      assert_instance_of Measured::Weight, @item.weight(type: :billable)
       flunk "This code path is broken but passed unexpectedly"
     rescue NoMethodError
       skip "This code path is broken"
     end
   end
 
-  def test_grams_value
+  test "#grams is the value" do
     assert_equal 100, @item.grams
   end
 
-  def test_grams_accepts_options_with_type
+  test "#grams accepts options with type" do
     begin
       assert_equal :todo, @item.grams(type: :volumetric)
       flunk "This code path is broken but passed unexpectedly"
@@ -142,23 +137,23 @@ class PackageItemTest < Minitest::Test
     end
   end
 
-  def test_grams_converts
+  test "#grams converts to another unit" do
     @item = PackageItem.new(@name, 100, @value, @quantity, @options.merge(units: :imperial))
 
     assert_in_delta 2834.9, @item.grams, 0.1
   end
 
-  def test_grams_alias_g
+  test "#grams aliases to g" do
     assert_equal @item.grams, @item.g
   end
 
-  def test_ounces_value
+  test "#ounces is the value" do
     @item = PackageItem.new(@name, @weight, @value, @quantity, @options.merge(units: :imperial))
 
     assert_equal 100, @item.ounces
   end
 
-  def test_ounces_accepts_options_with_type
+  test "#ounces accepts options with type" do
     begin
       assert_equal :todo, @item.ounces(type: :volumetric)
       flunk "This code path is broken but passed unexpectedly"
@@ -167,23 +162,23 @@ class PackageItemTest < Minitest::Test
     end
   end
 
-  def test_ounces_converts
+  test "#ounces converts to another unit" do
     @item = PackageItem.new(@name, @weight, @value, @quantity, @options.merge(units: :metric))
 
     assert_in_delta 3.5, @item.ounces, 0.1
   end
 
-  def test_ounces_alias_oz
+  test "#ounces aliases to oz" do
     assert_equal @item.ounces, @item.oz
   end
 
-  def test_pounds_value
+  test "#pounds is the value" do
     @item = PackageItem.new(@name, 32, @value, @quantity, @options.merge(units: :imperial))
 
     assert_equal 2, @item.pounds
   end
 
-  def test_pounds_accepts_options_with_type
+  test "#pounds accepts options with type" do
     begin
       assert_equal :todo, @item.pounds(type: :volumetric)
       flunk "This code path is broken but passed unexpectedly"
@@ -192,27 +187,27 @@ class PackageItemTest < Minitest::Test
     end
   end
 
-  def test_pounds_converts
+  test "#pounds converts to another unit" do
     @item = PackageItem.new(@name, 1000, @value, @quantity, @options.merge(units: :metric))
 
     assert_in_delta 2.2, @item.pounds, 0.1
   end
 
-  def test_pounds_alias_lb
+  test "#pounds aliases to lb" do
     assert_equal @item.pounds, @item.lb
   end
 
-  def test_pounds_alias_lbs
+  test "#pounds aliases to lbs" do
     assert_equal @item.pounds, @item.lbs
   end
 
-  def test_kilograms_value
+  test "#kilograms is the value" do
     @item = PackageItem.new(@name, 1000, @value, @quantity, @options.merge(units: :metric))
 
     assert_equal 1, @item.kilograms
   end
 
-  def test_kilograms_accepts_options_with_type
+  test "#kilograms accepts options with type" do
     begin
       assert_equal :todo, @item.kilograms(type: :volumetric)
       flunk "This code path is broken but passed unexpectedly"
@@ -221,17 +216,17 @@ class PackageItemTest < Minitest::Test
     end
   end
 
-  def test_kilograms_converts
+  test "#kilograms converts to another unit" do
     @item = PackageItem.new(@name, 1000, @value, @quantity, @options.merge(units: :imperial))
 
     assert_in_delta 28.3, @item.kilograms, 0.1
   end
 
-  def test_kilograms_alias_kg
+  test "#kilograms aliases to kg" do
     assert_equal @item.kilograms, @item.kg
   end
 
-  def test_kilograms_alias_kgs
+  test "#kilograms aliases to kgs" do
     assert_equal @item.kilograms, @item.kgs
   end
 end