IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-10 23:55:47 -06:00
Code Issues Packages Projects Releases Wiki Activity

Postgres: Convert tests to stdlib (#30536)

Browse Source 
* Postgres: Convert tests to stdlib

Signed-off-by: Arve Knudsen <arve.knudsen@gmail.com>
This commit is contained in:
Arve Knudsen 2021-01-22 16:34:53 +01:00 committed by GitHub
parent 9c20698dfe
commit be8ba8ef46
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 730 additions and 715 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

391
pkg/tsdb/postgres/postgres_test.go
View File

@ -23,7 +23,6 @@ import (
"xorm.io/xorm"
_ "github.com/lib/pq"
. "github.com/smartystreets/goconvey/convey"
)
// Test generateConnectionString.
@ -132,15 +131,17 @@ func TestPostgres(t *testing.T) {
t.Skip()
}
Convey("PostgreSQL", t, func() {
x := InitPostgresTestDB(t)
origXormEngine := sqleng.NewXormEngine
origInterpolate := sqleng.Interpolate
t.Cleanup(func() {
sqleng.NewXormEngine = origXormEngine
sqleng.Interpolate = origInterpolate
})
sqleng.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
return x, nil
}
origInterpolate := sqleng.Interpolate
sqleng.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
return sql, nil
}
@ -149,18 +150,13 @@ func TestPostgres(t *testing.T) {
JsonData: simplejson.New(),
SecureJsonData: securejsondata.SecureJsonData{},
})
So(err, ShouldBeNil)
require.NoError(t, err)
sess := x.NewSession()
t.Cleanup(sess.Close)
fromStart := time.Date(2018, 3, 15, 13, 0, 0, 0, time.UTC).In(time.Local)
Reset(func() {
sess.Close()
sqleng.NewXormEngine = origXormEngine
sqleng.Interpolate = origInterpolate
})
Convey("Given a table with different native data types", func() {
t.Run("Given a table with different native data types", func(t *testing.T) {
sql := `
DROP TABLE IF EXISTS postgres_types;
CREATE TABLE postgres_types(
@ -187,7 +183,7 @@ func TestPostgres(t *testing.T) {
);
`
_, err := sess.Exec(sql)
So(err, ShouldBeNil)
require.NoError(t, err)
sql = `
INSERT INTO postgres_types VALUES(
@ -199,9 +195,9 @@ func TestPostgres(t *testing.T) {
);
`
_, err = sess.Exec(sql)
So(err, ShouldBeNil)
require.NoError(t, err)
Convey("When doing a table query should map Postgres column types to Go types", func() {
t.Run("When doing a table query should map Postgres column types to Go types", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -215,35 +211,40 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
column := queryResult.Tables[0].Rows[0]
So(column[0].(int64), ShouldEqual, 1)
So(column[1].(int64), ShouldEqual, 2)
So(column[2].(int64), ShouldEqual, 3)
require.Equal(t, int64(1), column[0].(int64))
require.Equal(t, int64(2), column[1].(int64))
require.Equal(t, int64(3), column[2].(int64))
So(column[3].(float64), ShouldEqual, 4.5)
So(column[4].(float64), ShouldEqual, 6.7)
So(column[5].(float64), ShouldEqual, 1.1)
So(column[6].(float64), ShouldEqual, 1.2)
require.Equal(t, float64(4.5), column[3].(float64))
require.Equal(t, float64(6.7), column[4].(float64))
require.Equal(t, float64(1.1), column[5].(float64))
require.Equal(t, float64(1.2), column[6].(float64))
So(column[7].(string), ShouldEqual, "char10 ")
So(column[8].(string), ShouldEqual, "varchar10")
So(column[9].(string), ShouldEqual, "text")
require.Equal(t, "char10 ", column[7].(string))
require.Equal(t, "varchar10", column[8].(string))
require.Equal(t, "text", column[9].(string))
So(column[10].(time.Time), ShouldHaveSameTypeAs, time.Now())
So(column[11].(time.Time), ShouldHaveSameTypeAs, time.Now())
So(column[12].(time.Time), ShouldHaveSameTypeAs, time.Now())
So(column[13].(time.Time), ShouldHaveSameTypeAs, time.Now())
So(column[14].(time.Time), ShouldHaveSameTypeAs, time.Now())
_, ok := column[10].(time.Time)
require.True(t, ok)
_, ok = column[11].(time.Time)
require.True(t, ok)
_, ok = column[12].(time.Time)
require.True(t, ok)
_, ok = column[13].(time.Time)
require.True(t, ok)
_, ok = column[14].(time.Time)
require.True(t, ok)
So(column[15].(string), ShouldEqual, "00:15:00")
require.Equal(t, "00:15:00", column[15].(string))
})
})
Convey("Given a table with metrics that lacks data for some series ", func() {
t.Run("Given a table with metrics that lacks data for some series ", func(t *testing.T) {
sql := `
DROP TABLE IF EXISTS metric;
CREATE TABLE metric (
@ -253,7 +254,7 @@ func TestPostgres(t *testing.T) {
`
_, err := sess.Exec(sql)
So(err, ShouldBeNil)
require.NoError(t, err)
type metric struct {
Time time.Time
@ -279,9 +280,9 @@ func TestPostgres(t *testing.T) {
}
_, err = sess.InsertMulti(series)
So(err, ShouldBeNil)
require.NoError(t, err)
Convey("When doing a metric query using timeGroup", func() {
t.Run("When doing a metric query using timeGroup", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -295,22 +296,22 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
points := queryResult.Series[0].Points
// without fill this should result in 4 buckets
So(len(points), ShouldEqual, 4)
require.Len(t, points, 4)
dt := fromStart
for i := 0; i < 2; i++ {
aValue := points[i][0].Float64
aTime := time.Unix(int64(points[i][1].Float64)/1000, 0)
So(aValue, ShouldEqual, 15)
So(aTime, ShouldEqual, dt)
So(aTime.Unix()%300, ShouldEqual, 0)
require.Equal(t, float64(15), aValue)
require.Equal(t, dt, aTime)
require.Equal(t, int64(0), aTime.Unix()%300)
dt = dt.Add(5 * time.Minute)
}
@ -319,21 +320,19 @@ func TestPostgres(t *testing.T) {
for i := 2; i < 4; i++ {
aValue := points[i][0].Float64
aTime := time.Unix(int64(points[i][1].Float64)/1000, 0)
So(aValue, ShouldEqual, 20)
So(aTime, ShouldEqual, dt)
require.Equal(t, float64(20), aValue)
require.Equal(t, dt, aTime)
dt = dt.Add(5 * time.Minute)
}
})
Convey("When doing a metric query using timeGroup and $__interval", func() {
t.Run("When doing a metric query using timeGroup and $__interval", func(t *testing.T) {
mockInterpolate := sqleng.Interpolate
sqleng.Interpolate = origInterpolate
Reset(func() {
t.Cleanup(func() {
sqleng.Interpolate = mockInterpolate
})
Convey("Should replace $__interval", func() {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -352,14 +351,15 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(queryResult.Meta.Get(sqleng.MetaKeyExecutedQueryString).MustString(), ShouldEqual, "SELECT floor(extract(epoch from time)/60)*60 AS time, avg(value) as value FROM metric GROUP BY 1 ORDER BY 1")
})
require.NoError(t, queryResult.Error)
require.Equal(t,
"SELECT floor(extract(epoch from time)/60)*60 AS time, avg(value) as value FROM metric GROUP BY 1 ORDER BY 1",
queryResult.Meta.Get(sqleng.MetaKeyExecutedQueryString).MustString())
})
Convey("When doing a metric query using timeGroup with NULL fill enabled", func() {
t.Run("When doing a metric query using timeGroup with NULL fill enabled", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -377,42 +377,42 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
points := queryResult.Series[0].Points
So(len(points), ShouldEqual, 7)
require.Len(t, points, 7)
dt := fromStart
for i := 0; i < 2; i++ {
aValue := points[i][0].Float64
aTime := time.Unix(int64(points[i][1].Float64)/1000, 0)
So(aValue, ShouldEqual, 15)
So(aTime, ShouldEqual, dt)
require.Equal(t, float64(15), aValue)
require.Equal(t, dt, aTime)
dt = dt.Add(5 * time.Minute)
}
// check for NULL values inserted by fill
So(points[2][0].Valid, ShouldBeFalse)
So(points[3][0].Valid, ShouldBeFalse)
require.False(t, points[2][0].Valid)
require.False(t, points[3][0].Valid)
// adjust for 10 minute gap between first and second set of points
dt = dt.Add(10 * time.Minute)
for i := 4; i < 6; i++ {
aValue := points[i][0].Float64
aTime := time.Unix(int64(points[i][1].Float64)/1000, 0)
So(aValue, ShouldEqual, 20)
So(aTime, ShouldEqual, dt)
require.Equal(t, float64(20), aValue)
require.Equal(t, dt, aTime)
dt = dt.Add(5 * time.Minute)
}
// check for NULL values inserted by fill
So(points[6][0].Valid, ShouldBeFalse)
require.False(t, points[6][0].Valid)
})
Convey("When doing a metric query using timeGroup with value fill enabled", func() {
t.Run("When doing a metric query using timeGroup with value fill enabled", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -430,16 +430,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
points := queryResult.Series[0].Points
So(points[3][0].Float64, ShouldEqual, 1.5)
require.Equal(t, float64(1.5), points[3][0].Float64)
})
})
Convey("When doing a metric query using timeGroup with previous fill enabled", func() {
t.Run("When doing a metric query using timeGroup with previous fill enabled", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -457,17 +457,17 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
points := queryResult.Series[0].Points
So(points[2][0].Float64, ShouldEqual, 15.0)
So(points[3][0].Float64, ShouldEqual, 15.0)
So(points[6][0].Float64, ShouldEqual, 20.0)
require.Equal(t, float64(15.0), points[2][0].Float64)
require.Equal(t, float64(15.0), points[3][0].Float64)
require.Equal(t, float64(20.0), points[6][0].Float64)
})
Convey("Given a table with metrics having multiple values and measurements", func() {
t.Run("Given a table with metrics having multiple values and measurements", func(t *testing.T) {
type metric_values struct {
Time time.Time
TimeInt64 int64 `xorm:"bigint 'timeInt64' not null"`
@ -484,12 +484,12 @@ func TestPostgres(t *testing.T) {
}
if exist, err := sess.IsTableExist(metric_values{}); err != nil || exist {
So(err, ShouldBeNil)
require.NoError(t, err)
err = sess.DropTable(metric_values{})
So(err, ShouldBeNil)
require.NoError(t, err)
}
err := sess.CreateTable(metric_values{})
So(err, ShouldBeNil)
require.NoError(t, err)
rand.Seed(time.Now().Unix())
rnd := func(min, max int64) int64 {
@ -532,9 +532,11 @@ func TestPostgres(t *testing.T) {
}
_, err = sess.InsertMulti(series)
So(err, ShouldBeNil)
require.NoError(t, err)
Convey("When doing a metric query using epoch (int64) as time column and value column (int64) should return metric with time in milliseconds", func() {
t.Run(
"When doing a metric query using epoch (int64) as time column and value column (int64) should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -548,15 +550,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(tInitial.UnixNano()/1e6))
require.Equal(t, 1, len(queryResult.Series))
require.Equal(t, float64(tInitial.UnixNano()/1e6), queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query using epoch (int64 nullable) as time column and value column (int64 nullable) should return metric with time in milliseconds", func() {
t.Run("When doing a metric query using epoch (int64 nullable) as time column and value column (int64 nullable,) should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -570,15 +573,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(tInitial.UnixNano()/1e6))
require.Len(t, queryResult.Series, 1)
require.Equal(t, float64(tInitial.UnixNano()/1e6), queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query using epoch (float64) as time column and value column (float64) should return metric with time in milliseconds", func() {
t.Run("When doing a metric query using epoch (float64) as time column and value column (float64), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -592,15 +596,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(tInitial.UnixNano()/1e6))
require.Len(t, queryResult.Series, 1)
require.Equal(t, float64(tInitial.UnixNano()/1e6), queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query using epoch (float64 nullable) as time column and value column (float64 nullable) should return metric with time in milliseconds", func() {
t.Run("When doing a metric query using epoch (float64 nullable) as time column and value column (float64 nullable), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -614,15 +619,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(tInitial.UnixNano()/1e6))
require.Len(t, queryResult.Series, 1)
require.Equal(t, float64(tInitial.UnixNano()/1e6), queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query using epoch (int32) as time column and value column (int32) should return metric with time in milliseconds", func() {
t.Run("When doing a metric query using epoch (int32) as time column and value column (int32), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -636,15 +642,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(tInitial.UnixNano()/1e6))
require.Len(t, queryResult.Series, 1)
require.Equal(t, float64(tInitial.UnixNano()/1e6), queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query using epoch (int32 nullable) as time column and value column (int32 nullable) should return metric with time in milliseconds", func() {
t.Run("When doing a metric query using epoch (int32 nullable) as time column and value column (int32 nullable), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -658,15 +665,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(tInitial.UnixNano()/1e6))
require.Len(t, queryResult.Series, 1)
require.Equal(t, float64(tInitial.UnixNano()/1e6), queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query using epoch (float32) as time column and value column (float32) should return metric with time in milliseconds", func() {
t.Run("When doing a metric query using epoch (float32) as time column and value column (float32), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -680,15 +688,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(float32(tInitial.Unix()))*1e3)
require.Len(t, queryResult.Series, 1)
require.Equal(t, float64(float32(tInitial.Unix()))*1e3, queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query using epoch (float32 nullable) as time column and value column (float32 nullable) should return metric with time in milliseconds", func() {
t.Run("When doing a metric query using epoch (float32 nullable) as time column and value column (float32 nullable), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -702,15 +711,15 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 1)
So(queryResult.Series[0].Points[0][1].Float64, ShouldEqual, float64(float32(tInitial.Unix()))*1e3)
require.Len(t, queryResult.Series, 1)
require.Equal(t, float64(float32(tInitial.Unix()))*1e3, queryResult.Series[0].Points[0][1].Float64)
})
Convey("When doing a metric query grouping by time and select metric column should return correct series", func() {
t.Run("When doing a metric query grouping by time and select metric column should return correct series", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -724,16 +733,16 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 2)
So(queryResult.Series[0].Name, ShouldEqual, "Metric A - value one")
So(queryResult.Series[1].Name, ShouldEqual, "Metric B - value one")
require.Len(t, queryResult.Series, 2)
require.Equal(t, "Metric A - value one", queryResult.Series[0].Name)
require.Equal(t, "Metric B - value one", queryResult.Series[1].Name)
})
Convey("When doing a metric query with metric column and multiple value columns", func() {
t.Run("When doing a metric query with metric column and multiple value columns", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -747,18 +756,18 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 4)
So(queryResult.Series[0].Name, ShouldEqual, "Metric A valueOne")
So(queryResult.Series[1].Name, ShouldEqual, "Metric A valueTwo")
So(queryResult.Series[2].Name, ShouldEqual, "Metric B valueOne")
So(queryResult.Series[3].Name, ShouldEqual, "Metric B valueTwo")
require.Len(t, queryResult.Series, 4)
require.Equal(t, "Metric A valueOne", queryResult.Series[0].Name)
require.Equal(t, "Metric A valueTwo", queryResult.Series[1].Name)
require.Equal(t, "Metric B valueOne", queryResult.Series[2].Name)
require.Equal(t, "Metric B valueTwo", queryResult.Series[3].Name)
})
Convey("When doing a metric query grouping by time should return correct series", func() {
t.Run("When doing a metric query grouping by time should return correct series", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -772,17 +781,22 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
require.NoError(t, queryResult.Error)
So(len(queryResult.Series), ShouldEqual, 2)
So(queryResult.Series[0].Name, ShouldEqual, "valueOne")
So(queryResult.Series[1].Name, ShouldEqual, "valueTwo")
require.Len(t, queryResult.Series, 2)
require.Equal(t, "valueOne", queryResult.Series[0].Name)
require.Equal(t, "valueTwo", queryResult.Series[1].Name)
})
Convey("When doing a query with timeFrom,timeTo,unixEpochFrom,unixEpochTo macros", func() {
t.Run("When doing a query with timeFrom,timeTo,unixEpochFrom,unixEpochTo macros", func(t *testing.T) {
fakeInterpolate := sqleng.Interpolate
t.Cleanup(func() {
sqleng.Interpolate = fakeInterpolate
})
sqleng.Interpolate = origInterpolate
query := &tsdb.TsdbQuery{
TimeRange: tsdb.NewFakeTimeRange("5m", "now", fromStart),
Queries: []*tsdb.Query{
@ -798,27 +812,29 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(queryResult.Meta.Get(sqleng.MetaKeyExecutedQueryString).MustString(), ShouldEqual, "SELECT time FROM metric_values WHERE time > '2018-03-15T12:55:00Z' OR time < '2018-03-15T12:55:00Z' OR 1 < 1521118500 OR 1521118800 > 1 ORDER BY 1")
require.NoError(t, queryResult.Error)
require.Equal(t,
"SELECT time FROM metric_values WHERE time > '2018-03-15T12:55:00Z' OR time < '2018-03-15T12:55:00Z' OR 1 < 1521118500 OR 1521118800 > 1 ORDER BY 1",
queryResult.Meta.Get(sqleng.MetaKeyExecutedQueryString).MustString())
})
})
Convey("Given a table with event data", func() {
t.Run("Given a table with event data", func(t *testing.T) {
type event struct {
TimeSec int64
Description string
Tags string
}
if exist, err := sess.IsTableExist(event{}); err != nil || exist {
So(err, ShouldBeNil)
err = sess.DropTable(event{})
So(err, ShouldBeNil)
if exists, err := sess.IsTableExist(event{}); err != nil || exists {
require.NoError(t, err)
err := sess.DropTable(event{})
require.NoError(t, err)
}
err := sess.CreateTable(event{})
So(err, ShouldBeNil)
require.NoError(t, err)
events := []*event{}
for _, t := range genTimeRangeByInterval(fromStart.Add(-20*time.Minute), 60*time.Minute, 25*time.Minute) {
@ -835,11 +851,11 @@ func TestPostgres(t *testing.T) {
}
for _, e := range events {
_, err = sess.Insert(e)
So(err, ShouldBeNil)
_, err := sess.Insert(e)
require.NoError(t, err)
}
Convey("When doing an annotation query of deploy events should return expected result", func() {
t.Run("When doing an annotation query of deploy events should return expected result", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -858,11 +874,11 @@ func TestPostgres(t *testing.T) {
resp, err := endpoint.Query(context.Background(), nil, query)
queryResult := resp.Results["Deploys"]
So(err, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 3)
require.NoError(t, err)
require.Len(t, queryResult.Tables[0].Rows, 3)
})
Convey("When doing an annotation query of ticket events should return expected result", func() {
t.Run("When doing an annotation query of ticket events should return expected result", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -881,11 +897,11 @@ func TestPostgres(t *testing.T) {
resp, err := endpoint.Query(context.Background(), nil, query)
queryResult := resp.Results["Tickets"]
So(err, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 3)
require.NoError(t, err)
require.Len(t, queryResult.Tables[0].Rows, 3)
})
Convey("When doing an annotation query with a time column in datetime format", func() {
t.Run("When doing an annotation query with a time column in datetime format", func(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
dtFormat := "2006-01-02 15:04:05.999999999"
@ -906,17 +922,17 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 1)
require.NoError(t, queryResult.Error)
require.Len(t, queryResult.Tables[0].Rows, 1)
columns := queryResult.Tables[0].Rows[0]
//Should be in milliseconds
So(columns[0].(float64), ShouldEqual, float64(dt.UnixNano()/1e6))
require.Equal(t, float64(dt.UnixNano()/1e6), columns[0].(float64))
})
Convey("When doing an annotation query with a time column in epoch second format should return ms", func() {
t.Run("When doing an annotation query with a time column in epoch second format should return ms", func(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
query := &tsdb.TsdbQuery{
@ -936,17 +952,17 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 1)
require.NoError(t, queryResult.Error)
require.Len(t, queryResult.Tables[0].Rows, 1)
columns := queryResult.Tables[0].Rows[0]
//Should be in milliseconds
So(columns[0].(int64), ShouldEqual, dt.Unix()*1000)
require.Equal(t, dt.Unix()*1000, columns[0].(int64))
})
Convey("When doing an annotation query with a time column in epoch second format (int) should return ms", func() {
t.Run("When doing an annotation query with a time column in epoch second format (t *testing.Tint) should return ms", func(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
query := &tsdb.TsdbQuery{
@ -966,17 +982,17 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 1)
require.NoError(t, queryResult.Error)
require.Len(t, queryResult.Tables[0].Rows, 1)
columns := queryResult.Tables[0].Rows[0]
//Should be in milliseconds
So(columns[0].(int64), ShouldEqual, dt.Unix()*1000)
require.Equal(t, dt.Unix()*1000, columns[0].(int64))
})
Convey("When doing an annotation query with a time column in epoch millisecond format should return ms", func() {
t.Run("When doing an annotation query with a time column in epoch millisecond format should return ms", func(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
query := &tsdb.TsdbQuery{
@ -996,17 +1012,17 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 1)
require.NoError(t, queryResult.Error)
require.Len(t, queryResult.Tables[0].Rows, 1)
columns := queryResult.Tables[0].Rows[0]
//Should be in milliseconds
So(columns[0].(int64), ShouldEqual, dt.Unix()*1000)
require.Equal(t, dt.Unix()*1000, columns[0].(int64))
})
Convey("When doing an annotation query with a time column holding a bigint null value should return nil", func() {
t.Run("When doing an annotation query with a time column holding a bigint null value should return nil", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -1024,17 +1040,17 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 1)
require.NoError(t, queryResult.Error)
require.Len(t, queryResult.Tables[0].Rows, 1)
columns := queryResult.Tables[0].Rows[0]
//Should be in milliseconds
So(columns[0], ShouldBeNil)
require.Nil(t, columns[0])
})
Convey("When doing an annotation query with a time column holding a timestamp null value should return nil", func() {
t.Run("When doing an annotation query with a time column holding a timestamp null value should return nil", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
{
@ -1052,15 +1068,14 @@ func TestPostgres(t *testing.T) {
}
resp, err := endpoint.Query(context.Background(), nil, query)
So(err, ShouldBeNil)
require.NoError(t, err)
queryResult := resp.Results["A"]
So(queryResult.Error, ShouldBeNil)
So(len(queryResult.Tables[0].Rows), ShouldEqual, 1)
require.NoError(t, queryResult.Error)
require.Len(t, queryResult.Tables[0].Rows, 1)
columns := queryResult.Tables[0].Rows[0]
//Should be in milliseconds
So(columns[0], ShouldBeNil)
})
assert.Nil(t, columns[0])
})
})
}