telegraf/plugins/exec/exec_test.go

263 lines
5.7 KiB
Go
Raw Normal View History

2015-08-06 00:29:27 +00:00
package exec
import (
"fmt"
"github.com/influxdb/telegraf/testutil"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
2015-09-23 18:21:42 +00:00
"math"
2015-08-06 00:29:27 +00:00
"testing"
2015-09-23 18:21:42 +00:00
"time"
2015-08-06 00:29:27 +00:00
)
2015-09-23 18:21:42 +00:00
// Midnight 9/22/2015
const baseTimeSeconds = 1442905200
2015-08-06 00:29:27 +00:00
const validJson = `
{
"status": "green",
"num_processes": 82,
"cpu": {
"status": "red",
"nil_status": null,
2015-08-06 00:29:27 +00:00
"used": 8234,
"free": 32
},
"percent": 0.81,
"users": [0, 1, 2, 3]
}`
const malformedJson = `
{
"status": "green",
`
type runnerMock struct {
out []byte
err error
}
2015-09-23 18:21:42 +00:00
type clockMock struct {
now time.Time
}
2015-08-06 00:29:27 +00:00
func newRunnerMock(out []byte, err error) Runner {
2015-09-23 18:21:42 +00:00
return &runnerMock{
out: out,
err: err,
}
2015-08-06 00:29:27 +00:00
}
2015-09-23 18:21:42 +00:00
func (r runnerMock) Run(command *Command) ([]byte, error) {
2015-08-06 00:29:27 +00:00
if r.err != nil {
return nil, r.err
}
return r.out, nil
}
2015-09-23 18:21:42 +00:00
func newClockMock(now time.Time) Clock {
return &clockMock{now: now}
}
func (c clockMock) Now() time.Time {
return c.now
}
2015-08-06 00:29:27 +00:00
func TestExec(t *testing.T) {
runner := newRunnerMock([]byte(validJson), nil)
2015-09-23 18:21:42 +00:00
clock := newClockMock(time.Unix(baseTimeSeconds+20, 0))
command := Command{
Command: "testcommand arg1",
Name: "mycollector",
Interval: 10,
lastRunAt: time.Unix(baseTimeSeconds, 0),
}
e := &Exec{
runner: runner,
clock: clock,
Commands: []*Command{&command},
}
2015-08-06 00:29:27 +00:00
var acc testutil.Accumulator
2015-09-23 18:21:42 +00:00
initialPoints := len(acc.Points)
2015-08-06 00:29:27 +00:00
err := e.Gather(&acc)
2015-09-23 18:21:42 +00:00
deltaPoints := len(acc.Points) - initialPoints
2015-08-06 00:29:27 +00:00
require.NoError(t, err)
checkFloat := []struct {
name string
value float64
}{
{"mycollector_num_processes", 82},
{"mycollector_cpu_used", 8234},
{"mycollector_cpu_free", 32},
{"mycollector_percent", 0.81},
}
for _, c := range checkFloat {
assert.True(t, acc.CheckValue(c.name, c.value))
}
2015-09-23 18:21:42 +00:00
assert.Equal(t, deltaPoints, 4, "non-numeric measurements should be ignored")
2015-08-06 00:29:27 +00:00
}
func TestExecMalformed(t *testing.T) {
runner := newRunnerMock([]byte(malformedJson), nil)
2015-09-23 18:21:42 +00:00
clock := newClockMock(time.Unix(baseTimeSeconds+20, 0))
command := Command{
Command: "badcommand arg1",
Name: "mycollector",
Interval: 10,
lastRunAt: time.Unix(baseTimeSeconds, 0),
}
e := &Exec{
runner: runner,
clock: clock,
Commands: []*Command{&command},
}
2015-08-06 00:29:27 +00:00
var acc testutil.Accumulator
2015-09-23 18:21:42 +00:00
initialPoints := len(acc.Points)
2015-08-06 00:29:27 +00:00
err := e.Gather(&acc)
2015-09-23 18:21:42 +00:00
deltaPoints := len(acc.Points) - initialPoints
2015-08-06 00:29:27 +00:00
require.Error(t, err)
2015-09-23 18:21:42 +00:00
assert.Equal(t, deltaPoints, 0, "No new points should have been added")
2015-08-06 00:29:27 +00:00
}
func TestCommandError(t *testing.T) {
runner := newRunnerMock(nil, fmt.Errorf("exit status code 1"))
2015-09-23 18:21:42 +00:00
clock := newClockMock(time.Unix(baseTimeSeconds+20, 0))
command := Command{
Command: "badcommand",
Name: "mycollector",
Interval: 10,
lastRunAt: time.Unix(baseTimeSeconds, 0),
}
e := &Exec{
runner: runner,
clock: clock,
Commands: []*Command{&command},
}
2015-08-06 00:29:27 +00:00
var acc testutil.Accumulator
2015-09-23 18:21:42 +00:00
initialPoints := len(acc.Points)
2015-08-06 00:29:27 +00:00
err := e.Gather(&acc)
2015-09-23 18:21:42 +00:00
deltaPoints := len(acc.Points) - initialPoints
2015-08-06 00:29:27 +00:00
require.Error(t, err)
2015-09-23 18:21:42 +00:00
assert.Equal(t, deltaPoints, 0, "No new points should have been added")
}
func TestExecNotEnoughTime(t *testing.T) {
runner := newRunnerMock([]byte(validJson), nil)
clock := newClockMock(time.Unix(baseTimeSeconds+5, 0))
command := Command{
Command: "testcommand arg1",
Name: "mycollector",
Interval: 10,
lastRunAt: time.Unix(baseTimeSeconds, 0),
}
e := &Exec{
runner: runner,
clock: clock,
Commands: []*Command{&command},
}
var acc testutil.Accumulator
initialPoints := len(acc.Points)
err := e.Gather(&acc)
deltaPoints := len(acc.Points) - initialPoints
require.NoError(t, err)
assert.Equal(t, deltaPoints, 0, "No new points should have been added")
}
func TestExecUninitializedLastRunAt(t *testing.T) {
runner := newRunnerMock([]byte(validJson), nil)
clock := newClockMock(time.Unix(baseTimeSeconds, 0))
command := Command{
Command: "testcommand arg1",
Name: "mycollector",
Interval: math.MaxInt32,
// Uninitialized lastRunAt should default to time.Unix(0, 0), so this should
// run no matter what the interval is
}
e := &Exec{
runner: runner,
clock: clock,
Commands: []*Command{&command},
}
var acc testutil.Accumulator
initialPoints := len(acc.Points)
err := e.Gather(&acc)
deltaPoints := len(acc.Points) - initialPoints
require.NoError(t, err)
checkFloat := []struct {
name string
value float64
}{
{"mycollector_num_processes", 82},
{"mycollector_cpu_used", 8234},
{"mycollector_cpu_free", 32},
{"mycollector_percent", 0.81},
}
for _, c := range checkFloat {
assert.True(t, acc.CheckValue(c.name, c.value))
}
assert.Equal(t, deltaPoints, 4, "non-numeric measurements should be ignored")
}
func TestExecOneNotEnoughTimeAndOneEnoughTime(t *testing.T) {
runner := newRunnerMock([]byte(validJson), nil)
clock := newClockMock(time.Unix(baseTimeSeconds+5, 0))
notEnoughTimeCommand := Command{
Command: "testcommand arg1",
Name: "mycollector",
Interval: 10,
lastRunAt: time.Unix(baseTimeSeconds, 0),
}
enoughTimeCommand := Command{
Command: "testcommand arg1",
Name: "mycollector",
Interval: 3,
lastRunAt: time.Unix(baseTimeSeconds, 0),
}
e := &Exec{
runner: runner,
clock: clock,
Commands: []*Command{&notEnoughTimeCommand, &enoughTimeCommand},
}
var acc testutil.Accumulator
initialPoints := len(acc.Points)
err := e.Gather(&acc)
deltaPoints := len(acc.Points) - initialPoints
require.NoError(t, err)
checkFloat := []struct {
name string
value float64
}{
{"mycollector_num_processes", 82},
{"mycollector_cpu_used", 8234},
{"mycollector_cpu_free", 32},
{"mycollector_percent", 0.81},
}
for _, c := range checkFloat {
assert.True(t, acc.CheckValue(c.name, c.value))
}
assert.Equal(t, deltaPoints, 4, "Only one command should have been run")
2015-08-06 00:29:27 +00:00
}