workarea-klarna 1.0.0.beta1

data/test/lib/workarea/klarna/gateway/request_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+module Workarea
+  module Klarna
+    class Gateway
+      class RequestTest < TestCase
+        setup :configure_klarna_data, :payment
+
+        def order
+          @order ||= create_order
+        end
+
+        def payment
+          @payment ||= create_payment(id: order.id)
+        end
+
+        def request
+          Request.new(order)
+        end
+
+        def test_validate!
+          assert_raises(Gateway::ContinentNotSupported) { request.validate! }
+
+          payment.set_address(unsupported_address)
+          assert_raises(Gateway::ContinentNotSupported) { request.validate! }
+
+          payment.set_address(supported_na_address)
+          assert_nothing_raised { request.validate! }
+
+          Workarea.config.klarna_na_password = nil
+          assert_raises(Gateway::ContinentNotSupported) { request.validate! }
+        end
+
+        def test_username
+          assert_nil(request.username)
+
+          payment.set_address(unsupported_address)
+          assert_nil(request.username)
+
+          payment.set_address(supported_na_address)
+          assert_equal(Workarea.config.klarna_na_username, request.username)
+
+          payment.set_address(supported_eur_address)
+          assert_equal(Workarea.config.klarna_eur_username, request.username)
+
+          @env_eur_user = ENV['WORKAREA_KLARNA_EUR_USERNAME']
+          ENV['WORKAREA_KLARNA_EUR_USERNAME'] = 'env_eur_user'
+          assert_equal('env_eur_user', request.username)
+        ensure
+          ENV['WORKAREA_KLARNA_EUR_USERNAME'] = @env_eur_user
+        end
+
+        def test_password
+          assert_nil(request.password)
+
+          payment.set_address(unsupported_address)
+          assert_nil(request.password)
+
+          payment.set_address(supported_na_address)
+          assert_equal(Workarea.config.klarna_na_password, request.password)
+
+          payment.set_address(supported_eur_address)
+          assert_equal(Workarea.config.klarna_eur_password, request.password)
+
+          @env_eur_pass = ENV['WORKAREA_KLARNA_EUR_PASSWORD']
+          ENV['WORKAREA_KLARNA_EUR_PASSWORD'] = 'env_eur_user'
+          assert_equal('env_eur_user', request.password)
+        ensure
+          ENV['WORKAREA_KLARNA_EUR_PASSWORD'] = @env_eur_pass
+        end
+
+        def test_continent_key
+          assert_nil(request.continent_key)
+
+          payment.set_address(unsupported_address)
+          assert_nil(request.continent_key)
+
+          payment.set_address(supported_na_address)
+          assert_equal('NA', request.continent_key)
+
+          payment.set_address(supported_eur_address)
+          assert_equal('EUR', request.continent_key)
+        end
+      end
+    end
+  end
+end

data/test/lib/workarea/klarna/gateway/response_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+module Workarea
+  module Klarna
+    class Gateway
+      class ResponseTest < TestCase
+        def order
+          @order ||= create_order
+        end
+
+        def request
+          Request.new(order)
+        end
+
+        def test_body
+          response = Response.new(request, nil)
+          assert_equal({}, response.body)
+          assert_equal({}, response.params)
+
+          response = Response.new(
+            request,
+            OpenStruct.new(body: { foo: 'bar' }.to_json)
+          )
+          assert_equal({ 'foo' => 'bar' }, response.body)
+          assert_equal({ 'foo' => 'bar' }, response.params)
+        end
+
+        def test_success?
+          response = Response.new(request, nil)
+          refute(response.success?)
+
+          response = Response.new(request, OpenStruct.new(status: 404))
+          refute(response.success?)
+
+          response = Response.new(request, OpenStruct.new(status: 200))
+          assert(response.success?)
+        end
+
+        def test_message
+          response = Response.new(request, nil)
+          assert_equal(
+            t('workarea.klarna.gateway.response.failure', summary: ''),
+            response.message
+          )
+
+          response = Response.new(
+            request,
+            OpenStruct.new(
+              status: 500,
+              body: {
+                error_messages: ['address is invalid', 'tax rate missing']
+              }.to_json
+            )
+          )
+          assert_equal(
+            t(
+              'workarea.klarna.gateway.response.failure',
+              summary: 'address is invalid. tax rate missing'
+            ),
+            response.message
+          )
+
+          response = Response.new(request, OpenStruct.new(status: 204))
+          assert_equal(
+            t(
+              'workarea.klarna.gateway.response.success',
+              summary: t('workarea.klarna.gateway.request.base')
+            ),
+            response.message
+          )
+        end
+      end
+    end
+  end
+end

data/test/lib/workarea/klarna/gateway/update_session_request_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module Workarea
+  module Klarna
+    class Gateway
+      class UpdateSessionRequestTest < TestCase
+        setup :create_supporting_data_for_klarna
+
+        def test_details
+          session = create_klarna_session(id: @order.id)
+          request = UpdateSessionRequest.new(@order)
+
+          assert_equal('post', request.method)
+          assert_equal("payments/v1/sessions/#{session.session_id}", request.path)
+          assert(request.summary.present?)
+        end
+
+        def test_body
+          request = UpdateSessionRequest.new(@order, '123')
+
+          assert_nil(request.body[:shipping_address])
+          assert_nil(request.body[:billing_address])
+        end
+      end
+    end
+  end
+end

data/test/lib/workarea/klarna/gateway_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+module Workarea
+  module Klarna
+    class GatewayTest < TestCase
+      setup :configure_klarna_data, :payment
+
+      def order
+        @order ||= create_order
+      end
+
+      def payment
+        @payment ||= create_payment(id: order.id)
+      end
+
+      def request
+        Gateway::Request.new(order)
+      end
+
+      def test_send_request
+        response = Gateway.new.send_request(request)
+        refute(response.success?)
+        assert_equal(
+          t('workarea.klarna.gateway.unsupported_continent', continent: nil),
+          response.message
+        )
+
+        payment.set_address(unsupported_address)
+        response = Gateway.new.send_request(request)
+        refute(response.success?)
+        assert_equal(
+          t('workarea.klarna.gateway.unsupported_continent', continent: 'South America'),
+          response.message
+        )
+
+        payment.set_address(supported_na_address)
+
+        Faraday.expects(:send)
+               .with('get', 'https://api-na.playground.klarna.com/')
+
+        response = Gateway.new.send_request(request)
+      end
+
+      def test_send_transaction_request
+        payment.set_address(supported_na_address)
+        Faraday.expects(:send).returns(
+          OpenStruct.new(status: 200, body: { foo: 'bar' }.to_json)
+        )
+
+        response = Gateway.new.send_transaction_request(request)
+
+        assert(response.is_a?(ActiveMerchant::Billing::Response))
+        assert(response.success?)
+        assert_equal({ 'foo' => 'bar' }, response.params)
+      end
+    end
+  end
+end

data/test/models/workarea/checkout/steps/klarna_payment_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+module Workarea
+  class Checkout
+    module Steps
+      class KlarnaPaymentTest < TestCase
+        setup :set_shipping_service, :set_product, :set_addresses
+
+        def set_shipping_service
+          create_shipping_service(
+            name: 'Test',
+            rates: [{ price: 5.to_m }],
+            tax_code: '001'
+          )
+        end
+
+        def set_product
+          create_product(id: 'PROD')
+        end
+
+        def set_addresses
+          address_params = {
+            first_name:   'Ben',
+            last_name:    'Crouse',
+            street:       '22 S. 3rd St.',
+            city:         'Philadelphia',
+            region:       'PA',
+            postal_code:  '19106',
+            country:      'US',
+            phone_number: '2159251800'
+          }
+
+          Addresses.new(checkout).update(
+            shipping_address: address_params,
+            billing_address: address_params
+          )
+        end
+
+        def order
+          @order ||= create_order(
+            email: 'test@workarea.com',
+            items: [{ product_id: 'PROD', sku: 'SKU' }]
+          )
+        end
+
+        def checkout
+          @checkout ||= Checkout.new(order)
+        end
+
+        def payment
+          @payment ||= checkout.payment
+        end
+
+        def step
+          @step ||= Checkout::Steps::Payment.new(checkout)
+        end
+
+        def test_setting_klarna_tender
+          assert(
+            step.update(
+              payment: 'klarna_pay_later',
+              klarna: { authorization_token: '123' }
+            )
+          )
+
+          assert(payment.klarna.present?)
+          assert(payment.klarna.amount)
+          assert(payment.klarna.authorization_token.present?)
+
+          step.update
+          assert_nil(payment.klarna)
+
+          payment.address = nil
+          refute(step.update)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/klarna_payment_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module Workarea
+  class KlarnaPaymentTest < TestCase
+    setup :configure_klarna_data
+
+    def test_set_klarna
+      payment = Payment.new
+
+      assert_nil(payment.klarna)
+
+      payment.set_klarna(
+        authorization_token: '234',
+        authorization_token_expires_at: 1.hour.from_now,
+        payment_method_category: 'pay_later',
+        amount: 10000000.to_m
+      )
+
+      assert(payment.klarna.present?)
+      assert_equal('234', payment.klarna.authorization_token)
+      assert(payment.klarna.authorization_token_expires_at.present?)
+      assert_equal('pay_later', payment.klarna.payment_method_category)
+      assert_equal(0.to_m, payment.klarna.amount)
+
+      payment.clear_klarna
+      assert_nil(payment.klarna)
+    end
+
+    def test_eligible_for_klarna?
+      payment = Payment.new
+
+      refute(payment.eligible_for_klarna?)
+
+      payment.build_address(unsupported_address)
+
+      assert(payment.address.valid?)
+      refute(payment.eligible_for_klarna?)
+
+      payment.address.attributes = supported_eur_address
+
+      assert(payment.address.valid?)
+      assert(payment.eligible_for_klarna?)
+    end
+  end
+end

data/test/models/workarea/payment/authorize/klarna_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module Workarea
+  class Payment
+    module Authorize
+      class KlarnaTest < TestCase
+        setup :create_supporting_data_for_klarna, :add_tender, :enable_klarna
+
+        def add_tender
+          # this auth token will need to be an active one if you want to
+          # regenerate the VCR cassette.
+          create_klarna_tender(
+            payment: @payment,
+            authorization_token: '31ae5ab6-d4d5-145f-b71b-36cd8404c5ba',
+            payment_method_category: 'pay_later'
+          )
+        end
+
+        def test_operation
+          txn = @payment.klarna.build_transaction(action: 'authorize')
+          operation = Authorize::Klarna.new(@payment.klarna, txn)
+
+          VCR.use_cassette('klarna_authorize') do
+            operation.complete!
+          end
+
+          assert(txn.success?)
+          assert(txn.response.params['order_id'].present?)
+          assert(txn.response.params['redirect_url'].present?)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/payment/capture/klarna_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Workarea
+  class Payment
+    class Capture
+      class KlarnaTest < TestCase
+        setup :enable_klarna
+
+        def test_operation
+          payment = create_payment(
+            address: supported_na_address,
+            klarna: { amount: 10.to_m }
+          )
+
+          # You will need a valid order_id if you want to regenerate the
+          # VCR cassettes for this test.
+          payment.klarna.stubs(:order_id).returns('1dab0505-d1d5-1041-ac57-5ffda5af139c')
+
+          txn = payment.klarna.build_transaction(amount: 5.to_m, action: 'capture')
+          operation = Capture::Klarna.new(payment.klarna, txn)
+
+          VCR.use_cassette('klarna_capture') do
+            operation.complete!
+          end
+
+          assert(txn.success?)
+          assert_equal(
+            t(
+              'workarea.klarna.gateway.response.success',
+              summary: t('workarea.klarna.gateway.request.capture', amount: 5.to_m.format)
+            ),
+            txn.response.message
+          )
+
+          VCR.use_cassette('klarna_refund') do
+            operation.cancel!
+          end
+
+          assert(txn.cancellation.success?)
+          assert_equal(
+            t(
+              'workarea.klarna.gateway.response.success',
+              summary: t('workarea.klarna.gateway.request.refund', amount: 5.to_m.format)
+            ),
+            txn.cancellation.message
+          )
+        end
+      end
+    end
+  end
+end