friendly_shipping 0.8.0 → 0.9.0

data/lib/friendly_shipping/services/ups_json/parse_timings_response.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class ParseTimingsResponse
+        class << self
+          def call(request:, response:, shipment:)
+            parsed_response = ParseJsonResponse.call(
+              request: request,
+              response: response,
+              expected_root_key: 'emsResponse'
+            )
+            parsed_response.fmap do |parsing_result|
+              FriendlyShipping::ApiResult.new(
+                build_timings(parsing_result, shipment),
+                original_request: request,
+                original_response: response
+              )
+            end
+          end
+
+          def build_timings(timings_result, shipment)
+            service_timings = Array.wrap(timings_result.dig('emsResponse', 'services'))
+            service_timings.map do |timing|
+              service_description = timing['serviceLevelDescription']
+              shipping_method = SHIPPING_METHODS.detect do |potential_shipping_method|
+                service_description == potential_shipping_method.name &&
+                  potential_shipping_method.origin_countries.map(&:code).include?(shipment.origin.country.code)
+              end
+              delivery_date = timing['deliveryDate']
+              delivery_time = timing['deliveryTime']
+              delivery = Time.parse("#{delivery_date} #{delivery_time}")
+              pickup_date = timing['pickupDate']
+              pickup_time = timing['pickupTime']
+              pickup = Time.parse("#{pickup_date} #{pickup_time}")
+
+              guaranteed = timing['guaranteeIndicator'] == '1'
+              business_transit_days = timing['businessTransitDays']
+
+              FriendlyShipping::Timing.new(
+                shipping_method: shipping_method,
+                pickup: pickup,
+                delivery: delivery,
+                guaranteed: guaranteed,
+                data: {
+                  business_transit_days: business_transit_days
+                }
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/parse_void_response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class ParseVoidResponse
+        extend Dry::Monads::Result::Mixin
+
+        class << self
+          def call(request:, response:)
+            parsed_response = ParseJsonResponse.call(
+              request: request,
+              response: response,
+              expected_root_key: "VoidShipmentResponse"
+            )
+
+            parsed_response.bind do |void_response|
+              result = void_response["VoidShipmentResponse"]
+              Success(
+                FriendlyShipping::ApiResult.new(
+                  result,
+                  original_request: request,
+                  original_response: response
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/rates_item_options.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/item_options'
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      # Represents item options for determining rates.
+      # @option commodity_code [String] This item's HS or NMFC code for international shipments.
+      # @option country_of_origin [String] This item's country of origin for international shipments.
+      class RatesItemOptions < FriendlyShipping::ItemOptions
+        attr_reader :commodity_code, :country_of_origin
+
+        def initialize(commodity_code: nil, country_of_origin: nil, **kwargs)
+          @commodity_code = commodity_code
+          @country_of_origin = country_of_origin
+          super(**kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/rates_options.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/ups_json/rates_package_options'
+
+module FriendlyShipping
+  module Services
+    # Option container for rating a shipment via UPS
+    #
+    # Required:
+    #
+    # @option shipper_number [String] The shipper number of the origin of the shipment.
+    #
+    # Optional:
+    #
+    # @option carbon_neutral [Boolean] Ship with UPS' carbon neutral program
+    # @option customer_context [String ] Optional element to identify transactions between client and server
+    # @option customer_classification [Symbol] Which kind of rates to request. See UPS docs for more details. Default: `shipper_number`
+    # @option negotiated_rates [Boolean] if truthy negotiated rates will be requested from ups. Only valid if
+    #   shipper account has negotiated rates. Default: false
+    # @option pickup_type [String] UPS pickup type. See UPS docs for more details. Default: `daily_pickup`
+    # @option pickup_date [Time] UPS pickup date/time. Default: nil
+    # @option saturday_delivery [Boolean] should we request Saturday delivery?. Default: false
+    # @option saturday_pickup [Boolean] should we request Saturday pickup?. Default: false
+    # @option shipping_method [FriendlyShipping::ShippingMethod] Request rates for a particular shipping method only?
+    #   Default is `nil`, which translates to 'All shipping methods' (The "Shop" option in UPS parlance)
+    # @option sub_version [String] The UPS API sub-version to use for requests. Default: v2205
+    # @option with_time_in_transit [Boolean] Whether to request timing information alongside the rates
+    # @option package_options_class [Class] See FriendlyShipping::ShipmentOptions
+    #
+    class UpsJson
+      class RatesOptions < FriendlyShipping::ShipmentOptions
+        PICKUP_TYPE_CODES = {
+          daily_pickup: "01",
+          customer_counter: "03",
+          one_time_pickup: "06",
+          on_call_air: "07",
+          suggested_retail_rates: "11",
+          letter_center: "19",
+          air_service_center: "20"
+        }.freeze
+
+        CUSTOMER_CLASSIFICATION_CODES = {
+          shipper_number: "00",
+          daily_rates: "01",
+          retail_rates: "04",
+          regional_rates: "05",
+          general_rates: "06",
+          standard_rates: "53"
+        }.freeze
+
+        SUB_VERSIONS = %w[1 1601 1607 1701 1707 2108 2205].freeze
+
+        attr_reader :carbon_neutral,
+                    :customer_context,
+                    :destination_account,
+                    :negotiated_rates,
+                    :pickup_date,
+                    :saturday_delivery,
+                    :saturday_pickup,
+                    :shipper,
+                    :shipper_number,
+                    :shipping_method,
+                    :sub_version,
+                    :with_time_in_transit
+
+        def initialize(
+          shipper_number:,
+          carbon_neutral: true,
+          customer_context: nil,
+          customer_classification: :daily_rates,
+          destination_account: nil,
+          negotiated_rates: false,
+          pickup_type: :daily_pickup,
+          pickup_date: nil,
+          saturday_delivery: false,
+          saturday_pickup: false,
+          shipper: nil,
+          shipping_method: nil,
+          sub_version: "2205",
+          with_time_in_transit: false,
+          package_options_class: RatesPackageOptions,
+          **kwargs
+        )
+          raise ArgumentError, "Invalid sub-version: #{sub_version}" unless sub_version.in?(SUB_VERSIONS)
+
+          @carbon_neutral = carbon_neutral
+          @customer_context = customer_context
+          @customer_classification = customer_classification
+          @destination_account = destination_account
+          @negotiated_rates = negotiated_rates
+          @shipper_number = shipper_number
+          @pickup_type = pickup_type
+          @pickup_date = pickup_date
+          @saturday_delivery = saturday_delivery
+          @saturday_pickup = saturday_pickup
+          @shipper = shipper
+          @shipping_method = shipping_method
+          @sub_version = sub_version
+          @with_time_in_transit = with_time_in_transit
+          super(**kwargs.reverse_merge(package_options_class: package_options_class))
+        end
+
+        def pickup_type_code
+          PICKUP_TYPE_CODES[@pickup_type]
+        end
+
+        def customer_classification_code
+          CUSTOMER_CLASSIFICATION_CODES[@customer_classification]
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/rates_package_options.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      class RatesPackageOptions < FriendlyShipping::PackageOptions
+        attr_reader :transmit_dimensions
+
+        def initialize(transmit_dimensions: true,
+                       **kwargs)
+          @transmit_dimensions = transmit_dimensions
+          super(**kwargs.reverse_merge(item_options_class: RatesItemOptions))
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/shipping_methods.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      EU_COUNTRIES = %w(
+        AT BE BG CY CZ DE DK EE ES FI FR GB GR HR HU IE IT LT LU LV MT NL PO PT RO SE SI SK
+      ).map { |country_code| Carmen::Country.coded(country_code) }
+
+      class << self
+        private
+
+        def countries_by_code(code)
+          all_countries = Carmen::Country.all
+          covered_countries = EU_COUNTRIES + %w(US PR CA PL MX).map do |country_code|
+            Carmen::Country.coded(country_code)
+          end
+          other_countries = Carmen::Country.all - covered_countries
+          case code
+          when 'EU' then EU_COUNTRIES
+          when 'OTHER' then other_countries
+          when 'ALL' then all_countries
+          else
+            [Carmen::Country.coded(code)]
+          end
+        end
+      end
+
+      SHIPPING_METHODS = [
+        ['US', 'international', 'UPS Standard', '11'],
+        ['US', 'international', 'UPS Worldwide Express®', '07'],
+        ['US', 'international', 'UPS Worldwide Expedited®', '08'],
+        ['US', 'international', 'UPS Worldwide Express Plus®', '54'],
+        ['US', 'international', 'UPS Worldwide Saver', '65'],
+        ['US', 'domestic', 'UPS 2nd Day Air®', '02'],
+        ['US', 'domestic', 'UPS 2nd Day Air A.M.', '59'],
+        ['US', 'domestic', 'UPS 3 Day Select®', '12'],
+        ['US', 'domestic', 'UPS Ground', '03'],
+        ['US', 'domestic', 'UPS Next Day Air®', '01'],
+        ['US', 'domestic', 'UPS Next Day Air® Early', '14'],
+        ['US', 'domestic', 'UPS Next Day Air Saver®', '13'],
+        ['US', 'domestic', 'UPS SurePost Less than 1LB', '92'],
+        ['US', 'domestic', 'UPS SurePost 1LB or greater', '93'],
+        ['US', 'domestic', 'UPS SurePost BPM', '94'],
+        ['US', 'domestic', 'UPS SurePost Media Mail', '95'],
+        ['CA', 'domestic', 'UPS Expedited Canadian domestic shipments', '02'],
+        ['CA', 'domestic', 'UPS Express Saver Canadian domestic shipments', '13'],
+        ['CA', 'domestic', 'UPS 3 Day Select Shipments originating in Canada to CA and US 48', '12'],
+        ['CA', 'international', 'UPS 3 Day Select Shipments originating in Canada to CA and US 48', '12'],
+        ['CA', 'domestic', 'UPS Access Point Economy Canadian domestic shipments', '70'],
+        ['CA', 'domestic', 'UPS Express Canadian domestic shipments', '01'],
+        ['CA', 'domestic', 'UPS Express Early Canadian domestic shipments', '14'],
+        ['CA', 'international', 'UPS Express Saver International shipments originating in Canada', '65'],
+        ['CA', 'international', 'UPS Standard Shipments originating in Canada (Domestic and Int’l)', '11'],
+        ['CA', 'domestic', 'UPS Standard Shipments originating in Canada (Domestic and Int’l)', '11'],
+        ['CA', 'international', 'UPS Worldwide Expedited International shipments originating in Canada', '08'],
+        ['CA', 'international', 'UPS Worldwide Express International shipments originating in Canada', '07'],
+        ['CA', 'international', 'UPS Worldwide Express Plus International shipments originating in Canada', '54'],
+        ['CA', 'international', 'UPS Express Early Shipments originating in Canada to CA and US 48', '54'],
+        ['CA', 'domestic', 'UPS Express Early Shipments originating in Canada to CA and US 48', '54'],
+        ['EU', 'domestic', 'UPS Access Point Economy Shipments within the European Union', '70'],
+        ['EU', 'international', 'UPS Expedited Shipments originating in the European Union', '08'],
+        ['EU', 'international', 'UPS Express Shipments originating in the European Union', '07'],
+        ['EU', 'international', 'UPS Standard Shipments originating in the European Union', '11'],
+        ['EU', 'international', 'UPS Worldwide Express Plus Shipments originating in the European Union', '54'],
+        ['EU', 'international', 'UPS Worldwide Saver Shipments originating in the European Union', '65'],
+        ['MX', 'domestic', 'UPS Access Point Economy Shipments within Mexico', '70'],
+        ['MX', 'international', 'UPS Expedited Shipments originating in Mexico', '08'],
+        ['MX', 'international', 'UPS Express Shipments originating in Mexico', '07'],
+        ['MX', 'international', 'UPS Standard Shipments originating in Mexico', '11'],
+        ['MX', 'international', 'UPS Worldwide Express Plus Shipments originating in Mexico', '54'],
+        ['MX', 'international', 'UPS Worldwide Saver Shipments originating in Mexico', '65'],
+        ['PL', 'domestic', 'UPS Access Point Economy Polish domestic shipments', '70'],
+        ['PL', 'domestic', 'UPS Today Dedicated Courier Polish domestic shipments', '83'],
+        ['PL', 'domestic', 'UPS Today Express Polish domestic shipments', '85'],
+        ['PL', 'domestic', 'UPS Today Express Saver Polish domestic shipments', '86'],
+        ['PL', 'domestic', 'UPS Today Standard Polish domestic shipments', '82'],
+        ['PL', 'international', 'UPS Expedited Shipments originating in Poland', '08'],
+        ['PL', 'international', 'UPS Express Shipments originating in Poland', '07'],
+        ['PL', 'international', 'UPS Express Plus Shipments originating in Poland', '54'],
+        ['PL', 'international', 'UPS Express Saver Shipments originating in Poland', '65'],
+        ['PL', 'international', 'UPS Standard Shipments originating in Poland', '11'],
+        ['PR', 'domestic', 'UPS 2nd Day Air', '02'],
+        ['PR', 'domestic', 'UPS Ground', '03'],
+        ['PR', 'domestic', 'UPS Next Day Air', '01'],
+        ['PR', 'domestic', 'UPS Next Day Air Early', '14'],
+        ['PR', 'international', 'UPS Worldwide Expedited', '08'],
+        ['PR', 'international', 'UPS Worldwide Express', '07'],
+        ['PR', 'international', 'UPS Worldwide Express Plus', '54'],
+        ['PR', 'international', 'UPS Worldwide Saver', '65'],
+        ['DE', 'domestic', 'UPS Express 12:00 German domestic shipments', '74'],
+        ['OTHER', 'domestic', 'UPS Express', '07'],
+        ['OTHER', 'domestic', 'UPS Standard', '11'],
+        ['OTHER', 'international', 'UPS Worldwide Expedited', '08'],
+        ['OTHER', 'international', 'UPS Worldwide Express Plus', '54'],
+        ['OTHER', 'international', 'UPS Worldwide Saver', '65'],
+        ['ALL', 'international', 'UPS Worldwide Express Freight', '96'],
+        ['ALL', 'international', 'UPS Worldwide Express Freight Midday', '71']
+      ].freeze.map do |origin_country_code, dom_or_intl, name, code|
+        FriendlyShipping::ShippingMethod.new(
+          name: name,
+          service_code: code,
+          domestic: dom_or_intl == 'domestic',
+          international: dom_or_intl == 'international',
+          origin_countries: countries_by_code(origin_country_code),
+          multi_package: true
+        ).freeze
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json/timings_options.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      # Options for getting timing information from UPS
+      # @attribute [Time] pickup When the shipment will be picked up
+      # @attribute [Money] invoice_total How much the items in the shipment are worth
+      #   As this is not super important for getting timing information, we use a default
+      #   value of 50 USD here.
+      # @attribute [Boolean] documents_only Does the shipment only contain documents?
+      # @attribute [String] customer_context A string to connect request and response in the calling code
+      class TimingsOptions
+        attr_reader :pickup,
+                    :invoice_total,
+                    :documents_only,
+                    :customer_context
+
+        def initialize(
+          pickup: Time.now,
+          invoice_total: Money.new(5000, 'USD'),
+          documents_only: false,
+          customer_context: nil
+        )
+          @pickup = pickup
+          @invoice_total = invoice_total
+          @documents_only = documents_only
+          @customer_context = customer_context
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/ups_json.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+require 'friendly_shipping/http_client'
+require 'friendly_shipping/services/ups_json/access_token'
+require 'friendly_shipping/services/ups_json/api_error'
+require 'friendly_shipping/services/ups_json/generate_address_classification_payload'
+require 'friendly_shipping/services/ups_json/generate_labels_payload'
+require 'friendly_shipping/services/ups_json/generate_rates_payload'
+require 'friendly_shipping/services/ups_json/generate_timings_payload'
+require 'friendly_shipping/services/ups_json/label'
+require 'friendly_shipping/services/ups_json/label_options'
+require 'friendly_shipping/services/ups_json/parse_address_classification_response'
+require 'friendly_shipping/services/ups_json/parse_json_response'
+require 'friendly_shipping/services/ups_json/parse_labels_response'
+require 'friendly_shipping/services/ups_json/parse_money_hash'
+require 'friendly_shipping/services/ups_json/parse_rate_modifier_hash'
+require 'friendly_shipping/services/ups_json/parse_rates_response'
+require 'friendly_shipping/services/ups_json/parse_timings_response'
+require 'friendly_shipping/services/ups_json/parse_void_response'
+require 'friendly_shipping/services/ups_json/rates_item_options'
+require 'friendly_shipping/services/ups_json/rates_package_options'
+require 'friendly_shipping/services/ups_json/rates_options'
+require 'friendly_shipping/services/ups_json/shipping_methods'
+require 'friendly_shipping/services/ups_json/timings_options'
+
+module FriendlyShipping
+  module Services
+    class UpsJson
+      include Dry::Monads[:result]
+
+      attr_reader :access_token, :test, :client
+
+      CARRIER = FriendlyShipping::Carrier.new(
+        id: 'ups',
+        name: 'United Parcel Service',
+        code: 'ups',
+        shipping_methods: SHIPPING_METHODS
+      )
+
+      TEST_URL = 'https://wwwcie.ups.com'
+      LIVE_URL = 'https://onlinetools.ups.com'
+
+      def initialize(access_token:, test: true, client: nil)
+        @access_token = access_token
+        @test = test
+        error_handler = ApiErrorHandler.new(api_error_class: UpsJson::ApiError)
+        @client = client || HttpClient.new(error_handler: error_handler)
+      end
+
+      def carriers
+        Success([CARRIER])
+      end
+
+      # Creates an access token to be used for future API requests.
+      #
+      # @param client_id [String] the Client ID of your UPS application
+      # @param client_secret [String] the Client Secret of your UPS application
+      # @param merchant_id [String] the shipper number associated with your UPS application
+      # @param debug [Boolean] whether to append debug information to the API result
+      # @return [ApiResult<AccessToken>] the access token
+      def create_access_token(
+        client_id:,
+        client_secret:,
+        merchant_id:,
+        debug: false
+      )
+        request = FriendlyShipping::Request.new(
+          url: "#{base_url}/security/v1/oauth/token",
+          http_method: "POST",
+          body: "grant_type=client_credentials",
+          headers: {
+            Authorization: "Basic #{Base64.urlsafe_encode64("#{client_id}:#{client_secret}")}",
+            Content_Type: "application/x-www-form-urlencoded",
+            'X-Merchant-Id': merchant_id,
+            Accept: "application/json"
+          },
+          debug: debug
+        )
+        client.post(request).fmap do |response|
+          hash = JSON.parse(response.body)
+          FriendlyShipping::ApiResult.new(
+            AccessToken.new(
+              expires_in: hash['expires_in'],
+              issued_at: hash['issued_at'],
+              raw_token: hash['access_token']
+            ),
+            original_request: request,
+            original_response: response
+          )
+        end
+      end
+
+      # Get rates for a shipment
+      # @param [Physical::Shipment] shipment The shipment we want to get rates for
+      # @param [FriendlyShipping::Services::UpsJson::RatesOptions] options What options
+      #    to use for this rates request
+      # @return [Result<ApiResult<Array<Rate>>>] The rates returned from UPS encoded in a
+      #   `FriendlyShipping::ApiResult` object.
+      def rates(shipment, options:, debug: false)
+        rate_or_shop = options.shipping_method ? "Rate" : "Shop"
+        url = "#{base_url}/api/rating/v#{options.sub_version || '1'}/#{rate_or_shop}"
+        headers = required_headers(access_token)
+        rates_request_body = GenerateRatesPayload.call(shipment: shipment, options: options).to_json
+
+        request = FriendlyShipping::Request.new(
+          url: url,
+          http_method: "POST",
+          headers: headers,
+          body: rates_request_body,
+          debug: debug
+        )
+
+        client.post(request).bind do |response|
+          ParseRatesResponse.call(response: response, request: request, shipment: shipment)
+        end
+      end
+
+      alias_method :rate_estimates, :rates
+
+      # Get timing information for a shipment
+      # @param [Physical::Shipment] shipment The shipment we want to estimate timings for
+      # @param [FriendlyShipping::Services::UpsJson::TimingOptions] options Options for this call
+      def timings(shipment, options:, debug: false)
+        url = "#{base_url}/api/shipments/v1/transittimes"
+        headers = required_headers(access_token).merge(
+          "transId" => SecureRandom.uuid,
+          "transactionSrc" => "testing" # this is a required field according to https://developer.ups.com/api/reference?loc=en_US#operation/TimeInTransit
+        )
+        timings_request_body = GenerateTimingsPayload.call(shipment: shipment, options: options).to_json
+
+        request = FriendlyShipping::Request.new(
+          url: url,
+          http_method: "POST",
+          headers: headers,
+          body: timings_request_body,
+          debug: debug
+        )
+
+        client.post(request).bind do |response|
+          ParseTimingsResponse.call(response: response, request: request, shipment: shipment)
+        end
+      end
+
+      # Generate labels for a shipment, aka by UPS as the Shipping Shipment api:
+      #   https://developer.ups.com/api/reference?loc=en_US#tag/Shipping_other
+      # @param [Physical::Shipment] shipment The shipment we want to create labels for
+      # @param [FriendlyShipping::Services::UpsJson::LabelOptions] options Options for this call
+      # @return [Result<ApiResult<Array<Label>>>] The labels returned from UPS encoded in a
+      #   `FriendlyShipping::ApiResult` object.
+      def labels(shipment, options:, debug: false)
+        url = "#{base_url}/api/shipments/v#{options.sub_version || '2205'}/ship"
+        # the RequestOption field in the payload is documented as doing city validation but it does not
+        url += "?additionaladdressvalidation=city" if options.validate_address
+        headers = required_headers(access_token)
+        body = GenerateLabelsPayload.call(shipment: shipment, options: options).to_json
+        request = FriendlyShipping::Request.new(url: url, http_method: "POST", headers: headers, body: body, debug: debug)
+
+        client.post(request).bind do |response|
+          ParseLabelsResponse.call(response: response, request: request)
+        end
+      end
+
+      # Classify an address.
+      # @param [Physical::Location] location The address we want to classify
+      # @return [Result<ApiResult<String>>] Either `"commercial"`, `"residential"`, or `"unknown"`
+      def address_classification(location, debug: false)
+        url = "#{base_url}/api/addressvalidation/v1/2"
+        headers = required_headers(access_token)
+        body = GenerateAddressClassificationPayload.call(location: location).to_json
+
+        request = FriendlyShipping::Request.new(
+          url: url,
+          http_method: "POST",
+          headers: headers,
+          body: body,
+          debug: debug
+        )
+
+        client.post(request).bind do |response|
+          ParseAddressClassificationResponse.call(response: response, request: request)
+        end
+      end
+
+      # Void a label, aka by UPS as the Shipping Void Shipment api:
+      #   https://developer.ups.com/api/reference?loc=en_US#tag/Shipping_other
+      # @param [Label] label The label to be voided
+      # @return [Result<ApiResult>] The VoidShipmentResponse body from UPS.
+      def void(label, debug: false)
+        # The docs say to use both the shipment_id and tracking number, but the tracking number seems to work alone.
+        # url = "#{base_url}/api/shipments/v1/void/cancel/#{label.shipment_id}?trackingNumber=#{label.tracking_number}"
+        url = "#{base_url}/api/shipments/v1/void/cancel/#{label.tracking_number}"
+        headers = required_headers(access_token)
+        request = FriendlyShipping::Request.new(url: url, http_method: "DELETE", headers: headers, debug: debug)
+
+        client.delete(request).bind do |response|
+          ParseVoidResponse.call(response: response, request: request)
+        end
+      end
+
+      private
+
+      def required_headers(access_token)
+        {
+          "Authorization" => "Bearer #{access_token}",
+          "Content-Type" => "application/json",
+          "Accept" => "application/json"
+        }
+      end
+
+      def base_url
+        test ? TEST_URL : LIVE_URL
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/choose_package_rate.rb

@@ -7,13 +7,13 @@ module FriendlyShipping
         class CannotDetermineRate < StandardError; end
         # Some shipping rates use 'Flat Rate Boxes', indicating that
         # they are available for ALL flat rate boxes.
-        FLAT_RATE_BOX = /Flat Rate Box/i.freeze
+        FLAT_RATE_BOX = /Flat Rate Box/i
 
         # Select the corresponding rate for a package from all the rates USPS returns to us
         #
         # @param [FriendlyShipping::ShippingMethod] shipping_method The shipping method we want to filter by
-        # @param [Physical::Package] package The package we want to match with a rate
-        # @param [Array<FriendlyShipping::Rate>] The rates we select from
+        # @param [Array<FriendlyShipping::Rate>] rates The rates we select from
+        # @param [FriendlyShipping::PackageOptions] package_options The package options we want to match with a rate
         #
         # @return [FriendlyShipping::Rate] The rate that most closely matches our package
         def self.call(shipping_method, rates, package_options)

data/lib/friendly_shipping/services/usps/machinable_package.rb

@@ -21,7 +21,7 @@ module FriendlyShipping
 
         MAX_WEIGHT = Measured::Weight(25, :pounds)
 
-        # @param [Physical::Package]
+        # @param [Physical::Package] package
         def initialize(package)
           @package = package
         end