imgix 3.2.1 → 3.3.0

data/lib/imgix/param_helpers.rb

@@ -3,6 +3,7 @@
 module Imgix
   module ParamHelpers
     def rect(position)
+      warn "Warning: `ParamHelpers.rect` has been deprecated and will be removed in the next major version.\n"
       @options[:rect] = position and return self if position.is_a?(String)
 
       @options[:rect] = [

data/lib/imgix/path.rb

@@ -10,26 +10,26 @@ module Imgix
     include ParamHelpers
 
     ALIASES = {
-      width:           :w,
-      height:          :h,
-      rotation:        :rot,
+      width: :w,
+      height: :h,
+      rotation: :rot,
       noise_reduction: :nr,
-      sharpness:       :sharp,
-      exposure:        :exp,
-      vibrance:        :vib,
-      saturation:      :sat,
-      brightness:      :bri,
-      contrast:        :con,
-      highlight:       :high,
-      shadow:          :shad,
-      gamma:           :gam,
-      pixelate:        :px,
-      halftone:        :htn,
-      watermark:       :mark,
-      text:            :txt,
-      format:          :fm,
-      quality:         :q
-    }
+      sharpness: :sharp,
+      exposure: :exp,
+      vibrance: :vib,
+      saturation: :sat,
+      brightness: :bri,
+      contrast: :con,
+      highlight: :high,
+      shadow: :shad,
+      gamma: :gam,
+      pixelate: :px,
+      halftone: :htn,
+      watermark: :mark,
+      text: :txt,
+      format: :fm,
+      quality: :q
+    }.freeze
 
     def initialize(prefix, secure_url_token, path = '/')
       @prefix = prefix
@@ -75,10 +75,16 @@ module Imgix
 
     ALIASES.each do |from, to|
       define_method from do |*args|
+        warn "Warning: `Path.#{from}' has been deprecated and " \
+             "will be removed in the next major version (along " \
+             "with all parameter `ALIASES`).\n"
         self.send(to, *args)
       end
 
       define_method "#{from}=" do |*args|
+        warn "Warning: `Path.#{from}=' has been deprecated and " \
+             "will be removed in the next major version (along " \
+             "with all parameter `ALIASES`).\n"
         self.send("#{to}=", *args)
         return self
       end
@@ -88,20 +94,20 @@ module Imgix
       prev_options = @options.dup
       @options.merge!(params)
 
-      width = @options['w'.to_sym]
-      height = @options['h'.to_sym]
-      aspect_ratio = @options['ar'.to_sym]
+      width = @options[:w]
+      height = @options[:h]
+      aspect_ratio = @options[:ar]
 
-      if ((width) || (height && aspect_ratio))
-        srcset = build_dpr_srcset(options: options, params:@options)
-      else
-        srcset = build_srcset_pairs(options: options, params: @options)
-      end
+      srcset = if width || (height && aspect_ratio)
+                 build_dpr_srcset(options: options, params: @options)
+               else
+                 build_srcset_pairs(options: options, params: @options)
+               end
 
       @options = prev_options
       srcset
     end
-    
+
     private
 
     def signature
@@ -131,23 +137,24 @@ module Imgix
     def build_srcset_pairs(options:, params:)
       srcset = ''
 
-      widths = options['widths'.to_sym] || []
-      width_tolerance = options['width_tolerance'.to_sym] ||  DEFAULT_WIDTH_TOLERANCE
-      min_srcset = options['min_width'.to_sym] || MIN_WIDTH
-      max_srcset = options['max_width'.to_sym] || MAX_WIDTH
+      widths = options[:widths] || []
+      width_tolerance = options[:width_tolerance] || DEFAULT_WIDTH_TOLERANCE
+      min_width = options[:min_width] || MIN_WIDTH
+      max_width = options[:max_width] || MAX_WIDTH
 
       if !widths.empty?
         validate_widths!(widths)
         srcset_widths = widths
-      elsif width_tolerance != DEFAULT_WIDTH_TOLERANCE or min_srcset != MIN_WIDTH or max_srcset != MAX_WIDTH
-        validate_range!(min_srcset, max_srcset)
-        srcset_widths = TARGET_WIDTHS.call(width_tolerance, min_srcset, max_srcset)
+      elsif width_tolerance != DEFAULT_WIDTH_TOLERANCE || min_width != MIN_WIDTH || max_width != MAX_WIDTH
+        validate_range!(min_width, max_width)
+        validate_width_tolerance!(width_tolerance)
+        srcset_widths = TARGET_WIDTHS.call(width_tolerance, min_width, max_width)
       else
         srcset_widths = @target_widths
       end
 
       for width in srcset_widths do
-        params['w'.to_sym] = width
+        params[:w] = width
         srcset += "#{to_url(params)} #{width}w,\n"
       end
 
@@ -157,17 +164,17 @@ module Imgix
     def build_dpr_srcset(options:, params:)
       srcset = ''
 
-      disable_variable_quality = options['disable_variable_quality'.to_sym] || false
+      disable_variable_quality = options[:disable_variable_quality] || false
       validate_variable_qualities!(disable_variable_quality)
 
-      target_ratios = [1,2,3,4,5]
-      quality = params['q'.to_sym]
+      target_ratios = [1, 2, 3, 4, 5]
+      quality = params[:q]
 
       for ratio in target_ratios do
-        params['dpr'.to_sym] = ratio
+        params[:dpr] = ratio
 
         unless disable_variable_quality
-          params['q'.to_sym] = quality || DPR_QUALITY[ratio]
+          params[:q] = quality || DPR_QUALITY[ratio]
         end
 
         srcset += "#{to_url(params)} #{ratio}x,\n"
@@ -176,30 +183,37 @@ module Imgix
       srcset[0..-3]
     end
 
-    def validate_widths!(widths)
-      unless widths.is_a? Array
-        raise ArgumentError, "The widths argument must be passed a valid array of integers"
-      else
-        positive_integers = widths.all? {|i| i.is_a?(Integer) and i > 0}
-        unless positive_integers
-          raise ArgumentError, "A custom widths array must only contain positive integer values"  
-        end
+    def validate_width_tolerance!(width_tolerance)
+      width_increment_error = 'error: `width_tolerance` must be a positive `Numeric` value'
+
+      if !width_tolerance.is_a?(Numeric) || width_tolerance <= 0
+        raise ArgumentError, width_increment_error
       end
     end
 
+    def validate_widths!(widths)
+      widths_error = 'error: `widths` must be an array of positive `Numeric` values'
+      raise ArgumentError, widths_error unless widths.is_a?(Array)
+
+      all_positive_integers = widths.all? { |i| i.is_a?(Integer) && i > 0 }
+      raise ArgumentError, widths_error unless all_positive_integers
+    end
+
     def validate_range!(min_srcset, max_srcset)
-      if min_srcset.is_a? Numeric and max_srcset.is_a? Numeric
-        unless min_srcset > 0 and max_srcset > 0
-          raise ArgumentError, "The min and max arguments must be passed positive Numeric values"
-        end
-      else
-        raise ArgumentError, "The min and max arguments must be passed positive Numeric values"
+      range_numeric_error = 'error: `min_width` and `max_width` must be positive `Numeric` values'
+      unless min_srcset.is_a?(Numeric) && max_srcset.is_a?(Numeric)
+        raise ArgumentError, range_numeric_error
+      end
+
+      unless min_srcset > 0 && max_srcset > 0
+        raise ArgumentError, range_numeric_error
       end
     end
 
-    def validate_variable_qualities!(disable_variable_quality)
-      unless disable_variable_quality.is_a?(TrueClass) || disable_variable_quality.is_a?(FalseClass)
-        raise ArgumentError, "The disable_variable_quality argument must be passed a Boolean value"
+    def validate_variable_qualities!(disable_quality)
+      disable_quality_error = 'error: `disable_quality` must be a Boolean value'
+      unless disable_quality.is_a?(TrueClass) || disable_quality.is_a?(FalseClass)
+        raise ArgumentError, disable_quality_error
       end
     end
   end

data/lib/imgix/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Imgix
-  VERSION = '3.2.1'
+  VERSION = '3.3.0'
 end

data/test/units/param_helpers_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ParamHelpers < Imgix::Test
+  def test_param_helpers_emits_dep_warning
+    host_warn = "Warning: The identifier `host' has been deprecated and " \
+                "will\nappear as `domain' in the next major version, e.g. " \
+                "`@host'\nbecomes `@domain', `options[:host]' becomes " \
+                "`options[:domain]'.\n"
+
+    assert_output(nil, host_warn) {
+        client = Imgix::Client.new(host: 'test.imgix.net')
+
+        rect_warn = "Warning: `ParamHelpers.rect` has been deprecated and " \
+                    "will be removed in the next major version.\n"
+
+        assert_output(nil, rect_warn){
+            client.path('/images/demo.png').rect(x: 0, y: 50, width: 200, height: 300)
+        }
+    }
+  end
+end

data/test/units/path_test.rb

@@ -3,6 +3,27 @@
 require 'test_helper'
 
 class PathTest < Imgix::Test
+  def test_prefix_with_arg_warns
+    prefix_warn = "Warning: `Client::prefix' will take zero arguments " \
+      "in the next major version.\n"
+
+    assert_output(nil, prefix_warn) {
+      Imgix::Client.new(
+        domain: 'test.imgix.net',
+        include_library_param: false
+      ).prefix("")
+    }
+
+    # `new_prefix' is a placeholder until the bump, when it will become
+    # `prefix`.
+    assert_output(nil, nil) {
+      Imgix::Client.new(
+        domain: 'test.imgix.net',
+        include_library_param: false
+      ).new_prefix
+    }
+  end
+
   def test_creating_a_path
     path = client.path('/images/demo.png')
     assert_equal 'https://demo.imgix.net/images/demo.png?s=2c7c157eaf23b06a0deb2f60b81938c4', path.to_url
@@ -14,7 +35,12 @@ class PathTest < Imgix::Test
   def test_signing_path_with_param
     url = 'https://demo.imgix.net/images/demo.png?w=200&s=da421114ca238d1f4a927b889f67c34e'
     path = client.path('/images/demo.png')
-    path.width = 200
+
+    assert_output(nil, "Warning: `Path.width=' has been deprecated and " \
+      "will be removed in the next major version (along " \
+      "with all parameter `ALIASES`).\n") {
+        path.width = 200
+    }
 
     assert_equal url, path.to_url
 
@@ -22,13 +48,23 @@ class PathTest < Imgix::Test
     assert_equal url, path.to_url(w: 200)
 
     path = client.path('/images/demo.png')
-    assert_equal url, path.width(200).to_url
+
+    assert_output(nil, "Warning: `Path.width' has been deprecated and " \
+      "will be removed in the next major version (along " \
+      "with all parameter `ALIASES`).\n") {
+        assert_equal url, path.width(200).to_url
+    }
   end
 
   def test_resetting_defaults
     url = 'https://demo.imgix.net/images/demo.png?w=200&s=da421114ca238d1f4a927b889f67c34e'
     path = client.path('/images/demo.png')
-    path.height = 300
+    
+    assert_output(nil, "Warning: `Path.height=' has been deprecated and " \
+      "will be removed in the next major version (along " \
+      "with all parameter `ALIASES`).\n") {
+        path.height = 300
+    }
 
     assert_equal url, path.defaults.to_url(w: 200)
   end
@@ -40,7 +76,21 @@ class PathTest < Imgix::Test
     assert_equal url, path.to_url(h: 200, w: 200)
 
     path = client.path('/images/demo.png')
-    assert_equal url, path.height(200).width(200).to_url
+
+    assert_output(nil, "Warning: `Path.height' has been deprecated and " \
+      "will be removed in the next major version (along " \
+      "with all parameter `ALIASES`).\n") {
+        path.height(200)
+    }
+
+
+    assert_output(nil, "Warning: `Path.width' has been deprecated and " \
+      "will be removed in the next major version (along " \
+      "with all parameter `ALIASES`).\n") {
+        path.width(200)
+    }
+
+    assert_equal url, path.to_url
   end
 
   def test_path_with_multi_value_param_safely_encoded

data/test/units/srcset_test.rb

@@ -1,716 +1,755 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module SrcsetTest
+  RESOLUTIONS = [
+    100, 116, 135, 156, 181, 210, 244, 283,
+    328, 380, 441, 512, 594, 689, 799, 927,
+    1075, 1247, 1446, 1678, 1946, 2257, 2619,
+    3038, 3524, 4087, 4741, 5500, 6380, 7401, 8192
+  ].freeze
+
+  DPR_QUALITY = [75, 50, 35, 23, 20].freeze
+
+  DOMAIN = 'testing.imgix.net'
+  TOKEN = 'MYT0KEN'
+  JPG_PATH = 'image.jpg'
+
+  def mock_client
+    Imgix::Client.new(
+      host: DOMAIN,
+      include_library_param: false
+    ).path(JPG_PATH)
+  end
+
+  def mock_signed_client
+    Imgix::Client.new(
+      host: DOMAIN,
+      secure_url_token: TOKEN,
+      include_library_param: false
+    ).path(JPG_PATH)
+  end
+
+  def signature_base(params)
+    TOKEN + '/' + JPG_PATH + params
+  end
+
+  def get_sig_from(src)
+    src.slice(src.index('s=') + 2, src.length)
+  end
+
+  def get_params_from(src)
+    src[src.index('?')..src.index('s=') - 2]
+  end
+
+  def get_expected_signature(src)
+    # Ensure signature param exists.
+    assert_includes src, 's='
+
+    params = get_params_from(src)
+    signature_base = signature_base(params)
+
+    Digest::MD5.hexdigest(signature_base)
+  end
+
+  class SrcsetDefault < Imgix::Test
+    include SrcsetTest
+
+    def test_no_parameters
+      srcset = path.to_srcset
+
+      expected_number_of_pairs = 31
+      assert_equal expected_number_of_pairs, srcset.split(',').length
+    end
+
+    def test_srcset_pair_values
+      resolutions = RESOLUTIONS
+      srcset = path.to_srcset
+      srclist = srcset.split(',').map do |srcset_split|
+        srcset_split.split(' ')[1].to_i
+      end
+
+      for i in 0..srclist.length - 1
+        assert_equal(srclist[i], resolutions[i])
+      end
+    end
+
+    private
+
+    def path
+      @client ||= mock_signed_client
+    end
+  end
+
+  class SrcsetGivenWidth < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_in_dpr_form
+      device_pixel_ratio = 1
+
+      srcset.split(',').map do |src|
+        ratio = src.split(' ')[1]
+        assert_equal "#{device_pixel_ratio}x", ratio
+        device_pixel_ratio += 1
+      end
+    end
+
+    def test_srcset_has_dpr_params
+      i = 1
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        assert_includes src, "dpr=#{i}"
+        i += 1
+      end
+    end
+
+    def test_srcset_signs_urls
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        expected_signature = get_expected_signature(src)
+
+        assert_includes src, expected_signature
+      end
+    end
+
+    def test_srcset_has_variable_qualities
+      i = 0
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{DPR_QUALITY[i]}"
+        i += 1
+      end
+    end
+
+    def test_srcset_respects_overriding_quality
+      quality_override = 100
+      srcset = mock_signed_client.to_srcset(w: 100, q: quality_override)
+
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{quality_override}"
+      end
+    end
+
+    def test_disable_variable_quality
+      srcset = mock_signed_client.to_srcset(
+        w: 100,
+        options: { disable_variable_quality: true }
+      )
+
+      srcset.split(',').map do |src|
+        assert(not(src.include?('q=')))
+      end
+    end
+
+    def test_respects_quality_param_when_disabled
+      quality_override = 100
+      srcset = mock_signed_client.to_srcset(
+        w: 100, q: 100,
+        options: { disable_variable_quality: true }
+      )
+
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{quality_override}"
+      end
+    end
+
+    private
+
+    def srcset
+      @client ||= mock_signed_client.to_srcset(w: 100)
+    end
+  end
+
+  class SrcsetGivenHeight < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_generates_width_pairs
+      expected_number_of_pairs = 31
+      assert_equal expected_number_of_pairs, srcset.split(',').length
+    end
+
+    def test_srcset_pair_values
+      resolutions = RESOLUTIONS
+      srclist = srcset.split(',').map do |srcset_split|
+        srcset_split.split(' ')[1].to_i
+      end
+
+      for i in 0..srclist.length - 1
+        assert_equal(srclist[i], resolutions[i])
+      end
+    end
+
+    def test_srcset_respects_height_parameter
+      srcset.split(',').map do |src|
+        assert_includes src, 'h='
+      end
+    end
+
+    def test_srcset_within_bounds
+      min, *max = srcset.split(',')
+
+      # parse out the width descriptor as an integer
+      min = min.split(' ')[1].to_i
+      max = max[max.length - 1].split(' ')[1].to_i
+
+      assert_operator min, :>=, 100
+      assert_operator max, :<=, 8192
+    end
+
+    # a 17% testing threshold is used to account for rounding
+    def test_srcset_iterates_17_percent
+      increment_allowed = 0.17
+
+      # create an array of widths
+      widths = srcset.split(',').map do |src|
+        src.split(' ')[1].to_i
+      end
+
+      prev = widths[0]
+
+      for i in 1..widths.length - 1
+        element = widths[i]
+        assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
+        prev = element
+      end
+    end
+
+    def test_srcset_signs_urls
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        expected_signature = get_expected_signature(src)
+
+        assert_includes src, expected_signature
+      end
+    end
+
+    private
+
+    def srcset
+      @client ||= mock_signed_client.to_srcset(h: 100)
+    end
+  end
+
+  class SrcsetGivenWidthAndHeight < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_in_dpr_form
+      device_pixel_ratio = 1
+      srcset.split(',').map do |src|
+        ratio = src.split(' ')[1]
+        assert_equal "#{device_pixel_ratio}x", ratio
+        device_pixel_ratio += 1
+      end
+    end
+
+    def test_srcset_has_dpr_params
+      i = 1
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        assert_includes src, "dpr=#{i}"
+        i += 1
+      end
+    end
+
+    def test_srcset_signs_urls
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        expected_signature = get_expected_signature(src)
+
+        assert_includes src, expected_signature
+      end
+    end
+
+    def test_srcset_has_variable_qualities
+      i = 0
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{DPR_QUALITY[i]}"
+        i += 1
+      end
+    end
+
+    def test_srcset_respects_overriding_quality
+      quality_override = 100
+      srcset = mock_signed_client.to_srcset(w: 100, h: 100, q: quality_override)
+
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{quality_override}"
+      end
+    end
+
+    def test_disable_variable_quality
+      srcset = mock_signed_client.to_srcset(
+        w: 100, h: 100,
+        options: { disable_variable_quality: true }
+      )
+
+      srcset.split(',').map do |src|
+        assert(not(src.include?('q=')))
+      end
+    end
+
+    def test_respects_quality_param_when_disabled
+      quality_override = 100
+      srcset = mock_signed_client.to_srcset(
+        w: 100, h: 100, q: 100,
+        options: { disable_variable_quality: true }
+      )
+
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{quality_override}"
+      end
+    end
+
+    private
+
+    def srcset
+      @client ||= mock_signed_client.to_srcset(w: 100, h: 100)
+    end
+  end
+
+  class SrcsetGivenAspectRatio < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_generates_width_pairs
+      expected_number_of_pairs = 31
+      assert_equal expected_number_of_pairs, srcset.split(',').length
+    end
+
+    def test_srcset_pair_values
+      srclist = srcset.split(',').map do |srcset_split|
+        srcset_split.split(' ')[1].to_i
+      end
+
+      for i in 0..srclist.length - 1
+        assert_equal(srclist[i], RESOLUTIONS[i])
+      end
+    end
+
+    def test_srcset_within_bounds
+      min, *max = srcset.split(',')
+
+      # parse out the width descriptor as an integer
+      min = min.split(' ')[1].to_i
+      max = max[max.length - 1].split(' ')[1].to_i
+
+      assert_operator min, :>=, 100
+      assert_operator max, :<=, 8192
+    end
+
+    # a 17% testing threshold is used to account for rounding
+    def test_srcset_iterates_17_percent
+      increment_allowed = 0.17
+
+      # create an array of widths
+      widths = srcset.split(',').map do |src|
+        src.split(' ')[1].to_i
+      end
+
+      prev = widths[0]
+
+      for i in 1..widths.length - 1
+        element = widths[i]
+        assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
+        prev = element
+      end
+    end
+
+    def test_srcset_signs_urls
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        expected_signature = get_expected_signature(src)
+
+        assert_includes src, expected_signature
+      end
+    end
+
+    private
+
+    def srcset
+      @client ||= mock_signed_client.to_srcset(ar: '3:2')
+    end
+  end
+
+  class SrcsetGivenAspectRatioAndHeight < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_in_dpr_form
+      device_pixel_ratio = 1
+
+      srcset.split(',').map do |src|
+        ratio = src.split(' ')[1]
+        assert_equal "#{device_pixel_ratio}x", ratio
+        device_pixel_ratio += 1
+      end
+    end
+
+    def test_srcset_has_dpr_params
+      i = 1
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        assert_includes src, "dpr=#{i}"
+        i += 1
+      end
+    end
+
+    def test_srcset_signs_urls
+      srcset.split(',').map do |srcset_split|
+        src = srcset_split.split(' ')[0]
+        expected_signature = get_expected_signature(src)
+
+        assert_includes src, expected_signature
+      end
+    end
+
+    def test_srcset_has_variable_qualities
+      i = 0
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{DPR_QUALITY[i]}"
+        i += 1
+      end
+    end
+
+    def test_srcset_respects_overriding_quality
+      quality_override = 100
+      srcset = mock_signed_client.to_srcset(
+        w: 100, ar: '3:2', q: quality_override
+      )
+
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{quality_override}"
+      end
+    end
+
+    def test_disable_variable_quality
+      srcset = mock_signed_client.to_srcset(
+        w: 100, ar: '3:2',
+        options: { disable_variable_quality: true }
+      )
+
+      srcset.split(',').map do |src|
+        assert(not(src.include?('q=')))
+      end
+    end
+
+    def test_respects_quality_param_when_disabled
+      quality_override = 100
+      srcset = mock_signed_client.to_srcset(
+        w: 100, h: 100, q: 100,
+        options: { disable_variable_quality: true }
+      )
+
+      srcset.split(',').map do |src|
+        assert_includes src, "q=#{quality_override}"
+      end
+    end
+
+    private
+
+    def srcset
+      @client ||= mock_signed_client.to_srcset({ h: 100, ar: '3:2' })
+    end
+  end
+
+  class SrcsetWidthTolerance < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_generates_width_pairs
+      expected_number_of_pairs = 15
+      assert_equal expected_number_of_pairs, srcset.split(',').length
+    end
+
+    def test_srcset_pair_values
+      resolutions = [100, 140, 196, 274, 384,
+                     538, 753, 1054, 1476, 2066,
+                     2893, 4050, 5669, 7937, 8192]
+
+      srclist = srcset.split(',').map do |srcset_split|
+        srcset_split.split(' ')[1].to_i
+      end
+
+      for i in 0..srclist.length - 1
+        assert_equal(srclist[i], resolutions[i])
+      end
+    end
+
+    def test_srcset_within_bounds
+      min, *max = srcset.split(',')
+
+      # parse out the width descriptor as an integer
+      min = min.split(' ')[1].to_i
+      max = max[max.length - 1].split(' ')[1].to_i
+      assert_operator min, :>=, 100
+      assert_operator max, :<=, 8192
+    end
+
+    # a 41% testing threshold is used to account for rounding
+    def test_srcset_iterates_41_percent
+      increment_allowed = 0.41
+
+      # create an array of widths
+      widths = srcset.split(',').map do |src|
+        src.split(' ')[1].to_i
+      end
+
+      prev = widths[0]
+
+      for i in 1..widths.length - 1
+        element = widths[i]
+        assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
+        prev = element
+      end
+    end
+
+    def test_invalid_tolerance_emits_error
+      assert_raises(ArgumentError) do
+        mock_client.to_srcset(options: { width_tolerance: 'abc' })
+      end
+    end
+
+    def test_negative_tolerance_emits_error
+      assert_raises(ArgumentError) do
+        mock_client.to_srcset(options: { width_tolerance: -0.10 })
+      end
+    end
+
+    def test_with_param_after
+      srcset = mock_signed_client.to_srcset(
+        options: { width_tolerance: 0.20 },
+        h: 1000, fit: 'clip'
+      )
+
+      assert_includes(srcset, 'h=')
+      assert(not(srcset.include?('width_tolerance=')))
+    end
+
+    def test_with_param_before
+      srcset = mock_signed_client.to_srcset(
+        h: 1000, fit: 'clip',
+        options: { width_tolerance: 0.20 }
+      )
+
+      assert_includes(srcset, 'h=')
+      assert(not(srcset.include?('width_tolerance=')))
+    end
+
+    private
+
+    def srcset
+      @client ||= mock_signed_client.to_srcset(
+        options: { width_tolerance: 0.20 }
+      )
+    end
+  end
+
+  class SrcsetCustomWidths < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_generates_width_pairs
+      expected_number_of_pairs = 4
+      assert_equal expected_number_of_pairs, srcset.split(',').length
+    end
+
+    def test_srcset_pair_values
+      resolutions = [100, 500, 1000, 1800]
+      srclist = srcset.split(',').map do |srcset_split|
+        srcset_split.split(' ')[1].to_i
+      end
+
+      for i in 0..srclist.length - 1
+        assert_equal(srclist[i], resolutions[i])
+      end
+    end
+
+    def test_srcset_within_bounds
+      min, *max = srcset.split(',')
+
+      # parse out the width descriptor as an integer
+      min = min.split(' ')[1].to_i
+      max = max[max.length - 1].split(' ')[1].to_i
+
+      assert_operator min, :>=, @widths[0]
+      assert_operator max, :<=, @widths[-1]
+    end
+
+    def test_invalid_widths_input_emits_error
+      assert_raises(ArgumentError) do
+        mock_client.to_srcset(options: { widths: 'abc' })
+      end
+    end
+
+    def test_non_integer_array_emits_error
+      assert_raises(ArgumentError) do
+        mock_client.to_srcset(options: { widths: [100, 200, false] })
+      end
+    end
+
+    def test_negative_integer_array_emits_error
+      assert_raises(ArgumentError) do
+        mock_client.to_srcset(options: { widths: [100, 200, -100] })
+      end
+    end
+
+    def test_with_param_after
+      srcset = mock_signed_client.to_srcset(
+        options: { widths: [100, 200, 300] },
+        h: 1000, fit: 'clip'
+      )
+
+      assert_includes(srcset, 'h=')
+      assert(not(srcset.include?('widths=')))
+    end
+
+    def test_with_param_before
+      srcset = mock_client.to_srcset(
+        h: 1000, fit: 'clip',
+        options: { widths: [100, 200, 300] }
+      )
+      assert_includes(srcset, 'h=')
+      assert(not(srcset.include?('widths=')))
+    end
+
+    private
+
+    def srcset
+      @widths = [100, 500, 1000, 1800]
+      @client ||= mock_signed_client.to_srcset(options: { widths: @widths })
+    end
+  end
+
+  class SrcsetMinMaxWidths < Imgix::Test
+    include SrcsetTest
+
+    def test_srcset_generates_width_pairs
+      expected_number_of_pairs = 11
+      assert_equal expected_number_of_pairs, srcset.split(',').length
+    end
+
+    def test_srcset_pair_values
+      resolutions = [500, 580, 673, 780, 905, 1050,
+        1218, 1413, 1639, 1901, 2000]
+      srclist = srcset.split(',').map do |srcset_split|
+        srcset_split.split(' ')[1].to_i
+      end
+
+      for i in 0..srclist.length - 1
+        assert_equal(srclist[i], resolutions[i])
+      end
+    end
+
+    def test_srcset_within_bounds
+      min, *max = srcset.split(',')
+
+      # parse out the width descriptor as an integer
+      min = min.split(' ')[1].to_i
+      max = max[max.length - 1].split(' ')[1].to_i
+
+      assert_operator min, :>=, @MIN
+      assert_operator max, :<=, @MAX
+    end
+
+    # a 41% testing threshold is used to account for rounding
+    def test_with_custom_width_tolerance
+      srcset = mock_client.to_srcset(
+        options: { min_width: 500, max_width: 2000, width_tolerance: 0.20 }
+      )
+
+      increment_allowed = 0.41
+
+      # create an array of widths
+      widths = srcset.split(',').map do |src|
+        src.split(' ')[1].to_i
+      end
+
+      prev = widths[0]
+
+      for i in 1..widths.length - 1
+        element = widths[i]
+        assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
+        prev = element
+      end
+    end
+
+    def test_invalid_min_emits_error
+      assert_raises(ArgumentError) do
+        mock_client.to_srcset(options: { min_width: 'abc' })
+      end
+    end
+
+    def test_negative_max_emits_error
+      assert_raises(ArgumentError) do
+        mock_client.to_srcset(options: { max_width: -100 })
+      end
+    end
+
+    def test_with_param_after
+      srcset = mock_client.to_srcset(
+        options: { min_width: 500, max_width: 2000 },
+        h: 1000, fit: 'clip'
+      )
+
+      assert_includes(srcset, 'h=')
+      assert(not(srcset.include?('min_width=')))
+      assert(not(srcset.include?('max_width=')))
+    end
+
+    def test_with_param_before
+      srcset = mock_client.to_srcset(
+        h: 1000, fit: 'clip',
+        options: { min_width: 500, max_width: 2000 }
+      )
+
+      assert_includes(srcset, 'h=')
+      assert(not(srcset.include?('min_width=')))
+      assert(not(srcset.include?('max_width=')))
+    end
+
+    def test_only_min
+      min_width = 1000
+      max_width = 8192
+      srcset = mock_client.to_srcset(options: { min_width: min_width })
+
+      min, *max = srcset.split(',')
+
+      # parse out the width descriptor as an integer
+      min = min.split(' ')[1].to_i
+      max = max[max.length - 1].split(' ')[1].to_i
+
+      assert_operator min, :>=, min_width
+      assert_operator max, :<=, max_width
+    end
+
+    def test_only_max
+      min_width = 100
+      max_width = 1000
+      srcset = mock_client.to_srcset(options: { max_width: max_width })
+      min, *max = srcset.split(',')
+
+      # parse out the width descriptor as an integer
+      min = min.split(' ')[1].to_i
+      max = max[max.length - 1].split(' ')[1].to_i
+
+      assert_operator min, :>=, min_width
+      assert_operator max, :<=, max_width
+    end
+
+    def test_max_as_100
+      srcset = mock_client.to_srcset(options: { max_width: 100 })
+      assert_equal(srcset, 'https://testing.imgix.net/image.jpg?w=100 100w')
+    end
+
+    def test_min_as_8192
+      srcset = mock_client.to_srcset(options: { min_width: 8192 })
+      assert_equal(srcset, 'https://testing.imgix.net/image.jpg?w=8192 8192w')
+    end
+
+    private
 
-    class SrcsetDefault < Imgix::Test
-        def test_no_parameters
-            srcset = path.to_srcset()
-            expected_number_of_pairs = 31
-            assert_equal expected_number_of_pairs, srcset.split(',').length
-        end
-
-        def test_srcset_pair_values
-            resolutions = [100, 116, 134, 156, 182, 210, 244, 282,
-                328, 380, 442, 512, 594, 688, 798, 926,
-                1074, 1246, 1446, 1678, 1946, 2258, 2618,
-                3038, 3524, 4088, 4742, 5500, 6380, 7400, 8192]
-            srcset = path.to_srcset()
-            srclist = srcset.split(',').map { |srcset_split|
-                srcset_split.split(' ')[1].to_i
-            }
-
-            for i in 0..srclist.length - 1 do
-                assert_equal(srclist[i], resolutions[i])
-            end
-        end
-
-        private
-            def path
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg')
-            end
-    end
-
-    class SrcsetGivenWidth < Imgix::Test
-        def test_srcset_in_dpr_form
-            device_pixel_ratio = 1
-
-            srcset.split(',').map { |src|
-                ratio = src.split(' ')[1]
-                assert_equal ("#{device_pixel_ratio}x"), ratio
-                device_pixel_ratio += 1
-            }
-        end
-
-        def test_srcset_has_dpr_params
-            i = 1
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, "dpr=#{i}"
-                i += 1
-            }
-        end
-
-        def test_srcset_signs_urls
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, 's='
-
-                # parses out all parameters except for 's=...'
-                params = src[src.index('?')..src.index('s=') - 2]
-
-                # parses out the 's=...' parameter
-                generated_signature = src.slice(src.index('s=') + 2, src.length)
-
-                signature_base = 'MYT0KEN' + '/image.jpg' + params;
-                expected_signature = Digest::MD5.hexdigest(signature_base)
-                
-                assert_equal expected_signature, generated_signature
-            }
-        end
-
-        def test_srcset_has_variable_qualities
-            i = 0
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{DPR_QUALITY[i]}"
-                i += 1
-            }
-        end
-
-        def test_srcset_respects_overriding_quality
-            quality_override = 100
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, q:quality_override)
-
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{quality_override}"
-            }
-        end
-
-        def test_disable_variable_quality
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, options: { disable_variable_quality: true })
-
-            srcset.split(',').map { |src|
-                assert(not(src.include? "q="))
-            }
-        end
-
-        def test_respects_quality_param_when_disabled
-            quality_override = 100
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, q:100, options: { disable_variable_quality: true })
-
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{quality_override}"
-            }
-        end
-
-        private
-            DPR_QUALITY = [75, 50, 35, 23, 20]
-
-            def srcset
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100)
-            end
-    end
-
-    class SrcsetGivenHeight < Imgix::Test
-        def test_srcset_generates_width_pairs
-            expected_number_of_pairs = 31
-            assert_equal expected_number_of_pairs, srcset.split(',').length
-        end
-
-        def test_srcset_pair_values
-            resolutions = [100, 116, 134, 156, 182, 210, 244, 282,
-                328, 380, 442, 512, 594, 688, 798, 926,
-                1074, 1246, 1446, 1678, 1946, 2258, 2618,
-                3038, 3524, 4088, 4742, 5500, 6380, 7400, 8192]
-            srclist = srcset.split(',').map { |srcset_split|
-                srcset_split.split(' ')[1].to_i
-            }
-
-            for i in 0..srclist.length - 1 do
-                assert_equal(srclist[i], resolutions[i])
-            end
-        end
-
-        def test_srcset_respects_height_parameter
-            srcset.split(',').map { |src|
-                assert_includes src, 'h='
-            }
-        end
-
-        def test_srcset_within_bounds
-            min, *max = srcset.split(',')
-
-            # parse out the width descriptor as an integer
-            min = min.split(' ')[1].to_i
-            max = max[max.length - 1].split(' ')[1].to_i
-
-            assert_operator min, :>=, 100
-            assert_operator max, :<=, 8192
-        end
-
-        # a 17% testing threshold is used to account for rounding
-        def test_srcset_iterates_17_percent
-            increment_allowed = 0.17
-
-            # create an array of widths
-            widths = srcset.split(',').map { |src|
-                src.split(' ')[1].to_i
-            }
-
-            prev = widths[0]
-
-            for i in 1..widths.length - 1 do
-                element = widths[i]
-                assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
-                prev = element
-            end
-        end
-
-        def test_srcset_signs_urls
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, 's='
-
-                # parses out all parameters except for 's=...'
-                params = src[src.index('?')..src.index('s=') - 2]
-
-                # parses out the 's=...' parameter
-                generated_signature = src.slice(src.index('s=') + 2, src.length)
-
-                signature_base = 'MYT0KEN' + '/image.jpg' + params;
-                expected_signature = Digest::MD5.hexdigest(signature_base)
-                
-                assert_equal expected_signature, generated_signature
-            }
-        end
-
-        private
-            def srcset
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(h:100)
-            end
-    end
-
-    class SrcsetGivenWidthAndHeight < Imgix::Test
-        def test_srcset_in_dpr_form
-            device_pixel_ratio = 1
-            srcset.split(',').map { |src|
-                ratio = src.split(' ')[1]
-                assert_equal ("#{device_pixel_ratio}x"), ratio
-                device_pixel_ratio += 1
-            }
-        end
-
-        def test_srcset_has_dpr_params
-            i = 1
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, "dpr=#{i}"
-                i += 1
-            }
-        end
-
-        def test_srcset_signs_urls
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, 's='
-
-                # parses out all parameters except for 's=...'
-                params = src[src.index('?')..src.index('s=') - 2]
-
-                # parses out the 's=...' parameter
-                generated_signature = src.slice(src.index('s=') + 2, src.length)
-
-                signature_base = 'MYT0KEN' + '/image.jpg' + params;
-                expected_signature = Digest::MD5.hexdigest(signature_base)
-
-                assert_equal expected_signature, generated_signature
-            }
-        end
-
-        def test_srcset_has_variable_qualities
-            i = 0
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{DPR_QUALITY[i]}"
-                i += 1
-            }
-        end
-
-        def test_srcset_respects_overriding_quality
-            quality_override = 100
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, h:100, q:quality_override)
-
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{quality_override}"
-            }
-        end
-
-        def test_disable_variable_quality
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, h:100, options: { disable_variable_quality: true })
-
-            srcset.split(',').map { |src|
-                assert(not(src.include? "q="))
-            }
-        end
-
-        def test_respects_quality_param_when_disabled
-            quality_override = 100
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, h:100, q:100, options: { disable_variable_quality: true })
-
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{quality_override}"
-            }
-        end
-
-        private
-            DPR_QUALITY = [75, 50, 35, 23, 20]
-
-            def srcset
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100,h:100)
-            end
-    end
-
-    class SrcsetGivenAspectRatio < Imgix::Test
-        def test_srcset_generates_width_pairs
-            expected_number_of_pairs = 31
-            assert_equal expected_number_of_pairs, srcset.split(',').length
-        end
-
-        def test_srcset_pair_values
-            resolutions = [100, 116, 134, 156, 182, 210, 244, 282,
-                328, 380, 442, 512, 594, 688, 798, 926,
-                1074, 1246, 1446, 1678, 1946, 2258, 2618,
-                3038, 3524, 4088, 4742, 5500, 6380, 7400, 8192]
-            srclist = srcset.split(',').map { |srcset_split|
-                srcset_split.split(' ')[1].to_i
-            }
-
-            for i in 0..srclist.length - 1 do
-                assert_equal(srclist[i], resolutions[i])
-            end
-        end
-
-        def test_srcset_within_bounds
-            min, *max = srcset.split(',')
-
-            # parse out the width descriptor as an integer
-            min = min.split(' ')[1].to_i
-            max = max[max.length - 1].split(' ')[1].to_i
-
-            assert_operator min, :>=, 100
-            assert_operator max, :<=, 8192
-        end
-
-        # a 17% testing threshold is used to account for rounding
-        def test_srcset_iterates_17_percent
-            increment_allowed = 0.17
-
-            # create an array of widths
-            widths = srcset.split(',').map { |src|
-                src.split(' ')[1].to_i
-            }
-
-            prev = widths[0]
-
-            for i in 1..widths.length - 1 do
-                element = widths[i]
-                assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
-                prev = element
-            end
-        end
-
-        def test_srcset_signs_urls
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, 's='
-
-                # parses out all parameters except for 's=...'
-                params = src[src.index('?')..src.index('s=') - 2]
-
-                # parses out the 's=...' parameter
-                generated_signature = src.slice(src.index('s=') + 2, src.length)
-
-                signature_base = 'MYT0KEN' + '/image.jpg' + params;
-                expected_signature = Digest::MD5.hexdigest(signature_base)
-                
-                assert_equal expected_signature, generated_signature
-            }
-        end
-
-        private
-            def srcset
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(ar:'3:2')
-            end
-    end
-
-    class SrcsetGivenAspectRatioAndHeight < Imgix::Test
-        def test_srcset_in_dpr_form
-            device_pixel_ratio = 1
-
-            srcset.split(',').map { |src|
-                ratio = src.split(' ')[1]
-                assert_equal ("#{device_pixel_ratio}x"), ratio
-                device_pixel_ratio += 1
-            }
-        end
-
-        def test_srcset_has_dpr_params
-            i = 1
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, "dpr=#{i}"
-                i += 1
-            }
-        end
-
-        def test_srcset_signs_urls
-            srcset.split(',').map { |srcset_split|
-                src = srcset_split.split(' ')[0]
-                assert_includes src, 's='
-
-                # parses out all parameters except for 's=...'
-                params = src[src.index('?')..src.index('s=') - 2]
-
-                # parses out the 's=...' parameter
-                generated_signature = src.slice(src.index('s=') + 2, src.length)
-
-                signature_base = 'MYT0KEN' + '/image.jpg' + params;
-                expected_signature = Digest::MD5.hexdigest(signature_base)
-
-                assert_equal expected_signature, generated_signature
-            }
-        end
-
-        def test_srcset_has_variable_qualities
-            i = 0
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{DPR_QUALITY[i]}"
-                i += 1
-            }
-        end
-
-        def test_srcset_respects_overriding_quality
-            quality_override = 100
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, ar:'3:2', q:quality_override)
-
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{quality_override}"
-            }
-        end
-
-        def test_disable_variable_quality
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, ar:'3:2', options: { disable_variable_quality: true })
-
-            srcset.split(',').map { |src|
-                assert(not(src.include? "q="))
-            }
-        end
-
-        def test_respects_quality_param_when_disabled
-            quality_override = 100
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(w:100, h:100, q:100, options: { disable_variable_quality: true })
-
-            srcset.split(',').map { |src|
-                assert_includes src, "q=#{quality_override}"
-            }
-        end
-
-        private
-            DPR_QUALITY = [75, 50, 35, 23, 20]
-
-            def srcset
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset({h:100,ar:'3:2'})
-            end
-    end
-
-    class SrcsetWidthTolerance < Imgix::Test
-        def test_srcset_generates_width_pairs
-            expected_number_of_pairs = 15
-            assert_equal expected_number_of_pairs, srcset.split(',').length
-        end
-
-        def test_srcset_pair_values
-            resolutions = [100,140,196,274,384,538,752,1054,1476,2066,2892,4050,5670,7938,8192]
-            srclist = srcset.split(',').map { |srcset_split|
-                srcset_split.split(' ')[1].to_i
-            }
-
-            for i in 0..srclist.length - 1 do
-                assert_equal(srclist[i], resolutions[i])
-            end
-        end
-
-        def test_srcset_within_bounds
-            min, *max = srcset.split(',')
-
-            # parse out the width descriptor as an integer
-            min = min.split(' ')[1].to_i
-            max = max[max.length - 1].split(' ')[1].to_i
-            assert_operator min, :>=, 100
-            assert_operator max, :<=, 8192
-        end
-
-        # a 41% testing threshold is used to account for rounding
-        def test_srcset_iterates_41_percent
-            increment_allowed = 0.41
-
-            # create an array of widths
-            widths = srcset.split(',').map { |src|
-                src.split(' ')[1].to_i
-            }
-
-            prev = widths[0]
-
-            for i in 1..widths.length - 1 do
-                element = widths[i]
-                assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
-                prev = element
-            end
-        end
-
-        def test_invalid_tolerance_emits_error
-            assert_raises(ArgumentError) {
-                Imgix::Client.new(host: 'testing.imgix.net')
-                .path('image.jpg')
-                .to_srcset(options: {width_tolerance: 'abc'})
-            }
-        end
-
-        def test_negative_tolerance_emits_error
-            assert_raises(ArgumentError) {
-                Imgix::Client.new(host: 'testing.imgix.net')
-                .path('image.jpg')
-                .to_srcset(options: {width_tolerance: -0.10})
-            }
-        end
-
-        def test_with_param_after
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false)
-            .path('image.jpg')
-            .to_srcset(options: {width_tolerance: 0.20}, h:1000, fit:"clip")
-            assert_includes(srcset, "h=")
-            assert(not(srcset.include? "width_tolerance="))
-        end
-
-        def test_with_param_before
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false)
-            .path('image.jpg')
-            .to_srcset(h:1000, fit:"clip", options: {width_tolerance: 0.20})
-            assert_includes(srcset, "h=")
-            assert(not(srcset.include? "width_tolerance="))
-        end
-
-        private
-            def srcset
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(options: {width_tolerance: 0.20})
-            end
-    end
-
-    class SrcsetCustomWidths < Imgix::Test
-        def test_srcset_generates_width_pairs
-            expected_number_of_pairs = 4
-            assert_equal expected_number_of_pairs, srcset.split(',').length
-        end
-
-        def test_srcset_pair_values
-            resolutions = [100, 500, 1000, 1800]
-            srclist = srcset.split(',').map { |srcset_split|
-                srcset_split.split(' ')[1].to_i
-            }
-
-            for i in 0..srclist.length - 1 do
-                assert_equal(srclist[i], resolutions[i])
-            end
-        end
-
-        def test_srcset_within_bounds
-            min, *max = srcset.split(',')
-
-            # parse out the width descriptor as an integer
-            min = min.split(' ')[1].to_i
-            max = max[max.length - 1].split(' ')[1].to_i
-
-            assert_operator min, :>=, @widths[0]
-            assert_operator max, :<=, @widths[-1]
-        end
-
-        def test_invalid_widths_input_emits_error
-            assert_raises(ArgumentError) {
-                Imgix::Client.new(host: 'testing.imgix.net')
-                .path('image.jpg')
-                .to_srcset(options: {widths: 'abc'})
-            }
-        end
-
-        def test_non_integer_array_emits_error
-            assert_raises(ArgumentError) {
-                Imgix::Client.new(host: 'testing.imgix.net')
-                .path('image.jpg')
-                .to_srcset(options: {widths: [100, 200, false]})
-            }
-        end
-
-        def test_negative_integer_array_emits_error
-            assert_raises(ArgumentError) {
-                Imgix::Client.new(host: 'testing.imgix.net')
-                .path('image.jpg')
-                .to_srcset(options: {widths: [100, 200, -100]})
-            }
-        end
-
-        def test_with_param_after
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false)
-            .path('image.jpg')
-            .to_srcset(options: {widths: [100, 200, 300]}, h:1000, fit:"clip")
-            assert_includes(srcset, "h=")
-            assert(not(srcset.include? "widths="))
-        end
-
-        def test_with_param_before
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false)
-            .path('image.jpg')
-            .to_srcset(h:1000, fit:"clip", options: {widths: [100, 200, 300]})
-            assert_includes(srcset, "h=")
-            assert(not(srcset.include? "widths="))
-        end
-
-        private
-            def srcset
-                @widths = [100, 500, 1000, 1800]
-                @client ||= Imgix::Client.new(
-                    host: 'testing.imgix.net',
-                    include_library_param: false)
-                    .path('image.jpg')
-                    .to_srcset(options: {widths: @widths})
-            end
-    end
-
-    class SrcsetMinMaxWidths < Imgix::Test
-        def test_srcset_generates_width_pairs
-            expected_number_of_pairs = 11
-            assert_equal expected_number_of_pairs, srcset.split(',').length
-        end
-
-        def test_srcset_pair_values
-            resolutions = [500,580,672,780,906,1050,1218,1414,1640,1902,2000]
-            srclist = srcset.split(',').map { |srcset_split|
-                srcset_split.split(' ')[1].to_i
-            }
-
-            for i in 0..srclist.length - 1 do
-                assert_equal(srclist[i], resolutions[i])
-            end
-        end
-
-        def test_srcset_within_bounds
-            min, *max = srcset.split(',')
-
-            # parse out the width descriptor as an integer
-            min = min.split(' ')[1].to_i
-            max = max[max.length - 1].split(' ')[1].to_i
-
-            assert_operator min, :>=, @MIN
-            assert_operator max, :<=, @MAX
-        end
-
-        # a 41% testing threshold is used to account for rounding
-        def test_with_custom_width_tolerance
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', secure_url_token: 'MYT0KEN', include_library_param: false).path('image.jpg').to_srcset(options: {min_width: 500, max_width: 2000, width_tolerance: 0.20})
-
-            increment_allowed = 0.41
-
-            # create an array of widths
-            widths = srcset.split(',').map { |src|
-                src.split(' ')[1].to_i
-            }
-
-            prev = widths[0]
-
-            for i in 1..widths.length - 1 do
-                element = widths[i]
-                assert_operator (element.to_f / prev.to_f), :<, (1 + increment_allowed)
-                prev = element
-            end
-        end
-
-        def test_invalid_min_emits_error
-            assert_raises(ArgumentError) {
-                Imgix::Client.new(host: 'testing.imgix.net')
-                .path('image.jpg')
-                .to_srcset(options: {min_width: 'abc'})
-            }
-        end
-
-        def test_negative_max_emits_error
-            assert_raises(ArgumentError) {
-                Imgix::Client.new(host: 'testing.imgix.net')
-                .path('image.jpg')
-                .to_srcset(options: {max_width: -100})
-            }
-        end
-
-        def test_with_param_after
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', include_library_param: false)
-            .path('image.jpg')
-            .to_srcset(options: {min_width: 500, max_width:2000}, h:1000, fit:"clip")
-
-            assert_includes(srcset, "h=")
-            assert(not(srcset.include? "min_width="))
-            assert(not(srcset.include? "max_width="))
-        end
-
-        def test_with_param_before
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', include_library_param: false)
-            .path('image.jpg')
-            .to_srcset(h:1000, fit:"clip", options: {min_width: 500, max_width:2000})
-
-            assert_includes(srcset, "h=")
-            assert(not(srcset.include? "min_width="))
-            assert(not(srcset.include? "max_width="))
-        end
-
-        def test_only_min
-            min_width = 1000
-            max_width = 8192
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', include_library_param: false).path('image.jpg').to_srcset(options: {min_width: min_width})
-
-            min, *max = srcset.split(',')
-
-            # parse out the width descriptor as an integer
-            min = min.split(' ')[1].to_i
-            max = max[max.length - 1].split(' ')[1].to_i
-
-            assert_operator min, :>=, min_width
-            assert_operator max, :<=, max_width
-        end
-
-        def test_only_max
-            min_width = 100
-            max_width = 1000
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', include_library_param: false).path('image.jpg').to_srcset(options: {max_width: max_width})
-            min, *max = srcset.split(',')
-
-            # parse out the width descriptor as an integer
-            min = min.split(' ')[1].to_i
-            max = max[max.length - 1].split(' ')[1].to_i
-
-            assert_operator min, :>=, min_width
-            assert_operator max, :<=, max_width
-        end
-
-        def test_max_as_100
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', include_library_param: false).path('image.jpg').to_srcset(options: {max_width: 100})
-            assert_equal(srcset, "https://testing.imgix.net/image.jpg?w=100 100w")
-        end
-
-        def test_min_as_8192
-            srcset = Imgix::Client.new(host: 'testing.imgix.net', include_library_param: false).path('image.jpg').to_srcset(options: {min_width: 8192})
-            assert_equal(srcset, "https://testing.imgix.net/image.jpg?w=8192 8192w")
-        end
-
-        private
-            def srcset
-                @MIN = 500
-                @MAX = 2000
-                @client ||= Imgix::Client.new(host: 'testing.imgix.net', include_library_param: false).path('image.jpg').to_srcset(options: {min_width: @MIN, max_width: @MAX})
-            end
+    def srcset
+      @MIN = 500
+      @MAX = 2000
+      @client ||= mock_client.to_srcset(
+        options: { min_width: @MIN, max_width: @MAX }
+      )
     end
+  end
 end