sift 2.0.0.0 → 2.1.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,53 @@
+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_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,4 +1,4 @@
 module Sift
-  VERSION = "2.0.0.0"
+  VERSION = "2.1.0.0"
   API_VERSION = "204"
 end

data/sift.gemspec

@@ -20,7 +20,8 @@ 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 "rspec", "~> 3.5"
+  s.add_development_dependency "pry"
   s.add_development_dependency "webmock", ">= 1.16.0", "< 2"
 
   # Gems that must be intalled for sift to work

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,6 +1,6 @@
+$LOAD_PATH << Dir.pwd
 
 require "bundler/setup"
-require "sift"
 require "webmock/rspec"
 
 # Setup Fakeweb

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

@@ -0,0 +1,183 @@
+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",
+              decision: decision,
+              user_id: "user_1234"
+            }
+
+            applier = ApplyTo.new(api_key, decision_id, configs)
+            request_body = MultiJson.dump(applier.send(:request_body))
+
+            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 "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 "private#path" 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(applier.send(:path)).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(applier.send(:path)).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