d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-13 23:16:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

General formatting for currency

Browse Source
This commit is contained in:
Ryan O'Hara-Reid
2017-07-25 15:53:25 +10:00
committed by Adrian Gallagher
parent 4e6885410c
commit 745505a33e
7 changed files with 263 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
config/config.go
View File

@@ -226,7 +226,7 @@ func (c *Config) CheckWebserverConfigValues() error {
// pairs either cryptoCurrencies or fiatCurrencies
func (c *Config) RetrieveConfigCurrencyPairs() error {
cryptoCurrencies := common.SplitStrings(c.Cryptocurrencies, ",")
fiatCurrencies := common.SplitStrings(currency.DEFAULT_CURRENCIES, ",")
fiatCurrencies := common.SplitStrings(currency.DefaultCurrencies, ",")
for _, s := range cryptoCurrencies {
_, err := strconv.Atoi(s)

109
currency/currency.go
View File

@@ -11,8 +11,9 @@ import (
"github.com/thrasher-/gocryptotrader/common"
)
// Rate holds the current exchange rates for the currency pair.
type Rate struct {
Id string `json:"id"`
ID string `json:"id"`
Name string `json:"Name"`
Rate float64 `json:",string"`
Date string `json:"Date"`
@@ -21,12 +22,14 @@ type Rate struct {
Bid float64 `json:",string"`
}
// YahooJSONResponseInfo is a sub type that holds JSON response info
type YahooJSONResponseInfo struct {
Count int `json:"count"`
Created time.Time `json:"created"`
Lang string `json:"lang"`
}
// YahooJSONResponse holds Yahoo API responses
type YahooJSONResponse struct {
Query struct {
YahooJSONResponseInfo
@@ -37,31 +40,44 @@ type YahooJSONResponse struct {
}
const (
MAX_CURRENCY_PAIRS_PER_REQUEST = 350
YAHOO_YQL_URL = "http://query.yahooapis.com/v1/public/yql"
YAHOO_DATABASE = "store://datatables.org/alltableswithkeys"
DEFAULT_CURRENCIES = "USD,AUD,EUR,CNY"
DEFAULT_CRYPTOCURRENCIES = "BTC,LTC,ETH,DOGE,DASH,XRP,XMR"
maxCurrencyPairsPerRequest = 350
yahooYQLURL = "http://query.yahooapis.com/v1/public/yql"
yahooDatabase = "store://datatables.org/alltableswithkeys"
// DefaultCurrencies has the default minimum of FIAT values
DefaultCurrencies = "USD,AUD,EUR,CNY"
// DefaultCryptoCurrencies has the default minimum of crytpocurrency values
DefaultCryptoCurrencies = "BTC,LTC,ETH,DOGE,DASH,XRP,XMR"
)
// Variables for package which includes base error strings & exportable
// queries
var (
CurrencyStore map[string]Rate
BaseCurrencies string
CryptoCurrencies string
ErrCurrencyDataNotFetched = errors.New("Yahoo currency data has not been fetched yet.")
ErrCurrencyNotFound = errors.New("Unable to find specified currency.")
ErrQueryingYahoo = errors.New("Unable to query Yahoo currency values.")
ErrQueryingYahooZeroCount = errors.New("Yahoo returned zero currency data.")
ErrCurrencyDataNotFetched = errors.New("yahoo currency data has not been fetched yet")
ErrCurrencyNotFound = errors.New("unable to find specified currency")
ErrQueryingYahoo = errors.New("unable to query Yahoo currency values")
ErrQueryingYahooZeroCount = errors.New("yahoo returned zero currency data")
)
// IsDefaultCurrency checks if the currency passed in matches the default
// FIAT currency
func IsDefaultCurrency(currency string) bool {
return common.StringContains(DEFAULT_CURRENCIES, common.StringToUpper(currency))
return common.StringContains(
DefaultCurrencies, common.StringToUpper(currency),
)
}
// IsDefaultCryptocurrency checks if the currency passed in matches the default
// CRYPTO currency
func IsDefaultCryptocurrency(currency string) bool {
return common.StringContains(DEFAULT_CRYPTOCURRENCIES, common.StringToUpper(currency))
return common.StringContains(
DefaultCryptoCurrencies, common.StringToUpper(currency),
)
}
// IsFiatCurrency checks if the currency passed is an enabled FIAT currency
func IsFiatCurrency(currency string) bool {
if BaseCurrencies == "" {
log.Println("IsFiatCurrency: BaseCurrencies string variable not populated")
@@ -69,13 +85,18 @@ func IsFiatCurrency(currency string) bool {
return common.StringContains(BaseCurrencies, common.StringToUpper(currency))
}
// IsCryptocurrency checks if the currency passed is an enabled CRYPTO currency.
func IsCryptocurrency(currency string) bool {
if CryptoCurrencies == "" {
log.Println("IsCryptocurrency: CryptoCurrencies string variable not populated")
log.Println(
"IsCryptocurrency: CryptoCurrencies string variable not populated",
)
}
return common.StringContains(CryptoCurrencies, common.StringToUpper(currency))
}
// ContainsSeparator checks to see if the string passed contains "-" or "_"
// separated strings and returns what the separators were.
func ContainsSeparator(input string) (bool, string) {
separators := []string{"-", "_"}
var separatorsContainer []string
@@ -87,11 +108,12 @@ func ContainsSeparator(input string) (bool, string) {
}
if len(separatorsContainer) == 0 {
return false, ""
} else {
return true, strings.Join(separatorsContainer, ",")
}
return true, strings.Join(separatorsContainer, ",")
}
// ContainsBaseCurrencyIndex checks the currency against the baseCurrencies and
// returns a bool and its corresponding basecurrency.
func ContainsBaseCurrencyIndex(baseCurrencies []string, currency string) (bool, string) {
for _, x := range baseCurrencies {
if common.StringContains(currency, x) {
@@ -101,6 +123,8 @@ func ContainsBaseCurrencyIndex(baseCurrencies []string, currency string) (bool,
return false, ""
}
// ContainsBaseCurrency checks the currency against the baseCurrencies and
// returns a bool
func ContainsBaseCurrency(baseCurrencies []string, currency string) bool {
for _, x := range baseCurrencies {
if common.StringContains(currency, x) {
@@ -110,6 +134,9 @@ func ContainsBaseCurrency(baseCurrencies []string, currency string) bool {
return false
}
// CheckAndAddCurrency checks the string you passed with the input string array,
// if not already added, checks to see if it is part of the default currency
// list and returns the appended string.
func CheckAndAddCurrency(input []string, check string) []string {
for _, x := range input {
if IsDefaultCurrency(x) {
@@ -118,40 +145,39 @@ func CheckAndAddCurrency(input []string, check string) []string {
return input
}
continue
} else {
return input
}
return input
} else if IsDefaultCryptocurrency(x) {
if IsDefaultCryptocurrency(check) {
if check == x {
return input
}
continue
} else {
return input
}
} else {
return input
}
return input
}
input = append(input, check)
return input
}
// SeedCurrencyData takes the desired FIAT currency string, if not defined the
// function will assign it the default values. The function will query
// yahoo for the currency values and will seed currency data.
func SeedCurrencyData(fiatCurrencies string) error {
if fiatCurrencies == "" {
fiatCurrencies = DEFAULT_CURRENCIES
fiatCurrencies = DefaultCurrencies
}
err := QueryYahooCurrencyValues(fiatCurrencies)
if err != nil {
return ErrQueryingYahoo
}
return nil
}
// MakecurrencyPairs takes all supported currency and turns them into pairs.
func MakecurrencyPairs(supportedCurrencies string) string {
currencies := common.SplitStrings(supportedCurrencies, ",")
pairs := []string{}
@@ -167,9 +193,10 @@ func MakecurrencyPairs(supportedCurrencies string) string {
return common.JoinStrings(pairs, ",")
}
// ConvertCurrency for example converts $1 USD to the equivalent Japanese Yen
// or vice versa.
func ConvertCurrency(amount float64, from, to string) (float64, error) {
currency := common.StringToUpper(from + to)
if CurrencyStore[currency].Name != currency {
err := SeedCurrencyData(currency[:len(from)] + "," + currency[len(to):])
if err != nil {
@@ -185,24 +212,29 @@ func ConvertCurrency(amount float64, from, to string) (float64, error) {
return 0, ErrCurrencyNotFound
}
// FetchYahooCurrencyData seeds the variable CurrencyStore; this is a
// map[string]Rate
func FetchYahooCurrencyData(currencyPairs []string) error {
values := url.Values{}
values.Set("q", fmt.Sprintf("SELECT * from yahoo.finance.xchange WHERE pair in (\"%s\")", common.JoinStrings(currencyPairs, ",")))
values.Set(
"q", fmt.Sprintf("SELECT * from yahoo.finance.xchange WHERE pair in (\"%s\")",
common.JoinStrings(currencyPairs, ",")),
)
values.Set("format", "json")
values.Set("env", YAHOO_DATABASE)
values.Set("env", yahooDatabase)
headers := make(map[string]string)
headers["Content-Type"] = "application/x-www-form-urlencoded"
resp, err := common.SendHTTPRequest("POST", YAHOO_YQL_URL, headers, strings.NewReader(values.Encode()))
resp, err := common.SendHTTPRequest(
"POST", yahooYQLURL, headers, strings.NewReader(values.Encode()),
)
if err != nil {
return err
}
yahooResp := YahooJSONResponse{}
err = common.JSONDecode([]byte(resp), &yahooResp)
if err != nil {
return err
}
@@ -212,25 +244,29 @@ func FetchYahooCurrencyData(currencyPairs []string) error {
}
for i := 0; i < yahooResp.Query.YahooJSONResponseInfo.Count; i++ {
CurrencyStore[yahooResp.Query.Results.Rate[i].Id] = yahooResp.Query.Results.Rate[i]
CurrencyStore[yahooResp.Query.Results.Rate[i].ID] = yahooResp.Query.Results.Rate[i]
}
return nil
}
// QueryYahooCurrencyValues takes in desired currencies, creates pairs then
// uses FetchYahooCurrencyData to seed CurrencyStore
func QueryYahooCurrencyValues(currencies string) error {
CurrencyStore = make(map[string]Rate)
currencyPairs := common.SplitStrings(MakecurrencyPairs(currencies), ",")
log.Printf("%d fiat currency pairs generated. Fetching Yahoo currency data (this may take a minute)..\n", len(currencyPairs))
log.Printf(
"%d fiat currency pairs generated. Fetching Yahoo currency data (this may take a minute)..\n",
len(currencyPairs),
)
var err error
var pairs []string
index := 0
if len(currencyPairs) > MAX_CURRENCY_PAIRS_PER_REQUEST {
if len(currencyPairs) > maxCurrencyPairsPerRequest {
for index < len(currencyPairs) {
if len(currencyPairs)-index > MAX_CURRENCY_PAIRS_PER_REQUEST {
pairs = currencyPairs[index : index+MAX_CURRENCY_PAIRS_PER_REQUEST]
index += MAX_CURRENCY_PAIRS_PER_REQUEST
if len(currencyPairs)-index > maxCurrencyPairsPerRequest {
pairs = currencyPairs[index : index+maxCurrencyPairsPerRequest]
index += maxCurrencyPairsPerRequest
} else {
pairs = currencyPairs[index:len(currencyPairs)]
index += (len(currencyPairs) - index)
@@ -243,7 +279,6 @@ func QueryYahooCurrencyValues(currencies string) error {
} else {
pairs = currencyPairs[index:len(currencyPairs)]
err = FetchYahooCurrencyData(pairs)
if err != nil {
return err
}

180
currency/currency_test.go
View File

@@ -13,13 +13,20 @@ func TestIsDefaultCurrency(t *testing.T) {
var str1, str2, str3 string = "USD", "usd", "cats123"
if !IsDefaultCurrency(str1) {
t.Errorf("Test Failed. TestIsDefaultCurrency: \nCannot match currency, %s.", str1)
t.Errorf(
"Test Failed. TestIsDefaultCurrency: \nCannot match currency, %s.", str1,
)
}
if !IsDefaultCurrency(str2) {
t.Errorf("Test Failed. TestIsDefaultCurrency: \nCannot match currency, %s.", str2)
t.Errorf(
"Test Failed. TestIsDefaultCurrency: \nCannot match currency, %s.", str2,
)
}
if IsDefaultCurrency(str3) {
t.Errorf("Test Failed. TestIsDefaultCurrency: \nFunction return is incorrect with, %s.", str3)
t.Errorf(
"Test Failed. TestIsDefaultCurrency: \nFunction return is incorrect with, %s.",
str3,
)
}
}
@@ -29,13 +36,22 @@ func TestIsDefaultCryptocurrency(t *testing.T) {
var str1, str2, str3 string = "BTC", "btc", "dogs123"
if !IsDefaultCryptocurrency(str1) {
t.Errorf("Test Failed. TestIsDefaultCryptocurrency: \nCannot match currency, %s.", str1)
t.Errorf(
"Test Failed. TestIsDefaultCryptocurrency: \nCannot match currency, %s.",
str1,
)
}
if !IsDefaultCryptocurrency(str2) {
t.Errorf("Test Failed. TestIsDefaultCryptocurrency: \nCannot match currency, %s.", str2)
t.Errorf(
"Test Failed. TestIsDefaultCryptocurrency: \nCannot match currency, %s.",
str2,
)
}
if IsDefaultCryptocurrency(str3) {
t.Errorf("Test Failed. TestIsDefaultCryptocurrency: \nFunction return is incorrect with, %s.", str3)
t.Errorf(
"Test Failed. TestIsDefaultCryptocurrency: \nFunction return is incorrect with, %s.",
str3,
)
}
}
@@ -46,13 +62,19 @@ func TestIsFiatCurrency(t *testing.T) {
var str1, str2, str3 string = "BTC", "USD", "birds123"
if IsFiatCurrency(str1) {
t.Errorf("Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str1)
t.Errorf(
"Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str1,
)
}
if !IsFiatCurrency(str2) {
t.Errorf("Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str2)
t.Errorf(
"Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str2,
)
}
if IsFiatCurrency(str3) {
t.Errorf("Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str3)
t.Errorf(
"Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str3,
)
}
}
@@ -63,13 +85,19 @@ func TestIsCryptocurrency(t *testing.T) {
var str1, str2, str3 string = "USD", "BTC", "pterodactyl123"
if IsCryptocurrency(str1) {
t.Errorf("Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str1)
t.Errorf(
"Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str1,
)
}
if !IsCryptocurrency(str2) {
t.Errorf("Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str2)
t.Errorf(
"Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str2,
)
}
if IsCryptocurrency(str3) {
t.Errorf("Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str3)
t.Errorf(
"Test Failed. TestIsFiatCurrency: \nCannot match currency, %s.", str3,
)
}
}
@@ -80,19 +108,28 @@ func TestContainsSeparator(t *testing.T) {
doesIt, whatIsIt := ContainsSeparator(str1)
if doesIt != true || whatIsIt != "-" {
t.Errorf("Test Failed. ContainsSeparator: \nCannot find separator, %s.", str1)
t.Errorf(
"Test Failed. ContainsSeparator: \nCannot find separator, %s.", str1,
)
}
doesIt2, whatIsIt2 := ContainsSeparator(str2)
if doesIt2 != true || whatIsIt2 != "_" {
t.Errorf("Test Failed. ContainsSeparator: \nCannot find separator, %s.", str2)
t.Errorf(
"Test Failed. ContainsSeparator: \nCannot find separator, %s.", str2,
)
}
doesIt3, whatIsIt3 := ContainsSeparator(str3)
if doesIt3 != true || len(whatIsIt3) != 3 {
t.Errorf("Test Failed. ContainsSeparator: \nCannot find or incorrect separator, %s.", str3)
t.Errorf(
"Test Failed. ContainsSeparator: \nCannot find or incorrect separator, %s.",
str3,
)
}
doesIt4, whatIsIt4 := ContainsSeparator(str4)
if doesIt4 != false || whatIsIt4 != "" {
t.Errorf("Test Failed. ContainsSeparator: \nReturn Issues with string, %s.", str3)
t.Errorf(
"Test Failed. ContainsSeparator: \nReturn Issues with string, %s.", str3,
)
}
}
@@ -104,11 +141,17 @@ func TestContainsBaseCurrencyIndex(t *testing.T) {
isIt, whatIsIt := ContainsBaseCurrencyIndex(baseCurrencies, currency1)
if !isIt && whatIsIt != "USD" {
t.Errorf("Test Failed. ContainsBaseCurrencyIndex: \nReturned: %t & %s, with Currency as %s.", isIt, whatIsIt, currency1)
t.Errorf(
"Test Failed. ContainsBaseCurrencyIndex: \nReturned: %t & %s, with Currency as %s.",
isIt, whatIsIt, currency1,
)
}
isIt2, whatIsIt2 := ContainsBaseCurrencyIndex(baseCurrencies, currency2)
if isIt2 && whatIsIt2 != "DINGDONG" {
t.Errorf("Test Failed. ContainsBaseCurrencyIndex: \nReturned: %t & %s, with Currency as %s.", isIt2, whatIsIt2, currency2)
t.Errorf(
"Test Failed. ContainsBaseCurrencyIndex: \nReturned: %t & %s, with Currency as %s.",
isIt2, whatIsIt2, currency2,
)
}
}
@@ -120,11 +163,15 @@ func TestContainsBaseCurrency(t *testing.T) {
isIt := ContainsBaseCurrency(baseCurrencies, currency1)
if !isIt {
t.Errorf("Test Failed. ContainsBaseCurrency: \nReturned: %t, with Currency as %s.", isIt, currency1)
t.Errorf("Test Failed. ContainsBaseCurrency: \nReturned: %t, with Currency as %s.",
isIt, currency1,
)
}
isIt2 := ContainsBaseCurrency(baseCurrencies, currency2)
if isIt2 {
t.Errorf("Test Failed. ContainsBaseCurrency: \nReturned: %t, with Currency as %s.", isIt2, currency2)
t.Errorf("Test Failed. ContainsBaseCurrency: \nReturned: %t, with Currency as %s.",
isIt2, currency2,
)
}
}
@@ -133,6 +180,7 @@ func TestCheckAndAddCurrency(t *testing.T) {
inputFiat := []string{"USD", "AUD", "EUR"}
inputCrypto := []string{"BTC", "LTC", "ETH", "DOGE", "DASH", "XRP"}
testError := []string{"Testy"}
fiat := "USD"
fiatIncrease := "CNY"
crypto := "LTC"
@@ -141,37 +189,69 @@ func TestCheckAndAddCurrency(t *testing.T) {
appendedString := CheckAndAddCurrency(inputFiat, fiat)
if len(appendedString) > len(inputFiat) {
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.", fiat)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.",
fiat,
)
}
appendedString = CheckAndAddCurrency(inputFiat, fiatIncrease)
if len(appendedString) <= len(inputFiat) {
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.", fiatIncrease)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.",
fiatIncrease,
)
}
appendedString = CheckAndAddCurrency(inputFiat, crypto)
if len(appendedString) > len(inputFiat) {
t.Log(appendedString)
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.", crypto)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.",
crypto,
)
}
appendedString = CheckAndAddCurrency(inputFiat, obtuse)
if len(appendedString) > len(inputFiat) {
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.", obtuse)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputFiat, currency as %s.",
obtuse,
)
}
appendedString = CheckAndAddCurrency(inputCrypto, crypto)
if len(appendedString) > len(inputCrypto) {
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.", crypto)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.",
crypto,
)
}
appendedString = CheckAndAddCurrency(inputCrypto, cryptoIncrease)
if len(appendedString) <= len(inputCrypto) {
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.", cryptoIncrease)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.",
cryptoIncrease,
)
}
appendedString = CheckAndAddCurrency(inputCrypto, fiat)
if len(appendedString) > len(inputCrypto) {
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.", fiat)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.",
fiat,
)
}
appendedString = CheckAndAddCurrency(inputCrypto, obtuse)
if len(appendedString) > len(inputCrypto) {
t.Errorf("Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.", obtuse)
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputCrytpo, currency as %s.",
obtuse,
)
}
appendedString = CheckAndAddCurrency(testError, "USD")
if appendedString[0] != testError[0] {
t.Errorf(
"Test Failed. CheckAndAddCurrency: Error with inputCrytpo, basecurrency as %s.",
testError,
)
}
}
@@ -184,23 +264,34 @@ func TestSeedCurrencyData(t *testing.T) {
err := SeedCurrencyData(currencyRequestDefault)
if err != nil {
t.Errorf("Test Failed. SeedCurrencyData: Error %s with currency as %s.", err, currencyRequestDefault)
t.Errorf(
"Test Failed. SeedCurrencyData: Error %s with currency as %s.",
err, currencyRequestDefault,
)
}
err2 := SeedCurrencyData(currencyRequestUSDAUD)
if err2 != nil {
t.Errorf("Test Failed. SeedCurrencyData: Error %s with currency as %s.", err2, currencyRequestUSDAUD)
t.Errorf(
"Test Failed. SeedCurrencyData: Error %s with currency as %s.",
err2, currencyRequestUSDAUD,
)
}
err3 := SeedCurrencyData(currencyRequestObtuse)
if err3 == nil {
t.Errorf("Test Failed. SeedCurrencyData: Error %s with currency as %s.", err3, currencyRequestObtuse)
t.Errorf(
"Test Failed. SeedCurrencyData: Error %s with currency as %s.",
err3, currencyRequestObtuse,
)
}
}
func TestMakecurrencyPairs(t *testing.T) {
t.Parallel()
lengthDefault := len(common.SplitStrings(DEFAULT_CURRENCIES, ","))
fiatPairsLength := len(common.SplitStrings(MakecurrencyPairs(DEFAULT_CURRENCIES), ","))
lengthDefault := len(common.SplitStrings(DefaultCurrencies, ","))
fiatPairsLength := len(
common.SplitStrings(MakecurrencyPairs(DefaultCurrencies), ","),
)
if lengthDefault*(lengthDefault-1) > fiatPairsLength {
t.Error("Test Failed. MakecurrencyPairs: Error, mismatched length")
@@ -210,7 +301,7 @@ func TestMakecurrencyPairs(t *testing.T) {
func TestConvertCurrency(t *testing.T) {
t.Parallel()
fiatCurrencies := DEFAULT_CURRENCIES
fiatCurrencies := DefaultCurrencies
for _, currencyFrom := range common.SplitStrings(fiatCurrencies, ",") {
for _, currencyTo := range common.SplitStrings(fiatCurrencies, ",") {
if currencyFrom == currencyTo {
@@ -218,14 +309,18 @@ func TestConvertCurrency(t *testing.T) {
} else {
floatyMcfloat, err := ConvertCurrency(1000, currencyFrom, currencyTo)
if err != nil {
t.Errorf("Test Failed. ConvertCurrency: Error %s with return: %.2f Currency 1: %s Currency 2: %s",
err, floatyMcfloat, currencyFrom, currencyTo)
t.Errorf(
"Test Failed. ConvertCurrency: Error %s with return: %.2f Currency 1: %s Currency 2: %s",
err, floatyMcfloat, currencyFrom, currencyTo,
)
}
if reflect.TypeOf(floatyMcfloat).String() != "float64" {
t.Error("Test Failed. ConvertCurrency: Error, incorrect return type")
}
if floatyMcfloat <= 0 {
t.Error("Test Failed. ConvertCurrency: Error, negative return or a serious issue with current fiat")
t.Error(
"Test Failed. ConvertCurrency: Error, negative return or a serious issue with current fiat",
)
}
}
}
@@ -235,7 +330,7 @@ func TestConvertCurrency(t *testing.T) {
func TestFetchYahooCurrencyData(t *testing.T) {
t.Parallel()
var fetchData []string
fiatCurrencies := DEFAULT_CURRENCIES
fiatCurrencies := DefaultCurrencies
for _, currencyOne := range common.SplitStrings(fiatCurrencies, ",") {
for _, currencyTwo := range common.SplitStrings(fiatCurrencies, ",") {
@@ -255,14 +350,13 @@ func TestFetchYahooCurrencyData(t *testing.T) {
func TestQueryYahooCurrencyValues(t *testing.T) {
t.Parallel()
err := QueryYahooCurrencyValues(DEFAULT_CURRENCIES)
err := QueryYahooCurrencyValues(DefaultCurrencies)
if err != nil {
t.Errorf("Test Failed. QueryYahooCurrencyValues: Error, %s", err)
}
err2 := QueryYahooCurrencyValues(DEFAULT_CRYPTOCURRENCIES)
if err2 == nil {
t.Errorf("Test Failed. QueryYahooCurrencyValues: Error, %s", err2)
err = QueryYahooCurrencyValues(DefaultCryptoCurrencies)
if err == nil {
t.Errorf("Test Failed. QueryYahooCurrencyValues: Error, %s", err)
}
}

18
currency/pair/pair.go
View File

@@ -2,38 +2,49 @@ package pair
import "strings"
// CurrencyItem is an exported string with methods to manipulate the data instead
// of using array/slice access modifiers
type CurrencyItem string
// Lower converts the CurrencyItem object c to lowercase
func (c CurrencyItem) Lower() CurrencyItem {
return CurrencyItem(strings.ToLower(string(c)))
}
// Upper converts the CurrencyItem object c to uppercase
func (c CurrencyItem) Upper() CurrencyItem {
return CurrencyItem(strings.ToUpper(string(c)))
}
// String converts the CurrencyItem object c to string
func (c CurrencyItem) String() string {
return string(c)
}
// CurrencyPair holds currency pair information
type CurrencyPair struct {
Delimiter string `json:"delimiter"`
FirstCurrency CurrencyItem `json:"first_currency"`
SecondCurrency CurrencyItem `json:"second_currency"`
}
// GetFirstCurrency returns the first currency item
func (c CurrencyPair) GetFirstCurrency() CurrencyItem {
return c.FirstCurrency
}
// GetSecondCurrency returns the second currency item
func (c CurrencyPair) GetSecondCurrency() CurrencyItem {
return c.SecondCurrency
}
// Pair returns a currency pair string
func (c CurrencyPair) Pair() CurrencyItem {
return c.FirstCurrency + CurrencyItem(c.Delimiter) + c.SecondCurrency
}
// NewCurrencyPairDelimiter splits the desired currency string at delimeter,
// the returns a CurrencyPair struct
func NewCurrencyPairDelimiter(currency, delimiter string) CurrencyPair {
result := strings.Split(currency, delimiter)
return CurrencyPair{
@@ -43,6 +54,7 @@ func NewCurrencyPairDelimiter(currency, delimiter string) CurrencyPair {
}
}
// NewCurrencyPair returns a CurrencyPair without a delimiter
func NewCurrencyPair(firstCurrency, secondCurrency string) CurrencyPair {
return CurrencyPair{
FirstCurrency: CurrencyItem(firstCurrency),
@@ -50,10 +62,12 @@ func NewCurrencyPair(firstCurrency, secondCurrency string) CurrencyPair {
}
}
// NewCurrencyPairFromString converts currency string into a new CurrencyPair
// with or without delimeter
func NewCurrencyPairFromString(currency string) CurrencyPair {
delmiters := []string{"_", "-"}
delimiters := []string{"_", "-"}
var delimiter string
for _, x := range delmiters {
for _, x := range delimiters {
if strings.Contains(currency, x) {
delimiter = x
return NewCurrencyPairDelimiter(currency, delimiter)

44
currency/pair/pair_test.go
View File

@@ -1,8 +1,6 @@
package pair
import (
"testing"
)
import "testing"
func TestLower(t *testing.T) {
t.Parallel()
@@ -43,7 +41,10 @@ func TestGetFirstCurrency(t *testing.T) {
actual := pair.GetFirstCurrency()
expected := CurrencyItem("BTC")
if actual != expected {
t.Errorf("Test failed. GetFirstCurrency(): %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. GetFirstCurrency(): %s was not equal to expected value: %s",
actual, expected,
)
}
}
@@ -53,7 +54,10 @@ func TestGetSecondCurrency(t *testing.T) {
actual := pair.GetSecondCurrency()
expected := CurrencyItem("USD")
if actual != expected {
t.Errorf("Test failed. GetSecondCurrency(): %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. GetSecondCurrency(): %s was not equal to expected value: %s",
actual, expected,
)
}
}
@@ -63,7 +67,10 @@ func TestPair(t *testing.T) {
actual := pair.Pair()
expected := CurrencyItem("BTCUSD")
if actual != expected {
t.Errorf("Test failed. Pair(): %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. Pair(): %s was not equal to expected value: %s",
actual, expected,
)
}
}
@@ -73,7 +80,10 @@ func TestNewCurrencyPair(t *testing.T) {
actual := pair.Pair()
expected := CurrencyItem("BTCUSD")
if actual != expected {
t.Errorf("Test failed. Pair(): %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. Pair(): %s was not equal to expected value: %s",
actual, expected,
)
}
}
@@ -83,13 +93,19 @@ func TestNewCurrencyPairDelimiter(t *testing.T) {
actual := pair.Pair()
expected := CurrencyItem("BTC-USD")
if actual != expected {
t.Errorf("Test failed. Pair(): %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. Pair(): %s was not equal to expected value: %s",
actual, expected,
)
}
actual = CurrencyItem(pair.Delimiter)
expected = "-"
if actual != expected {
t.Errorf("Test failed. Delmiter: %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. Delmiter: %s was not equal to expected value: %s",
actual, expected,
)
}
}
@@ -100,7 +116,10 @@ func TestNewCurrencyPairFromString(t *testing.T) {
actual := pair.Pair()
expected := CurrencyItem("BTC-USD")
if actual != expected {
t.Errorf("Test failed. Pair(): %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. Pair(): %s was not equal to expected value: %s",
actual, expected,
)
}
pairStr = "BTCUSD"
@@ -108,6 +127,9 @@ func TestNewCurrencyPairFromString(t *testing.T) {
actual = pair.Pair()
expected = CurrencyItem("BTCUSD")
if actual != expected {
t.Errorf("Test failed. Pair(): %s was not equal to expected value: %s", actual, expected)
t.Errorf(
"Test failed. Pair(): %s was not equal to expected value: %s",
actual, expected,
)
}
}

6
exchanges/bitfinex/bitfinex_test.go
View File

@@ -41,9 +41,9 @@ func TestSetup(t *testing.T) {
RESTPollingDelay: time.Duration(10),
Verbose: true,
Websocket: true,
BaseCurrencies: currency.DEFAULT_CURRENCIES,
AvailablePairs: currency.MakecurrencyPairs(currency.DEFAULT_CURRENCIES),
EnabledPairs: currency.MakecurrencyPairs(currency.DEFAULT_CURRENCIES),
BaseCurrencies: currency.DefaultCurrencies,
AvailablePairs: currency.MakecurrencyPairs(currency.DefaultCurrencies),
EnabledPairs: currency.MakecurrencyPairs(currency.DefaultCurrencies),
}
setup := Bitfinex{}
setup.Setup(testConfig)

2
exchanges/stats/stats.go
View File

@@ -46,7 +46,7 @@ func (this ByVolume) Swap(i, j int) {
func AddExchangeInfo(exchange, crypto, fiat string, price, volume float64) {
if currency.BaseCurrencies == "" {
currency.BaseCurrencies = currency.DEFAULT_CURRENCIES
currency.BaseCurrencies = currency.DefaultCurrencies
}
if !currency.IsFiatCurrency(fiat) {