ruby_shopify_api 1.0.0

data/test/api_version_test.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class ApiVersionTest < Test::Unit::TestCase
+  test "find_version returns any version object given" do
+    version = ShopifyAPI::ApiVersion.new(handle: :unstable)
+    assert_same(version, ShopifyAPI::ApiVersion.find_version(version))
+  end
+
+  test "find_version converts a known version into a version object" do
+    versions = [
+      ShopifyAPI::ApiVersion.new(handle: :unstable),
+      ShopifyAPI::ApiVersion.new(handle: '2019-01'),
+    ]
+
+    assert_equal(versions, [
+      ShopifyAPI::ApiVersion.find_version('unstable'),
+      ShopifyAPI::ApiVersion.find_version('2019-01'),
+    ])
+  end
+
+  test "find_version removes unverified versions from version set if mode is set to :raise_on_unknown" do
+    ShopifyAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert ShopifyAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 6, ShopifyAPI::ApiVersion.versions.size
+
+    ShopifyAPI::ApiVersion.find_version('2019-30')
+    refute ShopifyAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 7, ShopifyAPI::ApiVersion.versions.size
+    ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+
+    assert ShopifyAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 6, ShopifyAPI::ApiVersion.versions.size
+  end
+
+  test "find_version does not raise when coercing a string if no versions are defined when version_lookup_mode is :define_on_unknown" do
+    ShopifyAPI::ApiVersion.clear_known_versions
+    ShopifyAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert_equal :define_on_unknown, ShopifyAPI::ApiVersion.version_lookup_mode
+    assert_nothing_raised do
+      ShopifyAPI::ApiVersion.find_version('made up version')
+    end
+  end
+
+  test "find_version does raise when coercing a string if no versions are defined when version_lookup_mode is :raise_on_unknown" do
+    refute ShopifyAPI::ApiVersion.versions['made up version']
+    ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+    assert_raises(ShopifyAPI::ApiVersion::UnknownVersion) do
+      ShopifyAPI::ApiVersion.find_version('made up version')
+    end
+  end
+
+  test "find_version raises ArgumentError when given an ShopifyAPI::ApiVersion::NullVersion object" do
+    ShopifyAPI::ApiVersion.clear_known_versions
+    ShopifyAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert_equal :define_on_unknown, ShopifyAPI::ApiVersion.version_lookup_mode
+    assert_raises(ArgumentError) do
+      ShopifyAPI::ApiVersion.find_version(ShopifyAPI::ApiVersion::NullVersion)
+    end
+  end
+
+  test 'two versions with the same version number are equal' do
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2018-09')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: '2018-09')
+
+    assert_equal version_2, version_1
+  end
+
+  test 'two versions with the different version numbers are not equal' do
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2019-07')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: '2019-11')
+
+    refute_equal version_2, version_1
+  end
+
+  test 'versions are ordered by version number with unstable always being the newest' do
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2017-11')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: '2019-11')
+    version_3 = ShopifyAPI::ApiVersion.new(handle: '2039-01')
+    version_4 = ShopifyAPI::ApiVersion.new(handle: '2039-02')
+    unstable = ShopifyAPI::ApiVersion.new(handle: :unstable)
+
+    assert_equal([
+      version_1,
+      version_2,
+      version_3,
+      version_4,
+      unstable,
+    ], [
+      version_3,
+      version_1,
+      version_4,
+      unstable,
+      version_2,
+    ].sort)
+  end
+
+  test 'latest_stable_version will return the version that is newest and stable' do
+    assert_equal(
+      ShopifyAPI::ApiVersion.versions,
+      {
+        "2019-01" => ShopifyAPI::ApiVersion.new(handle: '2019-01', supported: true, latest_supported: false),
+        "2019-04" => ShopifyAPI::ApiVersion.new(handle: '2019-04', supported: true, latest_supported: false),
+        "2019-07" => ShopifyAPI::ApiVersion.new(handle: '2019-07', supported: true, latest_supported: false),
+        "2019-10" => ShopifyAPI::ApiVersion.new(handle: '2019-10', supported: false, latest_supported: false),
+        "2020-01" => ShopifyAPI::ApiVersion.new(handle: '2020-01', supported: false, latest_supported: true),
+        "unstable" => ShopifyAPI::ApiVersion.new(handle: 'unstable', supported: false, latest_supported: false),
+      }
+    )
+    silence_warnings do
+      refute_equal(
+        ShopifyAPI::ApiVersion.new(handle: '2019-01'),
+        ShopifyAPI::ApiVersion.latest_stable_version
+      )
+
+      assert_equal(
+        ShopifyAPI::ApiVersion.new(handle: '2020-01'),
+        ShopifyAPI::ApiVersion.latest_stable_version
+      )
+    end
+  end
+
+  test "NullVersion raises ApiVersionNotSetError" do
+    assert_raises(ShopifyAPI::ApiVersion::ApiVersionNotSetError) do
+      ShopifyAPI::ApiVersion::NullVersion.construct_api_path(:string)
+    end
+
+    assert_raises(ShopifyAPI::ApiVersion::ApiVersionNotSetError) do
+      ShopifyAPI::ApiVersion::NullVersion.construct_graphql_path
+    end
+
+    assert_raises(ShopifyAPI::ApiVersion::ApiVersionNotSetError) do
+      ShopifyAPI::ApiVersion::NullVersion.stable?
+    end
+  end
+
+  test "NullVersion cannot be instantiated and raises NoMethodError if attempted" do
+    assert_raises(NoMethodError) do
+      ShopifyAPI::ApiVersion::NullVersion.new
+    end
+  end
+
+  test "handle_to_date converts a version handle to a date" do
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2019-01')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: 'unstable')
+
+    assert_equal(version_1.handle_as_date, Time.utc(2019, 01, 01))
+    assert_equal(version_2.handle_as_date, ShopifyAPI::ApiVersion::UNSTABLE_AS_DATE)
+  end
+
+  class TestApiVersion < ShopifyAPI::ApiVersion
+    def initialize(name)
+      super(name)
+      @version_name = name
+    end
+  end
+end

data/test/application_charge_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class ApplicationChargeTest < Test::Unit::TestCase
+  def test_application_charge_create
+    fake("application_charges", method: :post, status: 201, body: load_fixture('application_charge'))
+
+    charge = ShopifyAPI::ApplicationCharge.create(
+      name: "iPod Cleaning",
+      price: 5.00,
+      return_url: "http://google.com"
+    )
+
+    assert_equal(
+      'https://this-is-my-test-shop.myshopify.com/admin/charges/803742/confirm_application_charge?' \
+        'signature=BAhpA55DDA%3D%3D--55b44e274e438c619be4631c804abcbcb6ee915a',
+      charge.confirmation_url
+    )
+  end
+
+  def test_get_application_charge
+    fake("application_charges/803742", method: :get, status: 201, body: load_fixture('application_charge'))
+
+    charge = ShopifyAPI::ApplicationCharge.find(803742)
+
+    assert_equal("iPod Cleaning", charge.name)
+  end
+
+  def test_list_application_charges
+    fake("application_charges", method: :get, status: 201, body: load_fixture('application_charges'))
+
+    charges = ShopifyAPI::ApplicationCharge.find(:all)
+
+    assert_equal(4, charges.size)
+    assert_equal("iPhone Case", charges.last.name)
+  end
+
+  def test_list_pending_application_charges
+    fake("application_charges", method: :get, status: 201, body: load_fixture('application_charges'))
+
+    pending_charges = ShopifyAPI::ApplicationCharge.pending
+
+    assert_equal(1, pending_charges.size)
+    assert_equal("Screen Replacement", pending_charges.first.name)
+  end
+
+  def test_list_expired_application_charges
+    fake("application_charges", method: :get, status: 201, body: load_fixture('application_charges'))
+
+    expired_charges = ShopifyAPI::ApplicationCharge.expired
+
+    assert_equal(1, expired_charges.size)
+    assert_equal("iPod Cleaning", expired_charges.first.name)
+  end
+
+  def test_list_accepted_application_charges
+    fake("application_charges", method: :get, status: 201, body: load_fixture('application_charges'))
+
+    accepted_charges = ShopifyAPI::ApplicationCharge.accepted
+
+    assert_equal(1, accepted_charges.size)
+    assert_equal("iPhone Case", accepted_charges.first.name)
+  end
+
+  def test_list_declined_application_charges
+    fake("application_charges", method: :get, status: 201, body: load_fixture('application_charges'))
+
+    declined_charges = ShopifyAPI::ApplicationCharge.declined
+
+    assert_equal(1, declined_charges.size)
+    assert_equal("Magic Mouse", declined_charges.first.name)
+  end
+
+  def test_activate_application_charge
+    fake("application_charges", method: :get, status: 201, body: load_fixture('application_charges'))
+    fake("application_charges/803740/activate", method: :post, status: 200, body: "{}")
+
+    charge = ShopifyAPI::ApplicationCharge.accepted
+
+    assert(charge.last.activate)
+  end
+end

data/test/application_credit_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class ApplicationCreditTest < Test::Unit::TestCase
+  def test_application_credit_create
+    fake("application_credits", method: :post, status: 201, body: load_fixture('application_credit'))
+
+    credit = ShopifyAPI::ApplicationCredit.create(
+      description: "refund for application charge",
+      amount: 5.00,
+      api_client_id: 861378,
+      shop_id: 487168
+    )
+
+    assert_equal('refund for application charge', credit.description)
+    assert_equal('5.00', credit.amount)
+  end
+
+  def test_get_application_credit
+    fake("application_credits/803742", method: :get, status: 201, body: load_fixture('application_credit'))
+
+    credit = ShopifyAPI::ApplicationCredit.find(803742)
+
+    assert_equal('refund for application charge', credit.description)
+    assert_equal('5.00', credit.amount)
+  end
+
+  def test_list_application_credits
+    fake("application_credits", method: :get, status: 201, body: load_fixture('application_credits'))
+
+    credit = ShopifyAPI::ApplicationCredit.find(:all)
+
+    assert_equal(2, credit.size)
+    assert_equal('10.00', credit.last.amount)
+  end
+end

data/test/article_test.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class ArticleTest < Test::Unit::TestCase
+  def test_create_article
+    fake("blogs/1008414260/articles", method: :post, body: load_fixture('article'))
+    article = ShopifyAPI::Article.new(blog_id: 1008414260)
+    article.save
+    assert_equal("First Post", article.title)
+  end
+
+  def test_get_article
+    fake("articles/6242736", method: :get, body: load_fixture('article'))
+    article = ShopifyAPI::Article.find(6242736)
+    assert_equal("First Post", article.title)
+    assert_equal(1008414260, article.blog_id)
+  end
+
+  def test_get_articles
+    fake("articles", method: :get, body: load_fixture('articles'))
+    articles = ShopifyAPI::Article.all
+    assert_equal(3, articles.length)
+    assert_equal(1008414260, articles.first.blog_id)
+  end
+
+  def test_get_articles_namespaced
+    fake("blogs/1008414260/articles", method: :get, body: load_fixture('articles'))
+    articles = ShopifyAPI::Article.find(:all, params: { blog_id: 1008414260 })
+    assert_equal(3, articles.length)
+    assert_equal(1008414260, articles.first.blog_id)
+  end
+
+  def test_get_article_namespaced
+    fake("blogs/1008414260/articles/6242736", method: :get, body: load_fixture('article'))
+    article = ShopifyAPI::Article.find(6242736, params: { blog_id: 1008414260 })
+    assert_equal("First Post", article.title)
+    assert_equal(1008414260, article.blog_id)
+  end
+
+  def test_get_authors
+    fake("articles/authors", method: :get, body: load_fixture('authors'))
+    authors = ShopifyAPI::Article.authors
+    assert_equal("Shopify", authors.first)
+    assert_equal("development shop", authors.last)
+  end
+
+  def test_get_authors_for_blog_id
+    fake("blogs/1008414260/articles/authors", method: :get, body: load_fixture('authors'))
+    authors = ShopifyAPI::Article.authors(blog_id: 1008414260)
+    assert_equal(3, authors.length)
+  end
+
+  def test_get_tags
+    fake("articles/tags", method: :get, body: load_fixture('tags'))
+    tags = ShopifyAPI::Article.tags
+    assert_equal("consequuntur", tags.first)
+    assert_equal("repellendus", tags.last)
+  end
+
+  def test_get_tags_for_blog_id
+    fake("blogs/1008414260/articles/tags", method: :get, body: load_fixture('tags'))
+    tags = ShopifyAPI::Article.tags(blog_id: 1008414260)
+    assert_equal("consequuntur", tags.first)
+    assert_equal("repellendus", tags.last)
+  end
+
+  def test_get_popular_tags
+    fake("articles/tags.json?limit=1&popular=1", extension: false, method: :get, body: load_fixture('tags'))
+    tags = ShopifyAPI::Article.tags(popular: 1, limit: 1)
+    assert_equal(3, tags.length)
+  end
+end

data/test/asset_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class AssetTest < Test::Unit::TestCase
+  def test_get_assetss
+    fake("themes/1/assets", method: :get, body: load_fixture('assets'))
+    ShopifyAPI::Asset.find(:all, params: { theme_id: 1 })
+  end
+
+  def test_get_asset_namespaced
+    fake(
+      "themes/1/assets.json?asset%5Bkey%5D=templates%2Findex.liquid&theme_id=1",
+      extension: false,
+      method: :get,
+      body: load_fixture('asset')
+    )
+    ShopifyAPI::Asset.find('templates/index.liquid', params: { theme_id: 1 })
+  end
+
+  def test_get_asset
+    fake(
+      "assets.json?asset%5Bkey%5D=templates%2Findex.liquid", extension: false, method: :get, body: load_fixture('asset')
+    )
+    ShopifyAPI::Asset.find('templates/index.liquid')
+  end
+end

data/test/assigned_fulfillment_order_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'test_helper'
+require 'fulfillment_order_test_helper'
+
+class AssignedFulFillmentOrderTest < Test::Unit::TestCase
+  include FulfillmentOrderTestHelper
+
+  def setup
+    super
+    @url_prefix = url_prefix_for_activated_session_for('2020-01')
+    @fulfillment_order_fixture = load_fixture('assigned_fulfillment_orders')
+  end
+
+  context "AssignedFulfillmentOrder" do
+    context ".new" do
+      should "raise NotImplementedError when api_version is older than 2020-01" do
+        url_prefix_for_activated_session_for('2019-10')
+
+        assert_raises(NotImplementedError) do
+          ShopifyAPI::AssignedFulfillmentOrder.new(ActiveSupport::JSON.decode(@fulfillment_order_fixture))
+        end
+      end
+    end
+
+    context "#all" do
+      should "raise NotImplementedError when api_version is older than 2020-01" do
+        @url_prefix = url_prefix_for_activated_session_for('2019-10')
+
+        fake 'assigned_fulfillment_orders',
+          url: "#{@url_prefix}/assigned_fulfillment_orders.json",
+          method: :get,
+          body: @fulfillment_order_fixture,
+          extension: false
+
+        assert_raises(NotImplementedError) do
+          ShopifyAPI::AssignedFulfillmentOrder.all(params: { assigned_status: 'cancellation_requested' })
+        end
+      end
+
+      should "list assigned fulfillment orders by assigned_status" do
+        fake 'assigned_fulfillment_orders',
+          url: "#{@url_prefix}/assigned_fulfillment_orders.json?assigned_status=cancellation_requested",
+          method: :get,
+          body: @fulfillment_order_fixture,
+          extension: false
+
+        assigned_fulfillment_orders = ShopifyAPI::AssignedFulfillmentOrder.all(
+          params: { assigned_status: 'cancellation_requested' }
+        )
+
+        assert_equal 2, assigned_fulfillment_orders.count
+        assigned_fulfillment_orders.each do |fulfillment_order|
+          assert fulfillment_order.is_a?(ShopifyAPI::FulfillmentOrder)
+          assert_equal 'in_progress', fulfillment_order.status
+          assert_equal 'cancellation_accepted', fulfillment_order.request_status
+        end
+      end
+
+      should "be able to list assigned fulfillment orders by location_ids" do
+        assigned_location_id = 905684977
+        fake 'assigned_fulfillment_orders',
+          url: "#{@url_prefix}/assigned_fulfillment_orders.json?location_ids%5B%5D=#{assigned_location_id}",
+          method: :get,
+          body: @fulfillment_order_fixture, extension: false
+
+        assigned_fulfillment_orders = ShopifyAPI::AssignedFulfillmentOrder.all(
+          params: { location_ids: [assigned_location_id] }
+        )
+
+        assert_equal 2, assigned_fulfillment_orders.count
+        assigned_fulfillment_orders.each do |fulfillment_order|
+          assert fulfillment_order.is_a?(ShopifyAPI::FulfillmentOrder)
+          assert_equal assigned_location_id, fulfillment_order.assigned_location_id
+        end
+      end
+    end
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+require 'test_helper'
+require "active_support/log_subscriber/test_helper"
+
+class BaseTest < Test::Unit::TestCase
+  def setup
+    super
+    @session1 = ShopifyAPI::Session.new(domain: 'shop1.myshopify.com', token: 'token1', api_version: '2019-01')
+    @session2 = ShopifyAPI::Session.new(domain: 'shop2.myshopify.com', token: 'token2', api_version: '2019-01')
+  end
+
+  def teardown
+    super
+    clear_header('X-Custom')
+  end
+
+  test '#activate_session should set site and headers for given session' do
+    ShopifyAPI::Base.activate_session(@session1)
+
+    assert_nil(ActiveResource::Base.site)
+    assert_equal('https://shop1.myshopify.com', ShopifyAPI::Base.site.to_s)
+    assert_equal('https://shop1.myshopify.com', ShopifyAPI::Shop.site.to_s)
+
+    assert_nil(ActiveResource::Base.headers['X-Shopify-Access-Token'])
+    assert_equal('token1', ShopifyAPI::Base.headers['X-Shopify-Access-Token'])
+    assert_equal('token1', ShopifyAPI::Shop.headers['X-Shopify-Access-Token'])
+  end
+
+  test '#clear_session should clear base site settings from Base' do
+    ShopifyAPI::Base.site = "https://foo:bar@www.zombo.com"
+
+    assert_equal("foo", ShopifyAPI::Base.user)
+    assert_equal("bar", ShopifyAPI::Base.password)
+
+    ShopifyAPI::Base.clear_session
+
+    assert_nil(ShopifyAPI::Base.user)
+    assert_nil(ShopifyAPI::Base.password)
+    assert_nil(ShopifyAPI::Base.site)
+  end
+
+  # test to  check session reset api version remains the same after session reset
+  test '#clear_session should not change the api_version' do
+    ShopifyAPI::Base.site = "https://zoo:lion@www.zoo.com"
+
+    assert_equal("zoo", ShopifyAPI::Base.user)
+    assert_equal("lion", ShopifyAPI::Base.password)
+
+    ShopifyAPI::Base.clear_session
+
+    assert_nil(ShopifyAPI::Base.user)
+    assert_nil(ShopifyAPI::Base.password)
+    assert_nil(ShopifyAPI::Base.site)
+    assert_equal(ShopifyAPI::Base.api_version, @session1.api_version)
+  end
+
+  test '#clear_session should clear site and headers from Base' do
+    ShopifyAPI::Base.activate_session(@session1)
+    ShopifyAPI::Base.clear_session
+
+    assert_nil(ActiveResource::Base.site)
+    assert_nil(ShopifyAPI::Base.site)
+    assert_nil(ShopifyAPI::Shop.site)
+
+    assert_nil(ActiveResource::Base.headers['X-Shopify-Access-Token'])
+    assert_nil(ShopifyAPI::Base.headers['X-Shopify-Access-Token'])
+    assert_nil(ShopifyAPI::Shop.headers['X-Shopify-Access-Token'])
+  end
+
+  test '#activate_session with one session, then clearing and activating with another session should send request to correct shop' do
+    ShopifyAPI::Base.activate_session(@session1)
+    ShopifyAPI::Base.clear_session
+    ShopifyAPI::Base.activate_session(@session2)
+
+    assert_nil(ActiveResource::Base.site)
+    assert_equal('https://shop2.myshopify.com', ShopifyAPI::Base.site.to_s)
+    assert_equal('https://shop2.myshopify.com', ShopifyAPI::Shop.site.to_s)
+
+    assert_nil(ActiveResource::Base.headers['X-Shopify-Access-Token'])
+    assert_equal('token2', ShopifyAPI::Base.headers['X-Shopify-Access-Token'])
+    assert_equal('token2', ShopifyAPI::Shop.headers['X-Shopify-Access-Token'])
+  end
+
+  test '#activate_session with nil raises an InvalidSessionError' do
+    assert_raises(ShopifyAPI::Base::InvalidSessionError) do
+      ShopifyAPI::Base.activate_session(nil)
+    end
+  end
+
+  test "#delete should send custom headers with request" do
+    ShopifyAPI::Base.activate_session(@session1)
+    ShopifyAPI::Base.headers['X-Custom'] = 'abc'
+    ShopifyAPI::Base.connection
+      .expects(:delete)
+      .with('/admin/api/2019-01/bases/1.json', has_entry('X-Custom', 'abc'))
+    ShopifyAPI::Base.delete("1")
+  end
+
+  test "#headers includes the User-Agent" do
+    assert_not_includes ActiveResource::Base.headers.keys, 'User-Agent'
+    assert_includes(ShopifyAPI::Base.headers.keys, 'User-Agent')
+    thread = Thread.new do
+      assert_includes(ShopifyAPI::Base.headers.keys, 'User-Agent')
+    end
+    thread.join
+  end
+
+  test "prefix= will forward to resource when the value does not start with admin" do
+    session = ShopifyAPI::Session.new(domain: 'shop1.myshopify.com', token: 'token1', api_version: '2019-01')
+    ShopifyAPI::Base.activate_session(session)
+    silence_warnings do
+      TestResource.prefix = 'a/regular/path/'
+    end
+
+    assert_equal('/admin/api/2019-01/a/regular/path/', TestResource.prefix)
+  end
+
+  test "prefix= will raise an error if value starts with with /admin" do
+    assert_raises(ArgumentError) do
+      TestResource.prefix = '/admin/old/prefix/structure/'
+    end
+  end
+
+  test "#headers propagates changes to subclasses" do
+    ShopifyAPI::Base.headers['X-Custom'] = "the value"
+    assert_equal("the value", ShopifyAPI::Base.headers['X-Custom'])
+    assert_equal("the value", ShopifyAPI::Product.headers['X-Custom'])
+  end
+
+  test "#headers clears changes to subclasses" do
+    ShopifyAPI::Base.headers['X-Custom'] = "the value"
+    assert_equal("the value", ShopifyAPI::Product.headers['X-Custom'])
+    ShopifyAPI::Base.headers['X-Custom'] = nil
+    assert_nil(ShopifyAPI::Product.headers['X-Custom'])
+  end
+
+  test "#headers set in the main thread affect spawned threads" do
+    ShopifyAPI::Base.headers['X-Custom'] = "the value"
+    Thread.new do
+      assert_equal("the value", ShopifyAPI::Base.headers['X-Custom'])
+    end.join
+  end
+
+  test "#headers set in spawned threads do not affect the main thread" do
+    Thread.new do
+      ShopifyAPI::Base.headers['X-Custom'] = "the value"
+    end.join
+    assert_nil(ShopifyAPI::Base.headers['X-Custom'])
+  end
+
+  test "using a different version changes the url" do
+    release_2019_01 = ShopifyAPI::Session.new(domain: 'shop1.myshopify.com', token: 'token1', api_version: '2019-01')
+    unstable_version = ShopifyAPI::Session.new(domain: 'shop2.myshopify.com', token: 'token2', api_version: :unstable)
+
+    fake(
+      "shop",
+      url: "https://shop1.myshopify.com/admin/api/2019-01/shop.json",
+      method: :get,
+      status: 201,
+      body: '{ "shop": { "id": 1 } }'
+    )
+    fake(
+      "shop",
+      url: "https://shop2.myshopify.com/admin/api/unstable/shop.json",
+      method: :get,
+      status: 201,
+      body: '{ "shop": { "id": 2 } }'
+    )
+
+    ShopifyAPI::Base.activate_session(release_2019_01)
+    assert_equal(1, ShopifyAPI::Shop.current.id)
+
+    ShopifyAPI::Base.activate_session(unstable_version)
+    assert_equal(2, ShopifyAPI::Shop.current.id)
+  end
+
+  test "#api_version= should set ApiVersion" do
+    ShopifyAPI::Base.api_version = '2019-04'
+    assert_equal('2019-04', ShopifyAPI::Base.api_version.to_s)
+  end
+
+  test "#api_version= nil should set ApiVersion to ShopifyAPI::ApiVersion::NullVersion" do
+    ShopifyAPI::Base.api_version = nil
+    assert_equal(ShopifyAPI::ApiVersion::NullVersion, ShopifyAPI::Base.api_version)
+  end
+
+  test "#api_version= ShopifyAPI::ApiVersion::NullVersion should set ApiVersion to ShopifyAPI::ApiVersion::NullVersion" do
+    ShopifyAPI::Base.api_version = ShopifyAPI::ApiVersion::NullVersion
+    assert_equal(ShopifyAPI::ApiVersion::NullVersion, ShopifyAPI::Base.api_version)
+  end
+
+  test "#version_validation! does not raise is api_version is newer or equal to minimum supported version" do
+    ShopifyAPI::Base.api_version = '2020-01'
+    assert_nil(ShopifyAPI::Base::version_validation!('2020-01'))
+  end
+
+  test "#version_validation! raises NotImplemetedError if api_version is older than minimum supported version" do
+    ShopifyAPI::Base.api_version = '2019-10'
+    exception = assert_raises(NotImplementedError) do
+      ShopifyAPI::Base::version_validation!('2020-01')
+    end
+    assert_equal('The minimum supported version is 2020-01.', exception.message)
+  end
+
+  def clear_header(header)
+    [ActiveResource::Base, ShopifyAPI::Base, ShopifyAPI::Product].each do |klass|
+      klass.headers.delete(header)
+    end
+  end
+
+  class TestResource < ShopifyAPI::Base
+  end
+end

data/test/blog_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require 'test_helper'
+class BlogTest < Test::Unit::TestCase
+  test "blog creation" do
+    fake("blogs", method: :post, status: 202, body: load_fixture('blog'))
+    ShopifyAPI::Blog.create(title: "Test Blog")
+    assert_equal('{"blog":{"title":"Test Blog"}}', WebMock.last_request.body)
+  end
+end