shopify_api 9.0.4 → 10.1.0

data/lib/shopify_api/session.rb

@@ -1,172 +0,0 @@
-require 'openssl'
-require 'rack'
-
-module ShopifyAPI
-
-  class ValidationException < StandardError
-  end
-
-  class Session
-    cattr_accessor :api_key, :secret, :myshopify_domain
-    self.myshopify_domain = 'myshopify.com'
-
-    attr_accessor :domain, :token, :name, :extra
-    attr_reader :api_version
-    alias_method :url, :domain
-
-    class << self
-
-      def setup(params)
-        params.each { |k,value| public_send("#{k}=", value) }
-      end
-
-      def temp(domain:, token:, api_version:, &block)
-        session = new(domain: domain, token: token, api_version: api_version)
-
-        with_session(session, &block)
-      end
-
-      def with_session(session, &_block)
-        original_session = extract_current_session
-
-        begin
-          ShopifyAPI::Base.activate_session(session)
-          yield
-        ensure
-          ShopifyAPI::Base.activate_session(original_session)
-        end
-      end
-
-      def with_version(api_version, &block)
-        original_session = extract_current_session
-        session = new(domain: original_session.site, token: original_session.token, api_version: api_version)
-
-        with_session(session, &block)
-      end
-
-      def prepare_domain(domain)
-        return nil if domain.blank?
-        # remove http:// or https://
-        domain = domain.strip.gsub(%r{\Ahttps?://}, '')
-        # extract host, removing any username, password or path
-        shop = URI.parse("https://#{domain}").host
-        # extract subdomain of .myshopify.com
-        if idx = shop.index(".")
-          shop = shop.slice(0, idx)
-        end
-        return nil if shop.empty?
-        "#{shop}.#{myshopify_domain}"
-      rescue URI::InvalidURIError
-        nil
-      end
-
-      def validate_signature(params)
-        params = (params.respond_to?(:to_unsafe_hash) ? params.to_unsafe_hash : params).with_indifferent_access
-        return false unless signature = params[:hmac]
-
-        calculated_signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new(), secret, encoded_params_for_signature(params))
-
-        Rack::Utils.secure_compare(calculated_signature, signature)
-      end
-
-      private
-
-      def encoded_params_for_signature(params)
-        params = params.except(:signature, :hmac, :action, :controller)
-        params.map{|k,v| "#{URI.escape(k.to_s, '&=%')}=#{URI.escape(v.to_s, '&%')}"}.sort.join('&')
-      end
-
-      def extract_current_session
-        site = ShopifyAPI::Base.site.to_s
-        token = ShopifyAPI::Base.headers['X-Shopify-Access-Token']
-        version = ShopifyAPI::Base.api_version
-        new(domain: site, token: token, api_version: version)
-      end
-    end
-
-    def initialize(domain:, token:, api_version:, extra: {})
-      self.domain = self.class.prepare_domain(domain)
-      self.api_version = api_version
-      self.token = token
-      self.extra = extra
-    end
-
-    def create_permission_url(scope, redirect_uri, options = {})
-      params = { client_id: api_key, scope: scope.join(','), redirect_uri: redirect_uri }
-      params[:state] = options[:state] if options[:state]
-      construct_oauth_url("authorize", params)
-    end
-
-    def request_token(params)
-      return token if token
-
-      unless self.class.validate_signature(params) && params[:timestamp].to_i > 24.hours.ago.utc.to_i
-        raise ShopifyAPI::ValidationException, "Invalid Signature: Possible malicious login"
-      end
-
-      response = access_token_request(params[:code])
-      if response.code == "200"
-        self.extra = JSON.parse(response.body)
-        self.token = extra.delete('access_token')
-
-        if expires_in = extra.delete('expires_in')
-          extra['expires_at'] = Time.now.utc.to_i + expires_in
-        end
-        token
-      else
-        raise RuntimeError, response.msg
-      end
-    end
-
-    def shop
-      Shop.current
-    end
-
-    def site
-      "https://#{domain}"
-    end
-
-    def api_version=(version)
-      @api_version = ApiVersion::NullVersion.matches?(version) ? ApiVersion::NullVersion : ApiVersion.find_version(version)
-    end
-
-    def valid?
-      domain.present? && token.present? && api_version.is_a?(ApiVersion)
-    end
-
-    def expires_in
-      return unless expires_at.present?
-      [0, expires_at.to_i - Time.now.utc.to_i].max
-    end
-
-    def expires_at
-      return unless extra.present?
-      @expires_at ||= Time.at(extra['expires_at']).utc
-    end
-
-    def expired?
-      return false if expires_in.nil?
-      expires_in <= 0
-    end
-
-    private
-
-    def parameterize(params)
-      URI.escape(params.collect { |k, v| "#{k}=#{v}" }.join('&'))
-    end
-
-    def access_token_request(code)
-      uri = URI.parse(construct_oauth_url('access_token'))
-      https = Net::HTTP.new(uri.host, uri.port)
-      https.use_ssl = true
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request.set_form_data('client_id' => api_key, 'client_secret' => secret, 'code' => code)
-      https.request(request)
-    end
-
-    def construct_oauth_url(path, query_params = {})
-      query_string = "?#{parameterize(query_params)}" unless query_params.empty?
-      "https://#{domain}/admin/oauth/#{path}#{query_string}"
-    end
-  end
-end

data/test/abandoned_checkouts_test.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-require 'test_helper'
-
-class AbandonedCheckoutsTest < Test::Unit::TestCase
-  def setup
-    super
-
-    @expected_checkouts = JSON.parse(load_fixture('abandoned_checkouts'))['checkouts']
-    @expected_checkout_id = JSON.parse(load_fixture('abandoned_checkout'))['checkout']['id']
-  end
-
-  test ":create creates a checkout" do
-    fake 'checkouts', method: :post, status: 201, body: load_fixture('abandoned_checkout')
-
-    checkout = ShopifyAPI::AbandonedCheckout.create
-
-    assert_equal @expected_checkout_id, checkout.id
-    assert_equal true, checkout.attributes.include?(:abandoned_checkout_url)
-  end
-
-  test "get all checkouts indexed by token" do
-    fake 'checkouts', method: :get, status: 200, body: load_fixture('abandoned_checkouts')
-
-    checkouts = ShopifyAPI::AbandonedCheckout.all
-
-    assert_equal @expected_checkout_id, checkouts.first.id
-    assert_equal @expected_checkouts.size, checkouts.size
-  end
-end

data/test/access_scope_test.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require 'test_helper'
-
-class AccessScopeTest < Test::Unit::TestCase
-  test 'access scope does not use the versioned resource urls' do
-    fake(
-      'access_scopes',
-      url: 'https://shop2.myshopify.com/admin/oauth/access_scopes.json',
-      method: :get,
-      status: 201,
-      body: load_fixture('access_scopes'),
-      extension: false
-    )
-
-    unstable_version = ShopifyAPI::Session.new(domain: 'shop2.myshopify.com', token: 'token2', api_version: :unstable)
-
-    ShopifyAPI::Base.activate_session(unstable_version)
-
-    scope_handles = ShopifyAPI::AccessScope.find(:all).map(&:handle)
-
-    assert_equal(['write_product_listings', 'read_shipping'], scope_handles)
-  end
-end

data/test/access_token_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class AccessTokenTest < Test::Unit::TestCase
-
-  def test_delegate_access_token
-    fake "access_tokens/delegate.json?delegate_access_scope%5B%5D=write_orders&" \
-      "delegate_access_scope%5B%5D=read_products&expires_in=",
-      method: :post,
-      status: 201,
-      body: load_fixture('access_token_delegate'),
-      extension: false
-
-    delegate_scope = ['write_orders', 'read_products']
-    token = ShopifyAPI::AccessToken.delegate(delegate_scope)
-
-    assert_equal 'abracadabra', token.access_token
-    assert_equal 'write_orders,read_products', token.scope
-  end
-end

data/test/active_resource/json_errors_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-module ActiveResource
-  class JsonErrorsTest < Test::Unit::TestCase
-
-    def test_parsing_of_error_json_hash
-      @model = ShopifyAPI::Order.new
-      @model.errors.from_json({errors: {name: ['missing']}}.to_json)
-      assert_equal ['missing'], @model.errors[:name]
-    end
-
-    def test_parsing_of_error_json_plain_string
-      @model = ShopifyAPI::Order.new
-      @model.errors.from_json({errors: 'some generic error'}.to_json)
-      assert_equal ['some generic error'], @model.errors[:base]
-      assert_equal 'some generic error', @model.errors.full_messages.to_sentence
-    end
-  end
-end

data/test/api_permission_test.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-require 'test_helper'
-
-class ApiPermissionTest < Test::Unit::TestCase
-  test "revoke access token" do
-    fake "api_permissions/current", method: :delete, status: 200, body: "{}"
-    assert ShopifyAPI::ApiPermission.destroy
-  end
-end

data/test/api_version_test.rb

@@ -1,157 +0,0 @@
-# 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)
-      @version_name = name
-    end
-  end
-end

data/test/application_charge_test.rb

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

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

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

@@ -1,18 +0,0 @@
-require 'test_helper'
-
-class AssetTest < Test::Unit::TestCase
-  def test_get_assetss
-    fake "themes/1/assets", :method => :get, :body => load_fixture('assets')
-    v = 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')
-    v = 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')
-    v = ShopifyAPI::Asset.find('templates/index.liquid')
-  end
-end