sift 1.1.0 → 4.0.0

data/lib/sift/error.rb

@@ -0,0 +1,13 @@
+module Sift
+  class Error < StandardError
+  end
+
+  class ApiError < Error
+    attr_reader :message, :response
+
+    def initialize(message, response)
+      @message = message
+      @response = response
+    end
+  end
+end

data/lib/sift/router.rb

@@ -0,0 +1,41 @@
+require_relative "./version"
+require_relative "./client"
+
+module Sift
+  class Router
+    include HTTParty
+
+    class << self
+      def get(path, options = {})
+        serialize_body(options)
+        add_default_headers(options)
+        wrap_response(super(path, options))
+      end
+
+      def post(path, options = {})
+        serialize_body(options)
+        add_default_headers(options)
+        wrap_response(super(path, options))
+      end
+
+      def serialize_body(options)
+        options[:body] = MultiJson.dump(options[:body]) if options[:body]
+      end
+
+      def add_default_headers(options)
+        options[:headers] = {
+          "User-Agent" => Sift::Client.user_agent
+        }.merge(options[:headers] || {})
+      end
+
+      def wrap_response(response)
+        Response.new(
+          response.body,
+          response.code,
+          response.response
+        )
+      end
+    end
+
+  end
+end

data/lib/sift/utils/hash_getter.rb

@@ -0,0 +1,15 @@
+module Sift
+  module Utils
+    class HashGetter
+      attr_reader :hash
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def get(value)
+        hash[value.to_sym] || hash[value.to_s]
+      end
+    end
+  end
+end

data/lib/sift/validate/decision.rb

@@ -0,0 +1,65 @@
+require_relative "primitive"
+
+module Sift
+  module Validate
+    class Decision
+      attr_reader :configs, :error_messages
+
+      def initialize(configs = {})
+        @configs = configs
+      end
+
+      def valid_order?
+        run do
+          validate_key(:non_empty_string, :user_id, :order_id)
+        end
+      end
+
+      def valid_session?
+        run do
+          validate_key(:non_empty_string, :user_id, :session_id)
+        end
+      end
+
+      def valid_content?
+        run do
+          validate_key(:non_empty_string, :user_id, :content_id)
+        end
+      end
+      
+      def valid_user?
+        run do
+          validate_key(:non_empty_string, :user_id)
+        end
+      end
+
+      private
+
+      def run
+        clear_errors!
+        yield
+        error_messages.empty?
+      end
+
+      def validate_primitive
+        Validate::Primitive
+      end
+
+      def validate_key(type, *keys)
+        keys.each do |key|
+          if error_message = validate_primitive.public_send(type, get(key))
+            error_messages << "#{key} #{error_message}"
+          end
+        end
+      end
+
+      def clear_errors!
+        @error_messages = []
+      end
+
+      def get(key)
+        configs[key] || configs[key.to_s]
+      end
+    end
+  end
+end

data/lib/sift/validate/primitive.rb

@@ -0,0 +1,43 @@
+module Sift
+  module Validate
+    class Primitive
+      ERROR_MESSAGES = {
+        non_empty_string: "must be a non-empty string",
+        numeric: "must be a number",
+        string_or_number: "must be a string or a number",
+      }
+
+      class << self
+        def non_empty_string(value)
+          if !value.is_a?(String)
+            "#{ERROR_MESSAGES[:non_empty_string]}, got #{value.class}"
+          elsif value.empty?
+            empty_string_message(:non_empty_string)
+          end
+        end
+
+        def numeric(value)
+          if !value.is_a?(Numeric)
+            ERROR_MESSAGES[:numeric]
+          end
+        end
+
+        def string_or_number(value)
+          if (value.is_a?(String) && value.empty?)
+            return empty_string_message(:string_or_number)
+          end
+
+          if value.nil? || !(value.is_a?(String) || value.is_a?(Numeric))
+            "#{ERROR_MESSAGES[:string_or_number]}, got #{value.class}"
+          end
+        end
+
+        private
+
+        def empty_string_message(message)
+          "#{ERROR_MESSAGES[message]}, got an empty string"
+        end
+      end
+    end
+  end
+end

data/lib/sift/version.rb

@@ -1,3 +1,4 @@
 module Sift
-  VERSION = "1.1.0"
+  VERSION = "4.0.0"
+  API_VERSION = "205"
 end

data/lib/sift.rb

@@ -1,16 +1,69 @@
-require "sift/version"
-require "sift/client"
+require_relative './sift/version'
+require_relative './sift/client'
+require 'erb'
 
 module Sift
 
-  # Returns the path for the current API version
-  def self.current_rest_api_path
-    "/v203/events"
+  # Returns the path for the specified API version
+  def self.rest_api_path(version=API_VERSION)
+    "/v#{version}/events"
   end
 
-  def self.current_users_label_api_path(user_id)
-    # This API version is a minor version ahead of the /events API
-    "/v203/users/#{URI.encode(user_id)}/labels"
+  # Returns the Score API path for the specified user ID and API version
+  def self.score_api_path(user_id, version=API_VERSION)
+    "/v#{version}/score/#{ERB::Util.url_encode(user_id)}/"
+  end
+
+  # Returns the User Score API path for the specified user ID and API version
+  def self.user_score_api_path(user_id, version=API_VERSION)
+    "/v#{version}/users/#{ERB::Util.url_encode(user_id)}/score"
+  end
+
+  # Returns the users API path for the specified user ID and API version
+  def self.users_label_api_path(user_id, version=API_VERSION)
+    "/v#{version}/users/#{ERB::Util.url_encode(user_id)}/labels"
+  end
+
+  # Returns the path for the Workflow Status API
+  def self.workflow_status_path(account_id, run_id)
+    "/v3/accounts/#{ERB::Util.url_encode(account_id)}" \
+      "/workflows/runs/#{ERB::Util.url_encode(run_id)}"
+  end
+
+  # Returns the path for User Decisions API
+  def self.user_decisions_api_path(account_id, user_id)
+    "/v3/accounts/#{ERB::Util.url_encode(account_id)}" \
+      "/users/#{ERB::Util.url_encode(user_id)}/decisions"
+  end
+
+  # Returns the path for Orders Decisions API
+  def self.order_decisions_api_path(account_id, order_id)
+    "/v3/accounts/#{ERB::Util.url_encode(account_id)}" \
+      "/orders/#{ERB::Util.url_encode(order_id)}/decisions"
+  end
+
+  # Returns the path for Session Decisions API
+  def self.session_decisions_api_path(account_id, user_id, session_id)
+    "/v3/accounts/#{ERB::Util.url_encode(account_id)}" \
+      "/users/#{ERB::Util.url_encode(user_id)}" \
+      "/sessions/#{ERB::Util.url_encode(session_id)}/decisions"
+  end
+
+  # Returns the path for Content Decisions API
+  def self.content_decisions_api_path(account_id, user_id, content_id)
+    "/v3/accounts/#{ERB::Util.url_encode(account_id)}" \
+      "/users/#{ERB::Util.url_encode(user_id)}" \
+      "/content/#{ERB::Util.url_encode(content_id)}/decisions"
+  end
+
+  # Module-scoped public API key
+  class << self
+    attr_accessor :api_key
+  end
+
+  # Module-scoped account ID
+  class << self
+    attr_accessor :account_id
   end
 
   # Sets the Output logger to use within the client. This can be left uninitializaed
@@ -34,5 +87,4 @@ module Sift
   def self.fatal(msg)
     @logger.fatal(msg) if @logger
   end
-
 end

data/sift.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name        = "sift"
   s.version     = Sift::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Fred Sadaghiani"]
-  s.email       = ["freds@siftscience.com"]
+  s.authors     = ["Fred Sadaghiani", "Yoav Schatzberg", "Jacob Burnim"]
+  s.email       = ["support@siftscience.com"]
   s.homepage    = "http://siftscience.com"
   s.summary     = %q{Sift Science Ruby API Gem}
   s.description = %q{Sift Science Ruby API. Please see http://siftscience.com for more details.}
@@ -20,13 +20,14 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # Gems that must be intalled for sift to compile and build
-  s.add_development_dependency "rspec", "~> 2.14.1"
-  s.add_development_dependency "fakeweb", "~> 1.3.0"
+  s.add_development_dependency "rspec", "~> 3.5"
+  s.add_development_dependency "rspec_junit_formatter"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "webmock", ">= 1.16.0", "< 2"
 
   # Gems that must be intalled for sift to work
-  s.add_dependency "httparty", ">= 0.12.0"
-  s.add_dependency "multi_json", ">= 1.8.2"
+  s.add_dependency "httparty", ">= 0.11.0"
+  s.add_dependency "multi_json", ">= 1.0"
 
-  s.add_development_dependency("rspec", ">= 2.0")
   s.add_development_dependency("rake")
 end

data/spec/fixtures/fake_responses.rb

@@ -0,0 +1,16 @@
+class FakeDecisions
+  def self.index
+    {
+      data: [
+        {
+          "id" => "block_user",
+          "name" => "Block user"
+        },
+        {
+          "id" => "accept_user",
+          "name" => "Accept user"
+        }
+      ]
+    }
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,10 @@
+$LOAD_PATH << Dir.pwd
 
 require "bundler/setup"
-require "sift"
-require "fakeweb"
+require "webmock/rspec"
 
 # Setup Fakeweb
-FakeWeb.allow_net_connect = false
+WebMock.disable_net_connect!
 
 RSpec.configure do |config|
 end

data/spec/unit/client/decision/apply_to_spec.rb

@@ -0,0 +1,262 @@
+require_relative "../../../spec_helper"
+
+require "sift/client/decision/apply_to"
+
+module Sift
+  class Client
+    class Decision
+      describe ApplyTo do
+        let(:decision_id) { "block_it" }
+        let(:api_key) { "customer_key" }
+        let(:decision) { Decision.new(api_key, "account_id") }
+
+        describe "attributes" do
+          ApplyTo::PROPERTIES.each do |attribute|
+            it "can read #{attribute} whether it is a symbol or string" do
+              expected_value = "right_#{attribute}#{Time.now.to_i}"
+              string_hash = {}
+              string_hash[attribute] = expected_value
+
+              applier = ApplyTo.new(api_key, "id", string_hash)
+              expect(applier.public_send(attribute)).to(
+                eq(expected_value),
+                "#{attribute} did not read the right string value"
+              )
+
+              symbol_hash = {}
+              symbol_hash[attribute.to_sym] = expected_value
+
+              applier = ApplyTo.new(api_key, "id", symbol_hash)
+              expect(applier.public_send(attribute)).to(
+                eq(expected_value),
+                "#{attribute} did not read the right symbol value"
+              )
+            end
+          end
+        end
+
+        describe "#run" do
+          it "will send a request to block user" do
+            configs = {
+              source: "manual",
+              analyst: "foobar@example.com",
+              description: "be blocking errrday allday",
+              user_id: "user_1234",
+              time: 1234,
+              fake_param: "this should not exist"
+            }
+
+            applier = ApplyTo.new(api_key, decision_id, configs)
+            request_body = MultiJson.dump({
+              source: configs[:source],
+              description: configs[:description],
+              analyst: configs[:analyst],
+              decision_id: decision_id,
+              time: 1234
+            })
+
+            response_body = {
+              "entity" => {
+                "id" => "USER_ID",
+                "type" => "user"
+              },
+              "decision" => {
+                "id" => decision_id
+              },
+              "time" => Time.now.to_i
+            }
+
+            stub_request(:post, put_auth_in_url(api_key, applier.send(:path)))
+              .with(body: request_body)
+              .to_return(body: MultiJson.dump(response_body))
+
+            response = applier.run
+
+            expect(response.ok?).to be(true)
+            expect(response.body).to eq(response_body)
+          end
+
+          context "without a valid user_id or order_id" do
+            it "will return a response object with the error message" do
+              configs = {
+                source: "manual",
+                analyst: "foobar@example.com",
+                description: "be blocking errrday allday",
+                decision: decision,
+                user_id: "user_1234",
+                "order_id" => nil
+              }
+
+              applier = ApplyTo.new(api_key, decision_id, configs)
+
+              response = applier.run
+              non_empty_string_error =
+                Validate::Primitive::ERROR_MESSAGES[:non_empty_string]
+              error_message = "order_id #{non_empty_string_error}, got NilClass"
+
+              expect(response.ok?).to be(false)
+              expect(response.body["error_message"]).to eq(error_message)
+
+              ## Invalid user_id
+
+              configs.delete(:user_id)
+              configs.delete("order_id")
+
+              applier = ApplyTo.new(api_key, decision_id, configs)
+
+              response = applier.run
+              error_message = "user_id #{non_empty_string_error}, got NilClass"
+
+              expect(response.ok?).to be(false)
+              expect(response.body["error_message"]).to eq(error_message)
+            end
+          end
+
+          context "without a valid user_id or session_id" do
+            it "will return a response object with the error message" do
+              configs = {
+                source: "manual",
+                analyst: "foobar@example.com",
+                description: "be blocking errrday allday",
+                decision: decision,
+                "session_id" => nil,
+                user_id: "user_1234"                
+              }
+
+              applier = ApplyTo.new(api_key, decision_id, configs)
+
+              response = applier.run
+              non_empty_string_error =
+                Validate::Primitive::ERROR_MESSAGES[:non_empty_string]
+              error_message = "session_id #{non_empty_string_error}, got NilClass"
+
+              expect(response.ok?).to be(false)
+              expect(response.body["error_message"]).to eq(error_message)
+
+              ## Invalid user_id
+
+              configs.delete(:user_id)
+              configs.delete("session_id")
+
+              applier = ApplyTo.new(api_key, decision_id, configs)
+
+              response = applier.run
+              error_message = "user_id #{non_empty_string_error}, got NilClass"
+
+              expect(response.ok?).to be(false)
+              expect(response.body["error_message"]).to eq(error_message)
+            end
+          end
+
+          context "when api returns an error code" do
+            it "will return a response with the information" do
+              configs = {
+                source: "manual",
+                description: "be blocking errrday allday",
+                decision: decision,
+                user_id: "user_1234"
+              }
+
+              applier = ApplyTo.new(api_key, decision_id, configs)
+              request_body = MultiJson.dump(applier.send(:request_body))
+
+              response_body = {
+                "error" => "not_found",
+                "description" => "No decision with id non_existent_decision_id"
+              }
+
+              stub_request(:post, put_auth_in_url(api_key, applier.send(:path)))
+                .with(body: request_body)
+                .to_return(body: MultiJson.dump(response_body), status: 404)
+
+              response = applier.run
+
+              expect(response.ok?).to be(false)
+              expect(response.body).to eq(response_body)
+            end
+          end
+        end
+
+        describe "#run" do
+          it "will construct the right path given the configs" do
+            user_id = "bad_user@example.com"
+            order_id = "ORDER_1235"
+
+            applier = ApplyTo.new(api_key, decision_id, {
+              user_id: user_id,
+              account_id: decision.account_id,
+            })
+
+            path = Client::API3_ENDPOINT +
+              "/v3/accounts/#{decision.account_id}" +
+              "/users/#{CGI.escape(user_id)}" +
+              "/decisions"
+
+            expect("https://api3.siftscience.com/v3/accounts/account_id" +
+              "/users/bad_user%40example.com/decisions").to eq(path)
+
+            applier = ApplyTo.new(api_key, decision_id, {
+              user_id: user_id,
+              account_id: decision.account_id,
+              order_id: order_id
+            })
+
+            path = Client::API3_ENDPOINT +
+              "/v3/accounts/#{decision.account_id}/users/" +
+              "#{CGI.escape(user_id)}/orders/#{CGI.escape(order_id)}" +
+              "/decisions"
+            
+            expect("https://api3.siftscience.com/v3/accounts/account_id" + 
+              "/users/bad_user%40example.com/orders/ORDER_1235/decisions").to eq(path)
+          end
+        end
+
+        describe "#run" do
+          it "will construct the right path given the configs" do
+            user_id = "bad_user@example.com"
+            session_id = "gigtleqddo84l8cm15qe4il"
+
+            applier = ApplyTo.new(api_key, decision_id, {
+              user_id: user_id,
+              account_id: decision.account_id,
+            })
+
+            path = Client::API3_ENDPOINT +
+              "/v3/accounts/#{decision.account_id}" +
+              "/users/#{CGI.escape(user_id)}" +
+              "/decisions"
+
+            expect("https://api3.siftscience.com/v3/accounts/account_id" +
+              "/users/bad_user%40example.com/decisions").to eq(path)
+
+            applier = ApplyTo.new(api_key, decision_id, {
+              user_id: user_id,
+              account_id: decision.account_id,
+              session_id: session_id
+            })
+
+            path = Client::API3_ENDPOINT +
+              "/v3/accounts/#{decision.account_id}/users/" +
+              "#{CGI.escape(user_id)}/sessions/#{CGI.escape(session_id)}" +
+              "/decisions"
+
+            expect("https://api3.siftscience.com/v3/accounts/account_id" + 
+              "/users/bad_user%40example.com/sessions/gigtleqddo84l8cm15qe4il/decisions").to eq(path)
+          end
+        end
+
+
+        # 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
+        #
+        def put_auth_in_url(api_key, url)
+          protocal, uri = url.split(/(?<=https\:\/\/)/)
+
+          protocal + api_key + "@" + uri
+        end
+      end
+    end
+  end
+end

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