Emmanuel BENOîT
c46c9d76d9
This PR adds the `check_output_matches` plugin, which can be used to count regexp or substring matches from either text files or command outputs and determine the final status based on the amount of matches that were found. Reviewed-on: #5 Co-authored-by: Emmanuel BENOÎT <tseeker@nocternity.net> Co-committed-by: Emmanuel BENOÎT <tseeker@nocternity.net>
323 lines
6.5 KiB
Go
323 lines
6.5 KiB
Go
package perfdata
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"nocternity.net/gomonop/pkg/status"
|
|
)
|
|
|
|
func TestNewNoValue(t *testing.T) {
|
|
const label = "label"
|
|
const units = UomNone
|
|
|
|
out := New(label, units, "")
|
|
|
|
assert.Equal(t, label, out.Label)
|
|
assert.Equal(t, units, out.units)
|
|
assert.Equal(t, perfDataBits(0), out.bits)
|
|
assert.Equal(t, "U", out.value)
|
|
// min, max, warn and crit are meaningless here
|
|
}
|
|
|
|
func TestNewValidValue(t *testing.T) {
|
|
const label = "label"
|
|
const units = UomNone
|
|
const value = "1234"
|
|
|
|
out := New(label, units, value)
|
|
|
|
assert.Equal(t, label, out.Label)
|
|
assert.Equal(t, units, out.units)
|
|
assert.Equal(t, perfDataBits(0), out.bits)
|
|
assert.Equal(t, value, out.value)
|
|
// min, max, warn and crit are meaningless here
|
|
}
|
|
|
|
func TestNewInvalidValue(t *testing.T) {
|
|
assert.Panics(t, func() { New("label", UomNone, "nope") })
|
|
}
|
|
|
|
func TestSetWarn(t *testing.T) {
|
|
rangeValue := Range{start: "A", end: "B"}
|
|
rangeStr := rangeValue.String()
|
|
|
|
data := PerfData{}
|
|
data.SetWarn(&rangeValue)
|
|
|
|
assert.True(t, data.bits&PDatWarn != 0)
|
|
assert.Equal(t, rangeStr, data.warn.String())
|
|
}
|
|
|
|
func TestSetWarnNil(t *testing.T) {
|
|
data := PerfData{}
|
|
data.SetWarn(nil)
|
|
assert.Equal(t, perfDataBits(0), data.bits&PDatWarn)
|
|
}
|
|
|
|
func TestSetWarnTwice(t *testing.T) {
|
|
range1Value := Range{start: "A", end: "B"}
|
|
range2Value := Range{start: "C", end: "D"}
|
|
range2Str := range2Value.String()
|
|
require.NotEqual(t, range2Str, range1Value.String())
|
|
|
|
data := PerfData{}
|
|
data.SetWarn(&range1Value)
|
|
data.SetWarn(&range2Value)
|
|
|
|
assert.True(t, data.bits&PDatWarn != 0)
|
|
assert.Equal(t, range2Str, data.warn.String())
|
|
}
|
|
|
|
func TestSetWarnClear(t *testing.T) {
|
|
range1Value := Range{start: "A", end: "B"}
|
|
|
|
data := PerfData{}
|
|
data.SetWarn(&range1Value)
|
|
data.SetWarn(nil)
|
|
|
|
assert.Equal(t, perfDataBits(0), data.bits&PDatWarn)
|
|
}
|
|
|
|
func TestSetCrit(t *testing.T) {
|
|
rangeValue := Range{start: "A", end: "B"}
|
|
rangeStr := rangeValue.String()
|
|
|
|
data := PerfData{}
|
|
data.SetCrit(&rangeValue)
|
|
|
|
assert.True(t, data.bits&PDatCrit != 0)
|
|
assert.Equal(t, rangeStr, data.crit.String())
|
|
}
|
|
|
|
func TestSetCritNil(t *testing.T) {
|
|
data := PerfData{}
|
|
data.SetCrit(nil)
|
|
assert.Equal(t, perfDataBits(0), data.bits&PDatCrit)
|
|
}
|
|
|
|
func TestSetCritTwice(t *testing.T) {
|
|
range1Value := Range{start: "A", end: "B"}
|
|
range2Value := Range{start: "C", end: "D"}
|
|
range2Str := range2Value.String()
|
|
require.NotEqual(t, range2Str, range1Value.String())
|
|
|
|
data := PerfData{}
|
|
data.SetCrit(&range1Value)
|
|
data.SetCrit(&range2Value)
|
|
|
|
assert.True(t, data.bits&PDatCrit != 0)
|
|
assert.Equal(t, range2Str, data.crit.String())
|
|
}
|
|
|
|
func TestSetCritClear(t *testing.T) {
|
|
range1Value := Range{start: "A", end: "B"}
|
|
|
|
data := PerfData{}
|
|
data.SetCrit(&range1Value)
|
|
data.SetCrit(nil)
|
|
|
|
assert.Equal(t, perfDataBits(0), data.bits&PDatCrit)
|
|
}
|
|
|
|
func TestSetMin(t *testing.T) {
|
|
const min = "100"
|
|
|
|
data := PerfData{}
|
|
data.SetMin(min)
|
|
|
|
assert.True(t, data.bits&PDatMin != 0)
|
|
assert.Equal(t, min, data.min)
|
|
}
|
|
|
|
func TestSetMinInvalid(t *testing.T) {
|
|
data := PerfData{}
|
|
assert.Panics(t, func() { data.SetMin("nope") })
|
|
}
|
|
|
|
func TestSetMinTwice(t *testing.T) {
|
|
data := PerfData{}
|
|
data.SetMin("100")
|
|
data.SetMin("200")
|
|
assert.Equal(t, "200", data.min)
|
|
assert.True(t, data.bits&PDatMin != 0)
|
|
}
|
|
|
|
func TestSetMax(t *testing.T) {
|
|
const max = "100"
|
|
|
|
data := PerfData{}
|
|
data.SetMax(max)
|
|
|
|
assert.True(t, data.bits&PDatMax != 0)
|
|
assert.Equal(t, max, data.max)
|
|
}
|
|
|
|
func TestSetMaxInvalid(t *testing.T) {
|
|
data := PerfData{}
|
|
assert.Panics(t, func() { data.SetMax("nope") })
|
|
}
|
|
|
|
func TestSetMaxTwice(t *testing.T) {
|
|
data := PerfData{}
|
|
data.SetMax("100")
|
|
data.SetMax("200")
|
|
assert.Equal(t, "200", data.max)
|
|
assert.True(t, data.bits&PDatMax != 0)
|
|
}
|
|
|
|
func TestCheck(t *testing.T) {
|
|
warnRange := RangeMinMax("0", "10").Inside()
|
|
critRange := RangeMinMax("1", "9").Inside()
|
|
|
|
type Test struct {
|
|
in string
|
|
out status.Status
|
|
}
|
|
|
|
tests := []Test{
|
|
{in: "moo", out: status.StatusUnknown},
|
|
{in: "-1", out: status.StatusOK},
|
|
{in: "0", out: status.StatusWarning},
|
|
{in: "1", out: status.StatusCritical},
|
|
{in: "9", out: status.StatusCritical},
|
|
{in: "10", out: status.StatusWarning},
|
|
{in: "11", out: status.StatusOK},
|
|
}
|
|
for _, test := range tests {
|
|
pdat := PerfData{
|
|
value: test.in,
|
|
bits: PDatCrit | PDatWarn,
|
|
warn: *warnRange,
|
|
crit: *critRange,
|
|
}
|
|
assert.Equal(t, test.out, pdat.GetStatus())
|
|
}
|
|
}
|
|
|
|
func TestString(t *testing.T) {
|
|
type Test struct {
|
|
PerfData
|
|
expected string
|
|
}
|
|
|
|
range1 := Range{start: "A", end: "B"}
|
|
range2 := Range{start: "C", end: "D"}
|
|
|
|
tests := []Test{
|
|
{
|
|
PerfData{
|
|
Label: "label",
|
|
units: UomNone,
|
|
bits: perfDataBits(0),
|
|
value: "1234",
|
|
},
|
|
"label=1234;;;;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "la=bel",
|
|
units: UomNone,
|
|
bits: perfDataBits(0),
|
|
value: "1234",
|
|
},
|
|
"'la=bel'=1234;;;;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "la bel",
|
|
units: UomNone,
|
|
bits: perfDataBits(0),
|
|
value: "1234",
|
|
},
|
|
"'la bel'=1234;;;;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "la\"bel",
|
|
units: UomNone,
|
|
bits: perfDataBits(0),
|
|
value: "1234",
|
|
},
|
|
"'la\"bel'=1234;;;;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "la'bel",
|
|
units: UomNone,
|
|
bits: perfDataBits(0),
|
|
value: "1234",
|
|
},
|
|
"'la''bel'=1234;;;;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "label",
|
|
units: UomNone,
|
|
bits: PDatWarn,
|
|
value: "1234",
|
|
warn: range1,
|
|
},
|
|
"label=1234;" + range1.String() + ";;;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "label",
|
|
units: UomNone,
|
|
bits: PDatCrit,
|
|
value: "1234",
|
|
crit: range1,
|
|
},
|
|
"label=1234;;" + range1.String() + ";;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "label",
|
|
units: UomNone,
|
|
bits: PDatWarn | PDatCrit,
|
|
value: "1234",
|
|
warn: range1,
|
|
crit: range2,
|
|
},
|
|
"label=1234;" + range1.String() + ";" + range2.String() + ";;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "label",
|
|
units: UomNone,
|
|
bits: PDatMin,
|
|
value: "1234",
|
|
min: "X",
|
|
},
|
|
"label=1234;;;X;",
|
|
},
|
|
{
|
|
PerfData{
|
|
Label: "label",
|
|
units: UomNone,
|
|
bits: PDatMax,
|
|
value: "1234",
|
|
max: "Y",
|
|
},
|
|
"label=1234;;;;Y",
|
|
},
|
|
}
|
|
|
|
for _, units := range []UnitOfMeasurement{UomSeconds, UomPercent, UomBytes, UomKilobytes, UomMegabytes, UomGigabytes, UomTerabytes, UomCounter} {
|
|
tests = append(tests, Test{
|
|
PerfData{
|
|
Label: "label",
|
|
units: units,
|
|
bits: perfDataBits(0),
|
|
value: "1234",
|
|
},
|
|
fmt.Sprintf("label=1234%s;;;;", units),
|
|
})
|
|
}
|
|
|
|
for _, test := range tests {
|
|
assert.Equal(t, test.expected, test.PerfData.String())
|
|
}
|
|
}
|