Add a generic "post" endpoint to the go library

Remove web driver tests, make compatible with test helper utility

Added basic Post endpoint

Fixed travis tests to use environment PEM and existing merchant tokens.

removed go gets from .travis

Ginko command changed

Change env variable to use BITPAYAPI

Update readme

Author: Paul Daigle

.gitignore

@@ -25,6 +25,10 @@ _testmain.go
 *.log
 
 enviro.sh
+.bpenv
+
 
 src/
 temp/
+/bin
+.pem.data

.python-version

@@ -1,10 +1,7 @@
 language: go
 # command to install dependencies
-
-install:
-  - sudo pip install -r requirements.txt
-  - python helpers/pair_steps.py
-
+sudo: false
+# command to run tests
 before_script:
   - go get github.com/onsi/ginkgo/ginkgo
   - go get github.com/onsi/gomega
@@ -15,6 +12,5 @@ before_script:
   - go get github.com/axw/gocov/gocov
   - go get github.com/mattn/goveralls 
 
-# command to run tests
 script: 
-  - ginkgo -r --keepgoing
+  - ginkgo -r -keepGoing

.travis.yml

@@ -18,9 +18,7 @@ The bitpay client creates a cryptographically secure connection to your server b
 ## Pairing
 Most calls to the BitPay REST API require that your client is paired with the bitpay.com server.  To pair with bitpay.com you need to have an approved merchant account.
 
-Your client can be paired via the `pos` (point-of-sale) facade.  The `pos` facade allows for invoices to be created and retrieved.
-
-_For development or quick deployment purposes, consider the [BitPay Go Command-Line Interface](https://github.com/philosodad/bitpay-go-cli) to simplify the deployment process_
+The BitPay test helper is probably the easi
 
 ### Pairing Programatically
 
@@ -32,9 +30,10 @@ The example below demonstrates this, assuming that the bitpay-go client is impor
 
 ```go
 pemString := ku.GeneratePem()
-apiUri := "https://bitpay.com" 
-webClient := Client{ApiUri: apiUri, Pem: pemString} 
-token := webClient.PairWithCode(pairingCode) 
+id := ku.GenerateSinFromPem(pemString)
+apiUri := "https://bitpay.com"
+webClient := Client{ApiUri: apiUri, Pem: pemString, ClientId: id}
+token := webClient.PairWithCode(pairingCode)
 webClient.Token = token
 ```    
 
@@ -56,11 +55,10 @@ client.GetInvoice('PvVhgBfA7wKPWhuVC24rJo')
 
 ## Testnet Usage
 
-During development and testing, take advantage of the [Bitcoin TestNet](https://en.bitcoin.it/wiki/Testnet) by creating a client with the ApiUri value "https://test.bitpay.com" 
+During development and testing, take advantage of the [Bitcoin TestNet](https://en.bitcoin.it/wiki/Testnet) by creating a client with the ApiUri value "https://test.bitpay.com"
 
 Note that in order to pair with testnet, you will need a pairing code from test.bitpay.com.
 
 ## API Documentation
 
 API Documentation is available on the [BitPay site](https://bitpay.com/api).
-

GUIDE.md

@@ -1,11 +1,11 @@
-# BitPay Library for Go 
+# BitPay Library for Go
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](https://raw.githubusercontent.com/bitpay/bitpay-go/master/LICENSE)
 [![Travis Build](https://img.shields.io/travis/bitpay/bitpay-go.svg?style=flat-square)](http://travis-ci.org/bitpay/bitpay-go)
 
 
 Powerful, flexible, lightweight interface to the BitPay Bitcoin Payment Gateway API.
 
-## [Getting Started »](http://dev.bitpay.com/guides/go.html)
+## [Getting Started »](https://github.com/bitpay/bitpay-go/blob/master/GUIDE.md)
 
 Code documentation is available on [godoc](http://godoc.org/github.com/bitpay/bitpay-go).
 ## API Documentation
@@ -14,36 +14,35 @@ API Documentation is available on the [BitPay site](https://bitpay.com/api).
 
 ## Running the Tests
 
-The reference project is at https://github.com/bitpay/bitpay-go-cli. You will need a working go installation to follow these instructions.
-
 In order to run the tests, follow these steps:
 
-1. Clone the repository
+1. Set the $GOPATH and $PATH variables
 
-    `git clone https://github.com/bitpay/bitpay-go-cli.git`
+1. Install the dependencies
 
-1. Set the $GOPATH and $PATH variables
+ ```bash
+$ go get github.com/btcsuite/btcutil
+$ go get github.com/gorilla/mux
+$ go get github.com/onsi/ginkgo
+$ go get golang.org/x/crypto
+```
 
-    `source helpers/enviro.sh`
+1. Clone the repository
+
+    `git clone https://github.com/bitpay/bitpay-go.git`
 
-1. Set your test api url (such as https://test.bitpay.com) and your username and password.
+    Into src/github.com/bitpay/bitpay-go/
 
-    `source helpers/set_constants.sh <url> <username> <password>` 
-    
-    `python helpers/pair_steps.py`
-    
-   The python script should retrieve three pairing codes from the server and store them in three files in a `temp` directory in the main project directory, `temp/retrievecode.txt`, `temp/paircode.txt`, and `temp/invoicecode.txt`. If this does not go smoothly, you can manually add the pairing codes to those files by visiting (https://test.bitpay.com/dashboard/merchant/api-tokens) and creating three tokens, saving each pairing code into one of the files in temp.
+1. Set the environment variables `BITPAYAPI` & `BITPAYPEM` to "https://test.bitpay.com" and a valid PEM value.
 
-1. For reasons that are not entirely clear, we need to delete all of the required files and re-import them.
-  
-    `rm -rf src/github.com src/golang`
+    This is slightly tricky, the PEM file has to already be paired with a merchant token on your bitpay account. To do this it is probably best to use the [bitpay test helper](https://github.com/bitpay/bitpay-test-helper).
 
-    `go get -u -t github.com/bitpay/bitpay-go/client`
+1. You will also need a paid invoice on the server. Set the environment variable `INVOICEID` to the id of a paid invoice on the server.
 
 1. We are now ready to run the tests.
-  
+
   `ginkgo -r src/github.com/bitpay/`
- 
+
 ## Found a bug?
 Let us know! Send a pull request or a patch. Questions? Ask! We're here to help. We will respond to all filed issues.
 

README.md

@@ -61,8 +61,6 @@ func (client *Client) CreateInvoice(price float64, currency string) (inv invoice
 		err = errors.New("BitPayArgumentError: invalid currency code")
 		return inv, err
 	}
-	url := client.ApiUri + "/invoices"
-	htclient := setHttpClient(client)
 	paylo := make(map[string]string)
 	var floatPrec int
 	if currency == "BTC" {
@@ -75,34 +73,38 @@ func (client *Client) CreateInvoice(price float64, currency string) (inv invoice
 	paylo["currency"] = currency
 	paylo["token"] = client.Token.Token
 	paylo["id"] = client.ClientId
-	payload, _ := json.Marshal(paylo)
-	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
-	req.Header.Add("content-type", "application/json")
-	req.Header.Add("accept", "application/json")
-	req.Header.Add("X-accept-version", "2.0.0")
-	publ := ku.ExtractCompressedPublicKey(client.Pem)
-	req.Header.Add("X-Identity", publ)
-	sig := ku.Sign(url+string(payload), client.Pem)
-	req.Header.Add("X-Signature", sig)
-	response, _ := htclient.Do(req)
+	response, _ := client.Post("invoices", paylo)
 	inv, err = processInvoice(response)
 	return inv, err
 }
 
+// PairWithFacade
+func (client *Client) PairWithFacade(str string) (tok Token, err error) {
+	paylo := make(map[string]string)
+	paylo["facade"] = str
+	tok, err = client.PairClient(paylo)
+	return tok, err
+}
+
 // PairWithCode retrieves a token from the server and authenticates the keys of the calling client. The string passed to the client is a "pairing code" that must be retrieved from https://bitpay.com/dashboard/merchant/api-tokens. PairWithCode returns a Token type that must be assigned to the Token field of a client in order for that client to create invoices. For example `client.Token = client.PairWithCode("abcdefg")`.
 func (client *Client) PairWithCode(str string) (tok Token, err error) {
 	match, _ := regexp.MatchString("^[[:alnum:]]{7}$", str)
 	if !match {
 		err = errors.New("BitPayArgumentError: invalid pairing code")
 		return tok, err
 	}
+	paylo := make(map[string]string)
+	paylo["pairingCode"] = str
+	tok, err = client.PairClient(paylo)
+	return tok, err
+}
+
+func (client *Client) PairClient(paylo map[string]string) (tok Token, err error) {
+	paylo["id"] = client.ClientId
 	sin := ku.GenerateSinFromPem(client.Pem)
 	client.ClientId = sin
 	url := client.ApiUri + "/tokens"
 	htclient := setHttpClient(client)
-	paylo := make(map[string]string)
-	paylo["id"] = client.ClientId
-	paylo["pairingCode"] = str
 	payload, _ := json.Marshal(paylo)
 	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
 	req.Header.Add("content-type", "application/json")
@@ -122,6 +124,22 @@ func (client *Client) PairWithCode(str string) (tok Token, err error) {
 	return tok, err
 }
 
+func (client *Client) Post(path string, paylo map[string]string) (response *http.Response, err error) {
+	url := client.ApiUri + "/" + path
+	htclient := setHttpClient(client)
+	payload, _ := json.Marshal(paylo)
+	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
+	req.Header.Add("content-type", "application/json")
+	req.Header.Add("accept", "application/json")
+	req.Header.Add("X-accept-version", "2.0.0")
+	publ := ku.ExtractCompressedPublicKey(client.Pem)
+	req.Header.Add("X-Identity", publ)
+	sig := ku.Sign(url+string(payload), client.Pem)
+	req.Header.Add("X-Signature", sig)
+	response, err = htclient.Do(req)
+	return response, err
+}
+
 // GetInvoice is a public facade method, any client which has the ApiUri field set can retrieve an invoice from that endpoint, provided they have the invoice id.
 func (client *Client) GetInvoice(invId string) (inv invoice, err error) {
 	url := client.ApiUri + "/invoices/" + invId
@@ -131,6 +149,43 @@ func (client *Client) GetInvoice(invId string) (inv invoice, err error) {
 	return inv, err
 }
 
+func (client *Client) GetTokens() (tokes []map[string]string, err error) {
+	url := client.ApiUri + "/tokens"
+	htclient := setHttpClient(client)
+	req, _ := http.NewRequest("GET", url, nil)
+	req.Header.Add("content-type", "application/json")
+	req.Header.Add("accept", "application/json")
+	req.Header.Add("X-accept-version", "2.0.0")
+	publ := ku.ExtractCompressedPublicKey(client.Pem)
+	req.Header.Add("X-Identity", publ)
+	sig := ku.Sign(url, client.Pem)
+	req.Header.Add("X-Signature", sig)
+	response, _ := htclient.Do(req)
+	defer response.Body.Close()
+	contents, _ := ioutil.ReadAll(response.Body)
+	var jsonContents map[string]interface{}
+	json.Unmarshal(contents, &jsonContents)
+	if response.StatusCode/100 != 2 {
+		err = processErrorMessage(response, jsonContents)
+	} else {
+		this, _ := json.Marshal(jsonContents["data"])
+		json.Unmarshal(this, &tokes)
+		err = nil
+	}
+	return tokes, nil
+}
+
+func (client *Client) GetToken(facade string) (token string, err error) {
+	tokens, _ := client.GetTokens()
+	for _, token := range tokens {
+		toke, ok := token[facade]
+		if ok {
+			return toke, nil
+		}
+	}
+	return "error", errors.New("facade not available in tokens")
+}
+
 func setHttpClient(client *Client) *http.Client {
 	if client.Insecure {
 		trans := &http.Transport{

client/client.go

@@ -2,42 +2,24 @@ package client_test
 
 import (
 	. "github.com/bitpay/bitpay-go/client"
-	ku "github.com/bitpay/bitpay-go/key_utils"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"io/ioutil"
+	//"io/ioutil"
 	"os"
 	"time"
 )
 
 var _ = Describe("RetrieveInvoice", func() {
 	It("Retrieves an invoice from the server with an id", func() {
 		time.Sleep(3 * time.Second)
-		pm := ku.GeneratePem()
-		apiuri := os.ExpandEnv("$RCROOTADDRESS")
+		pm := os.ExpandEnv("$BITPAYPEM")
+		apiuri := os.ExpandEnv("$BITPAYAPI")
 		webClient := Client{ApiUri: apiuri, Insecure: true, Pem: pm}
-		gopath := os.ExpandEnv("$GOPATH")
-		tempFolder := gopath + "/temp/"
-		code, err := ioutil.ReadFile(tempFolder + "retrievecode.txt")
-		if err != nil {
-			println(err.Error())
-		}
-		token, err := webClient.PairWithCode(string(code))
-		if err != nil {
-			println(err.Error())
-		}
-		Expect(token.Token).NotTo(BeNil())
-		webClient.Token = token
-		response, err := webClient.CreateInvoice(10, "USD")
-		if err != nil {
-			println("the retrieve test errored while creating an invoice: Error - " + err.Error())
-		}
-		invoiceId := response.Id
+		invoiceId := os.ExpandEnv("$INVOICEID")
 		retrievedInvoice, err := webClient.GetInvoice(invoiceId)
 		if err != nil {
-			println(webClient.ApiUri + " errored retrieving an invoice: Error - " + err.Error())
+			println("\n" + webClient.ApiUri + " errored retrieving an invoice: Error - " + err.Error())
 		}
 		Expect(retrievedInvoice.Id).To(Equal(invoiceId))
-		Expect(retrievedInvoice.Price).To(Equal(response.Price))
 	})
 })

client/client_get_invoice_test.go

@@ -1,8 +1,10 @@
 package client_test
 
 import (
+	"encoding/json"
 	. "github.com/bitpay/bitpay-go/client"
 	ku "github.com/bitpay/bitpay-go/key_utils"
+	"strings"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -15,18 +17,31 @@ import (
 var _ = Describe("CreateInvoice", func() {
 	It("creates an invoice for the price and currency sent", func() {
 		time.Sleep(3 * time.Second)
-		pm := ku.GeneratePem()
-		apiuri := os.ExpandEnv("$RCROOTADDRESS")
-		webClient := Client{ApiUri: apiuri, Insecure: true, Pem: pm}
-		gopath := os.ExpandEnv("$GOPATH")
-		tempFolder := gopath + "/temp/"
-		code, err := ioutil.ReadFile(tempFolder + "invoicecode.txt")
-		if err != nil {
-			println(err.Error())
+		pm := os.ExpandEnv("$BITPAYPEM")
+		pm = strings.Replace(pm, "\\n", "\n", -1)
+		apiuri := os.ExpandEnv("$BITPAYAPI")
+		webClient := Client{ApiUri: apiuri, Insecure: true, Pem: pm, ClientId: ku.GenerateSinFromPem(pm)}
+		mertok, _ := webClient.GetToken("merchant")
+		params := make(map[string]string)
+		params["token"] = mertok
+		params["facade"] = "pos"
+		params["id"] = webClient.ClientId
+		res, err := webClient.Post("tokens", params)
+		defer res.Body.Close()
+		contents, _ := ioutil.ReadAll(res.Body)
+		var jsonContents map[string]interface{}
+		json.Unmarshal(contents, &jsonContents)
+		var tok Token
+		if res.StatusCode/100 != 2 {
+			Expect(res.StatusCode).To(Equal(200))
+		} else {
+			tok, err = processToken(res, jsonContents)
+			err = nil
 		}
+		code := tok.PairingCode
 		token, err := webClient.PairWithCode(string(code))
 		if err != nil {
-			println(err.Error())
+			Expect(err.Error).To(Equal("Should be no error"))
 		}
 		webClient.Token = token
 		response, err := webClient.CreateInvoice(10, "USD")