General engine improvements (#437)

* Add exchange manager to engine

* Several improvements for engine and friends

1) New file.Exists func
2) gRPC TLS cert expiration date check and regeneration
3) New donation var for use across the codebase
4) Use Go log package until the logger is initialised

* Add cert tests and create dir tree if it doesn't exist for file.Write

* Link up donation address to documentation tool plus minor adjustments

* Fix remaining donation addrs

* Move non-needed reload exchange funcs

* Revert accidental config_example.json changes 🕯️

* Use go logger for logging until the logger has initiliased, otherwise no output will be seen

* Link up portfolio delay val and other fixes

* Run go mod tidy after dependabot PR

* Address nitterinos

engine/helpers_test.go

@@ -1,10 +1,21 @@
 package engine
 
 import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"math/big"
+	"net"
+	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
 	"github.com/thrasher-corp/gocryptotrader/common"
+	"github.com/thrasher-corp/gocryptotrader/common/file"
 	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/account"
@@ -14,10 +25,6 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/exchanges/ticker"
 )
 
-const (
-	TestConfig = "../testdata/configtest.json"
-)
-
 var (
 	helperTestLoaded = false
 )
@@ -29,7 +36,7 @@ func SetupTestHelpers(t *testing.T) {
 				Bot = new(Engine)
 			}
 			Bot.Config = &config.Cfg
-			err := Bot.Config.LoadConfig("../testdata/configtest.json", true)
+			err := Bot.Config.LoadConfig(config.TestFile, true)
 			if err != nil {
 				t.Fatalf("SetupTest: Failed to load config: %s", err)
 			}
@@ -562,3 +569,167 @@ func TestGetCryptocurrenciesByExchange(t *testing.T) {
 		t.Fatalf("Err %s", err)
 	}
 }
+
+func TestGetExchangeNames(t *testing.T) {
+	SetupTest(t)
+	if e := GetExchangeNames(true); len(e) == 0 {
+		t.Error("exchange names should be populated")
+	}
+	if err := UnloadExchange(testExchange); err != nil {
+		t.Fatal(err)
+	}
+	if e := GetExchangeNames(true); common.StringDataCompare(e, testExchange) {
+		t.Error("Bitstamp should be missing")
+	}
+	if e := GetExchangeNames(false); len(e) != 27 {
+		t.Error("len should be all available exchanges")
+	}
+}
+
+func mockCert(derType string, notAfter time.Time) ([]byte, error) {
+	privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+
+	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
+	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
+	if err != nil {
+		return nil, err
+	}
+
+	host, err := os.Hostname()
+	if err != nil {
+		return nil, err
+	}
+
+	dnsNames := []string{host}
+	if host != "localhost" {
+		dnsNames = append(dnsNames, "localhost")
+	}
+
+	if notAfter.IsZero() {
+		notAfter = time.Now().Add(time.Hour * 24 * 365)
+	}
+
+	template := x509.Certificate{
+		SerialNumber: serialNumber,
+		Subject: pkix.Name{
+			Organization: []string{"gocryptotrader"},
+			CommonName:   host,
+		},
+		NotBefore:             time.Now(),
+		NotAfter:              notAfter,
+		IsCA:                  true,
+		BasicConstraintsValid: true,
+		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		IPAddresses: []net.IP{
+			net.ParseIP("127.0.0.1"),
+			net.ParseIP("::1"),
+		},
+		DNSNames: dnsNames,
+	}
+
+	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &privKey.PublicKey, privKey)
+	if err != nil {
+		return nil, err
+	}
+
+	if derType == "" {
+		derType = "CERTIFICATE"
+	}
+
+	certData := pem.EncodeToMemory(&pem.Block{Type: derType, Bytes: derBytes})
+	if certData == nil {
+		return nil, err
+	}
+
+	return certData, nil
+}
+
+func TestVerifyCert(t *testing.T) {
+	t.Parallel()
+
+	tester := []struct {
+		PEMType       string
+		CreateBypass  bool
+		NotAfter      time.Time
+		ErrorExpected error
+	}{
+		{
+			ErrorExpected: nil,
+		},
+		{
+			CreateBypass:  true,
+			ErrorExpected: errCertDataIsNil,
+		},
+		{
+			PEMType:       "MEOW",
+			ErrorExpected: errCertTypeInvalid,
+		},
+		{
+			NotAfter:      time.Now().Add(-time.Hour),
+			ErrorExpected: errCertExpired,
+		},
+	}
+
+	for x := range tester {
+		var cert []byte
+		var err error
+		if !tester[x].CreateBypass {
+			cert, err = mockCert(tester[x].PEMType, tester[x].NotAfter)
+			if err != nil {
+				t.Errorf("test %d unexpected error: %s", x, err)
+				continue
+			}
+		}
+		err = verifyCert(cert)
+		if err != tester[x].ErrorExpected {
+			t.Fatalf("test %d expected %v, got %v", x, tester[x].ErrorExpected, err)
+		}
+	}
+}
+
+func TestCheckAndGenCerts(t *testing.T) {
+	t.Parallel()
+
+	tempDir := filepath.Join(os.TempDir(), "gct-temp-tls")
+	cleanup := func() {
+		if err := os.RemoveAll(tempDir); err != nil {
+			t.Errorf("unable to remove temp dir %s, manual deletion required", tempDir)
+		}
+	}
+
+	if err := genCert(tempDir); err != nil {
+		cleanup()
+		t.Fatal(err)
+	}
+
+	defer cleanup()
+	if err := checkCerts(tempDir); err != nil {
+		t.Fatal(err)
+	}
+
+	// Now delete cert.pem and test regeneration of cert/key files
+	certFile := filepath.Join(tempDir, "cert.pem")
+	if err := os.Remove(certFile); err != nil {
+		t.Fatal(err)
+	}
+	if err := checkCerts(tempDir); err != nil {
+		t.Fatal(err)
+	}
+
+	// Now call checkCerts to test an expired cert
+	certData, err := mockCert("", time.Now().Add(-time.Hour))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = file.Write(certFile, certData)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = checkCerts(tempDir); err != nil {
+		t.Fatal(err)
+	}
+}