sift 1.1.6.2 → 4.5.0

data/spec/unit/client/decision_spec.rb

@@ -0,0 +1,83 @@
+require_relative "../../spec_helper"
+require "multi_json"
+
+require "spec/fixtures/fake_responses"
+require "sift/client/decision"
+require "sift/router"
+
+module Sift
+  class Client
+    describe Decision do
+      let(:api_key) { "test_api_key" }
+      let(:account_id) { "test_account_id" }
+      let(:decision) { Decision.new(api_key, account_id) }
+
+      let(:decision_index_path) {
+        # TODO(Kaoru): When we move to webmock 2 we won't need to do this
+        # hackery
+        #
+        # https://github.com/bblimke/webmock/blob/master/CHANGELOG.md#200
+        #
+        protocal, uri = decision.index_path.split(/(?<=https\:\/\/)/)
+
+        protocal + api_key + "@" + uri
+      }
+
+      describe "#list" do
+        it "will return a response object that is ok" do
+          stub_request(:get, decision_index_path)
+            .to_return(body: MultiJson.dump(FakeDecisions.index))
+
+          response = decision.list
+
+          expect(response.ok?).to be(true)
+          expect(response.body["data"])
+            .to contain_exactly(*FakeDecisions.index[:data])
+        end
+
+        it "will pass on query params" do
+          query_param = {
+            abuse_types: %w{promo_abuse content_abuse},
+            entity_type: "user",
+            limit: 10
+          }.inject("?")  do |result, (key, value)|
+            value = value.join(",") if value.is_a? Array
+            "#{result}&#{key}=#{CGI.escape(value.to_s)}"
+          end
+
+          stub_request(:get, "#{decision_index_path}#{query_param}")
+            .to_return(body: MultiJson.dump(FakeDecisions.index))
+
+          response = decision.list({
+            limit: 10,
+            entity_type: "user",
+            abuse_types: %w{promo_abuse content_abuse}
+          })
+
+          expect(response.ok?).to be(true)
+        end
+
+        it "with an unsuccessful response will return a response object" do
+          stub_request(:get, decision_index_path)
+            .to_return(status: 404, body: "{}")
+
+          response = decision.list
+
+          expect(response.ok?).to be(false)
+          expect(response.http_status_code).to be(404)
+        end
+
+        it "will fetch next page" do
+          next_page = "#{decision.index_path}?from=100"
+
+          stub_request(:get, "#{decision_index_path}?from=100")
+            .to_return(body: MultiJson.dump(FakeDecisions.index))
+
+          response = decision.list({ "next_ref" => next_page })
+
+          expect(response.ok?).to be(true)
+        end
+      end
+    end
+  end
+end

data/spec/unit/client_203_spec.rb

@@ -0,0 +1,193 @@
+require_relative "../spec_helper"
+require "sift"
+
+describe Sift::Client do
+
+  before :each do
+    Sift.api_key = nil
+  end
+
+  def valid_transaction_properties
+    {
+      :$buyer_user_id => "123456",
+      :$seller_user_id => "654321",
+      :$amount => 1253200,
+      :$currency_code => "USD",
+      :$time => Time.now.to_i,
+      :$transaction_id => "my_transaction_id",
+      :$billing_name => "Mike Snow",
+      :$billing_bin => "411111",
+      :$billing_last4 => "1111",
+      :$billing_address1 => "123 Main St.",
+      :$billing_city => "San Francisco",
+      :$billing_region => "CA",
+      :$billing_country => "US",
+      :$billing_zip => "94131",
+      :$user_email => "mike@example.com"
+    }
+  end
+
+  def score_response_json
+    {
+      :user_id => "247019",
+      :score => 0.93,
+      :reasons => [{
+                     :name => "UsersPerDevice",
+                     :value => 4,
+                     :details => {
+                     :users => "a, b, c, d"
+                     }
+                   }],
+      :status => 0,
+      :error_message => "OK"
+    }
+  end
+
+  def action_response_json
+    {
+      :user_id => "247019",
+      :score => 0.93,
+      :actions => [{
+                    :action_id => "1234567890abcdefghijklmn",
+                    :time => 1437421587052,
+                    :triggers => [{
+                      :triggerType => "FORMULA",
+                      :source => "synchronous_action",
+                      :trigger_id => "12345678900987654321abcd"
+                    }],
+                    :entity => {
+                      :type => "USER",
+                      :id => "23056"
+                    }
+                  },
+                  {
+                    :action_id => "12345678901234567890abcd",
+                    :time => 1437421587410,
+                    :triggers => [{
+                      :triggerType => "FORMULA",
+                      :source => "synchronous_action",
+                      :trigger_id => "abcd12345678901234567890"
+                    }],
+                    :entity => {
+                      :type => "ORDER",
+                      :id => "order_at_ 1437421587009"
+                    }
+                  }],
+      :status => 0,
+      :error_message => "OK"
+    }
+  end
+
+  def fully_qualified_api_endpoint
+    Sift::Client::API_ENDPOINT + Sift.rest_api_path
+  end
+
+  it "Successfully submits a v203 event with overridden key" do
+    response_json = { :status => 0, :error_message => "OK"}
+    stub_request(:post, "https://api.siftscience.com/v203/events").
+      with { | request|
+        parsed_body = JSON.parse(request.body)
+        expect(parsed_body).to include("$buyer_user_id" => "123456")
+        expect(parsed_body).to include("$api_key" => "overridden")
+      }.to_return(:status => 200, :body => MultiJson.dump(response_json), :headers => {})
+
+    api_key = "foobar"
+    event = "$transaction"
+    properties = valid_transaction_properties
+
+    response = Sift::Client.new(:api_key => api_key, :version => "203")
+               .track(event, properties, :api_key => "overridden")
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+
+  it "Successfully fetches a v203 score" do
+
+    api_key = "foobar"
+    response_json = score_response_json
+
+    stub_request(:get, "https://api.siftscience.com/v203/score/247019/?api_key=foobar")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json),
+                 :headers => {"content-type"=>"application/json; charset=UTF-8",
+                              "content-length"=> "74"})
+
+    response = Sift::Client.new(:api_key => api_key)
+               .score(score_response_json[:user_id], :version => 203)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+
+    expect(response.body["score"]).to eq(0.93)
+  end
+
+
+  it "Successfully fetches a v203 score with an overridden key" do
+
+    api_key = "foobar"
+    response_json = score_response_json
+
+    stub_request(:get, "https://api.siftscience.com/v203/score/247019/?api_key=overridden")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json), :headers => {})
+
+    response = Sift::Client.new(:api_key => api_key, :version => 203)
+               .score(score_response_json[:user_id], :api_key => "overridden")
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+
+    expect(response.body["score"]).to eq(0.93)
+  end
+
+
+  it "Successfuly make a v203 sync score request" do
+
+    api_key = "foobar"
+    response_json = {
+      :status => 0,
+      :error_message => "OK",
+      :score_response => score_response_json
+    }
+
+    stub_request(:post, "https://api.siftscience.com/v203/events?return_score=true")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json),
+                 :headers => {"content-type"=>"application/json; charset=UTF-8",
+                              "content-length"=> "74"})
+
+    event = "$transaction"
+    properties = valid_transaction_properties
+    response = Sift::Client.new(:api_key => api_key)
+               .track(event, properties, :return_score => true, :version => "203")
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+    expect(response.body["score_response"]["score"]).to eq(0.93)
+  end
+
+
+  it "Successfuly make a v203 sync action request" do
+
+    api_key = "foobar"
+    response_json = {
+      :status => 0,
+      :error_message => "OK",
+      :score_response => action_response_json
+    }
+
+    stub_request(:post, "https://api.siftscience.com/v203/events?return_action=true")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json),
+                 :headers => {"content-type"=>"application/json; charset=UTF-8",
+                              "content-length"=> "74"})
+
+    event = "$transaction"
+    properties = valid_transaction_properties
+    response = Sift::Client.new(:api_key => api_key, :version => "203")
+               .track(event, properties, :return_action => true)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+    expect(response.body["score_response"]["actions"].first["entity"]["type"]).to eq("USER")
+  end
+
+end

data/spec/unit/client_205_spec.rb

@@ -0,0 +1,117 @@
+require_relative '../spec_helper'
+require 'sift'
+
+describe Sift::Client do
+
+  before :each do
+    Sift.api_key = nil
+  end
+
+  def valid_transaction_properties
+    {
+      :$type => "$add_item_to_cart",
+      :$user_id => "haneeshv@exalture.com",
+      :$session_id => "gigtleqddo84l8cm15qe4il",
+      :$item => {
+        :$item_id => "B004834GQO",
+        :$product_title => "The Slanket Blanket-Texas Tea",
+        :$price => 39990000,
+        :$currency_code => "USD",
+        :$upc => "6786211451001",
+        :$sku => "004834GQ",
+        :$brand => "Slanket",
+        :$manufacturer => "Slanket",
+        :$category => "Blankets & Throws",
+        :$tags => [
+              "Awesome",
+              "Wintertime specials"
+        ],
+        :$color => "Texas Tea",
+        :$quantity => 16
+      },
+      :$brand_name => "sift",
+      :$site_domain => "sift.com",
+      :$site_country => "US",
+      :$browser => {
+        :$user_agent => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+        :$accept_language => "en-US",
+        :$content_language => "en-GB"
+      }
+    }
+  end
+
+  def percentile_response_json
+    {
+      :user_id => 'haneeshv@exalture.com',
+      :latest_labels => {},
+      :workflow_statuses => [],
+      :scores => {
+        :account_abuse => {
+          :score => 0.32787917675535705,
+          :reasons => [{
+            :name => 'Latest item product title',
+            :value => 'The Slanket Blanket-Texas Tea'
+          }],
+          :percentiles => {
+            :last_7_days => -1.0, :last_1_days => -1.0, :last_10_days => -1.0, :last_5_days => -1.0
+          }
+        },
+        :acontent_abuse => {
+          :score => 0.28056292905897995,
+          :reasons => [{
+            :name => 'timeSinceFirstEvent',
+            :value => '13.15 minutes'
+          }],
+          :percentiles => {
+            :last_7_days => -1.0, :last_1_days => -1.0, :last_10_days => -1.0, :last_5_days => -1.0
+          }
+        },
+        :payment_abuse => {
+          :score => 0.28610507028376797,
+          :reasons => [{
+            :name => 'Latest item currency code',
+            :value => 'USD'
+          }, {
+            :name => 'Latest item item ID',
+            :value => 'B004834GQO'
+          }, {
+            :name => 'Latest item product title',
+            :value => 'The Slanket Blanket-Texas Tea'
+          }],
+          :percentiles => {
+            :last_7_days => -1.0, :last_1_days => -1.0, :last_10_days => -1.0, :last_5_days => -1.0
+          }
+        },
+        :promotion_abuse => {
+          :score => 0.05731508921450917,
+          :percentiles => {
+            :last_7_days => -1.0, :last_1_days => -1.0, :last_10_days => -1.0, :last_5_days => -1.0
+          }
+        }
+      },
+      :status => 0,
+      :error_message => 'OK'
+    }
+  end
+
+  it "Successfully submits a v205 event with SCORE_PERCENTILES" do
+    response_json =
+    { :status => 0, :error_message => "OK",  :score_response => percentile_response_json}
+    stub_request(:post, "https://api.siftscience.com/v205/events?fields=SCORE_PERCENTILES&return_score=true").
+      with { | request|
+        parsed_body = JSON.parse(request.body)
+        expect(parsed_body).to include("$api_key" => "overridden")
+      }.to_return(:status => 200, :body => MultiJson.dump(response_json), :headers => {})
+
+    api_key = "foobar"
+    event = "$transaction"
+    properties = valid_transaction_properties
+
+    response = Sift::Client.new(:api_key => api_key, :version => "205")
+              .track(event, properties, :api_key => "overridden", :include_score_percentiles => "true", :return_score => "true")
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+    expect(response.body["score_response"]["scores"]["account_abuse"]["percentiles"]["last_7_days"]).to eq(-1.0)
+  end
+end

data/spec/unit/client_label_spec.rb

@@ -1,8 +1,17 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+require_relative "../spec_helper"
+require "sift"
 
 describe Sift::Client do
 
   def valid_label_properties
+    {
+      :$abuse_type => 'content_abuse',
+      :$is_bad => true,
+      :$description => "Listed a fake item"
+    }
+  end
+
+  def valid_label_properties_203
     {
       :$reasons => [ "$fake" ],
       :$is_bad => true,
@@ -10,26 +19,74 @@ describe Sift::Client do
     }
   end
 
-  def fully_qualified_users_labels_endpoint(user_id)
-    Sift::Client::API_ENDPOINT + Sift.current_users_label_api_path(user_id)
+
+  it "Successfuly handles a $label and returns OK" do
+
+    response_json = { :status => 0, :error_message => "OK" }
+    user_id = "frodo_baggins"
+
+    stub_request(:post, "https://api.siftscience.com/v205/users/frodo_baggins/labels")
+      .with(:body => ('{"$abuse_type":"content_abuse","$is_bad":true,"$description":"Listed a fake item","$type":"$label","$api_key":"foobar"}'))
+      .to_return(:body => MultiJson.dump(response_json), :status => 200,
+                 :headers => {"content-type"=>"application/json; charset=UTF-8",
+                              "content-length"=> "74"})
+
+    api_key = "foobar"
+    properties = valid_label_properties
+
+    response = Sift::Client.new(:api_key => api_key).label(user_id, properties)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
   end
 
+
+  it "Successfully handles an $unlabel and returns OK" do
+    user_id = "frodo_baggins"
+
+    stub_request(:delete,
+                 "https://api.siftscience.com/v205/users/frodo_baggins/labels?api_key=foobar&abuse_type=payment_abuse")
+      .to_return(:status => 204)
+
+    api_key = "foobar"
+
+    response = Sift::Client.new(:api_key => api_key).unlabel(user_id, :abuse_type => 'payment_abuse')
+    expect(response.ok?).to eq(true)
+  end
+
+
   it "Successfuly handles a $label with the v203 API and returns OK" do
 
     response_json = { :status => 0, :error_message => "OK" }
     user_id = "frodo_baggins"
 
-    stub_request(:post, "https://api.siftscience.com/v203/users/frodo_baggins/labels").
-      with(:body => '{"$reasons":["$fake"],"$is_bad":true,"$description":"Listed a fake item","$type":"$label","$api_key":"foobar"}').
-      to_return(:body => MultiJson.dump(response_json), :status => 200, :content_type => "text/json")
+    stub_request(:post, "https://api.siftscience.com/v203/users/frodo_baggins/labels")
+      .with(:body => ('{"$reasons":["$fake"],"$is_bad":true,"$description":"Listed a fake item","$type":"$label","$api_key":"foobar"}'))
+      .to_return(:body => MultiJson.dump(response_json), :status => 200,
+                 :headers => {"content-type"=>"application/json; charset=UTF-8",
+                              "content-length"=> "74"})
+
+    api_key = "foobar"
+    properties = valid_label_properties_203
+
+    response = Sift::Client.new(:api_key => api_key, :version => 203).label(user_id, properties)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+
+  it "Successfully handles an $unlabel with the v203 API endpoing and returns OK" do
+    user_id = "frodo_baggins"
+
+    stub_request(:delete,
+                 "https://api.siftscience.com/v203/users/frodo_baggins/labels?api_key=foobar")
+      .to_return(:status => 204)
 
     api_key = "foobar"
-    properties = valid_label_properties
 
-    response = Sift::Client.new(api_key).label(user_id, properties)
-    response.ok?.should eq(true)
-    response.api_status.should eq(0)
-    response.api_error_message.should eq("OK")
+    response = Sift::Client.new(:api_key => api_key).unlabel(user_id, :version => "203")
+    expect(response.ok?).to eq(true)
   end
 
 end

data/spec/unit/client_psp_merchant_spec.rb

@@ -0,0 +1,133 @@
+require_relative "../spec_helper"
+require "sift"
+
+describe Sift::Client do
+
+  before :each do
+    Sift.api_key = nil
+  end
+
+  def post_psp_merchant_properties
+    {
+      "id": "api-key1-6",
+      "name": "Wonderful Payments Inc.",
+      "description": "Wonderful Payments payment provider.",
+      "address": {
+          "name": "Alany",
+          "address_1": "Big Payment blvd, 22",
+          "address_2": "apt, 8",
+          "city": "New Orleans",
+          "region": "NA",
+          "country": "US",
+          "zipcode": "76830",
+          "phone": "0394888320"
+      },
+      "category": "1002",
+      "service_level": "Platinum",
+      "status": "active",
+      "risk_profile": {
+          "level": "low",
+          "score": 10
+      }
+    }
+  end
+
+  def put_psp_merchant_properties
+    {
+      "id": "api-key1-7",
+      "name": "Wonderful Payments Inc.",
+      "description": "Wonderful Payments payment provider.",
+      "address": {
+          "name": "Alany",
+          "address_1": "Big Payment blvd, 22",
+          "address_2": "apt, 8",
+          "city": "New Orleans",
+          "region": "NA",
+          "country": "US",
+          "zipcode": "76830",
+          "phone": "0394888320"
+      },
+      "category": "1002",
+      "service_level": "Platinum",
+      "status": "active",
+      "risk_profile": {
+          "level": "low",
+          "score": 10
+      }
+    }
+  end
+
+  it "Successfully sumit create psp merchant" do
+    api_key = "foobar1"
+
+    response_json = { :status => 0, :error_message => "OK" }
+
+    stub_request(:post, "https://foobar1:@api.siftscience.com/v3/accounts/ACCT/psp_management/merchants")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key, :account_id => "ACCT").create_psp_merchant_profile(post_psp_merchant_properties)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+  it "Successfully submit update psp merchant" do
+    api_key = "foobar1"
+    merchant_id = "api-key1-7"
+
+    response_json = { :status => 0, :error_message => "OK"}
+
+    stub_request(:put, "https://foobar1:@api.siftscience.com/v3/accounts/ACCT/psp_management/merchants/api-key1-7")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key, :account_id => "ACCT").update_psp_merchant_profile(merchant_id, put_psp_merchant_properties)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+  it "Successfully get a psp merchant profile" do
+    api_key = "foobar1"
+    merchant_id = "api-key1-7"
+
+    response_json = { :status => 0, :error_message => "OK"}
+
+    stub_request(:get, "https://foobar1:@api.siftscience.com/v3/accounts/ACCT/psp_management/merchants/api-key1-7")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key, :account_id => "ACCT").get_a_psp_merchant_profile(merchant_id)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+  it "Successfully get all psp merchant profile with batch size" do
+    api_key = "foobar1"
+
+    response_json = { :status => 0, :error_message => "OK"}
+
+    stub_request(:get, "https://foobar1:@api.siftscience.com/v3/accounts/ACCT/psp_management/merchants?batch_size=2")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key, :account_id => "ACCT").get_psp_merchant_profiles(2)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+  it "Successfully get all psp merchant profile with batch size and batch token" do
+    api_key = "foobar1"
+    batch_size =  2
+    batch_token = "batch_token"
+    response_json = { :status => 0, :error_message => "OK"}
+
+    stub_request(:get, "https://foobar1:@api.siftscience.com/v3/accounts/ACCT/psp_management/merchants?batch_size=2&batch_token=batch_token")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key, :account_id => "ACCT").get_psp_merchant_profiles(batch_size, batch_token)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+end