spree_affirm 0.2.19 → 0.2.20

data/lib/generators/spree_affirm/install/install_generator.rb

@@ -0,0 +1,21 @@
+module SpreeAffirm
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+
+      class_option :auto_run_migrations, :type => :boolean, :default => false
+
+      def add_migrations
+        run 'bundle exec rake railties:install:migrations FROM=spree_affirm'
+      end
+
+      def run_migrations
+        run_migrations = options[:auto_run_migrations] || ['', 'y', 'Y'].include?(ask 'Would you like to run the migrations now? [Y/n]')
+        if run_migrations
+          run 'bundle exec rake db:migrate'
+        else
+          puts 'Skipping rake db:migrate, don\'t forget to run it!'
+        end
+      end
+    end
+  end
+end

data/lib/spree_affirm.rb

@@ -0,0 +1,2 @@
+require 'spree_core'
+require 'spree_affirm/engine'

data/lib/spree_affirm/engine.rb

@@ -0,0 +1,27 @@
+module SpreeAffirm
+  class Engine < Rails::Engine
+    require 'spree/core'
+    isolate_namespace Spree
+    engine_name 'spree_affirm'
+
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    config.autoload_paths += %W(#{config.root}/lib)
+
+    def self.activate
+      Dir.glob(File.join(File.dirname(__FILE__), '../../app/**/*_decorator*.rb')) do |c|
+        Rails.configuration.cache_classes ? require(c) : load(c)
+      end
+    end
+
+    config.to_prepare &method(:activate).to_proc
+
+    initializer "spree.spree_affirm.payment_methods", :after => "spree.register.payment_methods" do |app|
+        app.config.spree.payment_methods << Spree::Gateway::Affirm
+    end
+  end
+end

data/lib/spree_affirm/factories.rb

@@ -0,0 +1,5 @@
+require 'factory_girl'
+
+Dir["#{File.dirname(__FILE__)}/factories/**"].each do |f|
+  require File.expand_path(f)
+end

data/lib/spree_affirm/factories/affirm_checkout_factory.rb

@@ -0,0 +1,219 @@
+def BASE_CHECKOUT_DETAILS
+  {
+    "merchant"=> {
+      "public_api_key"=> "PPPPPPPPPPPPPPP",
+      "user_cancel_url"=> "http=>//google.com/cancel",
+      "user_confirmation_url"=> "http=>//google.com/confirm",
+      "name"=> "Test Merchant"
+    },
+    "tax_amount"=> 0,
+    "billing"=> {
+      "address"=> {
+        "city"=> "San Francisco",
+        "street1"=> "12345 Main",
+        "street2"=> "300",
+        "region1_code"=> "AL",
+        "postal_code"=> "55555",
+        "country_code"=> "USA",
+        "for_billing"=> true,
+        "validation_source"=> 3
+      },
+      "email"=> "test@affirm.com",
+      "name"=> {
+        "for_billing"=> true,
+        "last"=> "Doe",
+        "first"=> "John"
+      }
+    },
+    "items"=> {
+      "xxx-xx-xxx-x"=> {
+        "sku"=> "xxx-xx-xxx-x",
+        "item_url"=> "http=>//google.com/products/the-blue-hat",
+        "display_name"=> "The Blue Hat",
+        "unit_price"=> 85000,
+        "qty"=> 1,
+        "item_type"=> "physical",
+        "item_image_url"=> "http=>//google.com/products/6/large/the-blue-hat"
+      }
+    },
+    "shipping"=> {
+      "name"=> {
+        "last"=> "Doe",
+        "first"=> "John"
+      },
+      "address"=> {
+        "city"=> "San Francisco",
+        "street1"=> "12345 Main Street",
+        "street2"=> "300",
+        "region1_code"=> "AL",
+        "postal_code"=> "94110",
+        "country_code"=> "USA",
+        "validation_source"=> 3
+      }
+    },
+    "checkout_id"=> "S123123-456",
+    "currency"=> "USD",
+    "meta"=> {
+      "release"=> "true",
+      "user_timezone"=> "America/Los_Angeles",
+      "__affirm_tracking_uuid"=> "97570a41-cd07-4f52-8869-46c6d2588407"
+    },
+    "discount_code"=> "",
+    "misc_fee_amount"=> 0,
+    "shipping_type"=> "Free National UPS",
+    "config"=> {
+      "financial_product_key"=> "XXXXXXXXXXXXXXX",
+      "financial_product_type"=> "splitpay",
+      "required_billing_fields"=> [
+        "name",
+        "address",
+        "email"
+      ]
+    },
+    "api_version"=> "v2",
+    "shipping_amount"=> 0
+  }
+end
+
+FactoryGirl.define do
+  factory :affirm_checkout, class: Spree::AffirmCheckout do
+    token "12345678910"
+    association(:payment_method, factory: :affirm_payment_method)
+    association(:order, factory: :order_with_line_items)
+
+
+    ignore do
+      stub_details true
+      product_key_mismatch false
+      shipping_address_mismatch false
+      billing_address_mismatch false
+      alternate_billing_address_format false
+      billing_address_full_name false
+      billing_email_mismatch false
+      extra_line_item false
+      missing_line_item false
+      quantity_mismatch false
+      price_mismatch false
+      full_name_case_mismatch false
+    end
+
+    after(:build) do |checkout, evaluator|
+
+      _details = BASE_CHECKOUT_DETAILS()
+
+      # product keys
+      unless evaluator.product_key_mismatch
+        _details['config']['financial_product_key'] = checkout.payment_method.preferred_product_key
+      end
+
+      # case mismatch
+      unless evaluator.full_name_case_mismatch
+        _details['billing']['name'] = {
+          "full" => checkout.order.bill_address.firstname.upcase + " " +
+                    checkout.order.bill_address.lastname.upcase
+        }
+      end
+
+      # shipping address
+      unless evaluator.shipping_address_mismatch
+        _details['shipping'] = {
+          "name" => {
+            "first" => checkout.order.ship_address.firstname,
+            "last"  => checkout.order.ship_address.lastname
+          },
+          "address"=> {
+            "city"=> checkout.order.ship_address.city,
+            "street1"=> checkout.order.ship_address.address1,
+            "street2"=> checkout.order.ship_address.address2,
+            "region1_code"=> checkout.order.ship_address.state.abbr,
+            "postal_code"=> checkout.order.ship_address.zipcode,
+            "country_code"=> checkout.order.ship_address.country.iso3
+          }
+        }
+      end
+
+      # billing address
+      unless evaluator.billing_address_mismatch
+        _details["billing"] = {
+          "email" => "joe@schmoe.com",
+          "name" => {
+            "first" => checkout.order.bill_address.firstname,
+            "last"  => checkout.order.bill_address.lastname
+          },
+          "address"=> {
+            "city"=> checkout.order.bill_address.city,
+            "street1"=> checkout.order.bill_address.address1,
+            "street2"=> checkout.order.bill_address.address2,
+            "region1_code"=> checkout.order.bill_address.state.abbr,
+            "postal_code"=> checkout.order.bill_address.zipcode,
+            "country_code"=> checkout.order.bill_address.country.iso3
+          }
+        }
+      end
+
+      # use alternate format for billing address
+      if evaluator.alternate_billing_address_format
+        _details['billing']["address"] = {
+          "city" => _details['billing']["address"]["city"],
+          "line1"=> _details['billing']["address"]["street1"],
+          "line2"=> _details['billing']["address"]["street2"],
+          "state"=> _details['billing']["address"]["postal_code"],
+          "zipcode"=> _details['billing']["address"]["region1_code"],
+          "country"=> _details['billing']["address"]["country_code"]
+        }
+      end
+
+      # use name.full instead of first/last
+      if evaluator.billing_address_full_name
+        _details['billing']['name'] = {
+          'full' => "#{_details['billing']['name']['first']} #{_details['billing']['name']['last']}"
+        }
+      end
+
+
+      # billing email
+      unless evaluator.billing_email_mismatch
+        _details["billing"]["email"] = checkout.order.email
+      end
+
+      # setup items in cart
+      _details['items'] = {}
+      checkout.order.line_items.each do |item|
+        _details['items'][item.variant.sku] = {
+          "qty" => item.quantity.to_s,
+          "unit_price" => (item.price*100).to_s,
+          "display_name" => item.product.name
+        }
+      end
+
+      if evaluator.extra_line_item
+        _details['items']['extra-1-2-3'] = {
+          "qty" => "1",
+          "unit_price" => "12300",
+          "display_name" => "Really cool hat"
+        }
+      end
+
+      if evaluator.missing_line_item
+        _details['items'].delete _details['items'].keys.last
+      end
+
+      if evaluator.quantity_mismatch
+        _last_item = _details['items'][_details['items'].keys.last]
+        _details['items'][_details['items'].keys.last]['qty'] = (_last_item['qty'].to_i + 1).to_s
+      end
+
+      if evaluator.price_mismatch
+        _last_item = _details['items'][_details['items'].keys.last]
+        _details['items'][_details['items'].keys.last]['unit_price'] = 456456
+      end
+
+      if evaluator.stub_details
+        checkout.stub(details: _details)
+      end
+    end
+
+  end
+end
+
+

data/lib/spree_affirm/factories/affirm_payment_method_factory.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :affirm_payment_method, class: Spree::Gateway::Affirm do
+    name "Staging Affirm Split Pay"
+    active true
+    environment "test"
+    auto_capture false
+  end
+end

data/lib/spree_affirm/factories/payment_factory.rb

@@ -0,0 +1,10 @@
+FactoryGirl.define do
+  factory :affirm_payment, class: Spree::Payment do
+    amount 45.75
+    association(:payment_method, factory: :affirm_payment_method)
+    association(:source, factory: :affirm_checkout)
+    order
+    state 'checkout'
+    response_code '12345'
+  end
+end

data/lib/spree_affirm/version.rb

@@ -0,0 +1,3 @@
+module SpreeAffirm
+  VERSION = "0.2.20"
+end

data/spec/controllers/affirm_controller_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe Spree::AffirmController do
+  let(:user) { FactoryGirl.create(:user) }
+  let(:checkout) { FactoryGirl.build(:affirm_checkout) }
+  let(:bad_billing_checkout) { FactoryGirl.build(:affirm_checkout, billing_address_mismatch: true) }
+  let(:bad_shipping_checkout) { FactoryGirl.build(:affirm_checkout, shipping_address_mismatch: true) }
+  let(:bad_email_checkout) { FactoryGirl.build(:affirm_checkout, billing_email_mismatch: true) }
+
+
+  describe "POST confirm" do
+
+    def post_request(token, payment_id)
+      post :confirm, checkout_token: token, payment_method_id: payment_id, use_route: 'spree'
+    end
+
+    before do
+      controller.stub authenticate_spree_user!: true
+      controller.stub spree_current_user: user
+    end
+
+    context "when the checkout matches the order" do
+      before do
+        Spree::AffirmCheckout.stub new: checkout
+        controller.stub current_order: checkout.order
+      end
+
+      context "when no checkout_token is provided" do
+        it "redirects to the current order state" do
+          post_request(nil, nil)
+          expect(response).to redirect_to(controller.checkout_state_path(checkout.order.state))
+        end
+      end
+
+      context "when the order is complete" do
+        before do
+          checkout.order.state = 'complete'
+        end
+        it "redirects to the current order state" do
+          post_request '123456789', checkout.payment_method.id
+          expect(response).to redirect_to(controller.order_path(checkout.order))
+        end
+      end
+
+      context "when the order state is payment" do
+        before do
+          checkout.order.state = 'payment'
+        end
+
+        it "creates a new payment" do
+          post_request "123423423", checkout.payment_method.id
+
+          expect(checkout.order.payments.first.source).to eq(checkout)
+        end
+
+        # it "transitions to complete if confirmation is not required" do
+        #   checkout.order.stub confirmation_required?: false
+        #   post_request "123423423", checkout.payment_method.id
+
+        #   expect(checkout.order.state).to eq("complete")
+        # end
+
+        it "transitions to confirm if confirmation is required" do
+          checkout.order.stub confirmation_required?: true
+          post_request "123423423", checkout.payment_method.id
+
+          expect(checkout.order.reload.state).to eq("confirm")
+        end
+      end
+
+    end
+
+    context "when the billing_address does not match the order" do
+      before do
+        Spree::AffirmCheckout.stub new: bad_billing_checkout
+        state = FactoryGirl.create(:state, abbr: bad_billing_checkout.details['billing']['address']['region1_code'])
+        Spree::State.stub find_by_abbr: state, find_by_name: state
+        controller.stub current_order: bad_billing_checkout.order
+      end
+
+      it "creates a new address record for the order" do
+        _old_billing_address = bad_billing_checkout.order.bill_address
+        post_request '12345789', bad_billing_checkout.payment_method.id
+
+        expect(bad_billing_checkout.order.bill_address).not_to be(_old_billing_address)
+        expect(bad_billing_checkout.valid?).to be(true)
+      end
+    end
+
+
+    context "when the shipping_address does not match the order" do
+      before do
+        Spree::AffirmCheckout.stub new: bad_shipping_checkout
+        state = FactoryGirl.create(:state, abbr: bad_shipping_checkout.details['shipping']['address']['region1_code'])
+        Spree::State.stub find_by_abbr: state, find_by_name: state
+        controller.stub current_order: bad_shipping_checkout.order
+      end
+
+      it "creates a new address record for the order" do
+        _old_shipping_address = bad_shipping_checkout.order.ship_address
+        post_request '12345789', bad_shipping_checkout.payment_method.id
+
+        expect(bad_shipping_checkout.order.ship_address).not_to be(_old_shipping_address)
+        expect(bad_shipping_checkout.valid?).to be(true)
+      end
+    end
+
+
+
+    context "when the billing_email does not match the order" do
+      before do
+        Spree::AffirmCheckout.stub new: bad_email_checkout
+        controller.stub current_order: bad_email_checkout.order
+      end
+
+      it "updates the billing_email on the order" do
+        _old_email = bad_email_checkout.order.email
+        post_request '12345789', bad_email_checkout.payment_method.id
+
+        expect(bad_email_checkout.order.email).not_to be(_old_email)
+        expect(bad_email_checkout.valid?).to be(true)
+      end
+    end
+
+
+    context "there is no current order" do
+      before(:each) do
+        controller.stub current_order: nil
+      end
+
+      it "raises an ActiveRecord::RecordNotFound error" do
+        expect do
+          post_request nil, nil
+        end.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end