test.go

// uses existing sqlite db in .gocryptotrader/database directory
func TestCandleSaving(t *testing.T) {
	var err error
	Bot, err = New()
	if err != nil {
		t.Fatalf("Failed to initialise engine. Err: %s", err)
	}
	Bot.Settings = Settings{
		DisableExchangeAutoPairUpdates: true,
		EnableExchangeHTTPRateLimiter:  true,
		EnableExchangeWebsocketSupport: true,

	}
	Bot.Config.Database = database.Config{
		Enabled:           true,
		Verbose:           false,
		Driver:            "sqlite",
		ConnectionDetails: drivers.ConnectionDetails{
			Host:     "localhost",
			Port:     0,
			Username: "",
			Password: "",
			Database: "postgres.db",
			SSLMode:  "",
		},
	}
	database.DB = &database.Instance{
		DataPath: filepath.Join(common.GetDefaultDataDir(runtime.GOOS), "database"),
		Config: &database.Config{
			Enabled: true,
			Verbose: false,
			Driver:  "sqlite",
			ConnectionDetails: drivers.ConnectionDetails{
				Host:     "localhost",
				Port:     0,
				Username: "",
				Password: "",
				Database: "postgres.db",
				SSLMode:  "",
			},
		},
		Connected: false,
		Mu:        sync.RWMutex{},
	}
	err = Bot.DatabaseManager.Start()
	if err != nil {
		t.Fatal(err)
	}
	var wg sync.WaitGroup
	for x := range exchange.Exchanges {
		name := exchange.Exchanges[x]
		exchCfg, err := Bot.Config.GetExchangeConfig(name)
		if err != nil {
			t.Errorf("Failed to load exchange %s. Err: %s", name, err)
		}
		exchCfg.Enabled = true
		exchCfg.Verbose = true
		err = LoadExchange(name, true, &wg)
		if err != nil {
			t.Errorf("Failed to load exchange %s. Err: %s", name, err)
		}
	}
	wg.Wait()
	server := grpc.NewServer()
	s := RPCServer{}
	gctrpc.RegisterGoCryptoTraderServer(server, &s)
	exchangesButts := GetExchanges()
	for i := range exchangesButts {
		assetTypes := exchangesButts[i].GetAssetTypes()
		for j := range assetTypes {
			pairs, err := exchangesButts[i].GetEnabledPairs(assetTypes[j])
			if err != nil {
				t.Error(err)
			}
			if len(pairs) > 0 {
				pp := pairs.GetRandomPair()
				req := &gctrpc.GetHistoricCandlesRequest{
					Exchange:     exchangesButts[i].GetName(),
					Pair:			&gctrpc.CurrencyPair{
						Delimiter: pp.Delimiter,
						Base:      pp.Base.String(),
						Quote:     pp.Quote.String(),
					},
					AssetType:    assetTypes[j].String(),
					Start:        time.Now().Add(-time.Hour * 24).Unix(),
					End:          time.Now().Unix(),
					TimeInterval: int64(kline.OneHour),
					ExRequest:    true,
					Sync:         true,
					UseDb:        false,
				}
				a, err := s.GetHistoricCandles(context.Background(), req)
				if err != nil  && err.Error() == "interval not supported" {
					req.TimeInterval = int64(kline.OneDay)
					a, err = s.GetHistoricCandles(context.Background(), req)
				}
 				if err != nil && err.Error() != "unsupported wrapper function"  {
					t.Errorf("%v %v", exchangesButts[i].GetName(), err)
					continue
				}
				if a== nil ||  a.Candle == nil {
					t.Errorf("%v failed to get data for %s %s", exchangesButts[i].GetName(), assetTypes[j].String(), pp.String())
					continue
				} else {
					t.Logf("%v got %v candles %s %s", exchangesButts[i].GetName(), len(a.Candle), assetTypes[j].String(), pp.String())
				}
				req.UseDb = true
				req.Sync = false
				a, err = s.GetHistoricCandles(context.Background(), req)
				if err != nil  && err.Error() == "interval not supported" {
					req.TimeInterval = int64(kline.OneDay)
					a, err = s.GetHistoricCandles(context.Background(), req)
				}
				if err != nil && err.Error() != "unsupported wrapper function"  {
					t.Errorf("%v %v", exchangesButts[i].GetName(), err)
				}
				if len(a.Candle) == 0 {
					t.Errorf("%v failed to get DB data for %s %s", exchangesButts[i].GetName(), assetTypes[j].String(), pp.String())
				}
			}
		}
	}
}