solidus_paypal_commerce_platform 0.5.0 → 1.0.0.beta1

data/spec/models/solidus_paypal_commerce_platform/paypal_order_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::PaypalOrder, type: :model do
+  describe '#to_json' do
+    subject(:to_json) { described_class.new(order).to_json('intent') }
+
+    let(:order) { create(:order_ready_to_complete, ship_address: ship_address, bill_address: bill_address) }
+    let(:ship_address) { create_address('John', 'Von Doe') }
+    let(:bill_address) { create_address('Johnny', 'Vonny Doey') }
+
+    it { expect { to_json }.not_to raise_error }
+
+    it 'represents amounts as strings with double decimals' do
+      purchase_unit = to_json.dig(:purchase_units, 0)
+      expect(purchase_unit.dig(:amount, :breakdown)).to eq(
+        item_total: { currency_code: "USD", value: "10.00" },
+        shipping: { currency_code: "USD", value: "100.00" },
+        tax_total: { currency_code: "USD", value: "0.00" },
+        discount: { currency_code: "USD", value: "0.00" }
+      )
+      expect(purchase_unit.dig(:items, 0, :unit_amount)).to eq(currency_code: "USD", value: "10.00")
+    end
+
+    it 'maps the bill and ship address names correctly' do
+      expect(to_json).to match hash_including(
+        purchase_units: array_including(
+          hash_including(shipping: hash_including(name: { full_name: 'John Von Doe' }))
+        ),
+        payer: hash_including(name: { given_name: 'Johnny', surname: 'Vonny Doey' })
+      )
+    end
+
+    context 'when the item name is greater than 127 characters' do
+      let(:variant) { create(:variant, product: create(:product, name: 'a' * 128)) }
+      let(:order) do
+        create(:order_ready_to_complete, line_items_attributes: [{ variant: variant, quantity: 1, price: 10 }])
+      end
+
+      it 'returns the truncated name' do
+        expect(to_json).to match hash_including(
+          purchase_units: array_including(
+            hash_including(
+              items: array_including(hash_including(name: "#{'a' * 124}..."))
+            )
+          )
+        )
+      end
+    end
+
+    context 'when checkout_steps does not include "delivery"' do
+      let(:old_checkout_flow) { Spree::Order.checkout_flow }
+
+      before do
+        old_checkout_flow
+
+        Spree::Order.class_eval do
+          remove_checkout_step :delivery
+        end
+      end
+
+      after do
+        Spree::Order.checkout_flow(&old_checkout_flow)
+      end
+
+      it 'disable shipping requirements' do
+        expect(to_json).to match hash_including(
+          application_context: hash_including(shipping_preference: 'NO_SHIPPING')
+        )
+      end
+    end
+  end
+
+  private
+
+  def create_address(firstname, lastname)
+    create(:address, name: "#{firstname} #{lastname}")
+  end
+end

data/spec/models/solidus_paypal_commerce_platform/state_guesser_spec.rb

@@ -0,0 +1,38 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::StateGuesser, type: :model do
+  let(:country) { create(:country, iso: "IT") }
+  let!(:state) { create(:state, country: country, name: "Abruzzo") }
+
+  describe "#guess" do
+    context "with a guessable state error" do
+      it "correctly guesses the state" do
+        expect(
+          described_class.new("Pescara", country).guess
+        ).to eq state
+      end
+
+      it "guesses the state using an abbreviation" do
+        expect(
+          described_class.new("PE", country).guess
+        ).to eq state
+      end
+    end
+
+    context "with an unsolvable state error" do
+      it "returns nil" do
+        expect(
+          described_class.new("Gondor", country).guess
+        ).to be_nil
+      end
+    end
+
+    context "with an already correct state" do
+      it "returns the correct state" do
+        expect(
+          described_class.new("Abruzzo", country).guess
+        ).to eq state
+      end
+    end
+  end
+end

data/spec/models/solidus_paypal_commerce_platform/wizard_spec.rb

@@ -0,0 +1,9 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::Wizard do
+  describe "#nonce" do
+    it 'is between 45 and 128 chars long' do
+      expect(subject.nonce.size).to be_between(45, 128)
+    end
+  end
+end

data/spec/requests/solidus_paypal_commerce_platform/orders_controller_spec.rb

@@ -0,0 +1,36 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::OrdersController, type: :request do
+  stub_authorization!
+  let(:order) { create(:order_with_line_items) }
+
+  describe "GET /solidus_paypal_commerce_platform/verify_total" do
+    context "when the amount is correct" do
+      it "passes" do
+        params = {
+          order_id: order.number,
+          paypal_total: order.total,
+          format: :json
+        }
+
+        get solidus_paypal_commerce_platform.verify_total_path, params: params
+
+        expect(response).to have_http_status(:ok)
+      end
+    end
+
+    context "when the amount is incorrect" do
+      it "fails" do
+        params = {
+          order_id: order.number,
+          paypal_total: order.total - 1,
+          format: :json
+        }
+
+        get solidus_paypal_commerce_platform.verify_total_path, params: params
+
+        expect(response).to have_http_status(:bad_request)
+      end
+    end
+  end
+end

data/spec/requests/solidus_paypal_commerce_platform/shipping_rates_controller_spec.rb

@@ -0,0 +1,44 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::ShippingRatesController, type: :request do
+  stub_authorization!
+  let(:new_country) { create(:country, iso: "IT", states_required: true) }
+  let(:new_state) { create(:state, country: new_country) }
+  let(:new_address) { build(:address, country: new_country, state: new_state) }
+  let(:order) { Spree::TestingSupport::OrderWalkthrough.up_to(:payment) }
+  let(:paypal_address) {
+    {
+      country_code: new_country.iso,
+      city: new_address.city,
+      state: new_state&.abbr,
+      postal_code: new_address.zipcode
+    }
+  }
+
+  describe "GET /simulate_shipping_rates" do
+    before do
+      get solidus_paypal_commerce_platform.shipping_rates_path, params: {
+        order_id: order.number,
+        address: paypal_address
+      }
+    end
+
+    it "returns a paypal_order without the simulated address" do
+      expect(response.body).not_to include "admin_area_1\":\"#{new_address.state.abbr}\""
+      expect(response.body).not_to include "admin_area_1\":\"#{order.ship_address.state.abbr}\""
+    end
+
+    it "does not modify original address" do
+      expect(order.ship_address).not_to eq new_address
+    end
+
+    context "with an invalid address" do
+      let(:new_state) { nil }
+
+      it "returns a list of errors" do
+        expect(response).to have_http_status(:unprocessable_entity) # unprocessable_entity
+        expect(response.body).to include "State can't be blank"
+      end
+    end
+  end
+end

data/spec/requests/solidus_paypal_commerce_platform/wizard_controller_spec.rb

@@ -0,0 +1,59 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe SolidusPaypalCommercePlatform::WizardController, type: :request do
+  stub_authorization!
+
+  let(:wizard) { SolidusPaypalCommercePlatform::Wizard.new }
+
+  describe "POST /solidus_paypal_commerce_platform/wizard" do
+    let(:params) {
+      {
+        authCode: "PFc4d2vp4DVfHqcnEHbGAA12C_H29U39NM_vmQrZBPzdLcxA12Br-GzjbliqXGu3AG6Gfwo5G9GTal6REkcKGMREc9fPsR_wv",
+        sharedId: "awj45zMAy1XonxWfgIhjjGHZGAPStkZFzXp4bfe1QmNWA-9DL6HkpklD0skHig4vVF7zVZD8Uwy5Qop4",
+        nonce: wizard.nonce,
+      }
+    }
+
+    it "creates a new payment method from data received from PayPal" do
+      expect_any_instance_of(SolidusPaypalCommercePlatform::Client).to receive(:execute) do |_client, request|
+        case request
+        when SolidusPaypalCommercePlatform::AccessTokenAuthorizationRequest
+          # rubocop:disable RSpec/VerifiedDoubles
+          double(
+            'response',
+            result: double(
+              'result',
+              access_token: "ACCESS-TOKEN"
+            )
+          )
+          # rubocop:enable RSpec/VerifiedDoubles
+        when SolidusPaypalCommercePlatform::FetchMerchantCredentialsRequest
+          expect(request.headers.fetch("Authorization")).to eq("Bearer ACCESS-TOKEN")
+
+          # rubocop:disable RSpec/VerifiedDoubles
+          double(
+            'response',
+            result: double(
+              'result',
+              client_id: "CLIENT-ID",
+              client_secret: "CLIENT-SECRET",
+            )
+          )
+          # rubocop:enable RSpec/VerifiedDoubles
+        else
+          raise "unexpected request: #{request}"
+        end
+      end.twice
+
+      expect {
+        post solidus_paypal_commerce_platform.wizard_index_path, params: params
+      }.to change(SolidusPaypalCommercePlatform::PaymentMethod, :count).from(0).to(1)
+
+      payment_method = SolidusPaypalCommercePlatform::PaymentMethod.last
+
+      expect(payment_method.preferred_client_id).to eq("CLIENT-ID")
+      expect(payment_method.preferred_client_secret).to eq("CLIENT-SECRET")
+      expect(response).to have_http_status(:created)
+    end
+  end
+end

data/spec/solidus_paypal_commerce_platform_spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'solidus_starter_frontend_helper'
+
+Dir["#{__dir__}/support/solidus_paypal_commerce_platform/**/*.rb"].sort.each { |f| require f }

data/spec/support/solidus_paypal_commerce_platform/factories.rb

@@ -0,0 +1,5 @@
+FactoryBot.definition_file_paths << SolidusPaypalCommercePlatform::Engine.root.join(
+  'lib/solidus_paypal_commerce_platform/testing_support/factories'
+).to_s
+
+FactoryBot.reload

data/spec/support/solidus_paypal_commerce_platform/paypal_sdk_script_tag_helper.rb

@@ -0,0 +1,13 @@
+module PaypalSdkScriptTagHelper
+  def js_sdk_script_query
+    URI(page.find('script[src*="sdk/js?"]', visible: false)[:src]).query.split('&')
+  end
+
+  def js_sdk_script_partner_id
+    page.find('script[src*="sdk/js?"]', visible: false)['data-partner-attribution-id']
+  end
+end
+
+RSpec.configure do |config|
+  config.include PaypalSdkScriptTagHelper, type: :system
+end

data/spec/system/backend/new_payment_method_spec.rb

@@ -0,0 +1,40 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe "creating a new payment" do
+  stub_authorization!
+
+  it "displays PayPal Commerce Platform as an option" do
+    visit "/admin/payment_methods/new"
+    expect(page).to have_select('payment_method_type', options: [
+      "PayPal Commerce Platform",
+      "Bogus Credit Card Payments",
+      "Check Payments",
+      "Simple Bogus Credit Card Payments",
+      "Store Credit Payments",
+    ])
+    select "PayPal Commerce Platform", from: 'payment_method_type'
+    fill_in "Name", with: "PayPal!"
+    click_on "Create"
+    expect(page).to have_text("Payment Method has been successfully created!")
+
+    fill_in "Client", with: "cli-123"
+    fill_in "Client secret", with: "cli-sec-123"
+    click_on "Update"
+    expect(page).to have_text("Payment Method has been successfully updated!")
+  end
+
+  it "displays the onboarding button", :js do
+    visit "/admin/payment_methods"
+
+    # main_window = current_window
+
+    within ".setup-wizard" do
+      paypal_button = page.find("button")
+      expect(paypal_button.text).to eq("Setup PayPal Commerce Platform")
+      # TODO: make this more complete
+      # paypal_window = window_opened_by do
+      #   paypal_button.click
+      # end
+    end
+  end
+end

data/spec/system/frontend/cart_spec.rb

@@ -0,0 +1,53 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe "Cart page" do
+  describe "paypal payment method", :skip do
+    let(:order) { Spree::TestingSupport::OrderWalkthrough.up_to(:address) }
+    let(:paypal_payment_method) { create(:paypal_payment_method) }
+
+    before do
+      user = create(:user)
+      order.user = user
+      visit '/'
+      click_link 'Login'
+
+      fill_in 'spree_user[email]', with: user.email
+      fill_in 'spree_user[password]', with: 'secret'
+      click_button 'Login'
+
+      paypal_payment_method
+      allow_any_instance_of(OrdersController).to receive_messages(
+        current_order: order,
+        try_spree_current_user: user
+      )
+    end
+
+    context "when generating a script tag" do
+      it "generates a url with the correct credentials attached" do
+        visit '/cart/edit'
+        expect(js_sdk_script_query).to include("client-id=#{paypal_payment_method.preferences[:client_id]}")
+      end
+
+      it "generates a partner_id attribute with the correct partner code attached" do
+        visit '/cart/edit'
+        expect(js_sdk_script_partner_id).to eq("Solidus_PCP_SP")
+      end
+
+      it "generates a URL with the correct currency" do
+        order.update currency: "EUR"
+        visit '/cart/edit'
+        expect(js_sdk_script_query).to include("currency=EUR")
+      end
+
+      context "when auto-capture is set to true" do
+        it "generates a url with intent capture" do
+          paypal_payment_method.update(auto_capture: true)
+          visit '/cart/edit'
+
+          expect(js_sdk_script_query).to include("client-id=#{paypal_payment_method.preferences[:client_id]}")
+          expect(js_sdk_script_query).to include("intent=capture")
+        end
+      end
+    end
+  end
+end

data/spec/system/frontend/checkout_spec.rb

@@ -0,0 +1,104 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe "Checkout" do
+  describe "paypal payment method" do
+    let(:order) { Spree::TestingSupport::OrderWalkthrough.up_to(:payment) }
+    let(:paypal_payment_method) { create(:paypal_payment_method) }
+    let(:failed_response) { double('response', status_code: 500) } # rubocop:disable RSpec/VerifiedDoubles
+
+    before do
+      user = create(:user)
+      visit '/'
+      click_link 'Login'
+      fill_in 'spree_user[email]', with: user.email
+      fill_in 'spree_user[password]', with: 'secret'
+      click_button 'Login'
+      order.user = user
+      order.recalculate
+
+      paypal_payment_method
+      allow_any_instance_of(CheckoutsController).to receive_messages(
+        current_order: order, try_spree_current_user: user
+      )
+    end
+
+    context "when generating a script tag" do
+      it "generates a url with the correct credentials attached" do
+        visit '/checkout/payment'
+        expect(js_sdk_script_query).to include("client-id=#{paypal_payment_method.preferences[:client_id]}")
+      end
+
+      it "generates a partner_id attribute with the correct partner code attached" do
+        visit '/checkout/payment'
+        expect(js_sdk_script_partner_id).to eq("Solidus_PCP_SP")
+      end
+
+      it "generates a URL with the correct currency" do
+        allow(order).to receive(:currency).and_return "EUR"
+        visit '/checkout/payment'
+        expect(js_sdk_script_query).to include("currency=EUR")
+      end
+
+      context "when auto-capture is set to true" do
+        it "generates a url with intent capture" do
+          paypal_payment_method.update(auto_capture: true)
+          visit '/checkout/payment'
+          expect(js_sdk_script_query).to include("client-id=#{paypal_payment_method.preferences[:client_id]}")
+          expect(js_sdk_script_query).to include("intent=capture")
+        end
+      end
+    end
+
+    context "when no payment has been made" do
+      it "fails to process" do
+        visit '/checkout/payment'
+        choose(option: paypal_payment_method.id)
+        click_button("Save and Continue")
+        expect(page).to have_content("Payments source PayPal order can't be blank")
+      end
+    end
+
+    context "when a payment has been made" do
+      it "proceeds to the next step" do
+        visit '/checkout/payment'
+        choose(option: paypal_payment_method.id)
+        find(:xpath, "//input[@id='payments_source_paypal_order_id']", visible: false).set SecureRandom.hex(8)
+        click_button("Save and Continue")
+        expect(page).to have_css(".current", text: "Confirm")
+      end
+
+      it "records the paypal email address" do
+        visit '/checkout/payment'
+        choose(option: paypal_payment_method.id)
+        find(:xpath, "//input[@id='payments_source_paypal_order_id']", visible: false).set SecureRandom.hex(8)
+        find(:xpath, "//input[@id='payments_source_paypal_email']", visible: false).set "fake@email.com"
+        click_button("Save and Continue")
+        expect(Spree::Payment.last.source.paypal_email).to eq "fake@email.com"
+      end
+
+      it "records the paypal funding source" do
+        visit '/checkout/payment'
+        choose(option: paypal_payment_method.id)
+        find(:xpath, "//input[@id='payments_source_paypal_order_id']", visible: false).set SecureRandom.hex(8)
+        find(:xpath, "//input[@id='payments_source_paypal_email']", visible: false).set "fake@email.com"
+        find(:xpath, "//input[@id='payments_source_paypal_funding_source']", visible: false).set "venmo"
+        click_button("Save and Continue")
+        expect(Spree::Payment.last.source.paypal_funding_source).to eq "venmo"
+      end
+    end
+
+    context "when a payment fails" do
+      before { allow_any_instance_of(PayPal::PayPalHttpClient).to receive(:execute) { failed_response } }
+
+      it "redirects the user back to the payments page" do
+        visit '/checkout/payment'
+        choose(option: paypal_payment_method.id)
+        find(:xpath, "//input[@id='payments_source_paypal_order_id']", visible: false).set SecureRandom.hex(8)
+        click_button("Save and Continue")
+        click_button("Place Order")
+        expect(page).to have_current_path("/checkout/payment")
+        expect(page).to have_content("Your payment was declined")
+      end
+    end
+  end
+end

data/spec/system/frontend/product_spec.rb

@@ -0,0 +1,98 @@
+require 'solidus_paypal_commerce_platform_spec_helper'
+
+RSpec.describe "Product page", js: true do
+  describe "paypal button", :skip do
+    before { create(:store, default: true) }
+
+    let!(:paypal_payment_method) { create(:paypal_payment_method) }
+    let!(:variants) {
+      option_type = create(:option_type)
+      product = create(:product, option_types: [option_type], slug: 'foo-bar')
+      option_s = create(:option_value, option_type: option_type, presentation: 'S')
+      option_xs = create(:option_value, option_type: option_type, presentation: 'XS')
+
+      [
+        create(:variant, product: product, option_values: [option_s]),
+        create(:variant, product: product, option_values: [option_xs]),
+      ]
+    }
+
+    context "when generating a script tag" do
+      it "generates a url with the correct credentials attached" do
+        visit "/products/foo-bar"
+
+        expect(js_sdk_script_query).to include("client-id=#{paypal_payment_method.preferences[:client_id]}")
+      end
+
+      it "generates a partner_id attribute with the correct partner code attached" do
+        visit "/products/foo-bar"
+
+        expect(js_sdk_script_partner_id).to eq("Solidus_PCP_SP")
+      end
+
+      it "generates a URL with the correct currency" do
+        allow_any_instance_of(SolidusPaypalCommercePlatform::PricingOptions).to receive(:currency).and_return "EUR"
+
+        visit "/products/foo-bar"
+
+        expect(js_sdk_script_query).to include("currency=EUR")
+      end
+
+      context "when auto-capture is set to true" do
+        it "generates a url with intent capture" do
+          paypal_payment_method.update(auto_capture: true)
+
+          visit "/products/foo-bar"
+
+          expect(js_sdk_script_query).to include("client-id=#{paypal_payment_method.preferences[:client_id]}")
+          expect(js_sdk_script_query).to include("intent=capture")
+        end
+      end
+    end
+
+    describe "order creation" do
+      it "creates an order successfully" do
+        visit "/products/foo-bar"
+        page.evaluate_script("SolidusPaypalCommercePlatform.createOrder()")
+
+        expect(Spree::Order.last).to be_an_instance_of(Spree::Order)
+      end
+
+      it "sets the Spree number and token variables" do
+        visit "/products/foo-bar"
+        page.evaluate_script("SolidusPaypalCommercePlatform.createOrder()")
+
+        order = Spree::Order.last
+        expect(page.evaluate_script("SolidusPaypalCommercePlatform.current_order_id")).to eq order.number
+        expect(page.evaluate_script("SolidusPaypalCommercePlatform.current_order_token")).to eq order.guest_token
+      end
+
+      it "uses the specified quantity" do
+        visit "/products/foo-bar"
+        fill_in('quantity', with: 12)
+        page.evaluate_script("SolidusPaypalCommercePlatform.createOrder()")
+
+        expect(Spree::Order.last.line_items.first.quantity).to eq(12)
+      end
+
+      it "uses the selected variant" do
+        visit "/products/foo-bar"
+        find('label', text: 'XS').click
+        page.evaluate_script("SolidusPaypalCommercePlatform.createOrder()")
+
+        expect(Spree::Order.last.line_items.first.variant).to eq(variants.last)
+      end
+
+      it "assigns the order to the api token holder" do
+        user = create(:user)
+        user.generate_spree_api_key!
+
+        visit "/products/foo-bar"
+        page.evaluate_script("SolidusPaypalCommercePlatform.api_key = #{user.spree_api_key.to_json}")
+        page.evaluate_script("SolidusPaypalCommercePlatform.createOrder()")
+
+        expect(Spree::Order.last.user).to eq(user)
+      end
+    end
+  end
+end