shopify_api 4.9.0 → 9.4.1

data/test/message_enricher_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class MessageEnricherTest < Test::Unit::TestCase
+  def test_enriches_initial_message_when_body_contains_error
+    response = enriched_response(422, 'InitialMessage', { error: 'My Error' })
+
+    assert_equal('InitialMessage (My Error)', response.message)
+  end
+
+  def test_enriches_initial_message_when_body_contains_errors_array
+    response = enriched_response(422, 'InitialMessage', { errors: ['My Error1', 'My Error2'] })
+
+    assert_equal('InitialMessage (My Error1; My Error2)', response.message)
+  end
+
+  def test_enriches_initial_message_when_body_contains_errors_single_value
+    response = enriched_response(422, 'InitialMessage', { errors: 'My Error1' })
+
+    assert_equal('InitialMessage (My Error1)', response.message)
+  end
+
+  def test_returns_initial_message_when_code_is_200
+    response = enriched_response(200, 'InitialMessage', { result: 'Success' })
+
+    assert_equal('InitialMessage', response.message)
+  end
+
+  def test_returns_initial_message_when_body_cant_be_parsed
+    response = enriched_response(422, 'InitialMessage', 'not a json')
+
+    assert_equal('InitialMessage', response.message)
+  end
+
+  private
+
+  def enriched_response(code, message, body)
+    mock_response =
+      Struct
+        .new(:code, :message, :body)
+        .new(code.to_s, message.to_s, body.to_json)
+
+    ShopifyAPI::MessageEnricher.new(mock_response)
+  end
+end

data/test/meta_test.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class ApiVersionTest < Test::Unit::TestCase
+  test ".admin_versions returns array of api versions for admin" do
+    versions = [
+      {
+        "handle": "2019-01",
+        "display_name": "2019-01",
+        "supported": true,
+        "latest_supported": false,
+      },
+      {
+        "handle": "2019-04",
+        "latest_supported": false,
+        "display_name": "2019-04",
+        "supported": true,
+      },
+      {
+        "handle": "2019-07",
+        "latest_supported": false,
+        "display_name": "2019-07",
+        "supported": true,
+      },
+      {
+        "handle": "2019-10",
+        "latest_supported": false,
+        "display_name": "2019-10",
+        "supported": true,
+      },
+      {
+        "handle": "2020-01",
+        "latest_supported": true,
+        "display_name": "2020-01 (Latest)",
+        "supported": true,
+      },
+      {
+        "handle": "unstable",
+        "latest_supported": false,
+        "display_name": "unstable",
+        "supported": false,
+      },
+    ].to_json
+
+    assert_equal versions, ShopifyAPI::Meta.admin_versions.to_json
+  end
+end

data/test/metafield_test.rb

@@ -1,46 +1,56 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class MetafieldTest < Test::Unit::TestCase
   def test_get_metafields
-    fake "metafields", :method => :get, :body => load_fixture('metafields')
-    metafields = ShopifyAPI::Metafield.find(:all)
+    fake("metafields", method: :get, body: load_fixture('metafields'))
+    ShopifyAPI::Metafield.find(:all)
   end
 
   def test_get_metafield
-    fake "metafields/721389482", :method => :get, :body => load_fixture('metafield')
-    assert ShopifyAPI::Metafield.find(721389482)
+    fake("metafields/721389482", method: :get, body: load_fixture('metafield'))
+    assert(ShopifyAPI::Metafield.find(721389482))
   end
 
   def test_get_metafield_of_a_blog
-    fake "blogs/1008414260/metafields/721389482", :method => :get, :body => load_fixture('metafield')
-    metafield = ShopifyAPI::Metafield.find(721389482, :params => {:resource => "blogs", :resource_id => 1008414260})
-    assert_equal 1008414260, metafield.prefix_options[:resource_id]
+    fake("blogs/1008414260/metafields/721389482", method: :get, body: load_fixture('metafield'))
+    metafield = ShopifyAPI::Metafield.find(721389482, params: { resource: "blogs", resource_id: 1008414260 })
+    assert_equal(1008414260, metafield.prefix_options[:resource_id])
   end
 
   def test_create_metafield_for_a_blog
-    fake "blogs/1008414260", :method => :get, :body => load_fixture('blog')
-    fake "blogs/1008414260/metafields", :method => :post, :status => 201, :body => load_fixture('metafield')
+    fake("blogs/1008414260", method: :get, body: load_fixture('blog'))
+    fake("blogs/1008414260/metafields", method: :post, status: 201, body: load_fixture('metafield'))
 
     blog = ShopifyAPI::Blog.find(1008414260)
-    metafield = blog.add_metafield(ShopifyAPI::Metafield.new(:namespace => "summaries", :key => "First Summary", :value => "Make commerce better", :value_type => "string"))
-
-    assert_equal ActiveSupport::JSON.decode('{"metafield":{"namespace":"summaries","key":"First Summary","value":"Make commerce better","value_type":"string"}}'), ActiveSupport::JSON.decode(FakeWeb.last_request.body)
-    assert !metafield.new_record?
+    metafield = blog.add_metafield(
+      ShopifyAPI::Metafield.new(
+        namespace: "summaries", key: "First Summary", value: "Make commerce better", value_type: "string"
+      )
+    )
+
+    assert_equal(
+      ActiveSupport::JSON.decode(
+        '{"metafield":{"namespace":"summaries","key":"First Summary",' \
+          '"value":"Make commerce better","value_type":"string"}}'
+      ),
+      ActiveSupport::JSON.decode(WebMock.last_request.body)
+    )
+    assert(!metafield.new_record?)
   end
 
   def test_update_metafield
-    fake "metafields/721389482", :method => :get, :body => load_fixture('metafield')
-    fake "metafields/721389482", :method => :put, :status => 200, :body => load_fixture('metafield')
+    fake("metafields/721389482", method: :get, body: load_fixture('metafield'))
+    fake("metafields/721389482", method: :put, status: 200, body: load_fixture('metafield'))
     metafield = ShopifyAPI::Metafield.find(721389482)
     metafield.namespace = "teaser"
-    assert metafield.save
+    assert(metafield.save)
   end
 
   def test_delete_metafield
-    fake "metafields/721389482", :method => :get, :body => load_fixture('metafield')
-    fake "metafields/721389482", :method => :delete, :body => 'destroyed'
+    fake("metafields/721389482", method: :get, body: load_fixture('metafield'))
+    fake("metafields/721389482", method: :delete, body: 'destroyed')
     metafield = ShopifyAPI::Metafield.find(721389482)
-    assert metafield.destroy
+    assert(metafield.destroy)
   end
 end
-

data/test/order_risk_test.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class OrderRiskTest < Test::Unit::TestCase
   def test_create_order_risk
-    fake "orders/450789469/risks", :method => :post, :body => load_fixture('order_risk')
-    v = ShopifyAPI::OrderRisk.new(:order_id => 450789469)
+    fake("orders/450789469/risks", method: :post, body: load_fixture('order_risk'))
+    v = ShopifyAPI::OrderRisk.new(order_id: 450789469)
     v.message = "This order was placed from a proxy IP"
     v.recommendation = "cancel"
     v.score = "1.0"
@@ -13,33 +14,33 @@ class OrderRiskTest < Test::Unit::TestCase
     v.cause_cancel = true
     v.save
 
-    assert_equal 284138680, v.id
+    assert_equal(284138680, v.id)
   end
 
   def test_get_order_risks
-    fake "orders/450789469/risks", :method => :get, :body => load_fixture('order_risks')
-    v = ShopifyAPI::OrderRisk.find(:all, :params => {:order_id => 450789469})
-    assert_equal 2, v.size
+    fake("orders/450789469/risks", method: :get, body: load_fixture('order_risks'))
+    v = ShopifyAPI::OrderRisk.find(:all, params: { order_id: 450789469 })
+    assert_equal(2, v.size)
   end
 
   def test_get_order_risk
-    fake "orders/450789469/risks/284138680", :method => :get, :body => load_fixture('order_risk')
-    v = ShopifyAPI::OrderRisk.find(284138680, :params => {:order_id => 450789469})
-    assert_equal 284138680, v.id
+    fake("orders/450789469/risks/284138680", method: :get, body: load_fixture('order_risk'))
+    v = ShopifyAPI::OrderRisk.find(284138680, params: { order_id: 450789469 })
+    assert_equal(284138680, v.id)
   end
 
   def test_delete_order_risk
-    fake "orders/450789469/risks/284138680", :method => :get, :body => load_fixture('order_risk')
-    fake "orders/450789469/risks/284138680", :method => :delete, :body => "destroyed"
-    v = ShopifyAPI::OrderRisk.find(284138680, :params => {:order_id => 450789469})
-    assert v.destroy
+    fake("orders/450789469/risks/284138680", method: :get, body: load_fixture('order_risk'))
+    fake("orders/450789469/risks/284138680", method: :delete, body: "destroyed")
+    v = ShopifyAPI::OrderRisk.find(284138680, params: { order_id: 450789469 })
+    assert(v.destroy)
   end
 
   def test_update_order_risk
-    fake "orders/450789469/risks/284138680", :method => :get, :body => load_fixture('order_risk')
-    fake "orders/450789469/risks/284138680", :method => :put, :body => load_fixture('order_risk')
+    fake("orders/450789469/risks/284138680", method: :get, body: load_fixture('order_risk'))
+    fake("orders/450789469/risks/284138680", method: :put, body: load_fixture('order_risk'))
 
-    v = ShopifyAPI::OrderRisk.find(284138680, :params => {:order_id => 450789469})
+    v = ShopifyAPI::OrderRisk.find(284138680, params: { order_id: 450789469 })
     v.position = 3
     v.save
   end

data/test/order_test.rb

@@ -1,47 +1,140 @@
+# frozen_string_literal: true
 require 'test_helper'
+require 'fulfillment_order_test_helper'
 
 class OrderTest < Test::Unit::TestCase
+  include FulfillmentOrderTestHelper
 
   test "create should create order" do
-    fake 'orders', :method => :post, :status => 201, :body => load_fixture('order')
-    order = ShopifyAPI::Order.create(line_items: [{quantity:1, variant_id:39072856}], financial_status:"authorized")
-    assert_equal 39072856, order.line_items.first.variant_id
+    fake('orders', method: :post, status: 201, body: load_fixture('order'))
+    order = ShopifyAPI::Order.create(
+      line_items: [{ quantity: 1, variant_id: 39072856 }],
+      financial_status: "authorized"
+    )
+    assert_equal(39072856, order.line_items.first.variant_id)
+  end
+
+  test "create should create an order with custom properties" do
+    props = [
+      {
+        "By default may label with \"Roasted for ": {
+          "Your First Name": {
+            "\". If you want something specific on the label, enter it here:": "",
+          },
+        },
+      },
+    ]
+    fake('orders', method: :post, status: 201, body: load_fixture('order_with_properties'))
+    order = ShopifyAPI::Order.create(
+      line_items: [{ quantity: 1, variant_id: 39072856, properties: props }],
+      financial_status: "authorized"
+    )
+    assert_equal(39072856, order.line_items.first.variant_id)
   end
 
   test "get should get an order" do
-    fake 'orders/450789469', :method => :get, :status => 200, :body => load_fixture('order')
+    fake('orders/450789469', method: :get, status: 200, body: load_fixture('order'))
+    order = ShopifyAPI::Order.find(450789469)
+    assert_equal(450789469, order.id)
+  end
+
+  test "get should get an order with custom properties" do
+    fake('orders/450789469', method: :get, status: 200, body: load_fixture('order_with_properties'))
     order = ShopifyAPI::Order.find(450789469)
-    assert_equal 450789469, order.id
+    assert_equal(450789469, order.id)
   end
 
   test "get all should get all orders" do
-    fake 'orders', :method => :get, :status => 200, :body => load_fixture('orders')
+    fake('orders', method: :get, status: 200, body: load_fixture('orders'))
     order = ShopifyAPI::Order.all
-    assert_equal 450789469, order.first.id
+    assert_equal(450789469, order.first.id)
   end
 
   test "add note should add a note to order" do
-    fake 'orders/450789469', :method => :get, :status => 200, :body => load_fixture('order')
+    fake('orders/450789469', method: :get, status: 200, body: load_fixture('order'))
     order = ShopifyAPI::Order.find(450789469)
     order.note = "Test note"
-    fake 'orders/450789469', :method => :put, :status => 200, :body => load_fixture('order')
+    fake('orders/450789469', method: :put, status: 200, body: load_fixture('order'))
     order.save
-    assert_equal "Test note", order.note
+    assert_equal("Test note", order.note)
   end
 
   test "delete should delete an order" do
-    fake 'orders/450789469', :method => :get, :status => 200, :body => load_fixture('order')
-    fake 'orders/450789469', :method => :delete, :body => 'destroyed'
+    fake('orders/450789469', method: :get, status: 200, body: load_fixture('order'))
+    fake('orders/450789469', method: :delete, body: 'destroyed')
     order = ShopifyAPI::Order.find(450789469)
-    assert order.destroy
+    assert(order.destroy)
   end
 
   test "cancel an order with params" do
-    fake 'orders/450789469', :method => :get, :status => 200, :body => load_fixture('order')
-    fake 'orders/450789469/cancel', :method => :post, :body => load_fixture('order')
+    fake('orders/450789469', method: :get, status: 200, body: load_fixture('order'))
+    fake('orders/450789469/cancel', method: :post, body: load_fixture('order'))
     order = ShopifyAPI::Order.find(450789469)
     order.cancel(email: false, restock: true)
-    assert_request_body({'email' => false, 'restock' => true}.to_json)
+    assert_request_body({ 'email' => false, 'restock' => true }.to_json)
+  end
+
+  test "capture an order with currency param" do
+    fake('orders/450789469', body: load_fixture('order'))
+    order = ShopifyAPI::Order.find(450789469)
+
+    fake('orders/450789469/transactions', method: :post, status: 201, body: load_fixture('transaction'))
+    order.capture(100.00, currency: 'CAD')
+
+    assert_request_body({
+      transaction: {
+        amount: 100.00,
+        kind: 'capture',
+        currency: 'CAD',
+      },
+    }.to_json)
   end
-end
 
+  test "fulfillment_orders should get fulfillment orders for an order with 2020-01 version" do
+    url_prefix = url_prefix_for_activated_session_for('2020-01')
+
+    fake(
+      'orders',
+      url: "#{url_prefix}/orders/450789469.json",
+      method: :get,
+      status: 200,
+      body: load_fixture('order'),
+      extension: false
+    )
+    order = ShopifyAPI::Order.find(450789469)
+
+    fake(
+      'orders',
+      url: "#{url_prefix}/orders/450789469/fulfillment_orders.json",
+      method: :get,
+      status: 200,
+      body: load_fixture('fulfillment_orders'),
+      extension: false
+    )
+    fulfillment_orders = order.fulfillment_orders
+
+    assert_equal([519788021, 519788022], fulfillment_orders.map(&:id).sort)
+    fulfillment_orders.each do |fulfillment_order|
+      assert(fulfillment_order.is_a?(ShopifyAPI::FulfillmentOrder))
+      assert_equal(450789469, fulfillment_order.order_id)
+    end
+  end
+
+  test "fulfillment_orders raises NotImplementedError when api_version is older than 2020-01" do
+    url_prefix = url_prefix_for_activated_session_for('2019-10')
+
+    fake(
+      'orders',
+      url: "#{url_prefix}/orders/450789469.json",
+      method: :get,
+      status: 200,
+      body: load_fixture('order'),
+      extension: false
+    )
+    order = ShopifyAPI::Order.find(450789469)
+
+    assert_raises(NotImplementedError) do
+      order.fulfillment_orders
+    end
+  end
+end

data/test/pagination_test.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @version = ShopifyAPI::ApiVersion.find_version('2019-10')
+    ShopifyAPI::Base.api_version = @version.to_s
+    @next_page_info = "eyJkaXJlY3Rpb24iOiJuZXh0IiwibGFzdF9pZCI6NDQwMDg5NDIzLCJsYXN0X3ZhbHVlIjoiNDQwMDg5NDIzIn0%3D"
+    @previous_page_info = "eyJsYXN0X2lkIjoxMDg4MjgzMDksImxhc3RfdmFsdWUiOiIxMDg4MjgzMDkiLCJkaXJlY3Rpb24iOiJuZXh0In0%3D"
+
+    @next_link_header = "<https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+      "orders.json?page_info=#{@next_page_info}>; rel=\"next\""
+    @previous_link_header = "<https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+      "orders.json?page_info=#{@previous_page_info}>; rel=\"previous\""
+  end
+
+  test "navigates using next and previous link headers with no original params" do
+    link_header = "#{@previous_link_header}, #{@next_link_header}"
+
+    fake('orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'), link: link_header)
+    orders = ShopifyAPI::Order.all
+
+    fake(
+      'orders',
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/orders.json?page_info=#{@next_page_info}",
+      method: :get,
+      status: 200,
+      body: load_fixture('orders')
+    )
+    next_page = orders.fetch_next_page
+    assert_equal(450789469, next_page.first.id)
+
+    fake(
+      'orders',
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/orders.json?page_info=#{@previous_page_info}",
+      method: :get,
+      status: 200,
+      body: load_fixture('orders').gsub("450789469", "1122334455")
+    )
+
+    previous_page = orders.fetch_previous_page
+    assert_equal(1122334455, previous_page.first.id)
+  end
+
+  test "uses all passed in querystring parameters" do
+    params = "page_info=#{@next_page_info}&limit=50&fields=#{CGI.escape('id,created_at')}"
+    @next_link_header = "<https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+      "orders.json?#{params}>; rel=\"next\""
+    fake(
+      'orders',
+      method: :get,
+      status: 200,
+      api_version: @version,
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/orders.json?fields=id%2Cupdated_at&limit=100",
+      body: load_fixture('orders'),
+      link: @next_link_header
+    )
+    orders = ShopifyAPI::Order.where(fields: 'id,updated_at', limit: 100)
+
+    fake(
+      'orders',
+      method: :get,
+      status: 200,
+      api_version: @version,
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+        "orders.json?fields=id%2Ccreated_at&limit=50&page_info=#{@next_page_info}",
+      body: load_fixture('orders')
+    )
+    next_page = orders.fetch_next_page
+    assert_equal(450789469, next_page.first.id)
+  end
+
+  test "returns empty next page if just the previous page is present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version,
+      body: load_fixture('orders'), link: @previous_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    next_page = orders.fetch_next_page
+    assert_empty(next_page)
+  end
+
+  test "returns an empty previous page if just the next page is present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'), link: @next_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    next_page = orders.fetch_previous_page
+    assert_empty(next_page)
+  end
+
+  test "#next_page? returns true if next page is present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'), link: @next_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    assert(orders.next_page?)
+  end
+
+  test "#next_page? returns false if next page is not present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version,
+      body: load_fixture('orders'), link: @previous_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    refute(orders.next_page?)
+  end
+
+  test "#next_page_info returns next_page_info if next page is present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'), link: @next_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    assert_equal(@next_page_info, orders.next_page_info)
+  end
+
+  test "#next_page_info returns nil if next page is not present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version,
+      body: load_fixture('orders'), link: @previous_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    assert_nil(orders.next_page_info)
+  end
+
+  test "#previous_page? returns true if previous page is present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version,
+      body: load_fixture('orders'), link: @previous_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    assert(orders.previous_page?)
+  end
+
+  test "#previous_page? returns false if next page is not present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'), link: @next_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    refute(orders.previous_page?)
+  end
+
+  test "#previous_page_info returns previous_page_info if next page is present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version,
+      body: load_fixture('orders'), link: @previous_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    assert_equal(@previous_page_info, orders.previous_page_info)
+  end
+
+  test "#previous_page_info returns nil if next page is not present" do
+    fake(
+      'orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'), link: @next_link_header
+    )
+    orders = ShopifyAPI::Order.all
+
+    assert_nil(orders.previous_page_info)
+  end
+
+  test "pagination handles no link headers" do
+    fake('orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'))
+    orders = ShopifyAPI::Order.all
+
+    refute(orders.next_page?)
+    refute(orders.previous_page?)
+    assert_empty(orders.fetch_next_page)
+    assert_empty(orders.fetch_previous_page)
+  end
+
+  test "raises on invalid pagination links" do
+    link_header = "<https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+      "orders.json?page_info=#{@next_page_info}>;"
+    fake('orders', method: :get, status: 200, api_version: @version, body: load_fixture('orders'), link: link_header)
+
+    assert_raises(ShopifyAPI::InvalidPaginationLinksError) do
+      ShopifyAPI::Order.all
+    end
+  end
+
+  test "raises on an older API version" do
+    version = ShopifyAPI::ApiVersion.find_version('2019-04')
+    ShopifyAPI::Base.api_version = version.to_s
+
+    fake('orders', method: :get, status: 200, api_version: version, body: load_fixture('orders'))
+    orders = ShopifyAPI::Order.all
+
+    assert_raises(NotImplementedError) do
+      orders.fetch_next_page
+    end
+  end
+
+  test "raises on 2019-07 API version for models that don't support new pagination yet" do
+    version = ShopifyAPI::ApiVersion.find_version('2019-07')
+    ShopifyAPI::Base.api_version = version.to_s
+
+    fake('orders', method: :get, status: 200, api_version: version, body: load_fixture('orders'))
+    orders = ShopifyAPI::Order.all
+
+    assert_raises(NotImplementedError) do
+      orders.fetch_next_page
+    end
+  end
+
+  test "new pagination works on 2019-07 API version for select models" do
+    version = ShopifyAPI::ApiVersion.find_version('2019-07')
+    ShopifyAPI::Base.api_version = version.to_s
+
+    fake('events', method: :get, status: 200, api_version: version, body: load_fixture('events'))
+    events = ShopifyAPI::Event.all
+
+    assert_empty(events.fetch_next_page)
+    assert_empty(events.fetch_previous_page)
+  end
+
+  test "does not raise on the unstable version" do
+    version = ShopifyAPI::ApiVersion.find_version('unstable')
+    ShopifyAPI::Base.api_version = version.to_s
+    @next_link_header = "<https://this-is-my-test-shop.myshopify.com/admin/api/unstable/" \
+      "orders.json?page_info=#{@next_page_info}>; rel=\"next\""
+
+    link_header = "#{@previous_link_header}, #{@next_link_header}"
+
+    fake('orders', method: :get, status: 200, api_version: version, body: load_fixture('orders'), link: link_header)
+    orders = ShopifyAPI::Order.all
+
+    fake(
+      'orders',
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/unstable/orders.json?page_info=#{@next_page_info}",
+      method: :get,
+      status: 200,
+      body: load_fixture('orders')
+    )
+    assert_nothing_raised do
+      next_page = orders.fetch_next_page
+      assert_equal(450789469, next_page.first.id)
+    end
+  end
+
+  test "allows for multiple concurrent API collection objects" do
+    first_request_params = "page_info=#{@next_page_info}&limit=5"
+    fake(
+      'orders',
+      method: :get,
+      status: 200,
+      api_version: @version,
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/orders.json?limit=5",
+      body: load_fixture('orders'),
+      link: "<https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+        "orders.json?#{first_request_params}>; rel=\"next\""
+    )
+    ShopifyAPI::Order.where(limit: 5)
+
+    second_request_params = "page_info=#{@next_page_info}&limit=5"
+    fake(
+      'orders',
+      method: :get,
+      status: 200,
+      api_version: @version,
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/orders.json?limit=10",
+      body: load_fixture('orders'),
+      link: "<https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+        "orders.json?#{second_request_params}>; rel=\"next\""
+    )
+    orders = ShopifyAPI::Order.where(limit: 10)
+
+    fake(
+      'orders',
+      method: :get,
+      status: 200,
+      api_version: @version,
+      url: "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/" \
+        "orders.json?limit=5&page_info=#{@next_page_info}",
+      body: load_fixture('orders')
+    )
+    next_page = orders.fetch_next_page
+    assert_equal(450789469, next_page.first.id)
+  end
+end