shopify_api 9.0.2 → 9.3.0

data/test/shipping_zone_test.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class ShippingZoneTest < Test::Unit::TestCase
   test "get all should get all shipping zones" do
-    fake 'shipping_zones', :method => :get, :status => 200, :body => load_fixture('shipping_zones')
+    fake('shipping_zones', method: :get, status: 200, body: load_fixture('shipping_zones'))
     checkout = ShopifyAPI::ShippingZone.all
-    assert_equal 1, checkout.first.id
-    assert_equal "Canada", checkout.first.name
+    assert_equal(1, checkout.first.id)
+    assert_equal("Canada", checkout.first.name)
   end
 end

data/test/shop_test.rb

@@ -1,68 +1,82 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class ShopTest < Test::Unit::TestCase
   def setup
     super
-    fake "shop"
+    fake("shop")
     @shop = ShopifyAPI::Shop.current
   end
 
   def test_current_should_return_current_shop
-    assert @shop.is_a?(ShopifyAPI::Shop)
-    assert_equal "Apple Computers", @shop.name
-    assert_equal "apple.myshopify.com", @shop.myshopify_domain
-    assert_equal 690933842, @shop.id
-    assert_equal "2007-12-31T19:00:00-05:00", @shop.created_at
-    assert_nil @shop.tax_shipping
+    assert(@shop.is_a?(ShopifyAPI::Shop))
+    assert_equal("Apple Computers", @shop.name)
+    assert_equal("apple.myshopify.com", @shop.myshopify_domain)
+    assert_equal(690933842, @shop.id)
+    assert_equal("2007-12-31T19:00:00-05:00", @shop.created_at)
+    assert_nil(@shop.tax_shipping)
   end
 
   def test_current_with_options_should_return_current_shop
-    fake "shop.json?fields%5B%5D=name&fields%5B%5D=myshopify_domain", :extension => false, :method => :get, :status => 201, :body => load_fixture('shop')
-
-    @shop = ShopifyAPI::Shop.current(params: { fields: [:name, :myshopify_domain]})
-    assert @shop.is_a?(ShopifyAPI::Shop)
-    assert_equal "Apple Computers", @shop.name
-    assert_equal "apple.myshopify.com", @shop.myshopify_domain
+    fake(
+      "shop.json?fields%5B%5D=name&fields%5B%5D=myshopify_domain",
+      extension: false,
+      method: :get,
+      status: 201,
+      body: load_fixture('shop')
+    )
+
+    @shop = ShopifyAPI::Shop.current(params: { fields: [:name, :myshopify_domain] })
+    assert(@shop.is_a?(ShopifyAPI::Shop))
+    assert_equal("Apple Computers", @shop.name)
+    assert_equal("apple.myshopify.com", @shop.myshopify_domain)
   end
 
   def test_get_all_metafields_for_shop
-    fake "metafields"
+    fake("metafields")
 
     metafields = @shop.metafields
 
-    assert_equal 3, metafields.length
-    assert metafields.all?{|m| m.is_a?(ShopifyAPI::Metafield)}
+    assert_equal(3, metafields.length)
+    assert(metafields.all? { |m| m.is_a?(ShopifyAPI::Metafield) })
   end
 
   def test_get_2_metafields_for_shop
-    body = ActiveSupport::JSON.decode load_fixture 'metafields'
-    body['metafields'].slice! 2, 1
+    body = ActiveSupport::JSON.decode(load_fixture('metafields'))
+    body['metafields'].slice!(2, 1)
 
-    fake 'metafields.json?limit=2', body: body.to_json, extension: false
+    fake('metafields.json?limit=2', body: body.to_json, extension: false)
 
-    metafields = @shop.metafields limit: 2
+    metafields = @shop.metafields(limit: 2)
 
-    assert_equal 2, metafields.length
-    assert metafields.all?{ |m| m.is_a? ShopifyAPI::Metafield }
+    assert_equal(2, metafields.length)
+    assert(metafields.all? { |m| m.is_a?(ShopifyAPI::Metafield) })
   end
 
   def test_add_metafield
-    fake "metafields", :method => :post, :status => 201, :body =>load_fixture('metafield')
-
-    field = @shop.add_metafield(ShopifyAPI::Metafield.new(:namespace => "contact", :key => "email", :value => "123@example.com", :value_type => "string"))
-    assert_equal ActiveSupport::JSON.decode('{"metafield":{"namespace":"contact","key":"email","value":"123@example.com","value_type":"string"}}'), ActiveSupport::JSON.decode(WebMock.last_request.body)
-    assert !field.new_record?
-    assert_equal "contact", field.namespace
-    assert_equal "email", field.key
-    assert_equal "123@example.com", field.value
+    fake("metafields", method: :post, status: 201, body: load_fixture('metafield'))
+
+    field = @shop.add_metafield(
+      ShopifyAPI::Metafield.new(namespace: "contact", key: "email", value: "123@example.com", value_type: "string")
+    )
+    assert_equal(
+      ActiveSupport::JSON.decode(
+        '{"metafield":{"namespace":"contact","key":"email","value":"123@example.com","value_type":"string"}}'
+      ),
+      ActiveSupport::JSON.decode(WebMock.last_request.body)
+    )
+    assert(!field.new_record?)
+    assert_equal("contact", field.namespace)
+    assert_equal("email", field.key)
+    assert_equal("123@example.com", field.value)
   end
 
   def test_events
-    fake "events"
+    fake("events")
 
     events = @shop.events
 
-    assert_equal 3, events.length
-    assert events.all?{|m| m.is_a?(ShopifyAPI::Event)}
+    assert_equal(3, events.length)
+    assert(events.all? { |m| m.is_a?(ShopifyAPI::Event) })
   end
 end

data/test/smart_collection_test.rb

@@ -1,35 +1,11 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class SmartCollectionTest < Test::Unit::TestCase
   test "Smart Collection creation" do
-    fake "smart_collections", :method => :post, :status => 201, :body => load_fixture('smart_collection')
-    rules = { :column => "title", :relation => "starts_with", :condition => "mac" }
-    smart_collection = ShopifyAPI::SmartCollection.create(:title => "Macbooks", :rules => rules)
-    assert_equal 1063001432, smart_collection.id
-  end
-
-  test "Smart Collection get products gets all products in a smart collection" do
-    fake "smart_collections/1063001432", method: :get, status: 200, body: load_fixture('smart_collection')
-    smart_collection = ShopifyAPI::SmartCollection.find(1063001432)
-
-    fake "products.json?collection_id=1063001432",
-      method: :get,
-      status: 200,
-      body:
-      load_fixture('smart_collection_products'),
-      extension: false
-    assert_equal [632910392, 921728736], smart_collection.products.map(&:id)
-  end
-
-  test "Smart Collection get products with only_sorted=only_manual gets only manually sorted products" do
-    fake "smart_collections/1063001432", method: :get, status: 200, body: load_fixture('smart_collection')
-    smart_collection = ShopifyAPI::SmartCollection.find(1063001432)
-
-    fake "smart_collections/1063001432/products.json?only_sorted=only_manual",
-      method: :get,
-      status: 200,
-      body: load_fixture('smart_collection_products'),
-      extension: false
-    assert_equal [632910392, 921728736], smart_collection.products(only_sorted: "only_manual").map(&:id)
+    fake("smart_collections", method: :post, status: 201, body: load_fixture('smart_collection'))
+    rules = { column: "title", relation: "starts_with", condition: "mac" }
+    smart_collection = ShopifyAPI::SmartCollection.create(title: "Macbooks", rules: rules)
+    assert_equal(1063001432, smart_collection.id)
   end
 end

data/test/storefront_access_token_test.rb

@@ -1,32 +1,30 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class StorefrontAccessTokenTest < Test::Unit::TestCase
-
   def test_create_storefront_access_token
-    fake "storefront_access_tokens", :method => :post, :body => load_fixture('storefront_access_token')
+    fake("storefront_access_tokens", method: :post, body: load_fixture('storefront_access_token'))
     storefront_access_token = ShopifyAPI::StorefrontAccessToken.create(title: 'Test')
-    assert_equal 1, storefront_access_token.id
-    assert_equal "Test", storefront_access_token.title
+    assert_equal(1, storefront_access_token.id)
+    assert_equal("Test", storefront_access_token.title)
   end
 
   def test_delete_storefront_access_token
-    fake 'storefront_access_tokens/1', method: :get, status: 200, body: load_fixture('storefront_access_token')
-    fake 'storefront_access_tokens/1', method: :delete, status: 200, body: 'destroyed'
-    
+    fake('storefront_access_tokens/1', method: :get, status: 200, body: load_fixture('storefront_access_token'))
+    fake('storefront_access_tokens/1', method: :delete, status: 200, body: 'destroyed')
     storefront_access_tokens = ShopifyAPI::StorefrontAccessToken.find(1)
-    assert storefront_access_tokens.destroy
+    assert(storefront_access_tokens.destroy)
   end
 
   def test_get_storefront_access_tokens
-    fake "storefront_access_tokens", method: :get, status: 201, body: load_fixture('storefront_access_tokens')
+    fake("storefront_access_tokens", method: :get, status: 201, body: load_fixture('storefront_access_tokens'))
 
     tokens = ShopifyAPI::StorefrontAccessToken.all
 
-    assert_equal 2, tokens.size
-    assert_equal 1, tokens.first.id
-    assert_equal 2, tokens.last.id
-    assert_equal 'Test 1', tokens.first.title
-    assert_equal 'Test 2', tokens.last.title
+    assert_equal(2, tokens.size)
+    assert_equal(1, tokens.first.id)
+    assert_equal(2, tokens.last.id)
+    assert_equal('Test 1', tokens.first.title)
+    assert_equal('Test 2', tokens.last.title)
   end
-
 end

data/test/tax_service_test.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
 require 'test_helper'
 class TaxServiceTest < Test::Unit::TestCase
   test "tax service creation" do
-    fake "tax_services", :method => :post, :status => 202, :body => load_fixture('tax_service')
-    tax_service = ShopifyAPI::TaxService.create(:name => "My Tax Service", :url => "https://mytaxservice.com")
-    assert_equal '{"tax_service":{"name":"My Tax Service","url":"https://mytaxservice.com"}}', WebMock.last_request.body
-
+    fake("tax_services", method: :post, status: 202, body: load_fixture('tax_service'))
+    ShopifyAPI::TaxService.create(name: "My Tax Service", url: "https://mytaxservice.com")
+    assert_equal(
+      '{"tax_service":{"name":"My Tax Service","url":"https://mytaxservice.com"}}',
+      WebMock.last_request.body
+    )
   end
 end

data/test/tender_transaction_test.rb

@@ -5,14 +5,14 @@ require 'test_helper'
 class TenderTransactionTest < Test::Unit::TestCase
   def setup
     super
-    fake "tender_transactions", method: :get, body: load_fixture('tender_transactions')
+    fake("tender_transactions", method: :get, body: load_fixture('tender_transactions'))
   end
 
   context "Tender Transaction" do
     should 'return a list of transactions' do
       tender_transactions = ShopifyAPI::TenderTransaction.all
-      assert_equal 3, tender_transactions.length
-      assert_equal [1, 2, 3], tender_transactions.map(&:id)
+      assert_equal(3, tender_transactions.length)
+      assert_equal([1, 2, 3], tender_transactions.map(&:id))
     end
   end
 end

data/test/test_helper.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 require 'rubygems'
 require 'minitest/autorun'
 require 'webmock/minitest'
 require_relative 'lib/webmock_extensions/last_request'
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'pry'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
@@ -23,7 +24,7 @@ module Test
         self.test("should_#{string}", &block)
       end
 
-      def self.context(string)
+      def self.context(_string)
         yield
       end
 
@@ -34,6 +35,7 @@ module Test
             const = mod.const_get(const)
             const.format = :json if const.respond_to?(:format=)
           rescue NameError
+            # Do nothing
           end
         end
 
@@ -68,7 +70,7 @@ module Test
 
       # Custom Assertions
       def assert_not(expression)
-        refute expression, "Expected <#{expression}> to be false!"
+        refute(expression, "Expected <#{expression}> to be false!")
       end
 
       def assert_nothing_raised
@@ -76,30 +78,30 @@ module Test
       end
 
       def assert_not_includes(array, value)
-        refute array.include?(value)
+        refute(array.include?(value))
       end
 
       def assert_includes(array, value)
-        assert array.include?(value)
+        assert(array.include?(value))
       end
 
-      def load_fixture(name, format=:json)
+      def load_fixture(name, format = :json)
         File.read(File.dirname(__FILE__) + "/fixtures/#{name}.#{format}")
       end
 
       def assert_request_body(expected)
-        assert_equal expected, WebMock.last_request.body
+        assert_equal(expected, WebMock.last_request.body)
       end
 
-      def fake(endpoint, options={})
-        request_body = options.has_key?(:request_body) ? options.delete(:request_body) : nil
-        body   = options.has_key?(:body) ? options.delete(:body) : load_fixture(endpoint)
+      def fake(endpoint, options = {})
+        request_body = options.key?(:request_body) ? options.delete(:request_body) : nil
+        body = options.key?(:body) ? options.delete(:body) : load_fixture(endpoint)
         format = options.delete(:format) || :json
         method = options.delete(:method) || :get
         api_version = options.delete(:api_version) || ShopifyAPI::ApiVersion.find_version('2019-01')
-        extension = ".#{options.delete(:extension)||'json'}" unless options[:extension]==false
+        extension = ".#{options.delete(:extension) || 'json'}" unless options[:extension] == false
         status = options.delete(:status) || 200
-        url = if options.has_key?(:url)
+        url = if options.key?(:url)
           options[:url]
         else
           "https://this-is-my-test-shop.myshopify.com#{api_version.construct_api_path("#{endpoint}#{extension}")}"

data/test/transaction_test.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class TransactionTest < Test::Unit::TestCase
   def setup
     super
-    fake "orders/450789469/transactions/389404469", :method => :get, :body => load_fixture('transaction')
+    fake("orders/450789469/transactions/389404469", method: :get, body: load_fixture('transaction'))
   end
 
   context "Transaction" do
     context "#find" do
       should "find a specific transaction" do
-        transaction = ShopifyAPI::Transaction.find(389404469, :params => {:order_id => 450789469})
-        assert_equal "409.94", transaction.amount
+        transaction = ShopifyAPI::Transaction.find(389404469, params: { order_id: 450789469 })
+        assert_equal("409.94", transaction.amount)
       end
     end
   end

data/test/usage_charge_test.rb

@@ -1,21 +1,25 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class UsageChargeTest < Test::Unit::TestCase
-
   def test_create_usage_charges
-    fake "recurring_application_charges/654381177/usage_charges", method: :post, body: load_fixture('usage_charge')
+    fake("recurring_application_charges/654381177/usage_charges", method: :post, body: load_fixture('usage_charge'))
 
     usage_charge = ShopifyAPI::UsageCharge.new(description: '1000 emails', price: 1.0)
-    usage_charge.prefix_options = {recurring_application_charge_id: 654381177}
-    assert usage_charge.save
+    usage_charge.prefix_options = { recurring_application_charge_id: 654381177 }
+    assert(usage_charge.save)
   end
 
   def test_get_usage_charges
-    fake "recurring_application_charges/654381177/usage_charges/359376002", method: :get, status: 201, body: load_fixture('usage_charge')
+    fake(
+      "recurring_application_charges/654381177/usage_charges/359376002",
+      method: :get,
+      status: 201,
+      body: load_fixture('usage_charge')
+    )
 
-    usage_charge = ShopifyAPI::UsageCharge.find(359376002, params: {recurring_application_charge_id: 654381177})
+    usage_charge = ShopifyAPI::UsageCharge.find(359376002, params: { recurring_application_charge_id: 654381177 })
 
-    assert_equal "1000 emails", usage_charge.description
+    assert_equal("1000 emails", usage_charge.description)
   end
-
 end

data/test/user_test.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class UserTest < Test::Unit::TestCase
   test 'get should get a user' do
     fake 'users/799407056', method: :get, status: 200, body: load_fixture('user')
-    
+
     user = ShopifyAPI::User.find(799407056)
     assert_equal 799407056, user.id
   end
-  
+
   test 'get should get all users' do
     fake 'users', method: :get, status: 200, body: load_fixture('users')
-    
+
     users = ShopifyAPI::User.all
     assert_equal 799407056, users.first.id
   end

data/test/variant_test.rb

@@ -1,46 +1,73 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class VariantTest < Test::Unit::TestCase
+  def setup
+    super
+    refresh_variant
+  end
 
   def test_get_variants
-    fake "products/632910392/variants", :method => :get, :body => load_fixture('variants')
+    fake("products/632910392/variants", method: :get, body: load_fixture('variants'))
 
-    variants = ShopifyAPI::Variant.find(:all, :params => { :product_id => 632910392 })
-    assert_equal variants.map(&:id).sort, [39072856, 49148385, 457924702, 808950810]
+    variants = ShopifyAPI::Variant.find(:all, params: { product_id: 632910392 })
+    assert_equal(variants.map(&:id).sort, [39072856, 49148385, 457924702, 808950810])
   end
 
   def test_get_variant_namespaced
-    fake "products/632910392/variants/808950810", :method => :get, :body => load_fixture('variant')
-
-    v = ShopifyAPI::Variant.find(808950810, :params => {:product_id => 632910392})
-    assert_equal 632910392, v.product_id
+    assert_equal(632910392, @variant.product_id)
   end
 
   def test_get_variant
-    fake "variants/808950810", :method => :get, :body => load_fixture('variant')
-
-    v = ShopifyAPI::Variant.find(808950810)
-    assert_equal 632910392, v.product_id
+    assert_equal(632910392, @variant.product_id)
   end
 
   def test_product_id_should_be_accessible_if_via_product_endpoint
-    fake "products/632910392/variants/808950810", :method => :get, :body => load_fixture('variant')
-
-    v = ShopifyAPI::Variant.find(808950810, :params => {:product_id => 632910392})
-    assert_equal 632910392, v.product_id
+    assert_equal(632910392, @variant.product_id)
   end
 
   def test_product_id_should_be_accessible_if_via_variant_endpoint
-    fake "variants/808950810", :method => :get, :body => load_fixture('variant')
-
-    v = ShopifyAPI::Variant.find(808950810)
-    assert_equal 632910392, v.product_id
+    assert_equal(632910392, @variant.product_id)
   end
 
   def test_delete_variant
-    fake "products/632910392/variants/808950810", :method => :get, :body => load_fixture('variant')
-    fake "products/632910392/variants/808950810", :method => :delete, :body => 'destroyed'
-    v = ShopifyAPI::Variant.find(808950810, :params => {:product_id => 632910392})
-    assert v.destroy
+    fake("products/632910392/variants/808950810", method: :delete, body: 'destroyed')
+    assert(@variant.destroy)
+  end
+
+  def test_read_only_inventory_quantity
+    ShopifyAPI::Base.api_version = '2020-01'
+    refresh_variant(api_version: ShopifyAPI::Base.api_version)
+    assert_equal(10, @variant.inventory_quantity)
+  end
+
+  def test_setting_variant_inventory_quantity_adjustment_fails_in_the_unstable_api
+    ShopifyAPI::Base.api_version = :unstable
+    assert_raises(ShopifyAPI::ValidationException) do
+      @variant.inventory_quantity_adjustment = 8
+    end
+  end
+
+  def test_setting_variant_inventory_quantity_fails_in_the_unstable_api
+    ShopifyAPI::Base.api_version = :unstable
+    assert_raises(ShopifyAPI::ValidationException) do
+      @variant.inventory_quantity = 8
+    end
+  end
+
+  def test_setting_variant_old_inventory_quantity_fails_in_the_unstable_api
+    ShopifyAPI::Base.api_version = :unstable
+    assert_raises(ShopifyAPI::ValidationException) do
+      @variant.old_inventory_quantity = 8
+    end
+  end
+
+  private
+
+  def refresh_variant(api_version: nil)
+    fake(
+      "products/632910392/variants/808950810", method: :get, body: load_fixture('variant'), api_version: api_version
+    )
+    @variant = ShopifyAPI::Variant.find(808950810, params: { product_id: 632910392 })
   end
 end