sift 1.1.7.3 → 2.0.0.0

data/lib/sift/version.rb

@@ -1,4 +1,4 @@
 module Sift
-  VERSION = "1.1.7.3"
-  API_VERSION = "203"
+  VERSION = "2.0.0.0"
+  API_VERSION = "204"
 end

data/sift.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "sift"
   s.version     = Sift::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Fred Sadaghiani", "Yoav Schatzberg"]
+  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}
@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
 
   # Gems that must be intalled for sift to compile and build
   s.add_development_dependency "rspec", ">=2.14.1"
-  s.add_development_dependency "webmock", ">= 1.16.0"
+  s.add_development_dependency "webmock", ">= 1.16.0", "< 2"
 
   # Gems that must be intalled for sift to work
   s.add_dependency "httparty", ">= 0.11.0"

data/spec/unit/client_203_spec.rb

@@ -0,0 +1,192 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+
+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_label_spec.rb

@@ -3,6 +3,14 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
 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,39 +18,75 @@ 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/v204/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
+    response_json = { :status => 0, :error_message => "OK" }
+    user_id = "frodo_baggins"
+
+    stub_request(:delete,
+                 "https://api.siftscience.com/v204/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, :headers => 
-        {"content-type"=>"application/json; charset=UTF-8","content-length"=> "74"})
+    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
+    properties = valid_label_properties_203
 
-    response = Sift::Client.new(api_key).label(user_id, properties)
+    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
     response_json = { :status => 0, :error_message => "OK" }
     user_id = "frodo_baggins"
 
-    stub_request(:delete, "https://api.siftscience.com/v203/users/frodo_baggins/labels?api_key=foobar").
-      to_return(:status => 204)
+    stub_request(:delete,
+                 "https://api.siftscience.com/v203/users/frodo_baggins/labels?api_key=foobar")
+      .to_return(:status => 204)
 
     api_key = "foobar"
 
-    response = Sift::Client.new(api_key).unlabel(user_id)
+    response = Sift::Client.new(:api_key => api_key).unlabel(user_id, :version => "203")
     expect(response.ok?).to eq(true)
   end
 

data/spec/unit/client_spec.rb

@@ -78,60 +78,69 @@ describe Sift::Client do
   end
 
   def fully_qualified_api_endpoint
-    Sift::Client::API_ENDPOINT + Sift.current_rest_api_path
+    Sift::Client::API_ENDPOINT + Sift.rest_api_path
   end
 
+
   it "Can instantiate client with blank api key if Sift.api_key set" do
     Sift.api_key = "test_global_api_key"
     expect(Sift::Client.new().api_key).to eq(Sift.api_key)
   end
 
+
   it "Parameter passed api key takes precedence over Sift.api_key" do
     Sift.api_key = "test_global_api_key"
     api_key = "test_local_api_key"
-    expect(Sift::Client.new(api_key).api_key).to eq(api_key)
+    expect(Sift::Client.new(:api_key => api_key).api_key).to eq(api_key)
   end
 
+
   it "Cannot instantiate client with nil, empty, non-string, or blank api key" do
-    expect(lambda { Sift::Client.new(nil) }).to raise_error(StandardError)
-    expect(lambda { Sift::Client.new("") }).to raise_error(StandardError)
-    expect(lambda { Sift::Client.new(123456) }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new(:api_key => nil) }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new(:api_key => "") }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new(:api_key => 123456) }).to raise_error(StandardError)
     expect(lambda { Sift::Client.new() }).to raise_error(StandardError)
   end
 
-  it "Cannot instantiate client with nil, empty, non-string, or blank path" do
+
+  it "Cannot instantiate client with empty, non-string, or blank path" do
     api_key = "test_local_api_key"
-    expect(lambda { Sift::Client.new(api_key, nil) }).to raise_error(StandardError)
-    expect(lambda { Sift::Client.new(api_key, "") }).to raise_error(StandardError)
-    expect(lambda { Sift::Client.new(api_key, 123456) }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new(:path => "") }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new(:path => 123456) }).to raise_error(StandardError)
   end
 
+
   it "Can instantiate client with non-default timeout" do
-    expect(lambda { Sift::Client.new("test_local_api_key", Sift.current_rest_api_path, 4) }).not_to raise_error
+    expect(lambda { Sift::Client.new(:api_key => "foo", :timeout => 4) })
+      .not_to raise_error
   end
 
+
   it "Track call must specify an event name" do
-    expect(lambda { Sift::Client.new("foo").track(nil) }).to raise_error(StandardError)
-    expect(lambda { Sift::Client.new("foo").track("") }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new().track(nil) }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new().track("") }).to raise_error(StandardError)
   end
 
+
   it "Must specify an event name" do
-    expect(lambda { Sift::Client.new("foo").track(nil) }).to raise_error(StandardError)
-    expect(lambda { Sift::Client.new("foo").track("") }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new().track(nil) }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new().track("") }).to raise_error(StandardError)
   end
 
+
   it "Must specify properties" do
     event = "custom_event_name"
-    expect(lambda { Sift::Client.new("foo").track(event) }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new().track(event) }).to raise_error(StandardError)
   end
 
+
   it "Score call must specify a user_id" do
-    expect(lambda { Sift::Client.new("foo").score(nil) }).to raise_error(StandardError)
-    expect(lambda { Sift::Client.new("foo").score("") }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new().score(nil) }).to raise_error(StandardError)
+    expect(lambda { Sift::Client.new().score("") }).to raise_error(StandardError)
   end
 
-  it "Doesn't raise an exception on Net/HTTP errors" do
 
+  it "Doesn't raise an exception on Net/HTTP errors" do
     api_key = "foobar"
     event = "$transaction"
     properties = valid_transaction_properties
@@ -140,11 +149,11 @@ describe Sift::Client do
 
     # This method should just return nil -- the track call failed because
     # of an HTTP error
-    expect(Sift::Client.new(api_key).track(event, properties)).to eq(nil)
+    expect(Sift::Client.new(:api_key => api_key).track(event, properties)).to eq(nil)
   end
 
-  it "Returns nil when a StandardError occurs within the request" do
 
+  it "Returns nil when a StandardError occurs within the request" do
     api_key = "foobar"
     event = "$transaction"
     properties = valid_transaction_properties
@@ -153,32 +162,35 @@ describe Sift::Client do
 
     # This method should just return nil -- the track call failed because
     # a StandardError exception was thrown
-    expect(Sift::Client.new(api_key).track(event, properties)).to eq(nil)
+    expect(Sift::Client.new(:api_key => api_key).track(event, properties)).to eq(nil)
   end
 
-  it "Successfuly handles an event and returns OK" do
 
+  it "Successfuly handles an event and returns OK" do
     response_json = { :status => 0, :error_message => "OK" }
 
-    stub_request(:post, "https://api.siftscience.com/v203/events").
+    stub_request(:post, "https://api.siftscience.com/v204/events").
       with { |request|
         parsed_body = JSON.parse(request.body)
         expect(parsed_body).to include("$buyer_user_id" => "123456")
-      }.to_return(:status => 200, :body => MultiJson.dump(response_json), :headers => {"content-type"=>"application/json; charset=UTF-8","content-length"=> "74"})
+    }.to_return(:status => 200, :body => MultiJson.dump(response_json),
+                :headers => {"content-type"=>"application/json; charset=UTF-8",
+                             "content-length"=> "74"})
 
     api_key = "foobar"
     event = "$transaction"
     properties = valid_transaction_properties
 
-    response = Sift::Client.new(api_key).track(event, properties)
+    response = Sift::Client.new(:api_key => api_key).track(event, 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 submits event with overridden key" do
     response_json = { :status => 0, :error_message => "OK"}
-    stub_request(:post, "https://api.siftscience.com/v203/events").
+    stub_request(:post, "https://api.siftscience.com/v204/events").
       with { | request|
         parsed_body = JSON.parse(request.body)
         expect(parsed_body).to include("$buyer_user_id" => "123456")
@@ -189,22 +201,25 @@ describe Sift::Client do
     event = "$transaction"
     properties = valid_transaction_properties
 
-    response = Sift::Client.new(api_key).track(event, properties, nil, nil, false, "overridden", false)
+    response = Sift::Client.new(:api_key => api_key)
+               .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 "Successfuly scrubs nils" do
 
+  it "Successfully scrubs nils" do
     response_json = { :status => 0, :error_message => "OK" }
 
-    stub_request(:post, "https://api.siftscience.com/v203/events").
-      with { |request|
+    stub_request(:post, "https://api.siftscience.com/v204/events")
+      .with { |request|
         parsed_body = JSON.parse(request.body)
         expect(parsed_body).not_to include("fake_property")
         expect(parsed_body).to include("sub_object" => {"one" => "two"})
-      }.to_return(:status => 200, :body => MultiJson.dump(response_json), :headers => {"content-type"=>"application/json; charset=UTF-8","content-length"=> "74"})
+    }.to_return(:status => 200, :body => MultiJson.dump(response_json),
+                :headers => {"content-type"=>"application/json; charset=UTF-8",
+                             "content-length"=> "74"})
 
     api_key = "foobar"
     event = "$transaction"
@@ -215,21 +230,23 @@ describe Sift::Client do
         "three" => nil
       }
     )
-    response = Sift::Client.new(api_key).track(event, properties)
+    response = Sift::Client.new(:api_key => api_key).track(event, 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 fetches a score" do
 
+  it "Successfully fetches a 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"})
+    stub_request(:get, "https://api.siftscience.com/v204/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).score(score_response_json[:user_id])
+    response = Sift::Client.new(:api_key => api_key).score(score_response_json[:user_id])
     expect(response.ok?).to eq(true)
     expect(response.api_status).to eq(0)
     expect(response.api_error_message).to eq("OK")
@@ -237,15 +254,16 @@ describe Sift::Client do
     expect(response.body["score"]).to eq(0.93)
   end
 
-  it "Successfully fetches a score with an overridden key" do
 
+  it "Successfully fetches a 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 => {})
+    stub_request(:get, "https://api.siftscience.com/v204/score/247019/?api_key=overridden")
+      .to_return(:status => 200, :body => MultiJson.dump(response_json), :headers => {})
 
-    response = Sift::Client.new(api_key).score(score_response_json[:user_id], nil, "overridden")
+    response = Sift::Client.new(:api_key => api_key)
+               .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")
@@ -254,8 +272,7 @@ describe Sift::Client do
   end
 
 
-  it "Successfuly make a sync score request" do
-
+  it "Successfully make a sync score request" do
     api_key = "foobar"
     response_json = {
       :status => 0,
@@ -263,20 +280,23 @@ describe Sift::Client do
       :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"})
+    stub_request(:post, "https://api.siftscience.com/v204/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).track(event, properties, nil, nil, true, nil, nil)
+    response = Sift::Client.new(:api_key => api_key)
+               .track(event, properties, :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"]["score"]).to eq(0.93)
   end
 
-  it "Successfuly make a sync action request" do
 
+  it "Successfully make a sync action request" do
     api_key = "foobar"
     response_json = {
       :status => 0,
@@ -284,12 +304,15 @@ describe Sift::Client do
       :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"})
+    stub_request(:post, "https://api.siftscience.com/v204/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).track(event, properties, nil, nil, nil, nil, true)
+    response = Sift::Client.new(:api_key => api_key)
+               .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")
@@ -297,5 +320,74 @@ describe Sift::Client do
   end
 
 
+  it "Successfully make a sync workflow request" do
+    api_key = "foobar"
+    response_json = {
+      :status => 0,
+      :error_message => "OK",
+      :score_response => {
+        :status => -1,
+        :error_message => "Internal server error."
+      }
+    }
+
+    stub_request(:post,
+                 "https://api.siftscience.com/v204/events?return_workflow_status=true&abuse_types=legacy,payment_abuse")
+      .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_workflow_status => true, :abuse_types => ['legacy', 'payment_abuse'])
+    expect(response.ok?).to eq(true)
+    expect(response.api_status).to eq(0)
+    expect(response.api_error_message).to eq("OK")
+  end
+
+
+  it "Successfully make a workflow status request" do
+    response_text = '{"id":"skdjfnkse","config":{"id":"5rrbr4iaaa","version":"1468367620871"},"config_display_name":"workflow config","abuse_types":["payment_abuse"],"state":"running","entity":{"id":"example_user","type":"user"},"history":[{"app":"user","name":"Entity","state":"finished","config":{}}]}'
+
+    stub_request(:get, "https://foobar:@api3.siftscience.com/v3/accounts/ACCT/workflows/runs/skdjfnkse")
+      .to_return(:status => 200, :body => response_text, :headers => {})
+
+    client = Sift::Client.new(:api_key => "foobar", :account_id => "ACCT")
+    response = client.get_workflow_status("skdjfnkse")
+
+    expect(response.ok?).to eq(true)
+    expect(response.body["id"]).to eq("skdjfnkse")
+    expect(response.body["state"]).to eq("running")
+  end
+
+
+    it "Successfully make a user decisions request" do
+    response_text = '{"decisions":{"content_abuse":{"decision":{"id":"user_decision"},"time":1468707128659,"webhook_succeeded":false}}}'
+
+    stub_request(:get, "https://foobar:@api3.siftscience.com/v3/accounts/ACCT/users/example_user/decisions")
+      .to_return(:status => 200, :body => response_text, :headers => {})
+
+    client = Sift::Client.new(:api_key => "foobar", :account_id => "ACCT")
+    response = client.get_user_decisions("example_user")
+
+    expect(response.ok?).to eq(true)
+    expect(response.body["decisions"]["content_abuse"]["decision"]["id"]).to eq("user_decision")    
+  end
+
+
+  it "Successfully make an order decisions request" do
+    response_text = '{"decisions":{"payment_abuse":{"decision":{"id":"decision7"},"time":1468599638005,"webhook_succeeded":false},"promotion_abuse":{"decision":{"id":"good_order"},"time":1468517407135,"webhook_succeeded":true}}}'
+
+    stub_request(:get, "https://foobar:@api3.siftscience.com/v3/accounts/ACCT/orders/example_order/decisions")
+      .to_return(:status => 200, :body => response_text, :headers => {})
+
+    client = Sift::Client.new(:api_key => "foobar", :account_id => "ACCT")
+    response = client.get_order_decisions("example_order", :timeout => 3)
+
+    expect(response.ok?).to eq(true)
+    expect(response.body["decisions"]["payment_abuse"]["decision"]["id"]).to eq("decision7")
+  end
 
 end