// Ensure a time duration can be formatted. func TestFormatDuration(t *testing.T) { var tests = []struct { d time.Duration s string }{ {d: 3 * time.Microsecond, s: `3`}, {d: 1001 * time.Microsecond, s: `1001`}, {d: 15 * time.Millisecond, s: `15ms`}, {d: 100 * time.Second, s: `100s`}, {d: 2 * time.Minute, s: `2m`}, {d: 2 * time.Hour, s: `2h`}, {d: 2 * 24 * time.Hour, s: `2d`}, {d: 2 * 7 * 24 * time.Hour, s: `2w`}, } for i, tt := range tests { s := influxql.FormatDuration(tt.d) if tt.s != s { t.Errorf("%d. %v: mismatch: %s != %s", i, tt.d, tt.s, s) } } }
func TestContinuousQueryService_ResampleOptions(t *testing.T) { s := NewTestService(t) mc := NewMetaClient(t) mc.CreateDatabase("db", "") mc.CreateContinuousQuery("db", "cq", `CREATE CONTINUOUS QUERY cq ON db RESAMPLE EVERY 10s FOR 2m BEGIN SELECT mean(value) INTO cpu_mean FROM cpu GROUP BY time(1m) END`) s.MetaClient = mc db, err := s.MetaClient.Database("db") if err != nil { t.Fatal(err) } cq, err := NewContinuousQuery(db.Name, &db.ContinuousQueries[0]) if err != nil { t.Fatal(err) } else if cq.Resample.Every != 10*time.Second { t.Errorf("expected resample every to be 10s, got %s", influxql.FormatDuration(cq.Resample.Every)) } else if cq.Resample.For != 2*time.Minute { t.Errorf("expected resample for 2m, got %s", influxql.FormatDuration(cq.Resample.For)) } // Set RunInterval high so we can trigger using Run method. s.RunInterval = 10 * time.Minute done := make(chan struct{}) expectCallCnt := 0 callCnt := 0 // Set a callback for ExecuteQuery. qe := s.QueryExecutor.(*QueryExecutor) qe.ExecuteQueryFn = func(query *influxql.Query, database string, chunkSize int, closing chan struct{}) (<-chan *influxql.Result, error) { callCnt++ if callCnt >= expectCallCnt { done <- struct{}{} } dummych := make(chan *influxql.Result, 1) dummych <- &influxql.Result{} return dummych, nil } s.Open() defer s.Close() // Set the 'now' time to the start of a 10 minute interval. Then trigger a run. // This should trigger two queries (one for the current time interval, one for the previous). now := time.Now().Truncate(10 * time.Minute) expectCallCnt += 2 s.RunCh <- &RunRequest{Now: now} if err := wait(done, 100*time.Millisecond); err != nil { t.Fatal(err) } // Trigger another run 10 seconds later. Another two queries should happen, // but it will be a different two queries. expectCallCnt += 2 s.RunCh <- &RunRequest{Now: now.Add(10 * time.Second)} if err := wait(done, 100*time.Millisecond); err != nil { t.Fatal(err) } // Reset the time period and send the initial request at 5 seconds after the // 10 minute mark. There should be exactly one call since the current interval is too // young and only one interval matches the FOR duration. expectCallCnt += 1 s.Run("", "", now.Add(5*time.Second)) if err := wait(done, 100*time.Millisecond); err != nil { t.Fatal(err) } // No overflow should be sent. if err := wait(done, 100*time.Millisecond); err == nil { t.Error("too many queries executed") } }