solidus_bolt 0.0.1

data/spec/services/solidus_bolt/accounts/detect_account_service_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Accounts::DetectAccountService, :vcr, :bolt_configuration do
+  subject(:api) { described_class.new(email: email) }
+
+  let(:email) { 'bolt@bolt.com' }
+
+  describe '#call', vcr: true do
+    it 'receives the correct response' do
+      expect(api.call).to eq({ "has_bolt_account" => false })
+    end
+  end
+end

data/spec/services/solidus_bolt/base_service_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::BaseService do
+  let!(:bolt_configuration) { create(:bolt_configuration) }
+
+  describe '#call' do
+    subject(:service) { described_class.new.call }
+
+    it 'raises a not implemented error' do
+      expect { service }.to raise_error(::NotImplementedError)
+    end
+  end
+
+  describe '#api_base_url' do
+    it 'returns correct url' do
+      expect(described_class.new.send(:api_base_url)).to eq bolt_configuration.environment_url
+    end
+  end
+
+  describe '#api_version' do
+    it 'returns correct api version' do
+      expect(described_class.new.send(:api_version)).to eq 'v1'
+    end
+  end
+
+  describe '#authentication_header' do
+    it 'returns the correct hash' do
+      expect(
+        described_class.new.send(:authentication_header)
+      ).to eq({ 'X-API-KEY' => bolt_configuration.api_key })
+    end
+  end
+
+  describe '#generate_nonce' do
+    it 'returns a unique nonce everytime' do
+      nonce = described_class.new.send(:generate_nonce)
+      expect(described_class.new.send(:generate_nonce)).not_to eq(nonce)
+    end
+  end
+
+  describe '#publishable_key' do
+    it 'returns the correct key' do
+      publishable_key = described_class.new.send(:publishable_key)
+      expect(described_class.new.send(:publishable_key)).to eq(publishable_key)
+    end
+  end
+end

data/spec/services/solidus_bolt/oauth/token_service_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Oauth::TokenService, :vcr, :bolt_configuration do
+  subject(:api) {
+    described_class.new(authorization_code: 'Bolt Authorization Code', scope: 'openid bolt.account.manage')
+  }
+
+  describe '#call', vcr: true do
+    it 'makes the API call' do
+      expect { api.call }.to raise_error SolidusBolt::ServerError
+    end
+  end
+end

data/spec/services/solidus_bolt/payments/capture_sync_service_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Payments::CaptureSyncService do
+  subject(:capture) do
+    described_class.call(payment: payment, capture_amount: capture_amount)
+  end
+
+  let(:payment) { create(:bolt_payment, amount: 15.00) }
+  let(:capture_amount) { 1000 }
+
+  describe '#call' do
+    it 'completes the payment' do
+      expect { capture }.to change { payment.reload.state }.from('checkout').to('completed')
+    end
+
+    it 'updates the payment amount' do
+      expect { capture }.to change { payment.reload.amount }.from(15.00).to(10.00)
+    end
+
+    it 'creates a capture event' do
+      capture
+      expect(payment.reload.capture_events.count).to eq(1)
+    end
+  end
+end

data/spec/services/solidus_bolt/payments/credit_sync_service_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Payments::CreditSyncService do
+  subject(:credit) { described_class.call(payment: payment, amount: amount, transaction_id: '123') }
+
+  let(:payment) { create(:bolt_payment, state: 'completed', amount: 10.0, order: create(:completed_order_with_totals)) }
+  let(:amount) { (payment.amount * 100).to_i }
+
+  describe '#call' do
+    before { create(:refund_reason, name: 'Return processing', mutable: false) }
+
+    context 'when not refunded already' do
+      it 'creates a new refund' do
+        credit
+        expect(payment.reload.refunds.count).to eq(1)
+      end
+
+      it 'creates a refund for the passed amount' do
+        credit
+        expect(payment.reload.refunds.first.amount).to eq(amount.to_f / 100)
+      end
+
+      it 'recalculates the order amount' do
+        expect { credit }.to change { payment.reload.order.payment_total }.from(10.0).to(0.0)
+      end
+    end
+
+    context 'when already refunded' do
+      before { create(:refund, transaction_id: '123') }
+
+      it 'silently fails' do
+        expect(credit).to be_nil
+      end
+    end
+  end
+end

data/spec/services/solidus_bolt/payments/void_sync_service_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Payments::VoidSyncService do
+  subject(:void) { described_class.call(payment: payment) }
+
+  let(:payment) { create(:bolt_payment) }
+
+  describe '#call' do
+    context 'when non-void payment' do
+      it 'voids the payment' do
+        expect { void }.to change { payment.reload.state }.from('checkout').to('void')
+      end
+    end
+
+    context 'when void payment' do
+      before { payment.update(state: 'void') }
+
+      it 'returns nil' do
+        expect(void).to be_nil
+      end
+    end
+  end
+end

data/spec/services/solidus_bolt/transactions/authorize_service_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Transactions::AuthorizeService, :vcr, :bolt_configuration do
+  let(:credit_card_payload) do
+    tokenize_credit_card(credit_card_number: '4111111111111004', cvv: '111').merge(
+      expiration: (Time.current + 1.year).strftime('%Y-%m'),
+      token_type: 'bolt'
+    )
+  end
+  let(:order) { create(:order_with_line_items) }
+  let(:payment_method) { create(:bolt_payment_method) }
+
+  context 'without auto capture' do
+    subject(:authorize) do
+      described_class.call(
+        order: order, credit_card: credit_card_payload, create_bolt_account: false, payment_method: payment_method
+      )
+    end
+
+    describe '#call' do
+      it 'makes the API call' do
+        response = authorize
+
+        expect(response).to match hash_including('transaction')
+        expect(response['transaction']['status']).to eq('pending')
+
+        # The Authorize Call with auto_capture takes some time to update the state of the transaction from
+        # pending to completed, hence the sleep is necessary to get the correct output from the API Call.
+
+        sleep(1)
+
+        reference = response['transaction']['reference']
+        transaction_details = SolidusBolt::Transactions::DetailService.call(
+          transaction_reference: reference, payment_method: payment_method
+        )
+        expect(transaction_details['status']).to eq('authorized')
+      end
+    end
+  end
+
+  context 'with auto capture' do
+    subject(:authorize) do
+      described_class.call(
+        order: order,
+        credit_card: credit_card_payload,
+        create_bolt_account: false,
+        payment_method: payment_method,
+        auto_capture: true
+      )
+    end
+
+    describe '#call', vcr: true do
+      it 'makes the API call' do
+        response = authorize
+
+        expect(response).to match hash_including('transaction')
+        expect(response['transaction']['status']).to eq 'pending'
+
+        # The Authorize Call with auto_capture takes some time to update the state of the transaction from
+        # pending to completed, hence the sleep is necessary to get the correct output from the API Call.
+
+        sleep(1)
+
+        reference = response['transaction']['reference']
+        transaction_details = SolidusBolt::Transactions::DetailService.call(
+          transaction_reference: reference, payment_method: payment_method
+        )
+        expect(transaction_details['order']['cart']['shipments'].first['shipping_address']).to be_present
+        expect(transaction_details['status']).to eq('completed')
+      end
+    end
+  end
+
+  context 'when repeat payment', vcr: true do
+    let(:access_token) { ENV['BOLT_ACCESS_TOKEN'] }
+
+    describe '#call' do
+      it 'makes the API call' do
+        credit_card_id = SolidusBolt::Accounts::AddPaymentMethodService.call(
+          access_token: access_token,
+          credit_card: credit_card_payload.merge(number: '4111111111111111', postal_code: order.bill_address.zipcode),
+          address: order.bill_address,
+          email: order.email
+        )['id']
+
+        # The AddPaymentMethodService call takes some time to create the credit card on Bolt's side, hence the sleep is
+        # necessary to get the correct output from the API Call.
+
+        sleep(1)
+
+        response = described_class.call(
+          order: order,
+          credit_card: { id: credit_card_id },
+          payment_method: payment_method,
+          repeat: true,
+          create_bolt_account: false
+        )
+
+        expect(response).to match hash_including('transaction')
+        expect(response['transaction']['status']).to eq('pending')
+
+        # The Authorize Call with auto_capture takes some time to update the state of the transaction from
+        # pending to completed, hence the sleep is necessary to get the correct output from the API Call.
+
+        sleep(1)
+
+        reference = response['transaction']['reference']
+        transaction_details = SolidusBolt::Transactions::DetailService.call(
+          transaction_reference: reference, payment_method: payment_method
+        )
+        expect(transaction_details['status']).to eq('authorized')
+      end
+    end
+  end
+end

data/spec/services/solidus_bolt/transactions/base_service_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Transactions::BaseService do
+  let!(:payment_method) { create(:bolt_payment_method) }
+
+  describe '#call' do
+    subject(:service) { described_class.new(payment_method: payment_method).call }
+
+    it 'raises a not implemented error' do
+      expect { service }.to raise_error(::NotImplementedError)
+    end
+  end
+
+  describe '#api_base_url' do
+    it 'returns correct url' do
+      expect(
+        described_class.new(payment_method: payment_method).send(:api_base_url)
+      ).to eq payment_method.preferred_bolt_api_url
+    end
+  end
+
+  describe '#authentication_header' do
+    it 'returns the correct hash' do
+      expect(
+        described_class.new(payment_method: payment_method).send(:authentication_header)
+      ).to eq({ 'X-API-KEY' => payment_method.preferred_bolt_api_key })
+    end
+  end
+
+  describe '#publishable_key' do
+    it 'returns the correct key' do
+      publishable_key = described_class.new(payment_method: payment_method).send(:publishable_key)
+      expect(described_class.new(payment_method: payment_method).send(:publishable_key)).to eq(publishable_key)
+    end
+  end
+end

data/spec/services/solidus_bolt/transactions/capture_service_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Transactions::CaptureService, :vcr, :bolt_configuration do
+  subject(:api) do
+    described_class.new(
+      transaction_reference: reference, amount: amount, currency: currency, payment_method: payment_method
+    )
+  end
+
+  let(:transaction) do
+    SolidusBolt::Transactions::AuthorizeService.call(
+      order: order, credit_card: credit_card_payload, create_bolt_account: false, payment_method: payment_method
+    )
+  end
+  let(:credit_card_payload) do
+    tokenize_credit_card(credit_card_number: '4111111111111004', cvv: '111').merge(
+      expiration: (Time.current + 1.year).strftime('%Y-%m'),
+      token_type: 'bolt'
+    )
+  end
+  let(:order) { create(:order_with_line_items) }
+  let(:reference) { transaction['transaction']['reference'] }
+  let(:amount) { 10 }
+  let(:currency) { 'USD' }
+  let(:payment_method) { create(:bolt_payment_method) }
+
+  describe '#call', vcr: true do
+    it 'makes the API call' do
+      response = api.call
+
+      expect(response['reference']).to eq(reference)
+      expect(response['capture']['status']).to eq 'succeeded'
+    end
+  end
+end

data/spec/services/solidus_bolt/transactions/detail_service_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Transactions::DetailService, :vcr, :bolt_configuration do
+  subject(:api) { described_class.new(transaction_reference: reference, payment_method: payment_method) }
+
+  let(:transaction) do
+    SolidusBolt::Transactions::AuthorizeService.call(
+      order: order, credit_card: credit_card_payload, create_bolt_account: false, payment_method: payment_method
+    )
+  end
+  let(:credit_card_payload) do
+    tokenize_credit_card(credit_card_number: '4111111111111004', cvv: '111').merge(
+      expiration: (Time.current + 1.year).strftime('%Y-%m'),
+      token_type: 'bolt'
+    )
+  end
+  let(:order) { create(:order_with_line_items) }
+  let(:reference) { transaction['transaction']['reference'] }
+  let(:payment_method) { create(:bolt_payment_method) }
+
+  describe '#call', vcr: true do
+    it 'makes the API call' do
+      response = api.call
+
+      expect(response['reference']).to eq reference
+      expect(response['status']).to eq 'authorized'
+    end
+  end
+end

data/spec/services/solidus_bolt/transactions/refund_service_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Transactions::RefundService, :vcr, :bolt_configuration do
+  subject(:api) do
+    described_class.new(
+      transaction_reference: reference, amount: amount, currency: currency, payment_method: payment_method
+    )
+  end
+
+  let(:transaction) do
+    SolidusBolt::Transactions::AuthorizeService.call(
+      order: order, credit_card: credit_card_payload, create_bolt_account: false, payment_method: payment_method
+    )
+  end
+  let(:credit_card_payload) do
+    tokenize_credit_card(credit_card_number: '4111111111111004', cvv: '111').merge(
+      expiration: (Time.current + 1.year).strftime('%Y-%m'),
+      token_type: 'bolt'
+    )
+  end
+  let(:order) { create(:order_with_line_items) }
+  let(:reference) { transaction['transaction']['reference'] }
+  let(:amount) { transaction['transaction']['amount']['amount'] }
+  let(:currency) { 'USD' }
+  let(:payment_method) { create(:bolt_payment_method) }
+
+  describe '#call', vcr: true do
+    before do
+      SolidusBolt::Transactions::CaptureService.call(
+        transaction_reference: reference, amount: amount, currency: currency, payment_method: payment_method
+      )
+    end
+
+    it 'makes the API call' do
+      response = api.call
+
+      expect(response['credit']['status']).to eq 'succeeded'
+    end
+  end
+end

data/spec/services/solidus_bolt/transactions/void_service_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Transactions::VoidService, :vcr, :bolt_configuration do
+  subject(:api) do
+    described_class.new(
+      transaction_reference: reference, transaction_id: transaction_id, payment_method: payment_method
+    )
+  end
+
+  let(:transaction) do
+    SolidusBolt::Transactions::AuthorizeService.call(
+      order: order, credit_card: credit_card_payload, create_bolt_account: false, payment_method: payment_method
+    )
+  end
+  let(:credit_card_payload) do
+    tokenize_credit_card(credit_card_number: '4111111111111004', cvv: '111').merge(
+      expiration: (Time.current + 1.year).strftime('%Y-%m'),
+      token_type: 'bolt'
+    )
+  end
+  let(:order) { create(:order_with_line_items) }
+  let(:reference) { transaction['transaction']['reference'] }
+  let(:transaction_id) { transaction['transaction']['id'] }
+  let(:payment_method) { create(:bolt_payment_method) }
+
+  describe '#call', vcr: true do
+    it 'makes the API call' do
+      response = api.call
+
+      expect(response['id']).to eq transaction_id
+      expect(response['reference']).to eq reference
+      expect(response['status']).to eq 'cancelled'
+    end
+
+    context 'when transaction_id is missing' do
+      subject(:api) do
+        described_class.new(
+          transaction_reference: reference, payment_method: payment_method
+        )
+      end
+
+      it 'makes the API call' do
+        response = api.call
+
+        expect(response['id']).to eq transaction_id
+        expect(response['reference']).to eq reference
+        expect(response['status']).to eq 'cancelled'
+      end
+    end
+
+    context 'when transaction_reference is missing' do
+      subject(:api) do
+        described_class.new(
+          transaction_id: transaction_id,
+          payment_method: payment_method
+        )
+      end
+
+      it 'makes the API call' do
+        response = api.call
+
+        expect(response['id']).to eq transaction_id
+        expect(response['reference']).to eq reference
+        expect(response['status']).to eq 'cancelled'
+      end
+    end
+  end
+end

data/spec/services/solidus_bolt/users/refresh_access_token_service_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Users::RefreshAccessTokenService do
+  subject(:refresh_access_token) { described_class.call(session: session) }
+
+  let(:session) { { bolt_access_token: bolt_access_token, bolt_expiration_time: bolt_expiration_time } }
+
+  describe '#call' do
+    context 'when not bolt user' do
+      let(:bolt_access_token) { nil }
+      let(:bolt_expiration_time) { nil }
+
+      it 'returns nil' do
+        expect(refresh_access_token).to be_nil
+      end
+    end
+
+    context 'with valid token' do
+      let(:bolt_access_token) { 'accesstoken' }
+      let(:bolt_expiration_time) { Time.now.utc + 10.minutes }
+
+      it 'returns current access token' do
+        expect(refresh_access_token).to eq(bolt_access_token)
+      end
+    end
+
+    context 'with expired token' do
+      let(:bolt_access_token) { 'accesstoken' }
+      let(:bolt_expiration_time) { Time.now.utc - 10.minutes }
+      let(:result) { { 'access_token' => 'newaccesstoken', 'expires_in' => 3600 } }
+
+      before do
+        allow(HTTParty).to receive(:post).and_return(result)
+        allow(result).to receive(:success?).and_return(true)
+        allow(result).to receive(:parsed_response).and_return(result)
+      end
+
+      it 'refreshes the access token' do
+        expect(refresh_access_token).to eq('newaccesstoken')
+      end
+    end
+  end
+end

data/spec/services/solidus_bolt/users/sync_addresses_service_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Users::SyncAddressesService, :vcr, :bolt_configuration do
+  subject(:sync_addresses_service) do
+    described_class.call(user: user, access_token: ENV.fetch('BOLT_ACCESS_TOKEN', 'Fake_access_token'))
+  end
+
+  let(:user) { create(:user) }
+  let(:country) { state.country }
+  let(:state) { create(:state) }
+  let(:payload) do
+    {
+      'profile' => { 'phone' => '987654321' },
+      'addresses' => [{
+        'id' => 'SA98t82gH2Grd',
+        'street_address1' => '380 DEGRAW ST',
+        'locality' => 'Brooklyn',
+        'region' => 'NEW YORK',
+        'region_code' => 'NY',
+        'postal_code' => '11231',
+        'country_code' => 'US',
+        'name' => 'Danny Dove',
+        'first_name' => 'Danny',
+        'last_name' => 'Dove',
+        'default' => true,
+        'phone_number' => phone
+      }]
+    }
+  end
+
+  before do
+    allow(Spree::Country).to receive(:find_by).and_return(country)
+    allow(Spree::State).to receive(:find_by).and_return(state)
+    allow(country).to receive(:states).and_return(Spree::State)
+  end
+
+  describe '#call', vcr: true do
+    it 'adds the ship_address to the user' do
+      expect { sync_addresses_service }.to change(user, :ship_address).from(nil)
+    end
+
+    it 'adds the bill_address to the user' do
+      expect { sync_addresses_service }.to change(user, :bill_address).from(nil)
+    end
+
+    context 'with address phone number', vcr: false do
+      let(:phone) { '123456789' }
+
+      before do
+        allow(SolidusBolt::Accounts::DetailService).to receive(:call).and_return(payload)
+        sync_addresses_service
+      end
+
+      it 'creates an address with the address phone' do
+        expect(user.bill_address.phone).to eq(phone)
+      end
+    end
+
+    context 'without address phone number', vcr: false do
+      let(:phone) { nil }
+
+      before do
+        allow(SolidusBolt::Accounts::DetailService).to receive(:call).and_return(payload)
+        sync_addresses_service
+      end
+
+      it 'creates an address with the user phone' do
+        expect(user.bill_address.phone).to eq('987654321')
+      end
+    end
+  end
+end

data/spec/services/solidus_bolt/users/sync_payment_sources_service_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusBolt::Users::SyncPaymentSourcesService, :vcr, :bolt_configuration do
+  subject(:sync_payment_sources) do
+    described_class.call(user: user, access_token: ENV.fetch('BOLT_ACCESS_TOKEN', 'Fake_access_token'))
+  end
+
+  let(:user) { create(:user) }
+  let(:bolt_payment_method) { create(:bolt_payment_method) }
+
+  describe '#call' do
+    before { bolt_payment_method }
+
+    it 'creates a new payment source with card ID' do
+      expect { sync_payment_sources }.to change { SolidusBolt::PaymentSource.count }.by(1)
+      bolt_payment_source = SolidusBolt::PaymentSource.last
+      expect(bolt_payment_source.card_id).to be_present
+      expect(bolt_payment_source.card_expiration).to be_present
+      expect(bolt_payment_source.payment_method_id).to eq(bolt_payment_method.id)
+      expect(user.wallet_payment_sources.last.payment_source).to eq(bolt_payment_source)
+    end
+  end
+end