workarea-gift_cards 3.4.10 → 4.0.3

data/test/integration/workarea/storefront/gift_cards_integration_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class GiftCardsIntegrationTest < Workarea::IntegrationTest
+      def test_balance_lookup
+        gift_card = create_gift_card(to: 'test@workarea.com', amount: 12.to_m)
+
+        get storefront.gift_cards_lookup_path,
+            params: {
+              email: gift_card.to,
+              token: gift_card.token
+            }
+
+        assert_redirected_to(storefront.gift_cards_balance_path)
+        assert_equal(
+          t(
+            'workarea.storefront.flash_messages.gift_card_balance',
+            balance: gift_card.balance.format
+          ),
+          flash[:success]
+        )
+
+        get storefront.gift_cards_lookup_path,
+            params: {
+              email: 'foo@workarea.com',
+              token: gift_card.token
+            }
+
+        assert_equal(
+          t('workarea.storefront.flash_messages.gift_card_not_found'),
+          flash[:error]
+        )
+
+        get storefront.gift_cards_lookup_path,
+            params: {
+              email: gift_card.to,
+              token: '125'
+            }
+
+        assert_equal(
+          t('workarea.storefront.flash_messages.gift_card_not_found'),
+          flash[:error]
+        )
+      end
+    end
+  end
+end

data/test/integration/workarea/storefront/purchase_gift_cards_integration_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class PurchaseGiftCardsIntegrationTest < Workarea::IntegrationTest
+      include Storefront::IntegrationTest
+
+      def test_generates_gift_card
+        pass && (return) unless Workarea::GiftCards.uses_system_cards?
+
+        product = create_product(
+          name: 'Gift Card',
+          gift_card: true,
+          customizations: 'gift_card',
+          variants: [{ sku: 'GIFTCARD', regular: 10.to_m }]
+        )
+
+        create_fulfillment_sku(id: 'GIFTCARD', policy: :create_gift_card)
+
+        post storefront.cart_items_path,
+             params: {
+               product_id: product.id,
+               sku:        product.skus.first,
+               email:      'recipient@workarea.com',
+               from:       'from@workarea.com',
+               message:    'this is a message',
+               quantity:   1
+             }
+
+        complete_checkout
+
+        assert_equal(1, Payment::GiftCard.count)
+
+        card = Payment::GiftCard.first
+        assert_equal(10.to_m, card.amount)
+        assert_equal(0.to_m, card.used)
+        assert_equal(10.to_m, card.balance)
+        assert(card.order_id.present?)
+        assert(card.purchased?)
+
+        assert_equal(2, ActionMailer::Base.deliveries.length)
+
+        gift_card_email = ActionMailer::Base.deliveries.detect do |email|
+          assert_includes(email.to, 'recipient@workarea.com')
+        end
+
+        gift_card_email.parts.each do |part|
+          assert_includes(part.body, card.token)
+          assert_includes(part.body, 'from@workarea.com')
+          assert_includes(part.body, 'this is a message')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+require 'test_helper'
+
+module Workarea
+  module GiftCards
+    class GatewayTest < TestCase
+      setup :gift_card
+
+      # Override this to instantiate an object that models a gift card
+      # on the remote system.
+      def gift_card
+        @gift_card ||= create_gift_card(amount: 10.to_m)
+      end
+
+      # The tender object used on an order that will be passed into each
+      # gateway method call. Override this to provide your own
+      # information.
+      #
+      # @return [Payment::Tender::GiftCard]
+      def tender
+        @tender ||= Payment::Tender::GiftCard.new(
+          number: gift_card.token,
+          amount: 5.to_m
+        )
+      end
+
+      # Override this in your test to instantiate a gateway for use in
+      # tests. The class name of the gateway is used to generate the
+      # folder name for the VCR cassettes used within this test.
+      def gateway
+        Gateway.new
+      end
+
+      # Use the class name of the gateway to generate a directory in
+      # `test/vcr_cassettes` where all cassettes for the custom gateway
+      # will go. This doesn't need to be overridden unless you need to
+      # customize the gateway cassette directory name.
+      #
+      # @return [String]
+      def gateway_cassette_name
+        gateway.class.name.systemize
+      end
+
+      def test_authorize
+        VCR.use_cassette "#{gateway_cassette_name}/authorize" do
+          response = gateway.authorize(200, tender)
+
+          assert(response.success?)
+          assert(response.message.present?)
+
+          gift_card.reload
+          assert_equal(8.to_m, gift_card.balance)
+          assert_equal(2.to_m, gift_card.used)
+        end
+      end
+
+      def test_cancel
+        VCR.use_cassette "#{gateway_cassette_name}/cancel" do
+          response = gateway.authorize(200, tender)
+          assert(response.success?)
+
+          response = gateway.cancel(200, tender)
+
+          assert(response.success?)
+          assert(response.message.present?)
+
+          gift_card.reload
+          assert_equal(10.to_m, gift_card.balance)
+          assert_equal(0.to_m, gift_card.used)
+        end
+      end
+
+      def test_capture
+        VCR.use_cassette "#{gateway_cassette_name}/capture" do
+          assert(gateway.capture(200, tender).success?)
+          assert_equal(10.to_m, gift_card.reload.balance)
+        end
+      end
+
+      def test_purchase
+        VCR.use_cassette "#{gateway_cassette_name}/purchase" do
+          response = gateway.purchase(200, tender)
+
+          assert(response.success?)
+          assert(response.message.present?)
+
+          gift_card.reload
+          assert_equal(8.to_m, gift_card.balance)
+          assert_equal(2.to_m, gift_card.used)
+        end
+      end
+
+      def test_refund
+        VCR.use_cassette "#{gateway_cassette_name}/refund" do
+          response = gateway.authorize(200, tender)
+          assert(response.success?)
+
+          response = gateway.refund(200, tender)
+
+          assert(response.success?)
+          assert(response.message.present?)
+
+          gift_card.reload
+          assert_equal(10.to_m, gift_card.balance)
+          assert_equal(0.to_m, gift_card.used)
+        end
+      end
+
+      def test_balance
+        VCR.use_cassette "#{gateway_cassette_name}/balance" do
+          balance = gateway.balance(gift_card.number)
+          assert_equal(10.to_m, balance)
+
+          gateway.authorize(300, tender)
+
+          balance = gateway.balance(gift_card.number)
+          assert_equal(7.to_m, balance)
+        end
+      end
+
+      def test_lookup
+        VCR.use_cassette "#{gateway_cassette_name}/lookup" do
+          lookup = gateway.lookup(email: gift_card.to, token: gift_card.token)
+          assert_equal(gift_card.id, lookup.id)
+
+          lookup = gateway.lookup(email: 'foo', token: gift_card.token)
+          assert_nil(lookup)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+module Workarea
+  class Checkout
+    module Steps
+      class GiftCardTest < TestCase
+        setup :setup_checkout
+
+        def setup_checkout
+          create_shipping_service(name: 'Ground', rates: [{ price: 7.to_m }])
+
+          product = create_product(
+            name: 'Integration Product',
+            variants: [{ sku: 'SKU1', regular: 5.to_m }]
+          )
+
+          @order = create_order.tap do |order|
+            order.add_item(
+              product_id: product.id,
+              sku: product.skus.first,
+              quantity: 2
+            )
+          end
+
+          @checkout = Checkout.new(@order)
+          @checkout.update(
+            email: 'test@workarea.com',
+            billing_address: factory_defaults(:billing_address),
+            shipping_address: factory_defaults(:shipping_address),
+            shipping_service: 'Ground'
+          )
+
+          @payment = @checkout.payment
+        end
+
+        def test_update
+          card_one = create_gift_card(amount: 10.to_m)
+          card_two = create_gift_card(amount: 20.to_m)
+
+          step = Checkout::Steps::GiftCard.new(@checkout)
+          assert(step.update(gift_card_number: " #{card_one.number}  "))
+
+          @payment.reload
+          assert_equal(1, @payment.gift_cards.count)
+
+          tender = @payment.gift_cards.first
+          assert_equal(card_one.token, tender.number)
+          assert_equal(10.to_m, tender.amount)
+
+          @order.reload
+          assert_equal(17.to_m, @order.total_price)
+
+          step = Checkout::Steps::GiftCard.new(@checkout)
+          assert(step.update(gift_card_number: card_two.number))
+
+          @payment.reload
+          assert_equal(2, @payment.gift_cards.count)
+
+          tender = @payment.gift_cards.first
+          assert_equal(card_one.token, tender.number)
+          assert_equal(10.to_m, tender.amount)
+
+          tender = @payment.gift_cards.last
+          assert_equal(card_two.token, tender.number)
+          assert_equal(7.to_m, tender.amount)
+        end
+
+        def test_remove
+          card_one = create_gift_card(amount: 10.to_m)
+          card_two = create_gift_card(amount: 20.to_m)
+
+          step = Checkout::Steps::GiftCard.new(@checkout)
+          step.update(gift_card_number: card_one.token)
+          step.update(gift_card_number: card_two.token)
+
+          assert_equal(2, @payment.reload.gift_cards.count)
+          assert_equal(10.to_m, @payment.gift_cards.first.amount)
+          assert_equal(7.to_m, @payment.gift_cards.last.amount)
+
+          step.remove(@payment.gift_cards.first)
+          assert_equal(1, @payment.reload.gift_cards.count)
+          assert_equal(card_two.token, @payment.gift_cards.first.number)
+          assert_equal(17.to_m, @payment.gift_cards.first.amount)
+        end
+
+        def test_complete?
+          card = create_gift_card(amount: 10.to_m)
+          step = Checkout::Steps::GiftCard.new(@checkout)
+
+          assert(step.complete?)
+
+          @payment.add_gift_card(number: card.number)
+          assert(step.complete?)
+
+          @payment.add_gift_card(number: '')
+          refute(step.complete?)
+
+          @payment.reload.add_gift_card(number: '1234')
+          refute(step.complete?)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/fulfillment/policies/create_gift_card_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Workarea
+  class Fulfillment
+    module Policies
+      class CreateGiftCardTest < TestCase
+        def test_process
+          order = create_order
+          order.add_item(
+            product_id: 'PROD',
+            sku: 'SKU',
+            gift_card: true,
+            fulfillment: 'create_gift_card',
+            customizations: {
+              'email' => 'bob@workarea.com',
+              'from' => 'system@workarea.com',
+              'message' => 'Hello'
+            },
+            price_adjustments: [{ amount: 10.to_m }]
+          )
+
+          fulfillment = Fulfillment.new(
+            id: order.id,
+            items: [{ order_item_id: order.items.first.id, quantity: 1 }]
+          )
+
+          sku = create_fulfillment_sku(id: 'SKU', policy: :create_gift_card)
+          policy = CreateGiftCard.new(sku)
+
+          policy.process(order_item: order.items.first, fulfillment: fulfillment)
+
+          card = Payment::GiftCard.first
+          assert(card.present?)
+          assert(card.notify)
+          assert(card.purchased)
+          assert_equal('bob@workarea.com', card.to)
+          assert_equal('system@workarea.com', card.from)
+          assert_equal('Hello', card.message)
+          assert_equal(order.id, card.order_id)
+          assert_equal(10.to_m, card.amount)
+
+          assert_equal(1, fulfillment.items.first.quantity_shipped)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/gift_card_payment_test.rb

@@ -2,11 +2,23 @@ require 'test_helper'
 
 module Workarea
   class GiftCardPaymentTest < TestCase
-    def test_set_gift_card
+    def test_add_gift_card
+      Workarea.config.max_gift_cards_per_order = 2
+
       payment = create_payment
 
-      payment.set_gift_card(number: '1234')
-      assert_equal('1234', payment.gift_card.number)
+      assert(payment.add_gift_card(number: '1234'))
+      assert_equal(1, payment.gift_cards.count)
+      assert_equal('1234', payment.gift_cards.first.number)
+
+      assert(payment.add_gift_card(number: '1234'))
+      assert_equal(1, payment.gift_cards.count)
+
+      assert(payment.add_gift_card(number: '3456'))
+      assert_equal(2, payment.gift_cards.count)
+
+      refute(payment.add_gift_card(number: '7890'))
+      assert_equal(2, payment.gift_cards.count)
     end
   end
 end

data/test/models/workarea/payment/purchase/gift_card_test.rb

@@ -15,16 +15,17 @@ module Workarea
         end
 
         def test_complete!
-          payment.set_gift_card(number: 'token')
+          payment.add_gift_card(number: 'token')
+          gift_card = payment.gift_cards.first
 
-          transaction = payment.gift_card.build_transaction(amount: 10.to_m)
+          transaction = gift_card.build_transaction(amount: 10.to_m)
 
-          GiftCard.new(payment.gift_card, transaction).complete!
+          GiftCard.new(gift_card, transaction).complete!
           refute(transaction.success?)
           assert(transaction.message.present?)
 
-          transaction = payment.gift_card.build_transaction(amount: 3.to_m)
-          purchase = GiftCard.new(payment.gift_card, transaction)
+          transaction = gift_card.build_transaction(amount: 3.to_m)
+          purchase = GiftCard.new(gift_card, transaction)
           purchase.complete!
 
           assert(transaction.success?)
@@ -32,10 +33,12 @@ module Workarea
         end
 
         def test_cancel!
-          payment.set_gift_card(number: 'token')
-          transaction = payment.gift_card.build_transaction(amount: 5.to_m)
+          payment.add_gift_card(number: 'token')
+          gift_card = payment.gift_cards.first
 
-          purchase = GiftCard.new(payment.gift_card, transaction)
+          transaction = gift_card.build_transaction(amount: 5.to_m)
+
+          purchase = GiftCard.new(gift_card, transaction)
           purchase.cancel!
 
           refute(transaction.cancellation.present?)