bitpay-client 2.0.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d735bbff357cf079a5f5ea6c357e3375644cde5
-  data.tar.gz: 55b7d5cbbe130d8412e74db9798e1a7bad3ac827
+  metadata.gz: b4dc42cd2a385367410f051b9a7def43a3ff3021
+  data.tar.gz: c6bd1df8c6e5d47deb49afae0ca2caf0c376f6d6
 SHA512:
-  metadata.gz: 43df16582f56058a03896e433f62a8c4338dd40c7598192d0811f437e628ebe601e53d28aa54913fae88a5f89f48b3306255df4153825d136f65504d468de85e
-  data.tar.gz: 4b679cc6bdae90dbb028081457b8990cf2c33ccc75024e43378ad7a687c36bd94fcee09d3ff2f0ea300e3e679db459483edba53c1c3463ea51f48fe2ad2b98c8
+  metadata.gz: 6cb61d057cae19d839dc050028c196256c0837e0f64424985aef98df2dd5d3dd6563c3222b5dd7e0310b1931359916c9ce6c178cab0c30f692fdeac72d82ef6b
+  data.tar.gz: 0e326cd00defdeeb8bae777cc42c5189155683aac1be108dcf05801b84dc5f4bab47d8554da6103ecb35514ec51f2c6033c0bc6c06a15a8aadcc75dcbe410aaa

data/README.md

@@ -1,4 +1,4 @@
-# BitPay Library for Ruby [![](https://secure.travis-ci.org/bitpay/ruby-client.png)](http://travis-ci.org/bitpay/ruby-client)
+# BitPay Library for Ruby [![](https://travis-ci.org/bitpay/ruby-cli.svg)](http://travis-ci.org/bitpay/ruby-cli)
 Powerful, flexible, lightweight interface to the BitPay Bitcoin Payment Gateway API.
 
 ## Installation

data/Rakefile

@@ -3,6 +3,8 @@ require 'rspec/core/rake_task'
 require 'capybara'
 require 'capybara/poltergeist'
 require 'mongo'
+require 'cucumber'
+require 'cucumber/rake/task'
 
 require_relative 'config/constants.rb'
 require_relative 'config/capybara.rb'
@@ -11,32 +13,24 @@ RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
+Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "features --format pretty"
+end
+
 desc "Bitpay Tasks"
 namespace :bitpay do
 
   desc "Clear all claim codes from the test server."
   task :clear_claim_codes do
     puts "clearing claim codes"
-    Capybara.visit ROOT_ADDRESS
-    Capybara.click_link('Login')
-    Capybara.fill_in 'email', :with => TEST_USER
-    Capybara.fill_in 'password', :with => TEST_PASS
-    Capybara.click_button('loginButton')
-    Capybara.click_link "My Account"
-    Capybara.click_link "API Tokens", match: :first
-    while Capybara.page.has_selector?(".token-claimcode") || Capybara.page.has_selector?(".token-requiredsins-key") do
-      Capybara.page.find(".api-manager-actions-edit", match: :first).click
-      Capybara.page.find(".api-manager-actions-revoke", match: :first).click
-      Capybara.click_button("Confirm Revoke")
-      # this back and forth bit is here because no other reload mechanism worked, and without it the task errors out: either because it can't find the revoke button or it finds multiple elements at each click point
-      Capybara.page.go_back
-      Capybara.click_link "API Tokens", match: :first
-    end
+    client = Mongo::MongoClient.new
+    db     = client['bitpay-dev']
+    coll   = db['tokenaccesses']
+    coll.remove()
     puts "claim codes cleared"
   end
 
   desc "Clear rate limiters from local mongo host"
-
   task :clear_rate_limiters do
     puts "clearing rate limiters"
     client = Mongo::MongoClient.new
@@ -46,7 +40,35 @@ namespace :bitpay do
     puts "rate limiters cleared"
   end
 
+  desc "Clear local pem and token file"
+  task :clear_local_files do
+    puts "clearing local files"
+    HOME_DIR = File.join(Dir.home, '.bitpay')
+    KEY_FILE = File.join(HOME_DIR, 'bitpay.pem')
+    TOKEN_FILE = File.join(HOME_DIR, 'tokens.json')
+    File.delete(KEY_FILE) if File.file?(KEY_FILE)
+    File.delete(TOKEN_FILE) if File.file?(TOKEN_FILE)
+    puts "local files cleared"
+  end
+
+  desc "Clear tokens, rate limiters, and local files."
+  task :clear do
+    ["bitpay:clear_local_files", "bitpay:clear_rate_limiters", "bitpay:clear_claim_codes"].each{|task| Rake::Task[task].reenable}
+    ["bitpay:clear_local_files", "bitpay:clear_rate_limiters", "bitpay:clear_claim_codes"].each{|task| Rake::Task[task].invoke}
+  end
+
   desc "Run specs and clear claim codes and rate_limiters."
   task :spec_clear => ['spec', 'clear_claim_codes', 'clear_rate_limiters']
 
+  desc "Run specs, clear data, run cukes, clear data"
+  task :tests_clear do
+    Rake::Task["bitpay:clear"].invoke
+    Rake::Task["spec"].invoke
+    Rake::Task["bitpay:clear"].reenable
+    Rake::Task["bitpay:clear"].invoke
+    Rake::Task["features"].invoke
+    Rake::Task["bitpay:clear"].reenable
+    Rake::Task["bitpay:clear"].invoke
+  end
+
 end

data/bin/bitpay

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
-require_relative '../lib/bitpay'
 require_relative '../lib/bitpay/cli'
+require_relative '../lib/bitpay/cli_client'

data/bitpay-client.gemspec

@@ -17,19 +17,21 @@ Gem::Specification.new do |s|
   s.bindir        = 'bin'
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
-  s.add_dependency 'json'
-  s.add_dependency 'rack',    '>= 0'
-  s.add_dependency 'ecdsa'
+  s.add_dependency 'bitpay-sdk',  '~>2.1'
+  s.add_dependency 'json',      '~> 1.8.1'
+  s.add_dependency 'rack',      '~> 1.5.2'
+  s.add_dependency 'ecdsa',     '~> 1.2.0'
   s.add_dependency 'commander'
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'webmock'
-  s.add_development_dependency 'pry'
-  s.add_development_dependency 'pry-byebug'
-  s.add_development_dependency 'pry-rescue'
-  s.add_development_dependency 'capybara'
-  s.add_development_dependency 'poltergeist'
-  s.add_development_dependency 'airborne'
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'mongo'
+  s.add_development_dependency 'rake', '~> 10.3.2'
+  s.add_development_dependency 'webmock', '~> 1.18.0'
+  s.add_development_dependency 'pry', '~> 0.10.1'
+  s.add_development_dependency 'pry-byebug', '~> 2.0.0'
+  s.add_development_dependency 'pry-rescue', '~> 1.4.1'
+  s.add_development_dependency 'capybara', '~> 2.4.3'
+  s.add_development_dependency 'cucumber', '~> 1.3.17'
+  s.add_development_dependency 'poltergeist', '~> 1.5.1'
+  s.add_development_dependency 'airborne', '~> 0.0.20'
+  s.add_development_dependency 'rspec', '~> 3.1.0'
+  s.add_development_dependency 'mongo', '~> 1.11.1'
 end

data/config/constants.rb

@@ -1,3 +1,5 @@
+BITPAY_ROOT = File.expand_path("~") + "./bp/"
+## test constants
 ROOT_ADDRESS = ENV['RCROOTADDRESS']
 TEST_USER = ENV['RCTESTUSER']
 TEST_PASS = ENV['RCTESTPASSWORD']

data/features/creating_invoices.feature

@@ -0,0 +1,26 @@
+Feature: creating an invoice
+  The user won't get any money 
+  If they can't
+  Create Invoices
+
+  Background:
+    Given the user is authenticated with BitPay
+
+  Scenario Outline: The request is correct
+    When the user creates an invoice for <price> <currency>
+    Then they should recieve an invoice in response for <price> <currency>
+  Examples:
+    | price    | currency |
+    | "500.23" | "USD"    |
+    | "300.21" | "EUR"    |
+
+  Scenario Outline: The invoice contains illegal characters
+    When the user creates an invoice for <price> <currency>
+    Then they will receive a BitPay::ArgumentError matching <message>
+  Examples:
+    | price    | currency  | message                              |
+    | "50,023" | "USD"     | "Price must be formatted as a float" |
+    | "300.21" | "EaUR"    | "Currency is invalid."               |
+    | ""       | "USD"     | "Price must be formatted as a float" |
+    | "Ten"    | "USD"     | "Price must be formatted as a float" |
+    | "100"    | ""        | "Currency is invalid."               |

data/features/pairing.feature

@@ -0,0 +1,21 @@
+Feature: pairing with bitpay
+  In order to access bitpay
+  It is required that the library
+  Is able to pair successfully
+
+  Scenario: the client has a correct pairing code
+    Given the user pairs with BitPay with a valid pairing code
+    Then the user is paired with BitPay
+
+  Scenario Outline: the client has a bad pairing code
+    Given the user fails to pair with a semantically <valid> code <code>
+    Then they will receive a <error> matching <message>
+  Examples:
+      | valid   | code       | error                 | message                       |
+      | valid   | "a1b2c3d"  | BitPay::BitPayError   | "500: Unable to create token" |
+      | invalid | "a1b2c3d4" | BitPay::ArgumentError | "pairing code is not legal"   |
+
+  Scenario: the client has a bad port configuration to a closed port
+    When the fails to pair with BitPay because of an incorrect port
+    Then they will receive a BitPay::ConnectionError matching "Connection refused" 
+

data/features/retrieving_invoices.feature

@@ -0,0 +1,7 @@
+Feature: retrieving an invoice
+  The user may want to retrieve invoices
+  So that they can view them
+
+  Scenario: The request is correct
+    Given that a user knows an invoice id
+    Then they can retrieve that invoice

data/features/step_definitions/invoice_steps.rb

@@ -0,0 +1,26 @@
+When(/^the user (?:tries to |)creates? an invoice (?:for|without) "(.*?)" (?:or |and |)"(.*?)"$/) do |price, currency|
+  begin
+    @response = @client.create_invoice(price: price, currency: currency)
+  rescue => error
+    @error = error
+  end
+end
+
+Then(/^they should recieve an invoice in response for "(.*?)" "(.*?)"$/) do |price, currency|
+  raise "#{@response['price']} != #{price} or #{@response['currency']} != #{currency}" unless (price == @response['price'].to_s && currency == @response['currency'])
+end
+
+Given(/^there is an invalid token$/) do
+    pending # express the regexp above with the code you wish you had
+end
+
+Given(/^that a user knows an invoice id$/) do
+  client = new_paired_client
+  @id = (client.create_invoice(price: 100, currency: "USD" ))['id']
+end
+
+Then(/^they can retrieve that invoice$/) do
+  invoice = BitPay::Client.new(api_uri: ROOT_ADDRESS, insecure: true).get_public_invoice(id: @id)
+  raise "That's the wrong invoice" unless invoice['id'] == @id
+end
+

data/features/step_definitions/keygen_steps.rb

@@ -0,0 +1,51 @@
+@token = nil
+@error = nil
+
+When(/^the user pairs with BitPay(?: with a valid pairing code|)$/) do
+  claim_code = get_claim_code_from_server
+  pem = BitPay::KeyUtils.generate_pem
+  @client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
+  @token = @client.pair_pos_client(claim_code)
+end
+
+When(/^the fails to pair with BitPay because of an incorrect port$/) do
+  pem = BitPay::KeyUtils.generate_pem
+  address = ROOT_ADDRESS.split(':').slice(0,2).join(':') + ":999"
+  client = BitPay::Client.new(api_uri: address, pem: pem, insecure: true)
+  begin
+    client.pair_pos_client("1ab2c34")
+    raise "pairing unexpectedly worked"
+  rescue => error
+    @error = error
+    true
+  end
+end
+
+Given(/^the user is authenticated with BitPay$/) do
+  @client = new_client_from_stored_values
+end
+
+Given(/^the user is paired with BitPay$/) do
+  raise "Client is not paired" unless @client.verify_token
+end
+
+Given(/^the user has a bad pairing_code "(.*?)"$/) do |arg1|
+    # This is a no-op, pairing codes are transient and never actually saved
+end
+
+Then(/^the user fails to pair with a semantically (?:in|)valid code "(.*?)"$/) do |code|
+  pem = BitPay::KeyUtils.generate_pem
+  client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
+  begin
+    client.pair_pos_client(code)
+    raise "pairing unexpectedly worked"
+  rescue => error
+    @error = error
+    true
+  end
+end
+
+Then(/^they will receive an? (.*?) matching "(.*?)"$/) do |error_class, error_message|
+  raise "Error: #{@error.class}, message: #{@error.message}" unless Object.const_get(error_class) == @error.class && @error.message.include?(error_message)
+end
+

data/features/step_definitions/step_helpers.rb

@@ -0,0 +1,73 @@
+require 'capybara/poltergeist'
+require 'pry'
+
+require File.join File.dirname(__FILE__), '..', '..', 'lib', 'bitpay.rb'
+require_relative '../../config/constants.rb'
+require_relative '../../config/capybara.rb'
+
+#
+## Test Variables
+#
+#PEM = "-----BEGIN EC PRIVATE KEY-----\nMHQCAQEEICg7E4NN53YkaWuAwpoqjfAofjzKI7Jq1f532dX+0O6QoAcGBSuBBAAK\noUQDQgAEjZcNa6Kdz6GQwXcUD9iJ+t1tJZCx7hpqBuJV2/IrQBfue8jh8H7Q/4vX\nfAArmNMaGotTpjdnymWlMfszzXJhlw==\n-----END EC PRIVATE KEY-----\n"
+#
+#PUB_KEY = '038d970d6ba29dcfa190c177140fd889fadd6d2590b1ee1a6a06e255dbf22b4017'
+#CLIENT_ID = "TeyN4LPrXiG5t2yuSamKqP3ynVk3F52iHrX"
+module BitPay
+  # Location for API Credentials
+  BITPAY_CREDENTIALS_DIR = File.join(Dir.home, ".bitpay")
+  PRIVATE_KEY_FILE = 'bitpay.pem'
+  PRIVATE_KEY_PATH = File.join(BITPAY_CREDENTIALS_DIR, PRIVATE_KEY_FILE)
+  TOKEN_FILE = 'tokens.json'
+  TOKEN_FILE_PATH = File.join(BITPAY_CREDENTIALS_DIR, TOKEN_FILE)
+end
+
+def get_claim_code_from_server
+  Capybara::visit ROOT_ADDRESS
+  if logged_in
+    Capybara::visit "#{ROOT_ADDRESS}/home"
+  else
+    log_in
+  end
+  Capybara::click_link "My Account"
+  Capybara::click_link "API Tokens", match: :first
+  Capybara::find(".token-access-new-button").find(".btn").find(".icon-plus").click
+  sleep 0.25
+  Capybara::find_button("Add Token", match: :first).click
+  Capybara::find(".token-claimcode", match: :first).text
+end
+
+def log_in
+  Capybara::click_link('Login')
+  Capybara::fill_in 'email', :with => TEST_USER
+  Capybara::fill_in 'password', :with => TEST_PASS
+  Capybara::click_button('loginButton')
+end
+
+def new_paired_client
+  claim_code = get_claim_code_from_server
+  pem = BitPay::KeyUtils.generate_pem
+  client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
+  client.pair_pos_client(claim_code)
+  client
+end
+
+def new_client_from_stored_values
+  if File.file?(BitPay::PRIVATE_KEY_PATH) && File.file?(BitPay::TOKEN_FILE_PATH)
+    token = get_token_from_file
+    pem = File.read(BitPay::PRIVATE_KEY_PATH)
+    BitPay::Client.new(pem: pem, tokens: token, insecure: true, api_uri: ROOT_ADDRESS )
+  else
+    claim_code = get_claim_code_from_server
+    client = BitPay::Client.new(api_uri: ROOT_ADDRESS, insecure: true)
+    client.pair_pos_client(claim_code)
+    client
+  end   
+end
+
+def get_token_from_file
+  token = JSON.parse(File.read(BitPay::TOKEN_FILE_PATH))
+end
+
+def logged_in
+  Capybara::has_link?('Dashboard')
+end

data/lib/bitpay/cli.rb

@@ -4,6 +4,7 @@
 
 require 'rubygems'
 require 'commander/import'
+require_relative '../bitpay'
 
 program :name, 'BitPay Ruby Library CLI'
 program :version, BitPay::VERSION

data/lib/bitpay/cli_client.rb

@@ -0,0 +1,24 @@
+module BitPay
+  class Client < BitPay::SDK::Client
+    def initialize opts={}
+      pem = File.read(PRIVATE_KEY_PATH) if File.exists?(PRIVATE_KEY_PATH)
+      pem = BitPay::KeyUtils.generate_pem unless File.exists?(PRIVATE_KEY_PATH)
+      pem = opts[:pem] if opts[:pem]
+      File.write(PRIVATE_KEY_PATH, pem)
+      opts[:pem] = pem
+      super opts
+    end
+
+    def pair_pos_client claim_code
+      response = super
+      token = get_token_from_response response
+      File.write(TOKEN_FILE_PATH, token)
+      return response
+    end
+
+    private
+    def get_token_from_response response
+      ({response["data"][0]["facade"] => response["data"][0]["token"]}).to_json
+    end
+  end
+end

data/lib/bitpay/cli_key_utils.rb

@@ -0,0 +1,40 @@
+# license Copyright 2011-2014 BitPay, Inc., MIT License
+# see http://opensource.org/licenses/MIT
+# or https://github.com/bitpay/php-bitpay-client/blob/master/LICENSE
+
+require 'uri'
+require 'net/https'
+require 'json'
+require 'openssl'
+require 'ecdsa'
+require 'securerandom'
+require 'digest/sha2'
+require 'cgi'
+
+module BitPay
+  class KeyUtils
+    class << self
+      ## Generates a new private key and writes to local FS
+      #
+      def retrieve_or_generate_pem
+        begin
+          pem = get_local_pem_file
+        rescue
+          pem = generate_pem
+          write_pem_file pem
+        end
+        pem
+      end
+
+      def write_pem_file pem
+        FileUtils.mkdir_p(BITPAY_CREDENTIALS_DIR)
+        File.open(PRIVATE_KEY_PATH, 'w') { |file| file.write(pem) }
+      end
+      ## Gets private key from ENV variable or local FS
+      #
+      def get_local_pem_file
+        File.read(PRIVATE_KEY_PATH) || (raise BitPayError, MISSING_KEY)
+      end
+    end
+  end
+end

data/lib/bitpay/version.rb

@@ -3,5 +3,5 @@
 # or https://github.com/bitpay/php-bitpay-client/blob/master/LICENSE
 
 module BitPay
-  VERSION = '2.0.1'
+  VERSION = '2.2.0'
 end

data/lib/bitpay.rb

@@ -4,31 +4,18 @@
 
 libdir = File.dirname(__FILE__)
 $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
-require 'bitpay/client'
+require 'bitpay_sdk'
+require 'bitpay/cli_client'
+require 'bitpay/cli_key_utils'
 require 'bitpay/version'
 
 module BitPay
 
-  # Location of SSL Certificate Authority File
-  # As sourced from http://curl.haxx.se/ca/cacert.pem
-  CA_FILE = File.join File.dirname(__FILE__), 'bitpay','cacert.pem'
-
-  # Location of API
-  API_URI = 'https://bitpay.com'
-  TEST_API_URI = 'https://test.bitpay.com'
-  CLIENT_REGISTRATION_PATH = '/api-access-request'
-  
-  # Location for API Credentials
-  BITPAY_CREDENTIALS_DIR = File.join(Dir.home, ".bitpay")
+  BITPAY_CREDENTIALS_DIR = ENV['RCBITPAYROOT'] || File.expand_path("~") + "/.bitpay/"
   PRIVATE_KEY_FILE = 'bitpay.pem'
   PRIVATE_KEY_PATH = File.join(BITPAY_CREDENTIALS_DIR, PRIVATE_KEY_FILE)
+  TOKEN_FILE = 'tokens.json'
+  TOKEN_FILE_PATH = File.join(BITPAY_CREDENTIALS_DIR, TOKEN_FILE)
 
-  # User agent reported to API
-  USER_AGENT = 'ruby-bitpay-client '+VERSION
-  
   MISSING_KEY = 'No Private Key specified.  Pass priv_key or set ENV variable PRIV_KEY'
-  MISSING_PEM = 'No pem file specified. Pass pem or set ENV variable BITPAY_PEM'
-  
-  class BitPayError < StandardError; end
-  
 end

data/spec/client_spec.rb

@@ -11,25 +11,15 @@ end
 
 describe BitPay::Client do
   let(:bitpay_client) { BitPay::Client.new({api_uri: BitPay::TEST_API_URI}) }
+  let(:claim_code) { "a12bc3d" }
 
   before do
       allow(BitPay::KeyUtils).to receive(:nonce).and_return('1')
       stub_request(:get, /#{BitPay::TEST_API_URI}\/tokens.*/).to_return(:status => 200, :body => tokens.to_json, :headers => {})
   end
 
-  describe "#initialize" do
-
-    it 'should be able to get pem file from the env' do
-      stub_const('ENV', {'BITPAY_PEM' => PEM})
-      expect {bitpay_client}.to_not raise_error
-    end
-    
-  end
 
   describe "#send_request" do
-    before do
-      stub_const('ENV', {'BITPAY_PEM' => PEM})
-    end
 
     context "GET" do    
       it 'should generate a get request' do
@@ -50,34 +40,70 @@ describe BitPay::Client do
   end
 
   describe "#pair_pos_client" do
-    it 'throws a BitPayError with the error message if the token setting fails' do
+    before do
       stub_const('ENV', {'BITPAY_PEM' => PEM})
+    end
+
+    it 'throws a BitPayError with the error message if the token setting fails' do
       stub_request(:any, /#{BitPay::TEST_API_URI}.*/).to_return(status: 500, body: "{\n  \"error\": \"Unable to create token\"\n}")
-      expect { bitpay_client.pair_pos_client(:claim_code) }.to raise_error(BitPay::BitPayError, '500: Unable to create token')
+      expect { bitpay_client.pair_pos_client(claim_code) }.to raise_error(BitPay::BitPayError, '500: Unable to create token')
     end 
 
     it 'gracefully handles 4xx errors' do
-      stub_const('ENV', {'BITPAY_PEM' => PEM})
       stub_request(:any, /#{BitPay::TEST_API_URI}.*/).to_return(status: 403, body: "{\n  \"error\": \"this is a 403 error\"\n}")
-      expect { bitpay_client.pair_pos_client(:claim_code) }.to raise_error(BitPay::BitPayError, '403: this is a 403 error')
+      expect { bitpay_client.pair_pos_client(claim_code) }.to raise_error(BitPay::BitPayError, '403: this is a 403 error')
+    end
+
+    it 'short circuits on invalid pairing codes' do
+      100.times do
+        claim_code = an_illegal_claim_code
+        expect{bitpay_client.pair_pos_client(claim_code)}.to raise_error BitPay::ArgumentError, "pairing code is not legal"
+      end
     end
   end
 
   describe "#create_invoice" do
     subject { bitpay_client }
-    before {stub_const('ENV', {'BITPAY_PEM' => PEM})}
     it { is_expected.to respond_to(:create_invoice) }
 
-    it 'should make call to the server to create an invoice' do
-      stub_request(:post, /#{BitPay::TEST_API_URI}\/invoices.*/).to_return(:body => '{"data": "awesome"}')
-      bitpay_client.create_invoice(id: "addd", price: 20, currency: "USD")
-      assert_requested :post, "#{BitPay::TEST_API_URI}/invoices"
+    describe "should make the call to the server to create an invoice" do
+      it 'allows numeric input for the price' do
+        stub_request(:post, /#{BitPay::TEST_API_URI}\/invoices.*/).to_return(:body => '{"data": "awesome"}')
+        bitpay_client.create_invoice(price: 20.00, currency: "USD")
+        assert_requested :post, "#{BitPay::TEST_API_URI}/invoices"
+      end
+
+      it 'allows string input for the price' do
+        stub_request(:post, /#{BitPay::TEST_API_URI}\/invoices.*/).to_return(:body => '{"data": "awesome"}')
+        bitpay_client.create_invoice(price: "20.00", currency: "USD")
+        assert_requested :post, "#{BitPay::TEST_API_URI}/invoices"
+      end
     end
 
     it 'should pass through the API error message from load_tokens' do
       stub_request(:get, /#{BitPay::TEST_API_URI}\/tokens.*/).to_return(status: 500, body: '{"error": "load_tokens_error"}')
-      expect { bitpay_client.create_invoice(id: "addd", price: 20, currency: "USD") }.to raise_error(BitPay::BitPayError, '500: load_tokens_error')         
+      expect { bitpay_client.create_invoice(price: 20, currency: "USD") }.to raise_error(BitPay::BitPayError, '500: load_tokens_error')         
+    end
+
+    it 'verifies the validity of the price argument' do
+      expect { bitpay_client.create_invoice(price: "3,999", currency: "USD") }.to raise_error(BitPay::ArgumentError, 'Illegal Argument: Price must be formatted as a float')
+    end
+    
+    it 'verifies the validity of the currency argument' do
+      expect { bitpay_client.create_invoice(price: "3999", currency: "UASD") }.to raise_error(BitPay::ArgumentError, 'Illegal Argument: Currency is invalid.')
     end
   end
-end
 
+  describe '#set_token' do
+    subject { bitpay_client }
+    it { is_expected.to respond_to(:set_token) }
+    it 'sets a token in the client' do
+
+    end
+  end
+
+  describe "#verify_token" do
+    subject { bitpay_client }
+    it { is_expected.to respond_to(:verify_token) }
+  end
+end

data/spec/features/pair_spec.rb

@@ -14,17 +14,19 @@ describe "pairing a token", javascript: true, type: :feature do
     click_button("Add Token")
     find(".token-claimcode", match: :first).text
   end
-  let(:pem) { BitPay::KeyUtils.generate_pem }
-  let(:client) { BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true) }
+  context "when no pem file exists" do
+    before do
+      File.delete(BitPay::PRIVATE_KEY_PATH) if File.exists?(BitPay::PRIVATE_KEY_PATH)
+      File.delete(BitPay::TOKEN_FILE) if File.exists?(BitPay::TOKEN_FILE)
+      `./bin/bitpay pair #{claimCode} --insecure #{ROOT_ADDRESS}`
+    end
 
-  context "pairing an unpaired client" do
-    it "should have no tokens before pairing" do
-      expect(client.instance_variable_get(:@tokens)).to be_empty
+    it "should save a pem file when pairing" do
+      expect(File.exists?(BitPay::PRIVATE_KEY_PATH)).to eq true
     end
-    it "should have a pos token after pairing" do
-      client.pair_pos_client(claimCode)  
-      expect(client.instance_variable_get(:@tokens)['pos']).not_to be_empty
+
+    it "should save a token when pairing" do
+      expect(JSON.parse(File.read(BitPay::TOKEN_FILE_PATH))["pos"]).to_not be_nil
     end
   end
-
 end

data/spec/features/pos_spec.rb

@@ -24,7 +24,7 @@ describe "create an invoice", javascript: true, type: :feature do
     @client ||= set_client.call
     @invoice_id ||= SecureRandom.uuid
     @price ||= (100..150).to_a.sample
-    @invoice = @client.create_invoice(id: @invoice_id, currency: "USD", price: @price)
+    @invoice = @client.create_invoice(currency: "USD", price: @price)
   end
 
   it "should create an invoice" do