uphold 1.0.0

data/spec/unit/api/private_transaction_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+module Uphold
+  module API
+    describe PrivateTransaction do
+      let(:client) { Client.new }
+
+      context '#create_transaction' do
+        it 'creates a transaction for a specific card' do
+          card_id = '1234'
+          request_data = RequestData.new(
+            Endpoints.with_placeholders(Endpoints::CARD_PRIVATE_TRANSACTIONS, ':card' => card_id),
+            Entities::Transaction,
+            client.authorization_header,
+            card_id: card_id, denomination: { currency: 'USD', amount: 10 }, destination: 'foo@bar.com'
+          )
+          allow(Request).to receive(:perform_with_object)
+
+          client.create_transaction(card_id: card_id, currency: 'USD', amount: 10, destination: 'foo@bar.com')
+
+          expect(Request).to have_received(:perform_with_object).
+            with(:post, request_data)
+        end
+      end
+
+      context '#commit_transaction' do
+        it 'commits a transaction for a specific card' do
+          card_id = '1234'
+          transaction_id = '4567'
+          request_data = RequestData.new(
+            Endpoints.with_placeholders(Endpoints::COMMIT_TRANSACTION, ':card' => card_id, ':id' => transaction_id),
+            Entities::Transaction,
+            client.authorization_header
+          )
+          allow(Request).to receive(:perform_with_object)
+
+          client.commit_transaction(card_id: card_id, transaction_id: transaction_id)
+
+          expect(Request).to have_received(:perform_with_object).
+            with(:post, request_data)
+        end
+      end
+
+      context '#cancel_transaction' do
+        it 'cancels a transaction for a specific card' do
+          card_id = '1234'
+          transaction_id = '4567'
+          request_data = RequestData.new(
+            Endpoints.with_placeholders(Endpoints::CANCEL_TRANSACTION, ':card' => card_id, ':id' => transaction_id),
+            Entities::Transaction,
+            client.authorization_header
+          )
+          allow(Request).to receive(:perform_with_object)
+
+          client.cancel_transaction(card_id: card_id, transaction_id: transaction_id)
+
+          expect(Request).to have_received(:perform_with_object).
+            with(:post, request_data)
+        end
+      end
+
+      context '#resend_transaction' do
+        it 'resends a transaction for a specific card' do
+          card_id = '1234'
+          transaction_id = '4567'
+          request_data = RequestData.new(
+            Endpoints.with_placeholders(Endpoints::RESEND_TRANSACTION, ':card' => card_id, ':id' => transaction_id),
+            Entities::Transaction,
+            client.authorization_header
+          )
+          allow(Request).to receive(:perform_with_object)
+
+          client.resend_transaction(card_id: card_id, transaction_id: transaction_id)
+
+          expect(Request).to have_received(:perform_with_object).
+            with(:post, request_data)
+        end
+      end
+
+      context '#all_user_transactions' do
+        it 'lists all the transactions associated with the current user' do
+          request_data = RequestData.new(
+            Endpoints::USER_PRIVATE_TRANSACTIONS,
+            Entities::Transaction,
+            client.authorization_header.merge(client.pagination_header_for_range(0..4))
+          )
+          allow(Request).to receive(:perform_with_objects)
+
+          client.all_user_transactions
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+
+      context '#all_card_transactions' do
+        it 'lists all the transactions associated with a specific card' do
+          card_id = '1234'
+          request_data = RequestData.new(
+            Endpoints.with_placeholders(Endpoints::CARD_PRIVATE_TRANSACTIONS, ':card' => card_id),
+            Entities::Transaction,
+            client.authorization_header.merge(client.pagination_header_for_range(0..4))
+          )
+          allow(Request).to receive(:perform_with_objects)
+
+          client.all_card_transactions(card_id: card_id)
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+    end
+  end
+end

data/spec/unit/api/public_transaction_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Uphold
+  module API
+    describe PublicTransaction do
+      let(:client) { Uphold::Client.new }
+
+      context '#all_public_transactions' do
+        it 'gets all public transactions' do
+          request_data = RequestData.new(Endpoints::PUBLIC_TRANSACTIONS, Entities::Transaction, client.authorization_header.merge(client.pagination_header_for_range(0..4)))
+          allow(Request).to receive(:perform_with_objects)
+
+          client.all_public_transactions
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+
+      context '#find_public_transaction' do
+        it 'gets a public transaction' do
+          id = '1234'
+          request_data = RequestData.new(Endpoints::PUBLIC_TRANSACTIONS + "/#{id}", Entities::Transaction, client.authorization_header)
+          allow(Request).to receive(:perform_with_object)
+
+          client.find_public_transaction(id: id)
+
+          expect(Request).to have_received(:perform_with_object).
+            with(:get, request_data)
+        end
+      end
+    end
+  end
+end

data/spec/unit/api/ticker_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Uphold
+  module API
+    describe Ticker do
+      let(:client) { Uphold::Client.new }
+
+      context '#all_tickers' do
+        it 'gets all the tickers' do
+          request_data = Uphold::RequestData.new(Endpoints::TICKER, Uphold::Entities::Ticker, client.authorization_header)
+          allow(Request).to receive(:perform_with_objects)
+
+          client.all_tickers
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+
+      context '#find_ticker' do
+        it 'gets a specific ticker' do
+          currency = 'USD'
+          request_data = Uphold::RequestData.new(Endpoints::TICKER + "/#{currency}", Uphold::Entities::Ticker, client.authorization_header)
+          allow(Request).to receive(:perform_with_objects)
+
+          client.find_ticker(currency: currency)
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+    end
+  end
+end

data/spec/unit/api/transparency_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Uphold
+  module API
+    describe Transparency do
+      let(:client) { Client.new }
+
+      context '#statistics' do
+        it 'gets all the uphold reserve stats' do
+          request_data = RequestData.new(Endpoints::STATS, Entities::Asset, client.authorization_header)
+          allow(Request).to receive(:perform_with_objects)
+
+          client.statistics
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+
+      context '#ledger' do
+        it 'gets all the uphold reserve stats' do
+          request_data = RequestData.new(Endpoints::LEDGER, Entities::LedgerEntry, client.authorization_header)
+          allow(Request).to receive(:perform_with_objects)
+
+          client.ledger
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+    end
+  end
+end

data/spec/unit/api/user_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Uphold
+  module API
+    describe User do
+      let(:client) { Uphold::Client.new }
+
+      context '#me' do
+        it 'gets my personal information' do
+          request_data = RequestData.new(Endpoints::USER, Entities::User, client.authorization_header)
+          allow(Request).to receive(:perform_with_object)
+
+          client.me
+
+          expect(Request).to have_received(:perform_with_object).
+            with(:get, request_data)
+        end
+      end
+
+      context '#phones' do
+        it 'gets my associated phone numbers' do
+          request_data = RequestData.new(Endpoints::USER_PHONES, Entities::Phone, client.authorization_header)
+          allow(Request).to receive(:perform_with_objects)
+
+          client.phones
+
+          expect(Request).to have_received(:perform_with_objects).
+            with(:get, request_data)
+        end
+      end
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Uphold
+  describe Client do
+    it 'takes a token on initialization' do
+      token = 'x'
+
+      client = Client.new(token: token)
+
+      expect(client.bearer_token).to eq token
+    end
+
+    it 'gets the token from the ENV if none is provided' do
+      token = 'x'
+
+      with_modified_env UPHOLD_AUTH_TOKEN: token do
+        client = Client.new
+
+        expect(client.bearer_token).to eq token
+      end
+    end
+
+    it 'uses the production api by default' do
+      Uphold.sandbox = false
+      expect(Uphold.api_base).to eq Uphold::Options::API_BASE
+    end
+
+    it 'uses the sandbox api when asked to' do
+      Uphold.sandbox = true
+      expect(Uphold.api_base).to eq Uphold::Options::SANDBOX_API_BASE
+    end
+  end
+end

data/spec/unit/entities/base_entity_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Uphold
+  module Entities
+    describe BaseEntity do
+      class MockEntity < BaseEntity
+        attribute :a_key
+      end
+
+      context '#initialize' do
+        it 'instantiates instance variables from arguments' do
+          entity = MockEntity.new(a_key: 'value')
+
+          expect(entity.a_key).to eq 'value'
+        end
+
+        it 'converts camelCase to snake_case' do
+          entity = MockEntity.new(a_key: 'value')
+
+          expect(entity.a_key).to eq 'value'
+        end
+      end
+
+      context '.from_collection' do
+        it 'instantiates each of the entities passed in' do
+          entity = double('Entity')
+          allow(MockEntity).to receive(:new)
+
+          MockEntity.from_collection([entity], '0-1/10')
+
+          expect(MockEntity).to have_received(:new).with(entity)
+        end
+      end
+    end
+  end
+end

data/spec/unit/helper_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Uphold
+  describe Helpers do
+    context '.undercored_key' do
+      it 'underscores a key correctly' do
+        underscored_key = Helpers.underscored_key(:firstName)
+
+        expect(underscored_key).to eq :first_name
+      end
+    end
+
+    context '.camelized_key' do
+      it 'camelizes a key correctly' do
+        camelized_key = Helpers.camelized_key(:first_name)
+
+        expect(camelized_key).to eq :firstName
+      end
+    end
+
+    context '.underscored_hash' do
+      it 'underscores a hash correctly' do
+        underscored_hash = Helpers.underscored_hash(firstName: 'name', email: 'email')
+
+        expect(underscored_hash.keys).to match %i(first_name email)
+      end
+    end
+
+    context '.camelized_hash' do
+      it 'camelizes a hash correctly' do
+        camelized_hash = Helpers.camelized_hash(first_name: 'name', email: 'email')
+
+        expect(camelized_hash.keys).to match %i(firstName email)
+      end
+    end
+  end
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module Uphold
+  shared_examples 'perform request method' do |method_name|
+    let(:object_class) { double('ObjectClass', new: nil, from_collection: nil) }
+    let(:response) { double('Response', code: 200, parsed_response: '', headers: {}) }
+    let(:request) { spy('request', get: response, post: response) }
+    let(:client) { Client.new }
+
+    context ".#{method_name}" do
+      it 'makes the correct call for a GET' do
+        allow(Request).to receive(:new).and_return(request)
+
+        Request.public_send(method_name, :get, request_data)
+
+        expect(request).to have_received(:get)
+      end
+
+      it 'makes the correct call for a POST' do
+        allow(Request).to receive(:new).and_return(request)
+
+        Request.public_send(method_name, :post, request_data)
+
+        expect(request).to have_received(:post)
+      end
+
+      it 'makes the actual GET call' do
+        url = '/some-url'
+        WebMockHelpers.uphold_stub_request(:get, url)
+        allow(Request).to receive(:get).and_call_original
+
+        Request.public_send(method_name, :get, request_data(url, client))
+
+        expect(Request).to have_received(:get).with(url, headers: client.authorization_header)
+      end
+
+      it 'makes the actual POST call' do
+        url = '/some-url'
+        data = { key: 'value' }
+        WebMockHelpers.uphold_stub_request(:post, url)
+        allow(Request).to receive(:post).and_call_original
+
+        Request.public_send(method_name, :post, request_data(url, client, data))
+
+        expect(Request).to have_received(:post).with(url, body: data, headers: client.authorization_header)
+      end
+
+      it 'makes a call with basic auth' do
+        url = '/some-url'
+        headers = { header1: 'I am a header' }
+        body = { description: 'whatever' }
+        request_data = RequestData.new(url, object_class, headers, body)
+        WebMockHelpers.uphold_stub_request(:get, url)
+        allow(Request).to receive(:get).and_call_original
+
+        Request.public_send(method_name, :get, request_data)
+
+        expect(Request).to have_received(:get).with(url, headers: headers, body: body)
+      end
+
+      it 'handles an auth error response' do
+        fake_error = { code: '401', error: 'invalid_token', error_description: 'A description' }
+        request_data = RequestData.new('/some-url', object_class)
+        WebMockHelpers.uphold_stub_request(:get, '/some-url', fake_error, status: 401)
+
+        result = Request.public_send(method_name, :get, request_data)
+
+        expect(result).to be_a(Entities::OAuthError)
+        expect(result.code).to eq '401'
+      end
+
+      it 'handles an error response' do
+        fake_error = { code: '400', errors: {} }
+        request_data = RequestData.new('/some-url', object_class)
+        WebMockHelpers.uphold_stub_request(:get, '/some-url', fake_error, status: 400)
+
+        result = Request.public_send(method_name, :get, request_data)
+
+        expect(result).to be_a(Entities::Error)
+        expect(result.code).to eq '400'
+      end
+    end
+
+    def request_data(url = anything, client = nil, payload = nil)
+      client ||= double('Client', authorization_header: {})
+      RequestData.new(url, object_class, client.authorization_header, payload)
+    end
+  end
+
+  describe Request do
+    include_examples 'perform request method', :perform_with_object
+    include_examples 'perform request method', :perform_with_objects
+  end
+end

data/uphold.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'uphold/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'uphold'
+  spec.version       = Uphold::VERSION
+  spec.authors       = ['Group Buddies']
+  spec.email         = ['miguel@subvisual.co', 'zamith@subvisual.co']
+  spec.summary       = %q{A wrapper for the Uphold API}
+  spec.homepage      = 'https://github.com/subvisual/uphold-ruby'
+  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_dependency 'httparty', '>= 0.13.3'
+  spec.add_dependency 'virtus', '>= 1.0.4'
+  spec.add_dependency 'dotenv'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'climate_control'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rubocop', '~> 0.27.1'
+  spec.add_development_dependency 'rspec', '~> 3.1.0'
+  spec.add_development_dependency 'webmock', '~> 1.20.4'
+end