sift 1.1.6.2 → 4.5.0

data/spec/unit/client_validationapi_spec.rb

@@ -0,0 +1,91 @@
+require_relative "../spec_helper"
+require "sift"
+
+describe Sift::Client do
+
+  before :each do
+    Sift.api_key = nil
+  end
+
+  def valid_send_properties
+    {
+      :$user_id => 'billy_jones_301',
+	    :$send_to => 'billy_jones_301@gmail.com',
+      :$verification_type => '$email',
+      :$brand_name => 'MyTopBrand',
+      :$language => 'en',
+      :$event => {
+                :$session_id => '09f7f361575d11ff',
+                :$verified_event => '$login',
+                :$reason => '$automated_rule',
+                :$ip => '192.168.1.1',
+                :$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'
+                }
+            }
+    }
+  end
+
+  def valid_resend_properties
+    {
+      :$user_id => 'billy_jones_301',
+      :$verified_event => '$login'
+    }
+  end
+
+  def valid_check_properties
+    {
+      :$user_id => 'billy_jones_301',
+      :$code => '123456'
+    }
+  end
+
+  it "Successfully calls send" do
+    api_key = "foobar1"
+    user_id = "foobar2"
+
+    response_json = { :status => 0, :error_message => "OK"}
+
+    stub_request(:post, "https://foobar1:@api.siftscience.com/v1.1/verification/send")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key,:user_id => user_id,:version=>1.1).verification_send(valid_send_properties,:version => 205)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+
+  end
+
+  it "Successfully calls resend" do
+    api_key = "foobar1"
+    user_id = "foobar2"
+
+    response_json = { :status => 0, :error_message => "OK"}
+
+    stub_request(:post, "https://foobar1:@api.siftscience.com/v1.1/verification/resend")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key,:user_id => user_id,:version=>1.1).verification_resend(valid_resend_properties,:version => 205)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+
+  end
+
+  it "Successfully calls check" do
+    api_key = "foobar1"
+    user_id = "foobar2"
+
+    response_json = { :status => 0, :error_message => "OK"}
+
+    stub_request(:post, "https://foobar1:@api.siftscience.com/v1.1/verification/check")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json))
+
+    response = Sift::Client.new(:api_key => api_key,:user_id => user_id,:version=>1.1).verification_check(valid_check_properties,:version => 205)
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+
+  end
+
+end

data/spec/unit/router_spec.rb

@@ -0,0 +1,37 @@
+require_relative "../spec_helper"
+
+require "sift/router"
+
+module Sift
+  describe Router do
+    let(:path) { "https://example.com" }
+    let(:body) { { question: "Do you wanna go ball?" } }
+
+    describe ".get" do
+      it "with a successful request will return a response object" do
+        stub_request(:get, path)
+          .with(body: MultiJson.dump(body))
+          .to_return(body: MultiJson.dump({ cool: true }))
+
+        response = Router.get(path, { body: body })
+
+        expect(response.ok?).to be(true)
+        expect(response.body["cool"]).to be(true)
+      end
+
+      it "with an unsuccessful request will return a response object" do
+        stub_request(:get, path)
+          .with(body: MultiJson.dump(body))
+          .to_return(body: MultiJson.dump({ cool: false}), status: 403)
+
+        response = Router.get(path, { body: body })
+
+        expect(response.ok?).to be(false)
+        expect(response.body["cool"]).to be(false)
+      end
+
+    end
+  end
+end
+
+

data/spec/unit/validate/decision_spec.rb

@@ -0,0 +1,85 @@
+require_relative "../../spec_helper"
+
+require "sift/validate/decision"
+
+module Sift
+  module Validate
+    describe Decision do
+      describe "#valid_user?" do
+        it "will return true" do
+          validator = Decision.new(
+            user_id: "hello world",
+            source: :hello_world,
+            analyst: "asdfsadf@heyo.com"
+          )
+
+          expect(validator.valid_user?).to be(true)
+        end
+
+        it "with invalid user_id, will return false" do
+          validator = Decision.new(order_id: "asfasdf")
+          expect(validator.valid_user?).to be(false), "nil user is valid"
+
+          validator = Decision.new(order_id: "asfasdf", user_id: {})
+          expect(validator.valid_user?).to be(false), "user hash is valid"
+
+          validator = Decision.new(order_id: "asfasdf", user_id: /werwer/)
+          expect(validator.valid_user?).to be(false), "regex user is valid"
+        end
+      end
+
+      describe "#valid_order?" do
+        it "will return true with valid configs" do
+          validator = Decision.new(
+            order_id: "order_foo_bar_12354",
+            user_id: "hello world",
+            source: :hello_world,
+            analyst: "asdfsadf@heyo.com"
+          )
+
+          expect(validator.valid_order?).to be(true)
+        end
+
+        context "with invalid params:" do
+          it "user_id, will return false" do
+            validator = Decision.new(order_id: "asfasdf")
+            expect(validator.valid_order?).to be(false), "nil user is valid"
+
+            validator = Decision.new(order_id: "asfasdf", user_id: {})
+            expect(validator.valid_order?).to be(false), "user hash is valid"
+
+            validator = Decision.new(order_id: "asfasdf", user_id: /werwer/)
+            expect(validator.valid_order?).to be(false), "regex user is valid"
+          end
+
+          it "order_id, will return false" do
+            validator = Decision.new(user_id: 1235)
+            expect(validator.valid_order?).to be(false)
+
+            validator = Decision.new(user_id: 1235, order_id: {})
+            expect(validator.valid_order?).to be(false)
+
+            validator = Decision.new(user_id: 1235, order_id: /23424/)
+            expect(validator.valid_order?).to be(false)
+          end
+        end
+      end
+
+      describe "#error_messages" do
+        it "will return an array of error messages" do
+          validator = Decision.new
+
+          error_message =
+            "#{Primitive::ERROR_MESSAGES[:non_empty_string]}, got NilClass"
+
+          validator.valid_order?
+
+          expect(validator.error_messages).to contain_exactly(
+            "order_id #{error_message}",
+            "user_id #{error_message}"
+          )
+        end
+      end
+    end
+  end
+end

data/spec/unit/validate/primitive_spec.rb

@@ -0,0 +1,73 @@
+require_relative "../../spec_helper"
+
+require "sift/validate/primitive"
+
+module Sift
+  module Validate
+    describe Primitive do
+      describe ".non_empty_string" do
+        it "will return nil for valid values" do
+          expect(Primitive.non_empty_string("foobar")).to be_nil
+        end
+
+        it "will return an error message" do
+          [nil, 1, /asdfasdf/].each do |value|
+            error_message = "#{Primitive::ERROR_MESSAGES[:non_empty_string]}" \
+                            ", got #{value.class}"
+
+            expect(Primitive.non_empty_string(value)).to eq(error_message)
+          end
+
+          expect(Primitive.non_empty_string("")).to(
+            eq(Primitive.send(:empty_string_message, :non_empty_string))
+          )
+        end
+      end
+
+      describe ".is_numeric" do
+        it "will return nil for numeric values" do
+          [1, 29.01, 29 ** 1992848499198, -2].each do |value|
+            expect(Primitive.numeric(value)).to(
+              be_nil,
+              "#{value} is a non numeric value"
+            )
+          end
+        end
+
+        it "will return an error message for non numeric values" do
+          ["foobar", nil, :hello_world, {}].each do |value|
+            expect(Primitive.numeric(value)).to(
+              be(Primitive::ERROR_MESSAGES[:numeric]),
+              "#{value} is a numeric value"
+            )
+          end
+        end
+      end
+
+      describe ".is_string_or_number?" do
+        it "will return nil for numeric or strings" do
+          [1234, "asdfasdf", "1234_asdfsdf"].each do |value|
+            expect(Primitive.string_or_number(value)).to(
+              be_nil,
+              "#{value} is a non numeric value"
+            )
+          end
+        end
+
+        it "will return an error message for any other type" do
+          [{}, [], :hello_world, nil].each do |value|
+            error_message = "#{Primitive::ERROR_MESSAGES[:string_or_number]}," \
+                            " got #{value.class}"
+
+            expect(Primitive.string_or_number(value)).to eq(error_message)
+          end
+
+          error_message = "#{Primitive::ERROR_MESSAGES[:string_or_number]}, " \
+                          "got an empty string"
+          expect(Primitive.string_or_number("")).to eq(error_message)
+        end
+      end
+    end
+  end
+end
+

data/test_integration_app/decisions_api/test_decisions_api.rb

@@ -0,0 +1,31 @@
+require "sift"
+
+class DecisionAPI
+
+    @@client = Sift::Client.new(:api_key => ENV["API_KEY"], :account_id => ENV["ACCOUNT_ID"])
+
+    def apply_user_decision()
+          properties = {
+            "decision_id": "integration_app_watch_account_abuse",
+            "description": "User linked to three other payment abusers and ordering high value items",
+            "source": "manual_review",
+            "analyst": "analyst@example.com",
+            "user_id": "userId"
+          }
+
+          return @@client.apply_decision(properties)
+      end
+
+      def apply_order_decision()
+          properties = {
+            "decision_id": "block_order_payment_abuse",
+            "description": "applied via the high priority queue, queued user because their risk score exceeded 85",
+            "source": "AUTOMATED_RULE",
+            "user_id": "userId",
+            "order_id": "orderId"
+          }
+  
+          return @@client.apply_decision(properties)
+      end
+
+end