Merge pull request #11 from aopoltorzhicky/auth-socket

Auth socket

.gitignore

@@ -16,3 +16,5 @@
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
+
+keys

.travis.yml

@@ -17,10 +17,10 @@ script:
   - golint .
   - cd websocket
   - go get -t -v
-  - go test -v -coverprofile=coverage.txt -covermode=atomic
+  - go test -v -coverprofile=coverage.txt -covermode=atomic -race
   - cd ../rest
   - go get -t -v
-  - go test -v -coverprofile=coverage.txt -covermode=atomic
+  - go test -v -coverprofile=coverage.txt -covermode=atomic -race
 
 after_success:
   - bash <(curl -s https://codecov.io/bash)

examples/auth/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"log"
+
+	ws "github.com/aopoltorzhicky/go_kraken/websocket"
+)
+
+func main() {
+	c := ws.NewAuth("", "")
+
+	if err := c.Connect(); err != nil {
+		log.Fatal("Error connecting to web socket : ", err)
+	}
+
+	if err := c.SubscribeOwnTrades(); err != nil {
+		log.Fatal("Error connecting to web socket : ", err)
+	}
+
+	if err := c.SubscribeOpenOrders(); err != nil {
+		log.Fatal("Error connecting to web socket : ", err)
+	}
+
+	for obj := range c.Listen() {
+		switch obj.(type) {
+		case error:
+			log.Printf("channel closed: %s", obj)
+		case ws.DataUpdate:
+			data := obj.(ws.DataUpdate)
+			log.Printf("MSG RECV: %#v", data)
+		}
+	}
+}

examples/rest/main.go

@@ -7,10 +7,11 @@ import (
 )
 
 func main() {
-	api := rest.New("pZai5d5lPFm4uE+raQlSHCRRqNE4MoPU/k1C8nu0/0bZZ9+iItHsiWoc", "iNYlYHYf5j4tE8EvSV+HN6VsJyX3dhkRlw/6+NLLHzDZ+9aA8j/o3ze9gpXDXyEZVnz88vtwsqF8fPZWv82egw==")
-	data, err1 := api.GetTradeBalance("")
-	if err1 != nil {
-		log.Fatalln(err1)
+	api := rest.New("api_key", "secret")
+	data, err := api.GetAccountBalances()
+	if err != nil {
+		log.Panicln(err)
+		return
 	}
 	log.Println(data)
 }

rest/kraken.go

@@ -5,15 +5,14 @@ import (
 	"crypto/sha256"
 	"crypto/sha512"
 	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
-
-	"github.com/ugorji/go/codec"
 )
 
 // clientInterface - for testing purpose
@@ -42,14 +41,20 @@ func New(key string, secret string) *Kraken {
 
 func (api *Kraken) getSign(requestURL string, data url.Values) (string, error) {
 	sha := sha256.New()
-	sha.Write([]byte(data.Get("nonce") + data.Encode()))
+
+	if _, err := sha.Write([]byte(data.Get("nonce") + data.Encode())); err != nil {
+		return "", err
+	}
 	hashData := sha.Sum(nil)
 	s, err := base64.StdEncoding.DecodeString(api.secret)
 	if err != nil {
 		return "", err
 	}
 	hmacObj := hmac.New(sha512.New, s)
-	hmacObj.Write(append([]byte(requestURL), hashData...))
+
+	if _, err := hmacObj.Write(append([]byte(requestURL), hashData...)); err != nil {
+		return "", err
+	}
 	hmacData := hmacObj.Sum(nil)
 	return base64.StdEncoding.EncodeToString(hmacData), nil
 }
@@ -82,45 +87,45 @@ func (api *Kraken) prepareRequest(method string, isPrivate bool, data url.Values
 	return req, nil
 }
 
-func (api *Kraken) parseResponse(response *http.Response, retType interface{}) (interface{}, error) {
+func (api *Kraken) parseResponse(response *http.Response, retType interface{}) error {
 	if response.StatusCode != 200 {
-		return nil, fmt.Errorf("Error during response parsing: invalid status code %d", response.StatusCode)
+		return fmt.Errorf("Error during response parsing: invalid status code %d", response.StatusCode)
 	}
 
 	if response.Body == nil {
-		return nil, fmt.Errorf("Error during response parsing: can not read response body")
+		return fmt.Errorf("Error during response parsing: can not read response body")
 	}
 
 	body, err := ioutil.ReadAll(response.Body)
 	if err != nil {
-		return nil, fmt.Errorf("Error during response parsing: can not read response body (%s)", err.Error())
+		return fmt.Errorf("Error during response parsing: can not read response body (%s)", err.Error())
 	}
+
+	log.Println(string(body))
 	var retData KrakenResponse
 	if retType != nil {
 		retData.Result = retType
 	}
 
-	log.Println(string(body))
-	err = codec.NewDecoderBytes(body, new(codec.JsonHandle)).Decode(&retData)
-	if err != nil {
-		return nil, fmt.Errorf("Error during response parsing: json marshalling (%s)", err.Error())
+	if err = json.Unmarshal(body, &retData); err != nil {
+		return fmt.Errorf("Error during response parsing: json marshalling (%s)", err.Error())
 	}
 
 	if len(retData.Error) > 0 {
-		return nil, fmt.Errorf("Kraken return errors: %s", retData.Error)
+		return fmt.Errorf("Kraken return errors: %s", retData.Error)
 	}
 
-	return retData.Result, nil
+	return nil
 }
 
-func (api *Kraken) request(method string, isPrivate bool, data url.Values, retType interface{}) (interface{}, error) {
+func (api *Kraken) request(method string, isPrivate bool, data url.Values, retType interface{}) error {
 	req, err := api.prepareRequest(method, isPrivate, data)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	resp, err := api.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("Error during request execution: %s", err.Error())
+		return fmt.Errorf("Error during request execution: %s", err.Error())
 	}
 	defer resp.Body.Close()
 	return api.parseResponse(resp, retType)

rest/kraken_test.go

@@ -231,7 +231,7 @@ func TestKraken_prepareRequest(t *testing.T) {
 						t.Errorf("Kraken.prepareRequest() expected = https, got %v", got.URL.Scheme)
 						return
 					}
-				} else if got == nil {
+				} else {
 					t.Errorf("Kraken.prepareRequest() got = %v, wantErr %v", got, tt.wantErr)
 					return
 				}
@@ -319,14 +319,11 @@ func TestKraken_parseResponse(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			api := New(tt.fields.key, tt.fields.secret)
-			got, err := api.parseResponse(tt.args.response, tt.args.retType)
+			err := api.parseResponse(tt.args.response, tt.args.retType)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Kraken.parseResponse() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("Kraken.parseResponse() = %v, want %v", got, tt.want)
-			}
 		})
 	}
 }
@@ -368,14 +365,11 @@ func TestKraken_request(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			api := New(tt.fields.key, tt.fields.secret)
-			got, err := api.request(tt.args.method, tt.args.isPrivate, tt.args.data, tt.args.retType)
+			err := api.request(tt.args.method, tt.args.isPrivate, tt.args.data, tt.args.retType)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Kraken.request() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("Kraken.request() = %v, want %v", got, tt.want)
-			}
 		})
 	}
 }