duodealer_api 1.0.0

data/lib/duodealer_api/resources/user.rb

@@ -0,0 +1,4 @@
+module DuodealerAPI
+  class User < Base
+  end
+end

data/lib/duodealer_api/resources/variant.rb

@@ -0,0 +1,8 @@
+module DuodealerAPI
+  class Variant < Base
+    include Metafields
+    include DisablePrefixCheck
+
+    conditional_prefix :product
+  end
+end

data/lib/duodealer_api/resources/webhook.rb

@@ -0,0 +1,4 @@
+module DuodealerAPI
+  class Webhook < Base
+  end
+end

data/lib/duodealer_api/session.rb

@@ -0,0 +1,171 @@
+require 'openssl'
+require 'rack'
+
+module DuodealerAPI
+  class ValidationException < StandardError
+  end
+
+  class Session
+    cattr_accessor :api_key, :secret, :duodealer_domain
+    self.duodealer_domain = 'duodealer.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
+          DuodealerAPI::Base.activate_session(session)
+          yield
+        ensure
+          DuodealerAPI::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 .duodealer.com
+        if idx = shop.index(".")
+          shop = shop.slice(0, idx)
+        end
+        return nil if shop.empty?
+        "#{shop}.#{duodealer_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 = DuodealerAPI::Base.site.to_s
+        token = DuodealerAPI::Base.headers['X-DuoDealer-Access-Token']
+        version = DuodealerAPI::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 DuodealerAPI::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/lib/duodealer_api/version.rb

@@ -0,0 +1,3 @@
+module DuodealerAPI
+  VERSION = "1.0.0"
+end

data/shipit.rubygems.yml

@@ -0,0 +1 @@
+# using the default shipit config

data/test/abandoned_checkouts_test.rb

@@ -0,0 +1,29 @@
+# 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 = DuodealerAPI::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 = DuodealerAPI::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

@@ -0,0 +1,23 @@
+# 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.duodealer.com/admin/oauth/access_scopes.json',
+      method: :get,
+      status: 201,
+      body: load_fixture('access_scopes'),
+      extension: false
+    )
+
+    unstable_version = DuodealerAPI::Session.new(domain: 'shop2.duodealer.com', token: 'token2', api_version: :unstable)
+
+    DuodealerAPI::Base.activate_session(unstable_version)
+
+    scope_handles = DuodealerAPI::AccessScope.find(:all).map(&:handle)
+
+    assert_equal(['write_product_listings', 'read_shipping'], scope_handles)
+  end
+end

data/test/access_token_test.rb

@@ -0,0 +1,19 @@
+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 = DuodealerAPI::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

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module ActiveResource
+  class JsonErrorsTest < Test::Unit::TestCase
+
+    def test_parsing_of_error_json_hash
+      @model = DuodealerAPI::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 = DuodealerAPI::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

@@ -0,0 +1,9 @@
+# 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 DuodealerAPI::ApiPermission.destroy
+  end
+end

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 = DuodealerAPI::ApiVersion.new(handle: :unstable)
+    assert_same(version, DuodealerAPI::ApiVersion.find_version(version))
+  end
+
+  test "find_version converts a known version into a version object" do
+    versions = [
+      DuodealerAPI::ApiVersion.new(handle: :unstable),
+      DuodealerAPI::ApiVersion.new(handle: '2019-01'),
+    ]
+
+    assert_equal(versions, [
+      DuodealerAPI::ApiVersion.find_version('unstable'),
+      DuodealerAPI::ApiVersion.find_version('2019-01'),
+    ])
+  end
+
+  test "find_version removes unverified versions from version set if mode is set to :raise_on_unknown" do
+    DuodealerAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert DuodealerAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 6, DuodealerAPI::ApiVersion.versions.size
+
+    DuodealerAPI::ApiVersion.find_version('2019-30')
+    refute DuodealerAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 7, DuodealerAPI::ApiVersion.versions.size
+    DuodealerAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+
+    assert DuodealerAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 6, DuodealerAPI::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
+    DuodealerAPI::ApiVersion.clear_known_versions
+    DuodealerAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert_equal :define_on_unknown, DuodealerAPI::ApiVersion.version_lookup_mode
+    assert_nothing_raised do
+      DuodealerAPI::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 DuodealerAPI::ApiVersion.versions['made up version']
+    DuodealerAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+    assert_raises DuodealerAPI::ApiVersion::UnknownVersion do
+      DuodealerAPI::ApiVersion.find_version('made up version')
+    end
+  end
+
+  test "find_version raises ArgumentError when given an DuodealerAPI::ApiVersion::NullVersion object" do
+    DuodealerAPI::ApiVersion.clear_known_versions
+    DuodealerAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert_equal :define_on_unknown, DuodealerAPI::ApiVersion.version_lookup_mode
+    assert_raises ArgumentError do
+      DuodealerAPI::ApiVersion.find_version(DuodealerAPI::ApiVersion::NullVersion)
+    end
+  end
+
+  test 'two versions with the same version number are equal' do
+    version_1 = DuodealerAPI::ApiVersion.new(handle: '2018-09')
+    version_2 = DuodealerAPI::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 = DuodealerAPI::ApiVersion.new(handle: '2019-07')
+    version_2 = DuodealerAPI::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 = DuodealerAPI::ApiVersion.new(handle: '2017-11')
+    version_2 = DuodealerAPI::ApiVersion.new(handle: '2019-11')
+    version_3 = DuodealerAPI::ApiVersion.new(handle: '2039-01')
+    version_4 = DuodealerAPI::ApiVersion.new(handle: '2039-02')
+    unstable = DuodealerAPI::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(
+      DuodealerAPI::ApiVersion.versions,
+      {
+        "2019-01" => DuodealerAPI::ApiVersion.new(handle: '2019-01', supported: true, latest_supported: false),
+        "2019-04" => DuodealerAPI::ApiVersion.new(handle: '2019-04', supported: true, latest_supported: false),
+        "2019-07" => DuodealerAPI::ApiVersion.new(handle: '2019-07', supported: true, latest_supported: false),
+        "2019-10" => DuodealerAPI::ApiVersion.new(handle: '2019-10', supported: false, latest_supported: false),
+        "2020-01" => DuodealerAPI::ApiVersion.new(handle: '2020-01', supported: false, latest_supported: true),
+        "unstable" => DuodealerAPI::ApiVersion.new(handle: 'unstable', supported: false, latest_supported: false),
+      }
+    )
+    silence_warnings do
+
+      refute_equal(
+        DuodealerAPI::ApiVersion.new(handle: '2019-01'),
+        DuodealerAPI::ApiVersion.latest_stable_version
+      )
+
+      assert_equal(
+        DuodealerAPI::ApiVersion.new(handle: '2020-01'),
+        DuodealerAPI::ApiVersion.latest_stable_version
+      )
+    end
+  end
+
+  test "NullVersion raises ApiVersionNotSetError" do
+    assert_raises(DuodealerAPI::ApiVersion::ApiVersionNotSetError) do
+      DuodealerAPI::ApiVersion::NullVersion.construct_api_path(:string)
+    end
+
+    assert_raises(DuodealerAPI::ApiVersion::ApiVersionNotSetError) do
+      DuodealerAPI::ApiVersion::NullVersion.construct_graphql_path
+    end
+
+    assert_raises(DuodealerAPI::ApiVersion::ApiVersionNotSetError) do
+      DuodealerAPI::ApiVersion::NullVersion.stable?
+    end
+  end
+
+  test "NullVersion cannot be instantiated and raises NoMethodError if attempted" do
+    assert_raises(NoMethodError) do
+      DuodealerAPI::ApiVersion::NullVersion.new
+    end
+  end
+
+  test "handle_to_date converts a version handle to a date" do
+    version_1 = DuodealerAPI::ApiVersion.new(handle: '2019-01')
+    version_2 = DuodealerAPI::ApiVersion.new(handle: 'unstable')
+
+    assert_equal(version_1.handle_as_date, Time.utc(2019, 01, 01))
+    assert_equal(version_2.handle_as_date, DuodealerAPI::ApiVersion::UNSTABLE_AS_DATE)
+  end
+
+  class TestApiVersion < DuodealerAPI::ApiVersion
+    def initialize(name)
+      @version_name = name
+    end
+  end
+end