solidus-adyen 0.1.2

data/spec/models/adyen_notification_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+RSpec.describe AdyenNotification do
+  it { is_expected.to have_many(:next).inverse_of(:prev) }
+  it { is_expected.to belong_to(:prev).inverse_of(:next) }
+  it { is_expected.to belong_to :order }
+
+  describe ".payment" do
+    subject { notification.payment }
+
+    let(:ref) { "999999999" }
+    let!(:payment) { create :payment, response_code: ref }
+    let!(:notification) { described_class.new attr => ref }
+
+    shared_examples "finds the payment" do
+      it { is_expected.to eq payment }
+    end
+
+    context "normal notification" do
+      let(:attr) { :original_reference }
+      include_examples "finds the payment"
+    end
+
+    context "modification notification" do
+      let(:attr) { :psp_reference }
+      include_examples "finds the payment"
+    end
+  end
+
+  describe "#build" do
+    subject { described_class.build params }
+
+    let(:params) do
+      { "currency" => "USD",
+        "eventCode" => "AUTHORISATION",
+        "eventDate" => "2013-10-21T00:00:00.00Z",
+        "live" => "false",
+        "merchantAccountCode" => "Test",
+        "merchantReference" => "R999999999",
+        "operations" => "CANCEL,CAPTURE,REFUND",
+        "originalReference" => "",
+        "paymentMethod" => "visa",
+        "pspReference" => "999999999",
+        "reason" => "41061:1111:6/2016",
+        "success" => "true",
+        "value" => "6999",
+      }
+    end
+
+    it "makes a new notification with the expected fields" do
+      is_expected.
+        to be_a_new_record.
+        and have_attributes(
+          currency: "USD",
+          event_code: "AUTHORISATION",
+          event_date: Time.utc(2013, 10, 21),
+          live: false,
+          merchant_account_code: "Test",
+          merchant_reference: "R999999999",
+          operations: "CANCEL,CAPTURE,REFUND",
+          original_reference: nil,
+          payment_method: "visa",
+          psp_reference: "999999999",
+          reason: "41061:1111:6/2016",
+          success: true,
+          value: 6999,
+        )
+    end
+  end
+
+  describe ".actions" do
+    subject { notification.actions }
+    let(:notification) { create :notification, :auth, operations: operations }
+
+    context "when the notification has operations" do
+      let(:operations) { "CAPTURE,REFUND,CANCEL_OR_REFUND" }
+
+      it { is_expected.to eq ["capture", "refund", "cancel_or_refund"] }
+    end
+
+    context "when the notification's operations are nil" do
+      let(:operations) { nil }
+      it { is_expected.to eq [] }
+    end
+  end
+end

data/spec/models/concerns/spree/adyen/order_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+RSpec.describe Spree::Order do
+  include_context "mock adyen api", success: true
+
+  describe "requires_manual_refund?" do
+    subject { order.requires_manual_refund? }
+
+    let!(:order) { create :order_ready_to_ship }
+
+    it { is_expected.to be false }
+
+    context "when it is cancelled and has a payment that much be manually refunded" do
+      let!(:payment) { create :hpp_payment, order: order, source: source }
+      let(:source) { create :hpp_source, :sofort, order: order }
+
+      before { order.cancel! }
+
+      it { is_expected.to be true }
+    end
+  end
+end

data/spec/models/concerns/spree/adyen/payment_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+describe Spree::Adyen::Payment do
+  let(:payment) { create :hpp_payment }
+
+  shared_examples "gateway action" do
+    context "when the action succeeds" do
+      include_context "mock adyen api", success: true
+
+      it "logs the response" do
+        expect{ subject }.to change{ payment.reload.log_entries.count }.by(1)
+      end
+
+      it "changes payment state to processing" do
+        expect{ subject }.to change{ payment.state }.to("processing")
+      end
+    end
+
+    context "when the action fails" do
+      include_context(
+        "mock adyen api",
+        success: false,
+        fault_message: "Expected message")
+
+      it "logs the response" do
+        expect{ subject }.
+          to raise_error(Spree::Core::GatewayError).
+          and change{ payment.reload.log_entries.count }.by(1)
+      end
+
+      it "does not change the status of the payment" do
+        expect{ subject }.
+          to raise_error(Spree::Core::GatewayError, "Expected message").
+          and keep { payment.reload.state }
+      end
+    end
+  end
+
+  describe "cancel!" do
+    subject { payment.cancel! }
+    include_examples "gateway action"
+
+    context "when the payment doesn't have an hpp source" do
+      let(:payment) { create :payment }
+
+      it "keeps the orginal behaviour" do
+        expect{ subject }.
+          to change { payment.reload.state }.
+          from("checkout").
+          to("void")
+      end
+    end
+
+    context "when payment is only manually refundable" do
+      let(:payment) { create :hpp_payment, source: source }
+      let(:source) { create :hpp_source, :sofort }
+
+      it "creates a log entry" do
+        expect { subject }.
+          to change { payment.reload.log_entries.count }
+      end
+
+      it "doesn't change the state" do
+        expect { subject }.
+          to_not change { payment.reload.state }
+      end
+    end
+  end
+
+  describe "capture!" do
+    subject { payment.capture! }
+    include_examples "gateway action"
+
+    context "when the payment doesn't have an hpp source" do
+      let(:payment) { create :payment }
+
+      it "keeps the orginal behaviour" do
+        expect{ subject }.
+          to change { payment.reload.state }.
+          from("checkout").
+          to("completed").
+
+          and change { payment.capture_events.count }.
+          by(1)
+      end
+    end
+  end
+
+  describe "credit!" do
+    subject { payment.credit! "1000", currency: "EUR" }
+    include_examples "gateway action"
+  end
+end

data/spec/models/spree/adyen/hpp_source_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+RSpec.describe Spree::Adyen::HppSource do
+  include_context "mock adyen api", success: true
+
+  it { is_expected.to belong_to(:order) }
+  it { is_expected.to have_one(:payment) }
+  it { is_expected.to have_many(:notifications) }
+
+  let(:hpp_source) do
+    create :hpp_source,
+      psp_reference: "999999999",
+      merchant_reference: "R11111111",
+      payment: create(:hpp_payment)
+  end
+
+  describe ".actions" do
+    subject { hpp_source.actions }
+    let!(:notification) do
+      create(
+        :notification,
+        :auth,
+        operations: "CAPTURE,REFUND",
+        psp_reference: "999999999",
+        merchant_reference: "R11111111",
+        processed: true
+      )
+    end
+
+    it { expect(hpp_source.notifications.count).to eq 1 }
+    it { expect(hpp_source.actions).
+         to eq %w{capture credit} }
+
+    shared_examples "has no actions" do
+      it { is_expected.to eq [] }
+    end
+
+    context "when it has no auth notification" do
+      let!(:notification) { nil }
+      include_examples "has no actions"
+    end
+
+    context "when the payment is void" do
+      before { hpp_source.payment.void }
+      include_examples "has no actions"
+    end
+
+    context "when the payment is still proccesing" do
+      before { hpp_source.payment.started_processing! }
+      include_examples "has no actions"
+    end
+  end
+
+  describe ".can_capture?" do
+    subject { hpp_source.can_capture? payment }
+    let!(:payment) { create :payment, amount: 10.0 }
+
+    it { is_expected.to be true }
+
+    context "when there is no outstanding balance" do
+      before do
+        payment.
+          capture_events.
+          create! amount: ::Money.new(1000, "EUR").to_f
+      end
+      it { is_expected.to be false }
+    end
+  end
+
+  describe ".authorised?" do
+    subject { described_class.new(auth_result: event).authorised? }
+
+    context "when pending" do
+      let(:event) { "PENDING" }
+      it { is_expected.to be true }
+    end
+
+    context "when authorised" do
+      let(:event) { "AUTHORISED" }
+      it { is_expected.to be true }
+    end
+
+    context "when something else" do
+      let(:event) { "REFUSED" }
+      it { is_expected.to be false }
+    end
+  end
+
+  describe ".can_cancel?" do
+    subject { hpp_source.can_cancel? hpp_source.payment }
+
+    context "when the payment has refunds" do
+      before { create :refund, amount: 1, payment: hpp_source.payment }
+      it { is_expected.to be false }
+    end
+
+    context "when the payment doesn't have refunds" do
+      it { is_expected.to be true }
+    end
+  end
+end

data/spec/models/spree/adyen/notification_processor_spec.rb

@@ -0,0 +1,205 @@
+require "spec_helper"
+
+RSpec.describe Spree::Adyen::NotificationProcessor do
+  include_context "mock adyen api", success: true
+
+  describe "#process" do
+    subject { described_class.new(notification).process! }
+
+    let!(:payment) do
+      create(
+        :payment,
+        amount: 23.99,
+        state: payment_state,
+        payment_method: hpp_gateway,
+        order: create(:order, currency: "EUR")
+      )
+    end
+
+    let!(:hpp_gateway) do
+      create(:hpp_gateway)
+    end
+
+    let!(:notification) do
+      create(
+        :notification,
+        event_type, # these are registered traits, refer to the factory
+        success: success,
+        value: 2399,
+        currency: "EUR",
+        payment: payment
+      )
+    end
+
+    let(:payment_state) { "pending" }
+    let(:success) { true }
+
+    shared_examples "returns the notification" do
+      it "always returns the notification" do
+        is_expected.to be_a AdyenNotification
+      end
+    end
+
+    shared_examples "processed event" do
+      include_examples "returns the notification"
+
+      it "marks the notification as processed" do
+        expect{ subject }.
+          to change{ notification.processed }.
+          from(false).
+          to(true)
+      end
+    end
+
+    shared_examples "completes payment" do
+      include_examples "processed event"
+
+      it "updates the captured amount" do
+        expect{ subject }.
+          to change{ payment.captured_amount }.
+          from(0).
+          to(23.99).
+
+          and change{ payment.capture_events.count }.
+          from(0).
+          to(1)
+      end
+
+      it "completes the payment" do
+        expect{ subject }.
+          to change{ payment.reload.state }.
+          from("pending").
+          to("completed")
+      end
+    end
+
+    shared_examples "fails payment" do
+      include_examples "processed event"
+
+      it "marks the payment as a failure" do
+        expect{ subject }.
+          to change{ payment.reload.state }.
+          from("pending").
+          to("failed")
+      end
+    end
+
+    shared_examples "does nothing" do
+      include_examples "processed event"
+
+      it "does not change the payment state" do
+        expect{ subject }.to_not change{ payment.state }
+      end
+
+      it "does not change the captured amount" do
+        expect{ subject }.to_not change{ payment.captured_amount }
+      end
+    end
+
+    context "when event is AUTHORISATION" do
+      let(:event_type) { :auth }
+
+      it "changes the available actions"
+
+      context "and payment method was c_cash", pending: true do
+        pending "completes payment"
+      end
+
+      context "and payment method was bank transfer", pending: true do
+        pending "completes payment"
+      end
+
+      context "and payment method was ideal" do
+        let(:event_type) { :ideal_auth }
+        include_examples "completes payment"
+      end
+
+      context "and it was not successful" do
+        let(:success) { false }
+        include_examples "fails payment"
+
+        context "and the payment was already complete" do
+          let(:payment_state) { "completed" }
+          include_examples "does nothing"
+        end
+      end
+    end
+
+    context "when event is CAPTURE" do
+      let(:event_type) { :capture }
+      include_examples "completes payment"
+    end
+
+    context "when event is CANCEL_OR_REFUND" do
+      let(:event_type) { :cancel_or_refund }
+
+      before do
+        payment.complete
+      end
+
+      it "voids the payment" do
+        expect { subject }.
+          to change { payment.reload.state }.
+          from("completed").
+          to("void")
+      end
+    end
+
+    context "when event is REFUND" do
+      include_examples "processed event"
+
+      let(:event_type) { :refund }
+      let(:payment_state) { "processing" }
+
+      it "creates a refund" do
+        expect { subject }.
+          to change { payment.reload.refunds.count }.
+          from(0).
+          to(1)
+      end
+
+      it "changes the payment state to completed" do
+        expect { subject }.
+          to change { payment.reload.state }.
+          from("processing").
+          to("completed")
+      end
+    end
+
+    context "when the event is an event we don't process" do
+      let(:event_type) { :pending }
+      include_examples "returns the notification"
+
+      it "sets processed to false" do
+        expect(subject.processed).to be false
+      end
+    end
+  end
+
+  describe "#process_outstanding!" do
+    subject { described_class.process_outstanding! payment }
+
+    let!(:payment) { create :hpp_payment, amount: 19.99, state: "pending" }
+
+    let!(:notifications) do
+      opts = {payment: payment, value: 1999}
+      [
+        create(:notification, :auth, **opts),
+        create(:notification, :capture, **opts)
+      ]
+    end
+
+    it "processes all notifications" do
+      subject
+      notifications.map(&:reload)
+      expect(notifications).to all be_processed
+    end
+
+    it "modifies the payment" do
+      expect { subject }.
+        to change { payment.state }.from("pending").to("completed").
+
+        and change { payment.captured_amount }.from(0).to(19.99)
+    end
+  end
+end

data/spec/models/spree/adyen/presenters/communication_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+module Spree
+  module Adyen
+    module Presenters
+      RSpec.describe Communication do
+        let!(:source) { payment.source }
+        let!(:payment) { create :hpp_payment }
+        let!(:notification) { create :notification, :auth, payment: payment }
+
+        let!(:log_entry) do
+          payment.send(
+            :record_response,
+            OpenStruct.new(success?: true, message: "sup")
+          )
+        end
+
+        describe "#from_source" do
+          subject { described_class.from_source source }
+
+          it "builds a collection of presenters that all implement the interface" do
+            expect(subject).
+              to be_an(Array).
+              and all(
+                be_a(Communications::Base).
+                and respond_to(:success?).
+                and respond_to(:processed?).
+                and respond_to(:inbound?).
+                and respond_to(:fields))
+          end
+        end
+
+        describe "#build" do
+          subject { described_class.build(record) }
+
+          [[:log_entry, Communications::LogEntry],
+           [:source, Communications::HppSource],
+           [:notification, Communications::AdyenNotification]
+          ].each do |assigned_name, presenter|
+            context "when presented object is a #{assigned_name.to_s.humanize}" do
+              let(:record) { send assigned_name }
+
+              it "creates a presenter using #{presenter}" do
+                is_expected.to be_a presenter
+              end
+            end
+          end
+
+          context "when a presenter cannot be found" do
+            let(:record) { Object.new }
+
+            it "fails" do
+              expect { subject }.to raise_error(
+                RuntimeError,
+                /Couldn't map to a communication type/)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/gateway/adyen_hpp_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "support/shared_contexts/mock_adyen_api"
+
+module Spree
+  describe Gateway::AdyenHPP do
+    let(:hpp_source) { create :hpp_source, psp_reference: "9999" }
+    let(:gateway) { described_class.new }
+
+    include_context "mock adyen api", success: true
+
+    shared_examples "delayed gateway action" do
+      context "when the action succeeds" do
+        include_context "mock adyen api", success: true
+
+        it { is_expected.to be_a ::ActiveMerchant::Billing::Response }
+
+        it "returns the orginal psp ref as an authorization" do
+          expect(subject.authorization).to eq "9999"
+        end
+      end
+
+      context "when the action fails" do
+        include_context(
+          "mock adyen api",
+          success: false,
+          fault_message: "Should fail")
+
+        it "has a response that contains the failure message" do
+          expect(subject.success?).to be false
+          expect(subject.message).to eq "Should fail"
+        end
+      end
+    end
+
+    describe ".capture" do
+      subject { gateway.capture(2000, "9999", currency: "EUR") }
+      include_examples "delayed gateway action"
+    end
+
+    describe ".credit" do
+      subject { gateway.credit(2000, "9999", currency: "EUR") }
+      include_examples "delayed gateway action"
+    end
+
+    describe ".cancel" do
+      subject { gateway.cancel("9999") }
+      include_examples "delayed gateway action"
+    end
+
+    describe ".authorize" do
+      subject { gateway.authorize 2000, hpp_source, currency: "EUR" }
+      it { is_expected.to be_a ActiveMerchant::Billing::Response }
+    end
+
+    context "calculate ship_before_date" do
+      let(:test_time) { Time.local(2015, 9, 1, 12, 0, 0) }
+
+      context "days_to_ship has been set" do
+        it "returns tomorrow" do
+          Timecop.freeze(test_time) do
+            expect(subject.ship_before_date).to eq  Time.local(2015, 9, 2, 12, 0, 0)
+          end
+        end
+      end
+
+      context "days_to_ship has not been set" do
+        it "returns date days_to_ship in the future" do
+          subject.preferred_days_to_ship = 3
+          Timecop.freeze(test_time) do
+            expect(subject.ship_before_date).to eq  Time.local(2015, 9, 4, 12, 0, 0)
+          end
+        end
+      end
+    end
+  end
+end