slidepay 0.0.2

data/spec/bank_account_spec.rb

@@ -0,0 +1,38 @@
+require "slidepay"
+require "spec_helper"
+
+describe SlidePay::BankAccount do
+  it "should have an id_attribute" do
+    b = SlidePay::BankAccount.new()
+    expect(b.id_attribute).to eq("bank_account_id")
+  end
+
+  it "should have a root url" do
+    b = SlidePay::BankAccount.new()
+    expect(b.url_root).to eq("bank_account")
+  end
+
+  describe "url" do
+    it "should not append the object id if no id is set" do
+      b = SlidePay::BankAccount.new()
+      expect(b.url()).to eq("bank_account")
+    end
+
+    it "should append the object id if set" do
+      b = SlidePay::BankAccount.new("bank_account_id" => 2)
+      expect(b.url()).to eq("bank_account/2")
+    end
+  end
+
+  describe "id" do
+    it "should return nil if the id is not set" do
+      b = SlidePay::BankAccount.new()
+      expect(b.id()).to eq(nil)
+    end
+
+    it "should return the id if it is present" do
+      b = SlidePay::BankAccount.new("bank_account_id" => 2)
+      expect(b.id()).to eq(2)
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,141 @@
+require "slidepay"
+require "spec_helper"
+
+describe SlidePay::Client do
+  before(:all) do
+    SlidePay.configure(development: true)
+  end
+
+  it "should allow instantiation with no parameters" do
+    c = SlidePay::Client.new
+    expect(c).to be_a(SlidePay::Client)
+  end
+
+  it "should set api_key, token, and endpoint when they are present" do
+    c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+
+    expect(c.api_key).to  eq("TEST_API_KEY")
+    expect(c.token).to  eq("TEST_TOKEN")
+    expect(c.endpoint).to  eq("TEST_ENDPOINT")
+  end
+
+  describe "basic request methods" do
+    describe "get" do
+      it "should accept a string" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", endpoint: "TEST_ENDPOINT")
+
+        SlidePay.should_receive(:get).with(path: 'test/path', api_key: "TEST_API_KEY", token: nil, endpoint: "TEST_ENDPOINT")
+        expect(c.get("test/path")).not_to raise_error
+      end
+
+      it "should accept a hash" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", endpoint: "TEST_ENDPOINT")
+
+        SlidePay.should_receive(:get).with(path: 'test/path', api_key: "TEST_API_KEY", token: nil, endpoint: "TEST_ENDPOINT")
+        expect(c.get(path: "test/path")).not_to raise_error
+      end
+    end
+
+    describe "post" do
+      it "should send the parameters hash with api_key and token to SlidePay" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", endpoint: "TEST_ENDPOINT")
+
+        SlidePay.should_receive(:post).with(path: 'test/path', data: "TEST_DATA", api_key: "TEST_API_KEY", token: nil, endpoint: "TEST_ENDPOINT")
+        expect(c.post(path: "test/path", data: "TEST_DATA")).not_to raise_error
+      end
+    end
+
+    describe "put" do
+      it "should send the parameters hash with api_key and token to SlidePay" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", endpoint: "TEST_ENDPOINT")
+
+        SlidePay.should_receive(:put).with(path: 'test/path', data: "TEST_DATA", api_key: "TEST_API_KEY", token: nil, endpoint: "TEST_ENDPOINT")
+        expect(c.put(path: "test/path", data: "TEST_DATA")).not_to raise_error
+      end
+    end
+
+    describe "delete" do
+      it "should accept a string" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", endpoint: "TEST_ENDPOINT")
+
+        SlidePay.should_receive(:delete).with(path: 'test/path', api_key: "TEST_API_KEY", token: nil, endpoint: "TEST_ENDPOINT")
+        expect(c.delete("test/path")).not_to raise_error
+      end
+
+      it "should accept a hash" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", endpoint: "TEST_ENDPOINT")
+
+        SlidePay.should_receive(:delete).with(path: 'test/path', api_key: "TEST_API_KEY", token: nil, endpoint: "TEST_ENDPOINT")
+        expect(c.delete(path: "test/path")).not_to raise_error
+      end
+    end
+  end
+
+  describe "resource request methods" do
+    describe "list" do
+      it "should use the resource's url_root with the SlidePay.get method" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        b = SlidePay::BankAccount.new()
+        SlidePay.should_receive(:get).with(path: b.url_root, api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT").and_return(a_response_object(bank_account_array_response))
+        c.list(b)
+      end
+
+      it "should return an array" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        b = SlidePay::BankAccount.new()
+        SlidePay.stub(:request) { a_response_object(bank_account_array_response) }
+
+        bank_accounts = c.list(b)
+        expect(bank_accounts).to be_a(Array)
+      end
+
+      it "should return an array of the proper length" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        b = SlidePay::BankAccount.new()
+        SlidePay.stub(:request) { a_response_object(bank_account_array_response) }
+
+        bank_accounts = c.list(b)
+        expect(bank_accounts).to be_a(Array)
+      end
+
+      it "should return an array of resources of the proper type" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        b = SlidePay::BankAccount.new()
+        SlidePay.stub(:request) { a_response_object(bank_account_array_response) }
+
+        bank_accounts = c.list(b)
+        expect(bank_accounts).to be_a(Array)
+        expect(bank_accounts.length).to eq(2)
+        expect(bank_accounts[0]).to be_a(SlidePay::BankAccount)
+        expect(bank_accounts[1]).to be_a(SlidePay::BankAccount)
+      end
+    end
+
+    describe "retrieve" do
+      it "should use the resource's method for fulfillment" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        b = SlidePay::BankAccount.new()
+        b.should_receive(:retrieve).with(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        c.retrieve(b)
+      end
+    end
+
+    describe "save" do
+      it "should use the resource's method for fulfillment" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        b = SlidePay::BankAccount.new()
+        b.should_receive(:save).with(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        c.save(b)
+      end
+    end
+
+    describe "destroy" do
+      it "should use the resource's method for fulfillment" do
+        c = SlidePay::Client.new(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        b = SlidePay::BankAccount.new("bank_account_id" => 1)
+        b.should_receive(:destroy).with(api_key: "TEST_API_KEY", token: "TEST_TOKEN", endpoint: "TEST_ENDPOINT")
+        c.destroy(b)
+      end
+    end
+  end
+end

data/spec/payment_spec.rb

@@ -0,0 +1,90 @@
+require "slidepay"
+require "spec_helper"
+
+describe SlidePay::Payment do
+  it "should have an id_attribute" do
+    p = SlidePay::Payment.new()
+    expect(p.id_attribute).to eq("payment_id")
+  end
+
+  it "should have a root url" do
+    p = SlidePay::Payment.new()
+    expect(p.url_root).to eq("payment")
+  end
+
+  describe "url" do
+    it "should not append the object id if no id is set" do
+      p = SlidePay::Payment.new()
+      expect(p.url()).to eq("payment")
+    end
+
+    it "should append the object id if set" do
+      p = SlidePay::Payment.new("payment_id" => 2)
+      expect(p.url()).to eq("payment/2")
+    end
+  end
+
+  describe "id" do
+    it "should return nil if the id is not set" do
+      p = SlidePay::Payment.new()
+      expect(p.id()).to eq(nil)
+    end
+
+    it "should return the id if it is present" do
+      p = SlidePay::Payment.new("payment_id" => 2)
+      expect(p.id()).to eq(2)
+    end
+  end
+
+  describe "save" do
+    it "should call the process method" do
+      p = SlidePay::Payment.new()
+      p.should_receive(:process)
+      p.save()
+    end
+  end
+
+  describe "destroy" do
+    it "should call the refund method" do
+      p = SlidePay::Payment.new()
+      p.should_receive(:refund)
+      p.destroy()
+    end
+  end
+
+  describe "process" do
+    it "should set the payment_id and the order_master_id on success" do
+      SlidePay.stub(:post) { a_response_object(successful_payment_response) }
+
+      p = SlidePay::Payment.new()
+      expect(p["order_master_id"]).to eq(nil)
+      expect(p["payment_id"]).to eq(nil)
+      p.process()
+      expect(p["order_master_id"]).to eq("10") # Test data found in spec_helper
+      expect(p["payment_id"]).to eq("12")
+    end
+
+    it "should raise an error on failure" do
+      SlidePay.stub(:post) { a_response_object(failed_payment_response) }
+
+      p = SlidePay::Payment.new()
+      expect{ p.process() }.to raise_error("TEST_PAYMENT_FAILED_MESSAGE")
+    end
+  end
+
+  describe "refund" do
+    it "should return false for failure" do
+      SlidePay.stub(:post) { a_response_object(failed_object_response) }
+
+      p = SlidePay::Payment.new()
+      expect(p.refund()).to eq(false)
+    end
+
+    it "should return true for successful refund" do
+      SlidePay.stub(:post) { a_response_object(successful_object_response) }
+
+      p = SlidePay::Payment.new()
+      expect(p.refund()).to eq(true)
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,135 @@
+require 'slidepay'
+require 'spec_helper'
+
+describe SlidePay::Response do
+  def public_methods
+    [:success, :custom, :operation, :endpoint, :timezone, :method, :obj,
+     :id, :milliseconds, :data, :data_md5]
+  end
+
+  it "should be a String" do
+    expect(SlidePay::Response.superclass).to eq(String)
+  end
+
+  it "should have a bunch of public instance methods" do
+    actual_public_methods = SlidePay::Response.public_instance_methods
+    public_methods.each do |method|
+      expect(actual_public_methods).to include(method)
+    end
+  end
+
+  describe "constructor" do
+    it "should create a blank instance if no string is provided" do
+      r = SlidePay::Response.new
+      expect(r).to eq("")
+    end
+
+    # it "should raise an error if created with invalid JSON" do
+    #   expect(SlidePay::Response.new("THIS IS NOT JSON")).to raise_error
+    # end
+
+    it "should set the response to any string passed in" do
+      json = "{ \"custom\": \"CUSTOM_VALUE\" }"
+
+      r = SlidePay::Response.new(json)
+
+      expect(r).to eq(json)
+    end
+
+    it "should try to parse any JSON string passed in on creation" do
+      json = "{ \"custom\": \"CUSTOM_VALUE\" }"
+
+      r = SlidePay::Response.new(json)
+      expect(r.custom).to eq("CUSTOM_VALUE")
+    end
+  end
+
+  describe "parse_object_from_json" do
+    it "should populate the object when given a valid SlidePay response JSON" do
+      r = SlidePay::Response.new(successful_endpoint_response)
+
+      expect(r).to eq(successful_endpoint_response)
+
+      expect(r.success).to eq(true)
+      expect(r.custom).to eq(nil)
+      expect(r.operation).to eq("GET endpoint")
+      expect(r.endpoint).to eq("https://api.getcube.com:65532#{SlidePay::ENDPOINT_SUFFIX}")
+      expect(r.timezone).to eq(nil)
+      expect(r.method).to eq("GET")
+      expect(r.obj).to eq(nil)
+      expect(r.id).to eq(0)
+      expect(r.milliseconds).to eq("31.25")
+      expect(r.data).to eq("https://api.getcube.com:65532/rest.svc/API/")
+      expect(r.data_md5).to eq("15D13569C731E9D77ABDCB3348A2EBDD")
+    end
+
+    it "should populate the data property of the response with an object when appropriate" do
+      r = SlidePay::Response.new(successful_token_detail_response)
+
+      response_object = object_from_response(successful_token_detail_response)
+
+      expect(r.data).to be_a(Hash)
+      expect(r.data).to eq(response_object["data"])
+    end
+
+    it "should populate the data property of the response with an array when appropriate" do
+      r = SlidePay::Response.new(successful_array_response)
+
+      response_object = object_from_response(successful_array_response)
+
+      expect(r.data).to be_a(Array)
+      expect(r.data).to eq(response_object["data"])
+    end
+  end
+
+  describe "was_successful?" do
+    it "should always return a boolean" do
+      r = SlidePay::Response.new("{\"success\" : true}")
+      expect(r.was_successful?).to be_a(TrueClass)
+
+      r = SlidePay::Response.new("{\"success\" : false}")
+      expect(r.was_successful?).to be_a(FalseClass)
+    end
+
+    it "should return true for a successful response" do
+      r = SlidePay::Response.new(successful_endpoint_response)
+      expect(r.was_successful?).to eq(true)
+    end
+
+    it "should return false for an unsuccessful response" do
+      r = SlidePay::Response.new(failed_endpoint_response)
+      expect(r.was_successful?).to eq(false)
+    end
+  end
+
+  describe "endpoint" do
+    it "should always include the SlidePay endpoint suffix" do
+      r = SlidePay::Response.new
+      expect(r.endpoint).to include(SlidePay::ENDPOINT_SUFFIX)
+    end
+
+    it "should add the endpoint suffix to the endpoint value retrieved" do
+      r = SlidePay::Response.new(successful_token_detail_response)
+      response_object = object_from_response(successful_token_detail_response)
+      expect(r.endpoint).to eq("#{response_object["endpoint"]}#{SlidePay::ENDPOINT_SUFFIX}")
+    end
+  end
+
+  describe "error" do
+    it "should return nil for a successful response" do
+      r = SlidePay::Response.new(successful_token_detail_response)
+      expect(r.error).to eq(nil)
+    end
+
+    it "should return a Hash object for an unsuccessful response" do
+      r = SlidePay::Response.new(failed_token_detail_response)
+      expect(r.error).to be_a(Hash)
+    end
+
+    it "should return an object containing an error_code and error_text" do
+      r = SlidePay::Response.new(failed_token_detail_response)
+      expect(r.error).to include("error_text")
+      expect(r.error).to include("error_code")
+    end
+  end
+end

data/spec/slidepay_spec.rb

@@ -0,0 +1,301 @@
+require "slidepay"
+require "spec_helper"
+
+describe SlidePay do
+  def public_methods
+    [:get_auth_option, :request, :get, :post, :put, :delete]
+  end
+
+  it "should have a version" do
+    expect(SlidePay::VERSION).not_to be_nil
+  end
+
+  it "should have a global token variable that is nil" do
+    expect(SlidePay.token).to be_nil
+  end
+
+  it "should have a global api_key variable that is nil" do
+    expect(SlidePay.api_key).to be_nil
+  end
+
+  it "should have a default endpoint" do
+    expect(SlidePay.endpoint).not_to be_nil
+  end
+
+  describe "configure" do
+    before(:each) do
+      clear_slidepay()
+    end
+
+    it "should only configure an endpoint by default" do
+      SlidePay.configure
+
+      expect(SlidePay.token).to be_nil
+      expect(SlidePay.api_key).to be_nil
+      expect(SlidePay.endpoint).to eq(SlidePay::SUPERVISOR_URL)
+    end
+
+    it "should allow configuration of token, api_key, and endpoint" do
+      SlidePay.configure(endpoint: "TEST_ENDPOINT", token: "TEST_TOKEN", api_key: "TEST_API_KEY")
+
+      expect(SlidePay.token).to eq("TEST_TOKEN")
+      expect(SlidePay.api_key).to eq("TEST_API_KEY")
+      expect(SlidePay.endpoint).to eq("TEST_ENDPOINT")
+    end
+
+    it "should allow a user to choose the development enpdoint" do
+      SlidePay.configure(development: true)
+
+      expect(SlidePay.endpoint).to eq(SlidePay::DEV_API_URL)
+    end
+  end
+
+  it "should have a bunch of public methods" do
+    actual_slidepay_methods = SlidePay.public_methods
+    public_methods.each do |method|
+      expect(actual_slidepay_methods).to include(method)
+    end
+  end
+
+  it "should have a bunch of configuration options" do
+    ENDPOINT_SUFFIX   = '/rest.svc/API/'
+    SUPERVISOR_URL    = 'https://supervisor.getcube.com:65532/rest.svc/API/'
+    PROD_API_URL      = 'https://api.getcube.com:65532/rest.svc/API/'
+    DEV_API_URL       = 'https://dev.getcube.com:65532/rest.svc/API/'
+    DEBUG             = false
+
+    expect(SlidePay::ENDPOINT_SUFFIX).to eq(ENDPOINT_SUFFIX)
+    expect(SlidePay::SUPERVISOR_URL).to eq(SUPERVISOR_URL)
+    expect(SlidePay::PROD_API_URL).to eq(PROD_API_URL)
+    expect(SlidePay::DEV_API_URL).to eq(DEV_API_URL)
+    expect(SlidePay::DEBUG).to eq(DEBUG)
+  end
+
+  describe "get_endpoint_option" do
+    after(:each) do
+      clear_endpoint()
+    end
+
+    it "should use the default endpoint if none is provided" do
+      set_global_endpoint()
+
+      endpoint = SlidePay.get_endpoint_option({})
+      expect(SlidePay.endpoint).to eq("TEST_ENDPOINT")
+      expect(endpoint).to eq("TEST_ENDPOINT")
+    end
+
+    it "should use the endpoint passed in if there is no default" do
+      endpoint = SlidePay.get_endpoint_option(endpoint: "NEW_ENDPOINT")
+      expect(SlidePay.endpoint).to eq(nil)
+      expect(endpoint).to eq("NEW_ENDPOINT")
+    end
+
+    it "should use the endpoint passed in over the default" do
+      set_global_endpoint()
+
+      endpoint = SlidePay.get_endpoint_option(endpoint: "NEW_ENDPOINT")
+      expect(SlidePay.endpoint).to eq("TEST_ENDPOINT")
+      expect(endpoint).to eq("NEW_ENDPOINT")
+    end
+  end
+
+
+  describe "get_auth_option" do
+    after(:each) do
+      clear_auth_data()
+    end
+
+    it "should use the default token over the default api_key if both are present" do
+      set_global_token()
+      set_global_api_key()
+
+      auth = SlidePay.get_auth_option({})
+      expect(SlidePay.token).to eq("TEST_TOKEN")
+      expect(SlidePay.api_key).to eq("TEST_API_KEY")
+      expect(auth).to eq({ "x-cube-token" => "TEST_TOKEN" })
+    end
+
+    it "should use the default api_key when nothing else is given" do
+      set_global_api_key()
+
+      auth = SlidePay.get_auth_option({})
+      expect(SlidePay.token).to eq(nil)
+      expect(SlidePay.api_key).to eq("TEST_API_KEY")
+      expect(auth).to eq({ "x-cube-api-key" => "TEST_API_KEY" })
+    end
+
+    it "should use the default token when nothing else is given" do
+      set_global_token()
+
+      auth = SlidePay.get_auth_option({})
+      expect(SlidePay.token).to eq("TEST_TOKEN")
+      expect(SlidePay.api_key).to eq(nil)
+      expect(auth).to eq({ "x-cube-token" => "TEST_TOKEN" })
+    end
+
+    it "should use the provided api_key even when a default is present" do
+      set_global_api_key()
+
+      auth = SlidePay.get_auth_option(api_key: "PASSED_IN_API_KEY")
+      expect(SlidePay.token).to eq(nil)
+      expect(SlidePay.api_key).to eq("TEST_API_KEY")
+      expect(auth).to eq({ "x-cube-api-key" => "PASSED_IN_API_KEY" })
+    end
+
+    it "should use the provided token even when a default is present" do
+      set_global_token()
+
+      auth = SlidePay.get_auth_option(token: "PASSED_IN_TOKEN")
+      expect(SlidePay.token).to eq("TEST_TOKEN")
+      expect(SlidePay.api_key).to eq(nil)
+      expect(auth).to eq({ "x-cube-token" => "PASSED_IN_TOKEN" })
+    end
+  end
+
+  describe "request" do
+    before(:each) do
+      SlidePay.configure(development: true)
+    end
+
+    it "should return a SlidePay::Response object on a get" do
+      RestClient.should_receive(:get).and_return(failed_token_response)
+      r_get = SlidePay.request("GET", { :path => 'login'})
+      expect(r_get).to be_a(SlidePay::Response)
+    end
+
+    it "should return a SlidePay::Response object on a put" do
+      RestClient.should_receive(:put).and_return(failed_token_response)
+      r_put = SlidePay.request("PUT", { :path => 'login'})
+      expect(r_put).to be_a(SlidePay::Response)
+    end
+
+    it "should return a SlidePay::Response object on a post" do
+      RestClient.should_receive(:post).and_return(failed_token_response)
+      r_post = SlidePay.request("POST", { :path => 'login'})
+      expect(r_post).to be_a(SlidePay::Response)
+    end
+
+    it "should return a SlidePay::Response object on a delete" do
+      RestClient.should_receive(:delete).and_return(failed_token_response)
+      r_delete = SlidePay.request("DELETE", { :path => 'login'})
+      expect(r_delete).to be_a(SlidePay::Response)
+    end
+
+    it "should raise an error for invalid request types" do
+      expect { SlidePay.request("INVALID_TYPE", {}) }.to raise_error
+    end
+  end
+
+  describe "get" do
+    before(:all) do
+      SlidePay.configure(development: true)
+      set_global_api_key_from_env
+    end
+
+    it "should accept a string" do
+      SlidePay.should_receive(:request).with("GET", path: 'token/detail').and_return(a_response_object(successful_token_detail_response))
+      expect(SlidePay.get('token/detail')).to be_a(SlidePay::Response)
+    end
+
+    it "should accept a hash" do
+      SlidePay.should_receive(:request).with("GET", path: 'token/detail').and_return(a_response_object(successful_token_detail_response))
+      expect(SlidePay.get(path: 'token/detail')).to be_a(SlidePay::Response)
+    end
+  end
+
+  describe "delete" do
+    before(:all) do
+      SlidePay.configure(development: true)
+      set_global_api_key_from_env
+    end
+
+    it "should accept a string" do
+      SlidePay.should_receive(:request).with("DELETE", path: 'fictional_object/2').and_return(a_response_object(successful_deletion_response))
+      expect(SlidePay.delete('fictional_object/2')).to be_a(SlidePay::Response)
+    end
+
+    it "should accept a hash" do
+      SlidePay.should_receive(:request).with("DELETE", path: 'fictional_object/2').and_return(a_response_object(successful_deletion_response))
+      expect(SlidePay.delete(path: 'fictional_object/2')).to be_a(SlidePay::Response)
+    end
+  end
+
+  describe "retrieve_token" do
+    before(:all) do
+      clear_slidepay
+      SlidePay.configure(development: true)
+    end
+
+    it "should always return a SlidePay::Response" do
+      SlidePay.should_receive(:get).with(path: 'login', email: '', password: '').and_return(a_response_object(successful_token_response))
+
+      r = SlidePay.retrieve_token('','')
+      expect(r).to be_a(SlidePay::Response)
+    end
+
+    it "should return a token value on success" do
+      SlidePay.should_receive(:get).with(path: 'login', email: SlidePay::TEST_EMAIL, password: SlidePay::TEST_PASSWORD).and_return(a_response_object(successful_token_response))
+      r = SlidePay.retrieve_token(SlidePay::TEST_EMAIL,SlidePay::TEST_PASSWORD)
+
+      expect(r.data).to be_a(String)
+      expect(r.data).to eq("TOKEN_FROM_THE_BEYOND")
+    end
+
+    it "should return an error object on failure" do
+      SlidePay.should_receive(:get).with(path: 'login', email: '', password: '').and_return(a_response_object(failed_token_response))
+      r = SlidePay.retrieve_token('','')
+
+      expect(r.data).to be_a(Hash)
+      expect(r.error).to be_a(Hash)
+    end
+  end
+
+  describe "retrieve_endpoint" do
+    before(:all) do
+      clear_slidepay
+      SlidePay.configure()
+    end
+
+    it "should always return a string" do
+      SlidePay.should_receive(:get).with(path: 'endpoint', email: '').and_return(a_response_object(failed_endpoint_response))
+      r = SlidePay.retrieve_endpoint('')
+      expect(r).to be_a(SlidePay::Response)
+    end
+
+    it "should return an endpoint value on success" do
+      SlidePay.should_receive(:get).with(path: 'endpoint', email: 'matt+test@getcube.com').and_return(a_response_object(successful_token_response))
+      r = SlidePay.retrieve_endpoint('matt+test@getcube.com')
+
+      expect(r.data).to be_a(String)
+      expect(r.data).to eq("TOKEN_FROM_THE_BEYOND")
+    end
+
+    it "should return an error object on failure" do
+      SlidePay.should_receive(:get).with(path: 'endpoint', email: '').and_return(a_response_object(failed_token_response))
+      r = SlidePay.retrieve_endpoint('')
+
+      expect(r.data).to be_a(Hash)
+      expect(r.error).to be_a(Hash)
+    end
+  end
+
+  describe "authenticate" do
+    before(:each) do
+      clear_slidepay
+      SlidePay.configure(development: true)
+    end
+
+    it "should have a token after a successful authentication" do
+      SlidePay.should_receive(:get).with(path: 'login', email: SlidePay::TEST_EMAIL, password: SlidePay::TEST_PASSWORD).and_return(a_response_object(successful_token_response))
+      expect(SlidePay.authenticate(SlidePay::TEST_EMAIL, SlidePay::TEST_PASSWORD)).to eq(true)
+      expect(SlidePay.token).not_to eq(nil)
+    end
+
+    it "should not have a token after a successful authentication" do
+      SlidePay.should_receive(:get).with(path: 'login', email: '', password: '').and_return(a_response_object(failed_token_response))
+      expect(SlidePay.authenticate('','')).to eq(false)
+      expect(SlidePay.token).to eq(nil)
+    end
+  end
+
+end