active_shipping 1.0.0.pre2 → 1.0.0.pre3

data/test/unit/carriers_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class CarriersTest < Minitest::Test
+
+  def test_get_usps_by_string
+    assert_equal ActiveShipping::USPS, ActiveShipping::Carriers.find('usps')
+    assert_equal ActiveShipping::USPS, ActiveShipping::Carriers.find('USPS')
+  end
+
+  def test_get_usps_by_name
+    assert_equal ActiveShipping::USPS, ActiveShipping::Carriers.find(:usps)
+  end
+
+  def test_get_unknown_carrier
+    assert_raises(NameError) { ActiveShipping::Carriers.find(:polar_north) }
+  end
+end

data/test/unit/label_response_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class LabelResponseTest < Minitest::Test
+  include ActiveShipping::Test::Fixtures
+
+  def test_build_label_from_xml_response
+    str      = xml_fixture('ups/shipment_accept_response')
+    mapping  = Hash.from_xml(str).values.first
+    response = LabelResponse.new(true, nil, mapping)
+
+    assert_equal 1, response.labels.count
+    assert_equal '1ZA03R691591538440', response.labels.first[:tracking_number]
+    assert response.labels.first[:image]
+  end
+end

data/test/unit/location_test.rb

@@ -0,0 +1,138 @@
+require 'test_helper'
+
+class LocationTest < Minitest::Test
+  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
+  end
+
+  def test_to_s
+    expected = "110 Laurier Avenue West Ottawa, ON, K1P 1J1 Canada"
+    assert_equal expected, location_fixtures[:ottawa].to_s
+  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
+  end
+
+  def test_includes_name
+    location = Location.from(:name => "Bob Bobsen")
+    assert_equal "Bob Bobsen", location.name
+  end
+
+  def test_name_is_nil_if_not_provided
+    location = Location.from({})
+    assert_nil location.name
+  end
+
+  def test_location_with_company_name
+    location = Location.from(:company => "Mine")
+    assert_equal "Mine", location.company_name
+
+    location = Location.from(:company_name => "Mine")
+    assert_equal "Mine", location.company_name
+  end
+
+  def test_set_address_type
+    location = location_fixtures[:ottawa]
+    assert !location.commercial?
+
+    location.address_type = :commercial
+    assert location.commercial?
+  end
+
+  def test_set_address_type_invalid
+    location = location_fixtures[:ottawa]
+
+    assert_raises(ArgumentError) do
+      location.address_type = :new_address_type
+    end
+
+    refute_equal "new_address_type", 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
+  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
+  end
+
+  def test_default_to_xml
+    location_xml = location_fixtures[:ottawa].to_xml
+    assert_equal location_fixtures[:ottawa].to_hash, Hash.from_xml(location_xml)["location"].symbolize_keys
+  end
+
+  def test_custom_root_to_xml
+    location_xml = location_fixtures[:ottawa].to_xml(:root => "destination")
+    assert_equal location_fixtures[:ottawa].to_hash, Hash.from_xml(location_xml)["destination"].symbolize_keys
+  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
+  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
+  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?
+  end
+
+  def test_address2_and_3
+    address2 = 'Apt 613'
+    address3 = 'Victory Lane'
+    location = Location.from(:address2 => address2)
+    assert_equal 'Apt 613', location.address2_and_3
+
+    location = Location.from(:address2 => address2, :address3 => address3)
+    assert_equal 'Apt 613, Victory Lane', location.address2_and_3
+
+    location = Location.from(:address3 => address3)
+    assert_equal 'Victory Lane', location.address2_and_3
+  end
+end

data/test/unit/package_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class PackageTest < Minitest::Test
+  include ActiveShipping::Test::Fixtures
+
+  GRAMS_IN_AN_OUNCE = 28.349523125
+  OUNCES_IN_A_GRAM = 0.0352739619495804
+  INCHES_IN_A_CM = 0.393700787401575
+  CM_IN_AN_INCH = 2.54
+
+  def setup
+    @imperial_package = Package.new(65, [3, 6, 8.5],
+                                    :units => :imperial,
+                                    :value => 10.65,
+                                    :currency => 'USD'
+                        )
+
+    @metric_package = Package.new(100, [5, 18.5, 40],
+                                  :value => 860,
+                                  :currency => 'CAD'
+                      )
+  end
+
+  def test_accessors
+    # :wii => Package.new((7.5 * 16), [15, 10, 4.5], :units => :imperial, :value => 269.99, :currency => 'GBP')
+    wii = package_fixtures[:wii]
+    [:x, :max, :long, :length].each do |sym|
+      assert_equal 15, wii.inches(sym)
+      assert_equal 15, wii.in(sym)
+      assert_equal 15 * CM_IN_AN_INCH, wii.centimetres(sym)
+      assert_equal 15 * CM_IN_AN_INCH, wii.cm(sym)
+    end
+    [:y, :mid, :width, :wide].each do |sym|
+      assert_equal 10, wii.inches(sym)
+      assert_equal 10, wii.in(sym)
+      assert_equal 10 * CM_IN_AN_INCH, wii.centimetres(sym)
+      assert_equal 10 * CM_IN_AN_INCH, wii.cm(sym)
+    end
+    [:z, :min, :height, :high, :depth, :deep].each do |sym|
+      assert_equal 4.5, wii.inches(sym)
+      assert_equal 4.5, wii.in(sym)
+      assert_equal 4.5 * CM_IN_AN_INCH, wii.centimetres(sym)
+      assert_equal 4.5 * CM_IN_AN_INCH, wii.cm(sym)
+    end
+    [:pounds, :lbs, :lb].each do |sym|
+      assert_equal 7.5, wii.send(sym)
+    end
+    [:ounces, :oz].each do |sym|
+      assert_equal 120, wii.send(sym)
+    end
+    [:grams, :g].each do |sym|
+      assert_equal 120 * GRAMS_IN_AN_OUNCE, wii.send(sym)
+    end
+    [:kilograms, :kgs, :kg].each do |sym|
+      assert_equal 120 * GRAMS_IN_AN_OUNCE / 1000, wii.send(sym)
+    end
+    assert_equal 675.0, wii.inches(:volume)
+    assert_equal 675.0, wii.inches(:box_volume)
+
+    assert_equal 'GBP', wii.currency
+    assert_equal 26999, wii.value
+  end
+
+  def test_package_from_mass
+    pkg = Package.new(Quantified::Mass.new(10, :pounds), [])
+    assert_equal 10, pkg.weight
+  end
+end

data/test/unit/rate_estimate_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class RateEstimateTest < Minitest::Test
+  include ActiveShipping::Test::Credentials
+
+  def setup
+    @origin      = {:address1 => "61A York St", :city => "Ottawa", :province => "ON", :country => "Canada", :postal_code => "K1N 5T2"}
+    @destination = {:city => "Beverly Hills", :state => "CA", :country => "United States", :postal_code => "90210"}
+    @line_items  = [Package.new(500, [2, 3, 4], :description => "a box full of stuff", :value => 2500)]
+    @carrier     = CanadaPost.new(credentials(:canada_post))
+    @options     = {:currency => 'USD'}
+
+    @rate_estimate = RateEstimate.new(@origin, @destination, @carrier, @service_name, @options)
+  end
+
+  def test_date_for_nil_string
+    assert_nil @rate_estimate.send(:date_for, nil)
+  end
+
+  def test_date_for_invalid_string_in_ruby_19
+    assert_nil @rate_estimate.send(:date_for, "Up to 2 weeks") if RUBY_VERSION.include?('1.9')
+  end
+
+  def test_rate_estimate_converts_noniso_to_iso
+    rate_estimate = RateEstimate.new(@origin, @destination, @carrier, @service_name, @options.merge(:currency => 'UKL'))
+    assert_equal 'GBP', rate_estimate.currency
+  end
+
+  def test_creating_an_estimate_with_an_invalid_currency_raises
+    assert_raises(ActiveUtils::InvalidCurrencyCodeError) do
+      RateEstimate.new(nil, nil, nil, nil, :currency => 'FAKE')
+    end
+  end
+end

data/test/unit/response_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class ResponseTest < Minitest::Test
+  def test_initialize_success
+    response = RateResponse.new(true, "success!", {:rate => 'Free!'}, :rates => [stub(:service_name => 'Free!', :total_price => 0)], :xml => "<rate>Free!</rate>")
+    assert response.success?
+  end
+
+  def test_initialize_failure
+    assert_raises(ActiveShipping::ResponseError) do
+      RateResponse.new(false, "fail!", {:rate => 'Free!'}, :rates => [stub(:service_name => 'Free!', :total_price => 0)], :xml => "<rate>Free!</rate>")
+    end
+  end
+end

data/test/unit/shipment_packer_test.rb

@@ -0,0 +1,174 @@
+require 'test_helper'
+
+class ShipmentPackerTest < Minitest::Test
+  def setup
+    @dimensions = [5.1, 15.2, 30.5]
+  end
+
+  def test_pack_divide_order_into_a_single_package
+    items = [{:grams => 1, :quantity => 1, :price => 1.0}]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+    assert_equal 1, packages.size
+
+    package = packages.first
+    assert_equal 1, package.weight
+  end
+
+  def test_divide_order_with_multiple_lines_into_a_single_package
+    items = [{:grams => 1, :quantity => 2, :price => 1.0}]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 2, 'USD')
+    assert_equal 1, packages.size
+
+    package = packages.first
+    assert_equal 2, package.weight
+  end
+
+  def test_divide_order_with_single_line_into_two_packages
+    items = [{:grams => 1, :quantity => 2, :price => 1.0}]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+    assert_equal 2, packages.size
+
+    packages.each do |package|
+      assert_equal 1, package.weight
+    end
+  end
+
+  def test_divide_order_with_multiple_lines_into_two_packages
+    items = [
+      {:grams => 1, :quantity => 1, :price => 1.0},
+      {:grams => 1, :quantity => 1, :price => 1.0}
+    ]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+    assert_equal 2, packages.size
+
+    packages.each do |package|
+      assert_equal 1, package.weight
+    end
+  end
+
+  def test_divide_order_into_two_packages_mixing_line_items
+    items = [
+      {:grams => 1, :quantity => 1, :price => 1.0},
+      {:grams => 1, :quantity => 1, :price => 1.0},
+      {:grams => 1, :quantity => 1, :price => 1.0}
+    ]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 2, 'USD')
+    assert_equal 2, packages.size
+
+    assert_equal 2, packages[0].weight
+    assert_equal 1, packages[1].weight
+  end
+
+  def test_raise_overweight_exception_when_a_single_item_exceeds_the_maximum_weight_of_a_package
+    assert_raises(ShipmentPacker::OverweightItem) do
+      items = [{:grams => 2, :quantity => 1, :price => 1.0}]
+      ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+    end
+  end
+
+  def test_raise_over_weight_exceptions_before_over_package_limit_exceptions
+      assert_raises(ShipmentPacker::OverweightItem) do
+        items = [{:grams => 5, :quantity => ShipmentPacker::EXCESS_PACKAGE_QUANTITY_THRESHOLD + 1, :price => 1.0}]
+        ShipmentPacker.pack(items, @dimensions, 4, 'USD')
+      end
+  end
+
+  def test_returns_an_empty_list_when_no_items_provided
+    assert_equal [], ShipmentPacker.pack([], @dimensions, 1, 'USD')
+  end
+
+  def test_add_summarized_prices_for_all_items_and_currency_to_package
+    items = [
+      {:grams => 1, :quantity => 3, :price => 1.0},
+      {:grams => 2, :quantity => 1, :price => 2.0}
+    ]
+    packages = ShipmentPacker.pack(items, @dimensions, 5, 'USD')
+    assert_equal 1, packages.size
+    assert_equal 500, packages.first.value
+    assert_equal 'USD', packages.first.currency
+  end
+
+  def test_divide_items_and_prices_accordingly_when_splitting_into_two_packages
+    items = [
+      {:grams => 1, :quantity => 1, :price => 1.0},
+      {:grams => 1, :quantity => 1, :price => 1.0},
+      {:grams => 1, :quantity => 1, :price => 1.0}
+    ]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 2, 'USD')
+    assert_equal 2, packages.size
+
+    assert_equal 200, packages[0].value
+    assert_equal 100, packages[1].value
+    assert_equal 'USD', packages[0].currency
+    assert_equal 'USD', packages[1].currency
+  end
+
+  def test_symbolize_item_keys
+    string_key_items          = [{'grams' => 1, 'quantity' => 1, 'price' => 1.0}]
+    indifferent_access_items  = [{'grams' => 1, 'quantity' => 1, 'price' => 1.0}.with_indifferent_access]
+
+    [string_key_items, indifferent_access_items].each do |items|
+      packages = ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+      assert_equal 1, packages.size
+
+      package = packages.first
+      assert_equal 1, package.weight
+      assert_equal 100, package.value
+    end
+  end
+
+  def test_cast_quantity_and_grams_to_int
+    items = [{:grams => '1', :quantity => '1', :price => '1.0'}]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+
+    package = packages.first
+    assert_equal 1, package.weight
+    assert_equal 100, package.value
+  end
+
+  def test_excess_packages
+    assert_raises(ShipmentPacker::ExcessPackageQuantity) do
+      items = [{:grams => 1, :quantity => ShipmentPacker::EXCESS_PACKAGE_QUANTITY_THRESHOLD + 1, :price => 1.0}]
+      ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+    end
+  end
+
+  def test_lots_of_zero_weight_items
+    items = [{:grams => 0, :quantity => 1_000_000, :price => 1.0}]
+    packages = ShipmentPacker.pack(items, @dimensions, 1, 'USD')
+
+    assert_equal 1, packages.size
+    assert_equal 0, packages[0].grams
+    assert_equal 100_000_000, packages[0].value
+  end
+
+  def test_dont_destroy_input_items
+    items = [{:grams => 1, :quantity => 5, :price => 1.0}]
+
+    packages = ShipmentPacker.pack(items, @dimensions, 10, 'USD')
+
+    assert_equal 1, items.size
+    assert_equal 1, packages.size
+  end
+
+  def test_dont_modify_input_item_quantities
+    items = [{:grams => 1, :quantity => 5, :price => 1.0}]
+
+    ShipmentPacker.pack(items, @dimensions, 10, 'USD')
+    assert_equal 5, items.first[:quantity]
+  end
+
+  def test_items_with_negative_weight
+    items = [{:grams => -1, :quantity => 5, :price => 1.0}]
+
+    ShipmentPacker.pack(items, @dimensions, 10, 'USD')
+    assert_equal 5, items.first[:quantity]
+  end
+end