shopify_api 4.13.0 → 12.2.1

data/test/session_test.rb

@@ -1,250 +0,0 @@
-require 'test_helper'
-require 'timecop'
-
-class SessionTest < Test::Unit::TestCase
-
-  def setup
-    super
-    ShopifyAPI::Session.secret = 'secret'
-  end
-
-  test "not be valid without a url" do
-    session = ShopifyAPI::Session.new(nil, "any-token")
-    assert_not session.valid?
-  end
-
-  test "not be valid without token" do
-    session = ShopifyAPI::Session.new("testshop.myshopify.com")
-    assert_not session.valid?
-  end
-
-  test "be valid with any token and any url" do
-    session = ShopifyAPI::Session.new("testshop.myshopify.com", "any-token")
-    assert session.valid?
-  end
-
-  test "not raise error without params" do
-    assert_nothing_raised do
-      session = ShopifyAPI::Session.new("testshop.myshopify.com", "any-token")
-    end
-  end
-
-  test "ignore everything but the subdomain in the shop" do
-    assert_equal "https://testshop.myshopify.com/admin", ShopifyAPI::Session.new("http://user:pass@testshop.notshopify.net/path", "any-token").site
-  end
-
-  test "append the myshopify domain if not given" do
-    assert_equal "https://testshop.myshopify.com/admin", ShopifyAPI::Session.new("testshop", "any-token").site
-  end
-
-  test "not raise error without params" do
-    assert_nothing_raised do
-      session = ShopifyAPI::Session.new("testshop.myshopify.com", "any-token")
-    end
-  end
-
-  test "raise error if params passed but signature omitted" do
-    assert_raises(ShopifyAPI::ValidationException) do
-      session = ShopifyAPI::Session.new("testshop.myshopify.com")
-      session.request_token({'code' => 'any-code'})
-    end
-  end
-
-  test "setup api_key and secret for all sessions" do
-    ShopifyAPI::Session.setup(:api_key => "My test key", :secret => "My test secret")
-    assert_equal "My test key", ShopifyAPI::Session.api_key
-    assert_equal "My test secret", ShopifyAPI::Session.secret
-  end
-
-  test "use 'https' protocol by default for all sessions" do
-    assert_equal 'https', ShopifyAPI::Session.protocol
-  end
-
-  test "#temp reset ShopifyAPI::Base.site to original value" do
-
-    ShopifyAPI::Session.setup(:api_key => "key", :secret => "secret")
-    session1 = ShopifyAPI::Session.new('fakeshop.myshopify.com', 'token1')
-    ShopifyAPI::Base.activate_session(session1)
-
-    ShopifyAPI::Session.temp("testshop.myshopify.com", "any-token") {
-      @assigned_site = ShopifyAPI::Base.site
-    }
-    assert_equal 'https://testshop.myshopify.com/admin', @assigned_site.to_s
-    assert_equal 'https://fakeshop.myshopify.com/admin', ShopifyAPI::Base.site.to_s
-  end
-
-  test "create_permission_url returns correct url with single scope no redirect uri" do
-    ShopifyAPI::Session.setup(:api_key => "My_test_key", :secret => "My test secret")
-    session = ShopifyAPI::Session.new('http://localhost.myshopify.com')
-    scope = ["write_products"]
-    permission_url = session.create_permission_url(scope)
-    assert_equal "https://localhost.myshopify.com/admin/oauth/authorize?client_id=My_test_key&scope=write_products", permission_url
-  end
-
-  test "create_permission_url returns correct url with single scope and redirect uri" do
-    ShopifyAPI::Session.setup(:api_key => "My_test_key", :secret => "My test secret")
-    session = ShopifyAPI::Session.new('http://localhost.myshopify.com')
-    scope = ["write_products"]
-    permission_url = session.create_permission_url(scope, "http://my_redirect_uri.com")
-    assert_equal "https://localhost.myshopify.com/admin/oauth/authorize?client_id=My_test_key&scope=write_products&redirect_uri=http://my_redirect_uri.com", permission_url
-  end
-
-  test "create_permission_url returns correct url with dual scope no redirect uri" do
-    ShopifyAPI::Session.setup(:api_key => "My_test_key", :secret => "My test secret")
-    session = ShopifyAPI::Session.new('http://localhost.myshopify.com')
-    scope = ["write_products","write_customers"]
-    permission_url = session.create_permission_url(scope)
-    assert_equal "https://localhost.myshopify.com/admin/oauth/authorize?client_id=My_test_key&scope=write_products,write_customers", permission_url
-  end
-
-  test "create_permission_url returns correct url with no scope no redirect uri" do
-    ShopifyAPI::Session.setup(:api_key => "My_test_key", :secret => "My test secret")
-    session = ShopifyAPI::Session.new('http://localhost.myshopify.com')
-    scope = []
-    permission_url = session.create_permission_url(scope)
-    assert_equal "https://localhost.myshopify.com/admin/oauth/authorize?client_id=My_test_key&scope=", permission_url
-  end
-
-  test "raise exception if code invalid in request token" do
-    ShopifyAPI::Session.setup(:api_key => "My test key", :secret => "My test secret")
-    session = ShopifyAPI::Session.new('http://localhost.myshopify.com')
-    fake nil, :url => 'https://localhost.myshopify.com/admin/oauth/access_token',:method => :post, :status => 404, :body => '{"error" : "invalid_request"}'
-    assert_raises(ShopifyAPI::ValidationException) do
-      session.request_token(params={:code => "bad-code"})
-    end
-    assert_equal false, session.valid?
-  end
-
-  test "#temp reset ShopifyAPI::Base.site to original value when using a non-standard port" do
-    ShopifyAPI::Session.setup(:api_key => "key", :secret => "secret")
-    session1 = ShopifyAPI::Session.new('fakeshop.myshopify.com:3000', 'token1')
-    ShopifyAPI::Base.activate_session(session1)
-  end
-
-  test "myshopify_domain supports non-standard ports" do
-    begin
-      ShopifyAPI::Session.setup(:api_key => "key", :secret => "secret", :myshopify_domain => 'localhost', port: '3000')
-      session = ShopifyAPI::Session.new('fakeshop.localhost:3000', 'token1')
-      ShopifyAPI::Base.activate_session(session)
-      assert_equal 'https://fakeshop.localhost:3000/admin', ShopifyAPI::Base.site.to_s
-
-      session = ShopifyAPI::Session.new('fakeshop', 'token1')
-      ShopifyAPI::Base.activate_session(session)
-      assert_equal 'https://fakeshop.localhost:3000/admin', ShopifyAPI::Base.site.to_s
-    ensure
-      ShopifyAPI::Session.myshopify_domain = "myshopify.com"
-      ShopifyAPI::Session.port = nil
-    end
-  end
-
-  test "return site for session" do
-    session = ShopifyAPI::Session.new("testshop.myshopify.com", "any-token")
-    assert_equal "https://testshop.myshopify.com/admin", session.site
-  end
-
-  test "return_token_if_signature_is_valid" do
-    fake nil,
-      url: 'https://testshop.myshopify.com/admin/oauth/access_token',
-      method: :post,
-      body: '{"access_token":"any-token"}'
-    session = ShopifyAPI::Session.new("testshop.myshopify.com")
-
-    params = { code: 'any-code', timestamp: Time.now }
-    token = session.request_token(params.merge(hmac: generate_signature(params)))
-
-    assert_equal "any-token", token
-    assert_equal "any-token", session.token
-  end
-
-  test "extra parameters are stored in session" do
-    fake nil,
-      url: 'https://testshop.myshopify.com/admin/oauth/access_token',
-      method: :post,
-      body: '{"access_token":"any-token","foo":"example"}'
-    session = ShopifyAPI::Session.new("testshop.myshopify.com")
-
-    params = { code: 'any-code', timestamp: Time.now }
-    assert session.request_token(params.merge(hmac: generate_signature(params)))
-
-    assert_equal ({ "foo" => "example" }), session.extra
-  end
-
-  test "expires_in is automatically converted in expires_at" do
-    fake nil,
-      url: 'https://testshop.myshopify.com/admin/oauth/access_token',
-      method: :post,
-      body: '{"access_token":"any-token","expires_in":86393}'
-    session = ShopifyAPI::Session.new("testshop.myshopify.com")
-
-    Timecop.freeze do
-      params = { code: 'any-code', timestamp: Time.now }
-      assert session.request_token(params.merge(hmac: generate_signature(params)))
-
-      expires_at = Time.now.utc + 86393
-      assert_equal ({ "expires_at" => expires_at.to_i }), session.extra
-      assert session.expires_at.is_a?(Time)
-      assert_equal expires_at.to_i, session.expires_at.to_i
-      assert_equal 86393, session.expires_in
-      assert_equal false, session.expired?
-
-      Timecop.travel(session.expires_at) do
-        assert_equal true, session.expired?
-      end
-    end
-  end
-
-  test "raise error if signature does not match expected" do
-    params = {:code => "any-code", :timestamp => Time.now}
-    signature = generate_signature(params)
-    params[:foo] = 'world'
-    assert_raises(ShopifyAPI::ValidationException) do
-      session = ShopifyAPI::Session.new("testshop.myshopify.com")
-      session.request_token(params.merge(:hmac => signature))
-    end
-  end
-
-  test "raise error if timestamp is too old" do
-    params = {:code => "any-code", :timestamp => Time.now - 2.days}
-    signature = generate_signature(params)
-    params[:foo] = 'world'
-    assert_raises(ShopifyAPI::ValidationException) do
-      session = ShopifyAPI::Session.new("testshop.myshopify.com")
-      session.request_token(params.merge(:hmac => signature))
-    end
-  end
-
-  test "return true when the signature is valid and the keys of params are strings" do
-    params = {"code" => "any-code", "timestamp" => Time.now}
-    params["hmac"] = generate_signature(params)
-    assert_equal true, ShopifyAPI::Session.validate_signature(params)
-  end
-
-  test "return true when validating signature of params with ampersand and equal sign characters" do
-    ShopifyAPI::Session.secret = 'secret'
-    params = {'a' => '1&b=2', 'c=3&d' => '4'}
-    to_sign = "a=1%26b=2&c%3D3%26d=4"
-    params['hmac'] = generate_signature(to_sign)
-
-    assert_equal true, ShopifyAPI::Session.validate_signature(params)
-  end
-
-  test "return true when validating signature of params with percent sign characters" do
-    ShopifyAPI::Session.secret = 'secret'
-    params = {'a%3D1%26b' => '2%26c%3D3'}
-    to_sign = "a%253D1%2526b=2%2526c%253D3"
-    params['hmac'] = generate_signature(to_sign)
-
-    assert_equal true, ShopifyAPI::Session.validate_signature(params)
-  end
-
-  private
-
-  def make_sorted_params(params)
-    sorted_params = params.with_indifferent_access.except(:signature, :hmac, :action, :controller).collect{|k,v|"#{k}=#{v}"}.sort.join('&')
-  end
-
-  def generate_signature(params)
-    params = make_sorted_params(params) if params.is_a?(Hash)
-    OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, ShopifyAPI::Session.secret, params)
-  end
-end

data/test/shipping_zone_test.rb

@@ -1,10 +0,0 @@
-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')
-    checkout = ShopifyAPI::ShippingZone.all
-    assert_equal 1, checkout.first.id
-    assert_equal "Canada", checkout.first.name
-  end
-end

data/test/shop_test.rb

@@ -1,68 +0,0 @@
-require 'test_helper'
-
-class ShopTest < Test::Unit::TestCase
-  def setup
-    super
-    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
-  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
-  end
-
-  def test_get_all_metafields_for_shop
-    fake "metafields"
-
-    metafields = @shop.metafields
-
-    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
-
-    fake 'metafields.json?limit=2', body: body.to_json, extension: false
-
-    metafields = @shop.metafields limit: 2
-
-    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(FakeWeb.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"
-
-    events = @shop.events
-
-    assert_equal 3, events.length
-    assert events.all?{|m| m.is_a?(ShopifyAPI::Event)}
-  end
-end

data/test/smart_collection_test.rb

@@ -1,10 +0,0 @@
-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
-end

data/test/storefront_access_token_test.rb

@@ -1,32 +0,0 @@
-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')
-    storefront_access_token = ShopifyAPI::StorefrontAccessToken.create(title: 'Test')
-    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'
-    
-    storefront_access_tokens = ShopifyAPI::StorefrontAccessToken.find(1)
-    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')
-
-    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
-  end
-
-end

data/test/tax_service_test.rb

@@ -1,8 +0,0 @@
-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"}}', FakeWeb.last_request.body
-  end
-end

data/test/test_helper.rb

@@ -1,97 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'fakeweb'
-require 'mocha/setup'
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'shopify_api'
-
-FakeWeb.allow_net_connect = false
-
-# setup ShopifyAPI with fake api_key and secret
-module Test
-  module Unit
-  end
-end
-
-class Test::Unit::TestCase < Minitest::Unit::TestCase
-  def self.test(string, &block)
-    define_method("test_#{string}", &block)
-  end
-
-  def self.should(string, &block)
-    self.test("should_#{string}", &block)
-  end
-
-  def self.context(string)
-    yield
-  end
-
-  def setup
-    ActiveResource::Base.format = :json
-    [ShopifyAPI, ShopifyAPI::Ping].each do |mod|
-      mod.constants.each do |const|
-        begin
-          const = mod.const_get(const)
-          const.format = :json if const.respond_to?(:format=)
-        rescue NameError
-        end
-      end
-    end
-
-    ShopifyAPI::Base.clear_session
-    ShopifyAPI::Base.site = "https://this-is-my-test-shop.myshopify.com/admin"
-    ShopifyAPI::Base.password = nil
-    ShopifyAPI::Base.user = nil
-  end
-
-  def teardown
-    FakeWeb.clean_registry
-
-    ShopifyAPI::Base.clear_session
-    ShopifyAPI::Base.site = nil
-    ShopifyAPI::Base.password = nil
-    ShopifyAPI::Base.user = nil
-  end
-
-  # Custom Assertions
-  def assert_not(expression)
-    refute expression, "Expected <#{expression}> to be false!"
-  end
-
-  def assert_nothing_raised
-    yield
-  end
-
-  def assert_not_includes(array, value)
-    refute array.include?(value)
-  end
-
-  def assert_includes(array, value)
-    assert array.include?(value)
-  end
-
-  def load_fixture(name, format=:json)
-    File.read(File.dirname(__FILE__) + "/fixtures/#{name}.#{format}")
-  end
-
-  def assert_request_body(expected)
-    assert_equal expected, FakeWeb.last_request.body
-  end
-
-  def fake(endpoint, options={})
-    body   = options.has_key?(:body) ? options.delete(:body) : load_fixture(endpoint)
-    format = options.delete(:format) || :json
-    method = options.delete(:method) || :get
-    extension = ".#{options.delete(:extension)||'json'}" unless options[:extension]==false
-
-    url = if options.has_key?(:url)
-      options[:url]
-    else
-      "https://this-is-my-test-shop.myshopify.com/admin/#{endpoint}#{extension}"
-    end
-
-    FakeWeb.register_uri(method, url, {:body => body, :status => 200, :content_type => "text/#{format}", :content_length => 1}.merge(options))
-  end
-end

data/test/transaction_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-
-class TransactionTest < Test::Unit::TestCase
-  def setup
-    super
-    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
-      end
-    end
-  end
-end

data/test/usage_charge_test.rb

@@ -1,21 +0,0 @@
-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')
-
-    usage_charge = ShopifyAPI::UsageCharge.new(description: '1000 emails', price: 1.0)
-    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')
-
-    usage_charge = ShopifyAPI::UsageCharge.find(359376002, params: {recurring_application_charge_id: 654381177})
-
-    assert_equal "1000 emails", usage_charge.description
-  end
-
-end

data/test/user_test.rb

@@ -1,17 +0,0 @@
-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
-end

data/test/variant_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-
-class VariantTest < Test::Unit::TestCase
-
-  def test_get_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]
-  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
-  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
-  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
-  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
-  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
-  end
-end

data/test/webhook_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-
-class WebhookTest < Test::Unit::TestCase
-  test 'create should create a webhook' do
-    fake 'webhooks', :method => :post, :status => 201, :body => load_fixture('webhook')
-    webhook = ShopifyAPI::Webhook.create(address: "http://www.yoloship.it/webhook", topic: "orders/create", format: "json")
-    assert_equal "http://www.yoloship.it/webhook", webhook.address
-  end
-
-  test 'get should retrieve a webhook' do
-    fake 'webhooks/123456', :method => :get, :status => 200, :body => load_fixture('webhook')
-    webhook = ShopifyAPI::Webhook.find(123456)
-    assert_equal "http://www.yoloship.it/webhook", webhook.address
-  end
-
-  test 'find all should return all webhooks' do
-    fake 'webhooks', :method => :get, :status => 200, :body => load_fixture('webhooks')
-    webhook = ShopifyAPI::Webhook.all
-    assert_equal 123456, webhook.first.id
-  end
-end