solidus_bolt 0.0.1

data/spec/services/solidus_bolt/webhooks/create_service_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Webhooks::CreateService, :vcr, :bolt_configuration do
+  describe '#call', vcr: true do
+    subject(:create) { described_class.call(url: 'https://solidus-test.com/webhook', event: event) }
+
+    context 'with an event' do
+      let(:event) { 'payment' }
+
+      it 'returns a webhook id' do
+        expect(create).to match hash_including('webhook_id')
+      end
+    end
+
+    context 'with "all" event' do
+      let(:event) { 'all' }
+
+      it 'returns a webhook id' do
+        expect(create).to match hash_including('webhook_id')
+      end
+    end
+
+    context 'with empty event' do
+      let(:event) { '' }
+
+      it 'raises a server error' do
+        expect{ create }.to raise_error SolidusBolt::ServerError
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+# Run Coverage report
+require 'solidus_dev_support/rspec/coverage'
+require 'pry'
+require 'vcr'
+require 'webmock/rspec'
+
+# Create the dummy app if it's still missing.
+dummy_env = "#{__dir__}/dummy/config/environment.rb"
+system 'bin/rake extension:test_app' unless File.exist? dummy_env
+require dummy_env
+
+# Requires factories and other useful helpers defined in spree_core.
+require 'solidus_dev_support/rspec/feature_helper'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{__dir__}/support/**/*.rb"].sort.each { |f| require f }
+
+require 'spree/testing_support/order_walkthrough'
+
+# Requires factories defined in lib/solidus_bolt/testing_support/factories.rb
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusBolt::Engine)
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+  config.use_transactional_fixtures = false
+  config.include SolidusBolt::BoltHelper
+
+  if Spree.solidus_gem_version < Gem::Version.new('2.11')
+    config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :system
+  end
+end

data/spec/support/bolt_configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.before(:example, :bolt_configuration) do
+    solidus_bolt_configuration = SolidusBolt::BoltConfiguration.fetch
+
+    solidus_bolt_configuration.bearer_token = ENV['BOLT_BEARER_TOKEN']
+    solidus_bolt_configuration.environment = 'sandbox'
+    solidus_bolt_configuration.merchant_public_id = ENV['BOLT_MERCHANT_PUBLIC_ID']
+    solidus_bolt_configuration.division_public_id = ENV['BOLT_DIVISION_PUBLIC_ID']
+    solidus_bolt_configuration.api_key = ENV['BOLT_API_KEY']
+    solidus_bolt_configuration.signing_secret = ENV['BOLT_SIGNING_SECRET']
+    solidus_bolt_configuration.publishable_key = ENV['BOLT_PUBLISHABLE_KEY']
+
+    solidus_bolt_configuration.save!
+
+    allow(SolidusBolt::BaseService).to receive(:generate_nonce).and_return('fakenonce')
+    allow(SolidusBolt::BoltHelper).to receive(:nonce).and_return('helpernonce')
+    allow(TweetNaCl).to receive(:crypto_box_keypair).and_return(
+      [
+        "\x8C\xEB\x1C^(\x99\n\xC9\xFE\x9D\xF5\xC5z\xD0E\xFBs\xA7\xD2p\x16\x81\xE7O\xF3\xB6[%B\xA2\xCC<",
+        "\x86(\x1D\x8B2s\x7F\xD0\xB1\xCC\"\x83\xE2Lqy4\xF6\x1D\xAA\xA1\xD5\e\x16#a\x1E\xF0F\xCF\xE1\t"
+      ]
+    )
+  end
+end

data/spec/support/bolt_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module BoltHelper
+    PUBLIC_KEY_URL = 'https://sandbox.bolttk.com/public_key'
+    TOKEN_URL = 'https://sandbox.bolttk.com/token'
+
+    def tokenize_credit_card(credit_card_number:, cvv:)
+      request_body = encrypt_request_body(credit_card_number, cvv)
+      response = make_request(request_body)
+      JSON.parse(decrypt_response_body(response))
+    end
+
+    def public_key
+      @public_key ||= HTTParty.get(URI.parse(PUBLIC_KEY_URL)).body
+    end
+
+    def nonce
+      @nonce ||= rand(10**24).to_s.rjust(24, '0')
+    end
+
+    def keys
+      @keys ||= TweetNaCl.crypto_box_keypair
+    end
+
+    def make_request(encrypted_request_body)
+      HTTParty.post(
+        TOKEN_URL,
+        {
+          body: JSON.dump(encrypted_request_body),
+          headers: {
+            'Content-Type' => 'application/json'
+          }
+        }
+      )
+    end
+
+    def encrypt_request_body(credit_card_number, cvv)
+      message = { cc: credit_card_number, cvv: cvv }.to_json
+
+      payload = TweetNaCl.crypto_box(
+        message,
+        nonce,
+        Base64.decode64(public_key),
+        keys[1]
+      )
+
+      {
+        payload: Base64.encode64(payload),
+        nonce: Base64.encode64(nonce),
+        public_key: Base64.encode64(keys[0])
+      }
+    end
+
+    def decrypt_response_body(response)
+      parsed_response = JSON.parse(response.body)
+
+      TweetNaCl.crypto_box_open(
+        Base64.decode64(parsed_response['payload']),
+        Base64.decode64(parsed_response['nonce']),
+        Base64.decode64(public_key),
+        keys[1]
+      )
+    end
+  end
+end

data/spec/support/vcr.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+VCR.configure do |config|
+  config.ignore_localhost = true
+  config.cassette_library_dir = "spec/fixtures/vcr_cassettes"
+  config.hook_into :webmock
+  config.configure_rspec_metadata!
+
+  config.filter_sensitive_data('<API_KEY>') do |interaction|
+    interaction.request.headers['X-API-KEY']&.first
+  end
+
+  config.filter_sensitive_data('<PUBLISHABLE_KEY>') do |interaction|
+    interaction.request.headers['X-Publishable-Key']&.first
+  end
+
+  config.filter_sensitive_data('<BEARER AUTHORIZATION>') do |interaction|
+    interaction.request.headers['Authorization']&.first
+  end
+
+  config.filter_sensitive_data('<PUBLISHABLE_KEY>') { SolidusBolt::BoltConfiguration.fetch.publishable_key }
+  config.filter_sensitive_data('<API_KEY>') { SolidusBolt::BoltConfiguration.fetch.api_key }
+  config.filter_sensitive_data('<DIVISION_ID>') { SolidusBolt::BoltConfiguration.fetch.division_public_id }
+
+  # Let's you set default VCR record mode with VCR_RECORDE_MODE=all for re-recording
+  # episodes. :once is VCR default
+  record_mode = ENV.fetch('VCR_RECORD_MODE', :once).to_sym
+  config.default_cassette_options = { record: record_mode }
+end

data/spec/webhooks/solidus_bolt/handlers/base_handler_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Handlers::BaseHandler do
+  subject(:handler) { described_class.new({}) }
+
+  it { expect(described_class).to respond_to(:call).with(1).arguments }
+
+  it { expect(handler).to respond_to(:call).with(0).arguments }
+
+  it { expect { handler.call }.to raise_exception(NotImplementedError) }
+end

data/spec/webhooks/solidus_bolt/handlers/capture_handler_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Handlers::CaptureHandler do
+  subject(:capture) { described_class.call(params) }
+
+  let(:payment) { create(:bolt_payment, response_code: 'V2YW-NYNR-2MYM') }
+  let(:capture_amount) { 500 }
+  let(:params) { { data: { reference: payment.response_code, captures: [{ amount: { amount: capture_amount } }] } } }
+
+  before do
+    allow(SolidusBolt::Payments::CaptureSyncService).to receive(:call).with(
+      payment: payment, capture_amount: capture_amount
+    )
+    capture
+  end
+
+  it 'calls the payment capture service' do
+    expect(SolidusBolt::Payments::CaptureSyncService).to have_received(:call).with(
+      payment: payment, capture_amount: capture_amount
+    )
+  end
+end

data/spec/webhooks/solidus_bolt/handlers/credit_handler_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Handlers::CreditHandler do
+  subject(:credit) { described_class.call(params) }
+
+  let(:transaction_id) { 'AAAA-BBBB-CCCC' }
+  let(:payment) { create(:bolt_payment, response_code: 'V2YW-NYNR-2MYM') }
+  let(:params) do
+    {
+      data: {
+        reference: transaction_id,
+        source_transaction: { reference: payment.response_code },
+        requested_refund_amount: { amount: 100 }
+      }
+    }
+  end
+
+  before do
+    allow(SolidusBolt::Payments::CreditSyncService).to receive(:call).with(
+      payment: payment, amount: 100, transaction_id: transaction_id
+    )
+    credit
+  end
+
+  it 'calls the payment credit service' do
+    expect(SolidusBolt::Payments::CreditSyncService).to have_received(:call).with(
+      payment: payment, amount: 100, transaction_id: transaction_id
+    )
+  end
+end

data/spec/webhooks/solidus_bolt/handlers/void_handler_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Handlers::VoidHandler do
+  subject(:void) { described_class.call(params) }
+
+  let(:payment) { create(:bolt_payment, response_code: 'V2YW-NYNR-2MYM') }
+  let(:params) { { data: { reference: payment.response_code } } }
+
+  before do
+    allow(SolidusBolt::Payments::VoidSyncService).to receive(:call).with(payment: payment)
+    void
+  end
+
+  it 'calls the payment void service' do
+    expect(SolidusBolt::Payments::VoidSyncService).to have_received(:call).with(payment: payment)
+  end
+end

data/spec/webhooks/solidus_bolt/sorter_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Sorter do
+  subject(:do_call) { described_class.call(params) }
+
+  let(:event_type) { 'EVENT.TYPE' }
+  let(:params) { { type: event_type, resource: {} } }
+
+  it { expect(described_class).to respond_to(:new).with(1).arguments }
+
+  it { expect(described_class).to respond_to(:call).with(1).arguments }
+
+  it { expect(described_class.new({})).to respond_to(:call).with(0).arguments }
+
+  describe '#call' do
+    context 'when the handler is not defined' do
+      it 'returns nil' do
+        expect(do_call).to be_nil
+      end
+    end
+
+    context 'when the handler is defined' do
+      let(:result) { 'result' }
+      let(:event_type) { 'BASE' }
+      let(:handler) { instance_double(SolidusBolt::Handlers::BaseHandler) }
+
+      before do
+        allow(SolidusBolt::Handlers::BaseHandler).to receive(:new).and_return(handler)
+        allow(handler).to receive(:call).and_return(result)
+      end
+
+      it { expect { do_call }.not_to raise_exception }
+
+      it { expect(do_call).to be result }
+    end
+  end
+end