promise_pay 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 657fe7151abb7b6dd76fbdb0e610697bf0f4e831
+  data.tar.gz: 2244b5986a100793fae53900ea53aebcc39ade4c
+SHA512:
+  metadata.gz: bee824f5f09fb802a33f336d8c6e9434ae1b195f2eddf0d61d7838c4ed6d2a2a6804e696afcc6341a841a856057bfea3b12c5ccad931795f97a0fa9c51fe80ba
+  data.tar.gz: 7d3bed8cbd8f7019952ebb1d028dddcac849e16aacf1910f42c7f8aa126e56e3e058688b82c790f0a98b8ac1cba209151cf52f6d7e51b73dfd01beab0ad22892

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in promise_pay.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Liam Norton
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# PromisePay
+
+PromisePay API calls wrapped in a gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'promise_pay'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install promise_pay
+
+Generate your PromizePay API key and the rails promise_pay initializer:
+
+    $ rails generate promise_pay:init EMAIL PASSWORD
+
+You're set to go!
+
+## Extra Info
+
+To use PromisePay's test API, set the following in `config/initializers/promise_pay.rb`:
+
+    PromisePay.env = :test
+
+Along with your test environments api user/key. You can generate all this by running:
+
+    $ rails generate promise_pay:init EMAIL PASSWORD --test
+
+Note this will overwrite anything in `config/initializers/promise_pay.rb`
+
+## Usage
+
+```ruby
+# A new PromisePay::Session that generates a session token
+session = PromisePay::Session.new(session_params)
+session.amount = 10
+session.token           => nil
+session.request_token   => "8cfd23e3-196e-4a45-ab16-d1213094871e"
+session.token           => "8cfd23e3-196e-4a45-ab16-d1213094871e"
+
+# Query PromisePay for a user (12345) returning a PromisePay::User object
+user = PromisePay::User.find(12345)
+user.email    => "email@addr"
+
+# Query PromisePay for an item (1s345) returning a PromisePay::Item object
+item = PromisePay::Item.find("1s345")
+item.amount   => 10
+
+```
+
+## TODO:
+
+1. Write .find_all methods
+2. Move all errors into shared file
+3. Don't enforce full params match on session request (?)
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/promise_pay/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec')

data/lib/generators/promise_pay/init_generator.rb

@@ -0,0 +1,43 @@
+require "rails/generators/base"
+require "promise_pay"
+
+module PromisePay
+  module Generators
+    class InitGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      argument :email,     type: :string
+      argument :password,  type: :string
+
+      class_option :test, type: :boolean, default: :false, description: "Initalize to test.api.promisepay.com"
+
+      desc "Request PromisePay API key and setup initializer"
+
+      def env
+        @env ||= options.test? ? :test : :production
+      end
+
+      def marketplace
+        @marketplace ||= (
+          PromisePay.env = env
+          PromisePay::Marketplace.new(user: email, password: password)
+        )
+      end
+
+      def token
+        @token ||= (
+          begin
+            marketplace.request_token
+          rescue PromisePay::RequestError
+            puts "WARNING: token generation failed (Check your credentials)"
+            "token"
+          end
+        )
+      end
+
+      def copy_initializer
+        template "promise_pay_initializer.rb", "config/initializers/promise_pay.rb"
+      end
+    end
+  end
+end

data/lib/generators/templates/promise_pay_initializer.rb

@@ -0,0 +1,5 @@
+require "promise_pay"
+
+PromisePay.api_user = "<%= email %>"
+PromisePay.api_key  = "<%= token %>"
+PromisePay.env      = :<%= env %>

data/lib/promise_pay/collection.rb

@@ -0,0 +1,15 @@
+module PromisePay
+  class Collection
+    attr_reader :collection_class
+
+    def initialize(collection_class)
+      @collection_class = collection_class
+    end
+
+    def parse
+      p collection_class.new
+      tmp = collection_class.new.fetch_all
+      p tmp
+    end
+  end
+end

data/lib/promise_pay/item.rb

@@ -0,0 +1,72 @@
+require "promise_pay/lib/dynamic_accessors"
+require "json"
+
+module PromisePay
+  class Item
+    attr_reader :id
+
+    def initialize(id = nil, options = {})
+      @id = id
+      assign_instance_variables({'item' => options}) unless options.empty?
+    end
+
+    class << self
+      def find(id)
+        new(id).find
+      end
+
+      def find_all
+        new.find_all
+      end
+    end
+
+    def find
+      assign_instance_variables(resource_result)
+      self
+    end
+
+    def find_all
+      resource_result.map do |result|
+        self.class.new(nil, result)
+      end
+    end
+
+    private
+
+    def resource_result
+      request = PromisePay::Request.new(path: api_resource)
+      response = request.execute
+      JSON.parse(response)["items"]
+    end
+
+    def api_resource
+      "items/#{id}"
+    end
+
+    def assign_instance_variables(result)
+      result.each do |attribute, value|
+        if value.is_a?(Hash)
+          value.each { |att, val| initialize_property(att, val) }
+        else
+          initialize_property(attribute, value)
+        end
+      end
+      self
+    end
+
+    def initialize_property(attribute, value)
+      attribute = attribute.gsub(/s$/, '_id') if ["buyers","sellers"].include? attribute
+      Lib::DynamicAccessors.define_accessor(attribute, value, self) unless accessor_defined?(attribute)
+      set_property(attribute, value)
+    end
+
+    def accessor_defined?(attribute)
+      respond_to?(attribute) && respond_to?("#{attribute}=")
+    end
+
+    def set_property(attribute, value)
+      setter_method = "#{attribute}="
+      self.send(setter_method, value)
+    end
+  end
+end

data/lib/promise_pay/lib/dynamic_accessors.rb

@@ -0,0 +1,42 @@
+module PromisePay
+  module Lib
+    module DynamicAccessors
+      class << self
+        def define_accessor(attribute, value, object)
+          klass = object.class
+          if attribute.to_s.end_with? "_at"
+            define_date_based_accessors(attribute, value, klass)
+          else
+            define_standard_accessors(attribute, value, klass)
+          end
+        end
+
+        private
+
+        def define_date_based_accessors(attribute, value, klass)
+          klass.class_eval %Q"
+            def #{attribute}=(value)
+              @#{attribute} = value.nil? ? nil : Time.parse(value).to_i
+            end
+
+            def #{attribute}
+              @#{attribute}.nil? ? nil : Time.at(@#{attribute})
+            end
+          "
+        end
+
+        def define_standard_accessors(attribute, value, klass)
+          klass.class_eval %Q"
+            def #{attribute}=(value)
+              @#{attribute} = value
+            end
+
+            def #{attribute}
+              @#{attribute}
+            end
+          "
+        end
+      end
+    end
+  end
+end

data/lib/promise_pay/marketplace.rb

@@ -0,0 +1,33 @@
+require "json"
+
+module PromisePay
+  class Marketplace
+
+    attr_reader :token
+
+    def initialize(options = {})
+      @user     = options.fetch :user
+      @password = options.fetch :password
+    end
+
+    def request_token
+      response = PromisePay::Request.new(
+        path:     api_resource,
+        user:     user,
+        password: password
+      ).execute
+
+      @token = JSON.parse(response)["token"]
+      token
+    end
+
+    private
+
+    def api_resource
+      "request_token"
+    end
+
+    attr_reader :user
+    attr_reader :password
+  end
+end

data/lib/promise_pay/request.rb

@@ -0,0 +1,54 @@
+require "rest_client"
+
+module PromisePay
+  class Request
+
+    def initialize(options = {})
+      @path     = options.fetch :path
+      @user     = options.fetch :user,          PromisePay.api_user
+      @password = options.fetch :password,      PromisePay.api_key
+      @request  = build_request
+    end
+
+    def execute
+      begin
+        response = request.execute
+      rescue RestClient::Unauthorized, RestClient::BadRequest => e
+        raise RequestError, e.message
+      end
+
+      response
+    end
+
+    private
+
+    def build_request
+      RestClient::Request.new(
+        method:   :get,
+        url:      endpoint,
+        user:     user,
+        password: password,
+        headers:  { accept: :json, content_type: :json }
+      )
+    end
+
+    def endpoint
+      host + path
+    end
+
+    def host
+      if PromisePay.env && PromisePay.env == :test
+        TEST_HOST
+      else
+        API_HOST
+      end
+    end
+
+    attr_reader :path
+    attr_reader :user
+    attr_reader :password
+    attr_reader :request
+  end
+
+  class RequestError < StandardError; end
+end

data/lib/promise_pay/session.rb

@@ -0,0 +1,106 @@
+require "json"
+require 'active_support/core_ext/object'
+
+module PromisePay
+  class Session
+
+    attr_reader   :token
+    attr_accessor :current_user_id
+    attr_accessor :currency
+    attr_accessor :item_name
+    attr_accessor :amount
+    attr_accessor :seller_lastname
+    attr_accessor :seller_firstname
+    attr_accessor :buyer_lastname
+    attr_accessor :buyer_firstname
+    attr_accessor :seller_email
+    attr_accessor :buyer_email
+    attr_accessor :external_item_id
+    attr_accessor :external_seller_id
+    attr_accessor :external_buyer_id
+    attr_accessor :fee_ids
+    attr_accessor :payment_type_id
+
+    def initialize(options = {})
+      @current_user_id    = options.fetch :current_user_id,     nil
+      @currency           = options.fetch :currency,            nil
+      @item_name          = options.fetch :item_name,           nil
+      @amount             = options.fetch :amount,              nil
+      @seller_lastname    = options.fetch :seller_lastname,     nil
+      @seller_firstname   = options.fetch :seller_firstname,    nil
+      @buyer_lastname     = options.fetch :buyer_lastname,      nil
+      @buyer_firstname    = options.fetch :buyer_firstname,     nil
+      @seller_email       = options.fetch :seller_email,        nil
+      @buyer_email        = options.fetch :buyer_email,         nil
+      @external_item_id   = options.fetch :external_item_id,    nil
+      @external_seller_id = options.fetch :external_seller_id,  nil
+      @external_buyer_id  = options.fetch :external_buyer_id,   nil
+      @fee_ids            = options.fetch :fee_ids,             nil
+      @payment_type_id    = options.fetch :payment_type_id,     nil
+    end
+
+    def request_token
+      enforce_valid_params!
+
+      request = PromisePay::Request.new(path: api_resource)
+      response = request.execute
+
+      @token = JSON.parse(response)["token"]
+      token
+    end
+
+    private
+
+    def api_resource
+      "request_session_token?#{query_string}"
+    end
+
+    def query_string
+      {
+        current_user_id:    current_user_id,
+        currency:           currency,
+        item_name:          item_name,
+        amount:             amount,
+        seller_lastname:    seller_lastname,
+        seller_firstname:   seller_firstname,
+        buyer_lastname:     buyer_lastname,
+        buyer_firstname:    buyer_firstname,
+        seller_email:       seller_email,
+        buyer_email:        buyer_email,
+        external_item_id:   external_item_id,
+        external_seller_id: external_seller_id,
+        external_buyer_id:  external_buyer_id,
+        fee_ids:            fee_ids,
+        payment_type_id:    payment_type_id
+      }.to_param
+    end
+
+    def enforce_valid_params!
+      required_params.each do |attr|
+        if self.send(attr).blank?
+          raise InvalidSessionRequest, "Missing #{attr} value"
+        end
+      end
+    end
+
+    def required_params
+      [
+        :current_user_id,
+        :currency,
+        :item_name,
+        :amount,
+        :seller_lastname,
+        :seller_firstname,
+        :buyer_lastname,
+        :buyer_firstname,
+        :seller_email,
+        :buyer_email,
+        :external_item_id,
+        :external_seller_id,
+        :external_buyer_id,
+        :fee_ids,
+        :payment_type_id
+      ]
+    end
+  end
+end

data/lib/promise_pay/user.rb

@@ -0,0 +1,67 @@
+require "promise_pay/lib/dynamic_accessors"
+require "json"
+
+module PromisePay
+  class User
+    attr_reader :id
+
+    def initialize(id = nil, options = {})
+      @id = id
+      assign_instance_variables({'user' => options}) unless options.empty?
+    end
+
+    class << self
+      def find(id)
+        new(id).find
+      end
+
+      def find_all
+        new.find_all
+      end
+    end
+
+    def find
+      assign_instance_variables(resource_result)
+      self
+    end
+
+    def find_all
+      resource_result["users"].map do |result|
+        self.class.new(nil, result)
+      end
+    end
+
+    private
+
+    def resource_result
+      request = PromisePay::Request.new(path: api_resource)
+      response = request.execute
+      JSON.parse(response)
+    end
+
+    def api_resource
+      "users/#{id}"
+    end
+
+    def assign_instance_variables(result)
+      result["user"].each do |attribute, value|
+        initialize_property(attribute, value)
+      end
+      self
+    end
+
+    def initialize_property(attribute, value)
+      Lib::DynamicAccessors.define_accessor(attribute, value, self) unless accessor_defined?(attribute)
+      set_property(attribute, value)
+    end
+
+    def accessor_defined?(attribute)
+      respond_to?(attribute) && respond_to?("#{attribute}=")
+    end
+
+    def set_property(attribute, value)
+      setter_method = "#{attribute}="
+      self.send(setter_method, value)
+    end
+  end
+end

data/lib/promise_pay/version.rb

@@ -0,0 +1,3 @@
+module PromisePay
+  VERSION = "0.0.1"
+end

data/lib/promise_pay.rb

@@ -0,0 +1,21 @@
+require "promise_pay/item"
+require "promise_pay/marketplace"
+require "promise_pay/request"
+require "promise_pay/session"
+require "promise_pay/user"
+require "promise_pay/version"
+require "promise_pay/collection"
+
+module PromisePay
+  API_HOST  = "https://secure.api.promisepay.com/"
+  TEST_HOST = "https://test.api.promisepay.com/"
+
+  class << self
+    attr_accessor :api_user
+    attr_accessor :api_key
+    attr_accessor :env
+  end
+
+  class InvalidRequest < StandardError; end
+  class InvalidSessionRequest < StandardError; end
+end

data/promise_pay.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'promise_pay/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "promise_pay"
+  spec.version       = PromisePay::VERSION
+  spec.authors       = ["Liam Norton"]
+  spec.email         = ["liam.norton@flippa.com"]
+  spec.summary       = %q{PromisePay gem}
+  spec.description   = %q{PromisePay gem for API calls wrapped in Ruby}
+  spec.homepage      = "https://github.com/iamliamnorton/promise_pay"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "rest_client"
+  spec.add_runtime_dependency "json"
+end

data/spec/promise_pay/item_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe PromisePay::Item do
+  let(:request) { double("PromisePay::Request", execute: sample_response) }
+
+  before do
+    PromisePay::Request.stub(:new) { request }
+  end
+
+  describe ".find" do
+    let(:sample_response) { File.read("./spec/support/fixtures/item/find.json") }
+    let(:item_id)         { "wef9834tg" }
+
+    it "returns a PromisePay::Item object" do
+      expect(described_class.find(item_id)).to be_a_kind_of PromisePay::Item
+    end
+
+    it "returned object has correctly assigned attributes" do
+      promise_pay_item = described_class.find(item_id)
+      expect(promise_pay_item.id).to eq "wef9834tg"
+      expect(promise_pay_item.name).to eq "ItemName"
+      expect(promise_pay_item.amount).to eq 10
+      expect(promise_pay_item.state).to eq "pending"
+    end
+
+    it "formats created_at and updated_at as Time" do
+      promise_pay_item = described_class.find(item_id)
+      expect(promise_pay_item.created_at).to be_a_kind_of Time
+      expect(promise_pay_item.updated_at).to be_a_kind_of Time
+    end
+
+    it "instantiates PromisePay::Request with the correct path" do
+      valid_path = "items/#{item_id}"
+      PromisePay::Request.should_receive(:new).with(path: valid_path)
+      described_class.find(item_id)
+    end
+  end
+
+  describe ".find_all" do
+    let(:sample_response) { File.read("./spec/support/fixtures/item/find_all.json") }
+
+    it "returns an array of PromisePay::Item objects" do
+      result = described_class.find_all
+      expect(result).to be_a_kind_of Array
+      expect(result.first).to be_a_kind_of PromisePay::Item
+    end
+
+    it "returned objects have correctly assigned attributes" do
+      promise_pay_user = described_class.find_all.first
+      expect(promise_pay_user.id).to eq "wef9834tg"
+      expect(promise_pay_user.name).to eq "ItemName"
+      expect(promise_pay_user.amount).to eq 10
+    end
+
+    it "instantiates PromisePay::Request with the correct path" do
+      valid_path = "items/"
+      PromisePay::Request.should_receive(:new).with(path: valid_path)
+      described_class.find_all
+    end
+  end
+end

data/spec/promise_pay/marketplace_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe PromisePay::Marketplace do
+  let(:request)   { double("RestClient::Request", execute: sample_response) }
+
+  describe ".request_token" do
+    let(:sample_response) { File.read("./spec/support/fixtures/token_generation.json") }
+    let(:user)            { "test@email.com" }
+    let(:password)        { "password" }
+
+    before do
+      PromisePay::Request.stub(:new) { request }
+    end
+
+    it "instantiates PromisePay::Request with the correct path" do
+      valid_path = "request_token"
+
+      PromisePay::Request.should_receive(:new).with(
+        path:     valid_path,
+        user:     user,
+        password: password
+      )
+
+      described_class.new(user: user, password: password).request_token
+    end
+
+    it "returns the generated marketplace token" do
+      described_class.new(user: user, password: password).request_token.should eq("123abc")
+    end
+  end
+end

data/spec/promise_pay/request_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe PromisePay::Request do
+  let(:request) { described_class.new(path: "users/") }
+
+  before do
+    PromisePay.api_user = "some@email"
+    PromisePay.api_key  = "generated_key_123"
+  end
+
+  describe "#initialize" do
+    it "takes an mandatory path arguement" do
+      expect { described_class.new(user: "user@email.com", password: "password") }.
+        to raise_error KeyError
+    end
+
+    it "takes optional user and password arguements" do
+      expect(request).to be_an_instance_of PromisePay::Request
+    end
+
+    it "uses the test api when configured" do
+      expect { PromisePay.env = :test }.
+        to change { request.send(:endpoint).start_with? PromisePay::TEST_HOST }.
+        from(false).to(true)
+    end
+
+    it "builds a RestClient::Request" do
+      expect(request.send(:request)).to be_an_instance_of RestClient::Request
+    end
+  end
+
+  describe "#execute" do
+    it "calls the RestClient::Request to be exectued" do
+      rest_client_request = request.send(:request)
+      rest_client_request.should_receive(:execute)
+      request.execute
+    end
+
+    it "re-raises RestClient::Unauthorized exceptions" do
+      RestClient::Request.any_instance.stub(:execute) { raise RestClient::Unauthorized }
+      expect { request.execute }.to raise_error PromisePay::RequestError
+    end
+
+    it "re-raises RestClient::BadRequest exceptions" do
+      RestClient::Request.any_instance.stub(:execute) { raise RestClient::BadRequest }
+      expect { request.execute }.to raise_error PromisePay::RequestError
+    end
+
+    it "raises exception when no api credentials are present" do
+      PromisePay.api_user = nil
+      expect { request.execute }.to raise_error PromisePay::RequestError
+    end
+  end
+end

data/spec/promise_pay/session_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe PromisePay::Session do
+  valid_params = {
+    current_user_id:    "1",
+    currency:           "USD",
+    item_name:          "ItemName",
+    amount:             "10",
+    seller_firstname:   "Alex",
+    seller_lastname:    "Jones",
+    buyer_firstname:    "Sam",
+    buyer_lastname:     "Smith",
+    seller_email:       "seller@email.com",
+    buyer_email:        "buyer@email.com",
+    external_item_id:   "wef9834tg",
+    external_seller_id: "1",
+    external_buyer_id:  "2",
+    fee_ids:            "3bfc26e3-093d-4f75-ac06-d2023294882b",
+    payment_type_id:    "1"
+  }
+
+  let(:request) { double("RestClient::Request", execute: sample_response) }
+
+  describe ".request_token" do
+    let(:sample_response) { File.read("./spec/support/fixtures/token_generation.json") }
+    let(:session)         { described_class.new(valid_params) }
+
+    context "with valid params" do
+      before do
+        PromisePay::Request.stub(:new) { request }
+      end
+
+      it "returns the generated session token from PromisePay" do
+        expect(session.request_token).to eq("123abc")
+      end
+
+      it "assigns the token to #token attribute" do
+        expect { session.request_token }.to change { session.token }.
+          from(nil).to("123abc")
+      end
+
+      it "instantiates PromisePay::Request with the correct path" do
+        valid_path = "request_session_token?#{valid_params.to_param}"
+        PromisePay::Request.should_receive(:new).with(path: valid_path)
+        session.request_token
+      end
+    end
+
+    context "with invalid params" do
+      valid_params.each do |param|
+        let(:invalid_params)  { valid_params.reject { |k, v| k == param[0] } }
+        let(:session)         { described_class.new(invalid_params) }
+
+        it "raises an error if #{param[0]} option is missing" do
+          expect { session.request_token }.
+            to raise_error PromisePay::InvalidSessionRequest
+        end
+      end
+    end
+  end
+end

data/spec/promise_pay/user_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe PromisePay::User do
+  let(:request) { double("PromisePay::Request", execute: sample_response) }
+
+  before do
+    PromisePay::Request.stub(:new) { request }
+  end
+
+  describe ".find" do
+    let(:sample_response) { File.read("./spec/support/fixtures/user/find.json") }
+    let(:user_id)         { 1 }
+
+    it "returns a PromisePay::User object" do
+      expect(described_class.find(user_id)).to be_a_kind_of PromisePay::User
+    end
+
+    it "returned object has correctly assigned attributes" do
+      promise_pay_user = described_class.find(user_id)
+      expect(promise_pay_user.id).to eq "1"
+      expect(promise_pay_user.email).to eq "seller@email.com"
+      expect(promise_pay_user.website).to be_nil
+    end
+
+    it "formats created_at and updated_at as Time" do
+      promise_pay_user = described_class.find(user_id)
+      expect(promise_pay_user.created_at).to be_a_kind_of Time
+      expect(promise_pay_user.updated_at).to be_a_kind_of Time
+    end
+
+    it "instantiates PromisePay::Request with the correct path" do
+      valid_path = "users/#{user_id}"
+      PromisePay::Request.should_receive(:new).with(path: valid_path)
+      described_class.find(user_id)
+    end
+  end
+
+  describe ".find_all" do
+    let(:sample_response) { File.read("./spec/support/fixtures/user/find_all.json") }
+
+    it "returns an array of PromisePay::User objects" do
+      result = described_class.find_all
+      expect(result).to be_a_kind_of Array
+      expect(result.first).to be_a_kind_of PromisePay::User
+    end
+
+    it "returned objects have correctly assigned attributes" do
+      promise_pay_user = described_class.find_all.first
+      expect(promise_pay_user.id).to eq "2"
+      expect(promise_pay_user.email).to eq "buyer@email.com"
+      expect(promise_pay_user.website).to be_nil
+    end
+
+    it "instantiates PromisePay::Request with the correct path" do
+      valid_path = "users/"
+      PromisePay::Request.should_receive(:new).with(path: valid_path)
+      described_class.find_all
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "promise_pay"
+require "promise_pay/item"
+require "promise_pay/marketplace"
+require "promise_pay/request"
+require "promise_pay/session"
+require "promise_pay/user"

data/spec/support/fixtures/item/find.json

@@ -0,0 +1,20 @@
+{
+  "links" : {
+    "items_buyers" : "/items/{items.id}/buyers",
+    "items_sellers" : "/items/{items.id}/sellers"
+  },
+  "items" : {
+    "id" : "wef9834tg",
+    "name" : "ItemName",
+    "created_at" : "2014-07-08T17:10:11.304+10:00",
+    "updated_at" : "2014-07-08T17:13:38.599+10:00",
+    "amount" : 10,
+    "status" : 22000,
+    "href" : "/items/wef9834tg",
+    "state" : "pending",
+    "links" : {
+      "buyers" : "2",
+      "sellers" : "1"
+    }
+  }
+}

data/spec/support/fixtures/item/find_all.json

@@ -0,0 +1,27 @@
+{
+  "links" : {
+    "items_buyers" : "/items/{items.id}/buyers",
+    "items_sellers" : "/items/{items.id}/sellers"
+  },
+  "meta" : {
+    "limit" : 10,
+    "offset" : 0,
+    "total" : 1
+  },
+  "items" : [
+    {
+      "id" : "wef9834tg",
+      "name" : "ItemName",
+      "created_at" : "2014-07-08T17:10:11.304+10:00",
+      "updated_at" : "2014-07-08T17:13:38.599+10:00",
+      "amount" : 10,
+      "status" : 22000,
+      "href" : "/items/wef9834tg",
+      "state" : "pending",
+      "links" : {
+        "buyers" : "2",
+        "sellers" : "1"
+      }
+    }
+  ]
+}

data/spec/support/fixtures/token_generation.json

@@ -0,0 +1,3 @@
+{
+  "token" : "123abc"
+}

data/spec/support/fixtures/user/find.json

@@ -0,0 +1,32 @@
+{
+  "links" : {
+    "users_items" : "/users/{users.id}/items"
+  },
+  "user" : {
+    "id" : "1",
+    "email" : "seller@email.com",
+    "firstname" : "Alex",
+    "lastname" : "Jones",
+    "companyname" : null,
+    "created_at" : "2014-07-08T17:10:11.232+10:00",
+    "updated_at" : "2014-07-08T17:10:11.232+10:00",
+    "abn" : null,
+    "phone" : null,
+    "fax" : null,
+    "website" : null,
+    "mobile" : null,
+    "fullname" : "Alex Jones",
+    "href" : "/users/1",
+    "address" : {
+      "addressline1" : null,
+      "addressline2" : null,
+      "city" : null,
+      "state" : null,
+      "postcode" : null,
+      "country" : "Australia"
+    },
+    "links" : {
+      "items" : ["wef9834tg"]
+    }
+  }
+}

data/spec/support/fixtures/user/find_all.json

@@ -0,0 +1,68 @@
+{
+  "links" : {
+    "users_items" : "/users/{users.id}/items"
+  },
+  "meta" : {
+    "limit" : 10,
+    "offset" : 0,
+    "total" : 2
+  },
+  "users" : [
+    {
+      "id" : "2",
+      "email" : "buyer@email.com",
+      "firstname" : "Sam",
+      "lastname" : "Smith",
+      "companyname" : null,
+      "created_at" : "2014-07-08T17:10:10.929+10:00",
+      "updated_at":"2014-07-08T17:10:10.929+10:00",
+      "abn" : null,
+      "phone" : null,
+      "fax" : null,
+      "website" : null,
+      "mobile" : null,
+      "fullname" : "Sam Smith",
+      "href" : "/users/2",
+      "address" : {
+        "addressline1" : null,
+        "addressline2" : null,
+        "city" : null,
+        "state" : null,
+        "postcode" : null,
+        "country" : "Australia"
+      },
+      "links" : {
+        "items" : [
+          "wef9834tg"
+        ]
+      }
+    },
+    {
+      "id" : "1",
+      "email" : "seller@email.com",
+      "firstname" : "Alex",
+      "lastname" : "Jones",
+      "companyname" : null,
+      "created_at" : "2014-07-08T17:10:11.232+10:00",
+      "updated_at" : "2014-07-08T17:10:11.232+10:00",
+      "abn" : null,
+      "phone" : null,
+      "fax" : null,
+      "website" : null,
+      "mobile" : null,
+      "fullname" : "Alex Jones",
+      "href" : "/users/1",
+      "address" : {
+        "addressline1" : null,
+        "addressline2" : null,
+        "city" : null,
+        "state" : null,
+        "postcode" : null,
+        "country" : "Australia"
+      },
+      "links" : {
+        "items" : ["wef9834tg"]
+      }
+    }
+  ]
+}

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: promise_pay
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Liam Norton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: PromisePay gem for API calls wrapped in Ruby
+email:
+- liam.norton@flippa.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/promise_pay/init_generator.rb
+- lib/generators/templates/promise_pay_initializer.rb
+- lib/promise_pay.rb
+- lib/promise_pay/collection.rb
+- lib/promise_pay/item.rb
+- lib/promise_pay/lib/dynamic_accessors.rb
+- lib/promise_pay/marketplace.rb
+- lib/promise_pay/request.rb
+- lib/promise_pay/session.rb
+- lib/promise_pay/user.rb
+- lib/promise_pay/version.rb
+- promise_pay.gemspec
+- spec/promise_pay/item_spec.rb
+- spec/promise_pay/marketplace_spec.rb
+- spec/promise_pay/request_spec.rb
+- spec/promise_pay/session_spec.rb
+- spec/promise_pay/user_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures/item/find.json
+- spec/support/fixtures/item/find_all.json
+- spec/support/fixtures/token_generation.json
+- spec/support/fixtures/user/find.json
+- spec/support/fixtures/user/find_all.json
+homepage: https://github.com/iamliamnorton/promise_pay
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: PromisePay gem
+test_files:
+- spec/promise_pay/item_spec.rb
+- spec/promise_pay/marketplace_spec.rb
+- spec/promise_pay/request_spec.rb
+- spec/promise_pay/session_spec.rb
+- spec/promise_pay/user_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures/item/find.json
+- spec/support/fixtures/item/find_all.json
+- spec/support/fixtures/token_generation.json
+- spec/support/fixtures/user/find.json
+- spec/support/fixtures/user/find_all.json