solidus_signifyd 0.1.1

data/spec/lib/spree_signifyd/create_signifyd_case_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe CreateSignifydCase do
+    describe "#perform" do
+      let(:order) { create(:order_ready_to_ship) }
+      let(:json) { JSON.parse(OrderSerializer.new(order).to_json) }
+
+      it "calls Signifyd::Case#create with the correct params" do
+        Signifyd::Case.should_receive(:create).with(json, SpreeSignifyd::Config[:api_key])
+        CreateSignifydCase.perform(order.id)
+      end
+
+      it "calls Signifyd::Case#create with the correct params" do
+        Signifyd::Case.should_receive(:create).with(json, SpreeSignifyd::Config[:api_key])
+        CreateSignifydCase.perform(order.number)
+      end
+    end
+  end
+end

data/spec/lib/spree_signifyd/request_verifier_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe RequestVerifier do
+    include RequestVerifier
+
+    describe "#encode_request" do
+      context "request has special characters" do
+        it "returns an unescaped UTF-8 string" do
+          expect(encode_request("R\xE9n\xE9 Pe\xF1a")).to eq "Réné Peña"
+        end
+      end
+
+      context "request doesn't contain special characters" do
+        it "returns the original string" do
+          expect(encode_request("John Doe")).to eq "John Doe"
+        end
+      end
+    end
+
+    describe "#build_sha" do
+      it "returns an HMAC SHA256 encoded message" do
+        expect(build_sha('ABCDE', 'test')).to eq "K0y2rIeTA77lBEHP8cRPk64fVRbhMrZqEk7la39EjEM="
+      end
+    end
+  end
+end

data/spec/lib/spree_signifyd_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe SpreeSignifyd do
+
+    describe ".set_score" do
+
+      let(:order) { FactoryGirl.create(:order) }
+
+      def set_score(score)
+        SpreeSignifyd.set_score(order: order, score: score)
+      end
+
+      it 'creates or updates the score' do
+        expect {
+          set_score(100)
+        }.to change { SpreeSignifyd::OrderScore.count }.by(1)
+
+        expect(order.signifyd_order_score.score).to eq 100
+
+        expect {
+          set_score(200)
+        }.not_to change { SpreeSignifyd::OrderScore.count }
+
+        expect(order.signifyd_order_score.score).to eq 200
+      end
+
+    end
+
+    describe ".approve" do
+
+      let(:order) { FactoryGirl.create(:order_ready_to_ship, line_items_count: 1) }
+
+      before do
+        order.shipments.each { |shipment| shipment.update_attributes!(state: 'pending') }
+        order.updater.update_shipment_state
+      end
+
+      def approve
+        SpreeSignifyd.approve(order: order)
+      end
+
+      context "updates the order" do
+        it { expect { approve }.to change { order.approver_name }.to "SpreeSignifyd" }
+        it { expect { approve }.to change { order.shipment_state }.to 'ready' }
+        it do
+          expect(order.approved_at).to eq nil
+          expect { approve }.to change { order.approved_at }
+        end
+      end
+
+      it 'readies all of the shipments' do
+        order.shipments.each { |shipment| shipment.should_receive(:ready!) }
+        approve
+      end
+    end
+
+    describe ".create_case" do
+      it 'enqueues in resque' do
+        expect(Resque).to receive(:enqueue).with(SpreeSignifyd::CreateSignifydCase, 111)
+        SpreeSignifyd.create_case(order_number: 111)
+      end
+    end
+
+  end
+end

data/spec/models/spree/order_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Spree::Order, :type => :model do
+
+  let!(:order) { create(:order_ready_to_ship, line_items_count: 1) }
+
+  before do
+    order.shipments.each { |shipment| shipment.update_attributes!(state: 'pending') }
+    order.updater.update_shipment_state
+  end
+
+  describe "#is_risky?" do
+    subject { order.is_risky? }
+
+    context "no signifyd_score" do
+      it { should eq false }
+    end
+
+    context "signifyd_score present" do
+      before { SpreeSignifyd.set_score(score: 500, order: order) }
+
+      context "approved" do
+        before { SpreeSignifyd.approve(order: order) }
+        it { should eq false }
+      end
+
+      context "not approved" do
+        it { should eq true }
+      end
+    end
+  end
+
+  describe "transition to complete" do
+    let(:order) { create(:order_with_line_items, state: 'confirm') }
+    let!(:payment) { create(:payment, amount: order.total, order: order ) }
+
+    it "calls #create_signifyd_case" do
+      expect(SpreeSignifyd).to receive(:create_case).with(order_number: order.number)
+      order.complete!
+    end
+
+    context "the order is already approved" do # e.g. unreturned exchanges are automatically approved
+      it "does not create a case" do
+        order.contents.approve(user: Spree.user_class.first)
+        expect(SpreeSignifyd).not_to receive(:create_case)
+        order.complete!
+      end
+    end
+  end
+
+end

data/spec/models/spree/shipment_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Spree::Shipment, :type => :model do
+
+  let(:shipment) { create(:shipment) }
+  subject { shipment.determine_state(shipment.order) }
+
+  describe "#determine_state_with_signifyd" do
+
+    context "with a risky order" do
+      before { shipment.order.stub(:is_risky?).and_return(true) }
+
+      context "the order is not approved" do
+        it "returns pending" do
+          shipment.order.stub(:approved?).and_return(false)
+          subject.should eq "pending"
+        end
+      end
+
+      context "the order is approved" do
+        it "defaults to existing behavior" do
+          shipment.order.stub(:approved?).and_return(true)
+          shipment.should_receive(:determine_state).with(shipment.order)
+          subject
+        end
+      end
+    end
+
+    context "without a risky order" do
+      before { shipment.order.stub(:is_risky?).and_return(false) }
+
+      it "defaults to existing behavior" do
+        shipment.should_receive(:determine_state).with(shipment.order)
+        subject
+      end
+    end
+
+    context "shipment state" do
+      [:shipped, :ready].each do |state|
+        context "the shipment is #{state}" do
+          before { shipment.update_columns(state: state) }
+          it "defaults to existing behavior" do
+            shipment.should_receive(:determine_state).with(shipment.order)
+            subject
+          end
+        end
+      end
+
+      [:pending, :canceled].each do |state|
+        context "the shipment is #{state}" do
+          before { shipment.update_columns(state: state) }
+          it "is pending" do
+            subject.should eq "pending"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/serializers/spree_signifyd/address_serializer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe AddressSerializer do
+    let(:ship_address) { create(:address) }
+    let(:serialized_address) { JSON.parse(AddressSerializer.new(ship_address).to_json) }
+
+    context "node values" do
+      let(:address) { serialized_address['address'] }
+
+      it "streetAddress" do
+        expect(address['streetAddress']).to eq ship_address.address1
+      end
+
+      it "unit" do
+        expect(address['unit']).to eq ship_address.address2
+      end
+
+      it "city" do
+        expect(address['city']).to eq ship_address.city
+      end
+
+      describe "provinceCode" do
+        it "with a state entity associated" do
+          expect(address['provinceCode']).to eq ship_address.state.abbr
+        end
+        it "with a state_name and no state entity" do
+          ship_address.update_attributes!(state_name: ship_address.state.name, state_id: nil)
+          expect(address['provinceCode']).to eq ship_address.state_name
+        end
+      end
+
+      it "postalCode" do
+        expect(address['postalCode']).to eq ship_address.zipcode
+      end
+
+      it "countryCode" do
+        expect(address['countryCode']).to eq ship_address.country.iso
+      end
+    end
+  end
+end

data/spec/serializers/spree_signifyd/billing_address_serializer.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe BillingAddressSerializer do
+    let(:bill_address) { create(:address) }
+    let(:serialized_address) { JSON.parse(BillingAddressSerializer.new(bill_address).to_json) }
+
+    context "node values" do
+      it { serialized_address.should include 'billingAddress' }
+    end
+  end
+end

data/spec/serializers/spree_signifyd/credit_card_serializer_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe CreditCardSerializer do
+    let(:credit_card) { create(:credit_card) }
+    let(:serialized_credit_card) { JSON.parse(CreditCardSerializer.new(credit_card).to_json) }
+
+    context "node values" do
+      it "cardHolderName" do
+        expect(serialized_credit_card['cardHolderName']).to eq "#{credit_card.first_name} #{credit_card.last_name}"
+      end
+
+      it "last4" do
+        expect(serialized_credit_card['last4']).to eq credit_card.last_digits
+      end
+
+      it "expiryMonth" do
+        expect(serialized_credit_card['expiryMonth']).to eq credit_card.month
+      end
+
+      it "expiryYear" do
+        expect(serialized_credit_card['expiryYear']).to eq credit_card.year
+      end
+    end
+  end
+end

data/spec/serializers/spree_signifyd/delivery_address_serializer_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe DeliveryAddressSerializer do
+    let(:delivery_address) { create(:address) }
+    let(:serialized_address) { JSON.parse(DeliveryAddressSerializer.new(delivery_address).to_json) }
+
+    context "node values" do
+      it { serialized_address.should include 'deliveryAddress' }
+      it { serialized_address['fullName'].should eq delivery_address.full_name }
+    end
+  end
+end

data/spec/serializers/spree_signifyd/line_item_serializer_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe LineItemSerializer do
+    let(:line_item) { create(:line_item) }
+    let(:serialized_line_item) { JSON.parse(LineItemSerializer.new(line_item).to_json) }
+
+    context "node values" do
+      it "itemId" do
+        expect(serialized_line_item['itemId']).to eq line_item.variant_id
+      end
+
+      it "itemName" do
+        expect(serialized_line_item['itemName']).to eq line_item.name
+      end
+
+      it "itemQuantity" do
+        expect(serialized_line_item['itemQuantity']).to eq line_item.quantity
+      end
+
+      it "itemPrice" do
+        expect(serialized_line_item['itemPrice']).to eq line_item.price.to_s
+      end
+    end
+  end
+end

data/spec/serializers/spree_signifyd/order_serializer_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe OrderSerializer do
+    let(:order) { create(:shipped_order, line_items_count: 1) }
+    let(:line_item) { order.line_items.first }
+    let(:serialized_order) { JSON.parse(OrderSerializer.new(order).to_json) }
+
+    describe "node values" do
+      context "purchase" do
+
+        let(:purchase) { serialized_order['purchase'] }
+
+        it { purchase['browserIpAddress'].should eq order.last_ip_address }
+        it { purchase['orderId'].should eq order.number }
+        it { purchase['createdAt'].should eq order.completed_at.utc.iso8601 }
+        it { purchase['currency'].should eq order.currency }
+        it { purchase['totalPrice'].should eq order.total.to_s }
+
+        context "with a payment" do
+          it { purchase['avsResponseCode'].should eq order.payments.last.avs_response }
+          it { purchase['cvvResponseCode'].should eq order.payments.last.cvv_response_code }
+        end
+
+        context "without a payment" do
+          let(:order) { create(:completed_order_with_totals) }
+
+          it { purchase['avsResponseCode'].should be nil }
+          it { purchase['cvvResponseCode'].should be nil }
+        end
+
+        it "contains a products node" do
+          purchase['products'].should eq [ JSON.parse(SpreeSignifyd::LineItemSerializer.new(line_item).to_json) ]
+        end
+      end
+
+      context "userAccount" do
+        it { serialized_order.should include 'userAccount' }
+      end
+
+      context "recipient" do
+        it { serialized_order.should include 'recipient' }
+        it { serialized_order["recipient"]["confirmationEmail"].should eq order.email }
+      end
+
+      context "card" do
+        it { serialized_order.should include 'card' }
+
+        context "credit card payment" do
+          let!(:payment) { create(:payment, order: order) }
+
+          it { serialized_order["card"].should include 'billingAddress'}
+        end
+
+        context "no payment source" do
+          let(:order) { create(:completed_order_with_totals) }
+
+          it "contains no data" do
+            expect(serialized_order["card"]).to eq({})
+          end
+        end
+
+        context "non credit card payment" do
+          it "contains no data" do
+            Spree::CreditCard.any_instance.stub(:instance_of?).and_return(false)
+            expect(serialized_order["card"]).to eq({})
+          end
+        end
+      end
+    end
+  end
+end

data/spec/serializers/spree_signifyd/user_serializer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module SpreeSignifyd
+  describe UserSerializer do
+    let(:user) { create(:user) }
+    let!(:incomplete_order) { create(:order, user: user) }
+    let!(:old_complete_order) { create(:shipped_order, user: user, created_at: 30.days.ago) }
+    let!(:new_complete_order) { create(:shipped_order, user: user) }
+
+    let(:serialized_user) { JSON.parse(UserSerializer.new(user).to_json) }
+
+    context "node values" do
+      it "emailAddress" do
+        expect(serialized_user['emailAddress']).to eq user.email
+      end
+
+      it "username" do
+       expect(serialized_user['username']).to eq user.email
+      end
+
+      it "createdDate" do
+       expect(serialized_user['createdDate']).to eq user.created_at.utc.iso8601
+      end
+
+      it "lastUpdateDate" do
+       expect(serialized_user['lastUpdateDate']).to eq user.updated_at.utc.iso8601
+      end
+
+      context "with at least 2 orders" do
+        it "lastOrderId" do
+          expect(serialized_user['lastOrderId']).to eq old_complete_order.number
+        end
+      end
+
+      context "without prior orders" do
+        let(:user_without_orders) { create(:user) }
+        let(:serialized_user) { JSON.parse(UserSerializer.new(user_without_orders).to_json) }
+
+        it "lastOrderId" do
+          expect(serialized_user['lastOrderId']).to eq nil
+        end
+      end
+
+      it "aggregateOrderCount" do
+        expect(serialized_user['aggregateOrderCount']).to eq 2
+      end
+
+      it "aggregateOrderDollars" do
+        expect(serialized_user['aggregateOrderDollars']).to eq (old_complete_order.total + new_complete_order.total).to_s
+      end
+    end
+  end
+end