446 lines
16 KiB
Go
446 lines
16 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/url"
|
|
"regexp"
|
|
"testing"
|
|
"time"
|
|
|
|
simplejson "github.com/bitly/go-simplejson"
|
|
"github.com/grafana/grafana_plugin_model/go/datasource"
|
|
hclog "github.com/hashicorp/go-hclog"
|
|
"github.com/stretchr/testify/assert"
|
|
"golang.org/x/net/context"
|
|
)
|
|
|
|
type RoundTripFunc func(req *http.Request) *http.Response
|
|
|
|
func (f RoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
|
|
return f(req), nil
|
|
}
|
|
|
|
//NewTestClient returns *http.Client with Transport replaced to avoid making real calls
|
|
func NewTestClient(fn RoundTripFunc) *http.Client {
|
|
return &http.Client{
|
|
Transport: RoundTripFunc(fn),
|
|
}
|
|
}
|
|
|
|
var basicDatasourceInfo = &datasource.DatasourceInfo{
|
|
Id: 1,
|
|
Name: "TestDatasource",
|
|
Url: "http://zabbix.org/zabbix",
|
|
JsonData: `{"username":"username", "password":"password"}}`,
|
|
}
|
|
|
|
func mockDataSourceRequest(modelJSON string) *datasource.DatasourceRequest {
|
|
return &datasource.DatasourceRequest{
|
|
Datasource: basicDatasourceInfo,
|
|
Queries: []*datasource.Query{
|
|
&datasource.Query{
|
|
ModelJson: modelJSON,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func mockZabbixDataSource(body string, statusCode int) ZabbixDatasource {
|
|
apiUrl, _ := url.Parse(basicDatasourceInfo.Url)
|
|
return ZabbixDatasource{
|
|
url: apiUrl,
|
|
dsInfo: basicDatasourceInfo,
|
|
queryCache: NewCache(10*time.Minute, 10*time.Minute),
|
|
httpClient: NewTestClient(func(req *http.Request) *http.Response {
|
|
return &http.Response{
|
|
StatusCode: statusCode,
|
|
Body: ioutil.NopCloser(bytes.NewBufferString(body)),
|
|
Header: make(http.Header),
|
|
}
|
|
}),
|
|
authToken: "sampleAuthToken",
|
|
logger: hclog.Default(),
|
|
}
|
|
}
|
|
|
|
func TestZabbixAPIQuery(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp, err := zabbixDatasource.ZabbixAPIQuery(context.Background(), mockDataSourceRequest(`{"target":{"method":"Method","params":{"param1" : "Param1"}}}`))
|
|
|
|
assert.Equal(t, "\"sampleResult\"", resp.GetResults()[0].GetMetaJson())
|
|
assert.Equal(t, "zabbixAPI", resp.GetResults()[0].GetRefId())
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestZabbixAPIQueryEmptyQuery(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp, err := zabbixDatasource.ZabbixAPIQuery(context.Background(), mockDataSourceRequest(``))
|
|
|
|
assert.Nil(t, resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestZabbixAPIQueryNoQueries(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
basicDatasourceRequest := &datasource.DatasourceRequest{
|
|
Datasource: &datasource.DatasourceInfo{
|
|
Id: 1,
|
|
Name: "TestDatasource",
|
|
},
|
|
}
|
|
resp, err := zabbixDatasource.ZabbixAPIQuery(context.Background(), basicDatasourceRequest)
|
|
|
|
assert.Nil(t, resp)
|
|
assert.Equal(t, "At least one query should be provided", err.Error())
|
|
}
|
|
|
|
func TestZabbixAPIQueryError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 500)
|
|
resp, err := zabbixDatasource.ZabbixAPIQuery(context.Background(), mockDataSourceRequest(`{"target":{"method":"Method","params":{"param1" : "Param1"}}}`))
|
|
|
|
assert.Nil(t, resp)
|
|
assert.Equal(t, "ZabbixAPIQuery is not implemented yet", err.Error())
|
|
}
|
|
|
|
func TestLogin(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp, err := zabbixDatasource.login(context.Background(), "username", "password")
|
|
|
|
assert.Equal(t, "sampleResult", resp)
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestLoginError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 500)
|
|
resp, err := zabbixDatasource.login(context.Background(), "username", "password")
|
|
|
|
assert.Equal(t, "", resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestLoginWithDs(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
err := zabbixDatasource.loginWithDs(context.Background())
|
|
|
|
assert.Equal(t, "sampleResult", zabbixDatasource.authToken)
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestLoginWithDsError(t *testing.T) {
|
|
errResponse := `{"error":{"code":-32500,"message":"Application error.","data":"Login name or password is incorrect."}}`
|
|
zabbixDatasource := mockZabbixDataSource(errResponse, 200)
|
|
err := zabbixDatasource.loginWithDs(context.Background())
|
|
|
|
assert.Equal(t, "", zabbixDatasource.authToken)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestZabbixRequest(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp, err := zabbixDatasource.ZabbixRequest(context.Background(), "method", ZabbixAPIParams{})
|
|
assert.Equal(t, "sampleResult", resp.MustString())
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestZabbixRequestWithNoAuthToken(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"auth"}`, 200)
|
|
resp, err := zabbixDatasource.ZabbixRequest(context.Background(), "method", ZabbixAPIParams{})
|
|
assert.Equal(t, "auth", resp.MustString())
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestZabbixRequestError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 500)
|
|
resp, err := zabbixDatasource.ZabbixRequest(context.Background(), "method", ZabbixAPIParams{})
|
|
assert.Nil(t, resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestZabbixAPIRequest(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp, err := zabbixDatasource.ZabbixAPIRequest(context.Background(), "item.get", ZabbixAPIParams{}, "auth")
|
|
|
|
assert.Equal(t, "sampleResult", resp.MustString())
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestZabbixAPIRequestError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 500)
|
|
resp, err := zabbixDatasource.ZabbixAPIRequest(context.Background(), "item.get", ZabbixAPIParams{}, "auth")
|
|
|
|
assert.Nil(t, resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestTestConnection(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp, err := zabbixDatasource.TestConnection(context.Background(), mockDataSourceRequest(``))
|
|
|
|
assert.Equal(t, "{\"zabbixVersion\":\"sampleResult\",\"dbConnectorStatus\":null}", resp.Results[0].GetMetaJson())
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestTestConnectionError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 500)
|
|
resp, err := zabbixDatasource.TestConnection(context.Background(), mockDataSourceRequest(``))
|
|
|
|
assert.Equal(t, "", resp.Results[0].GetMetaJson())
|
|
assert.NotNil(t, resp.Results[0].GetError())
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestIsNotAuthorized(t *testing.T) {
|
|
testPositive := isNotAuthorized("Not authorised.")
|
|
assert.True(t, testPositive)
|
|
|
|
testNegative := isNotAuthorized("testNegative")
|
|
assert.False(t, testNegative)
|
|
}
|
|
|
|
func TestHandleAPIResult(t *testing.T) {
|
|
expectedResponse, err := handleAPIResult([]byte(`{"result":"sampleResult"}`))
|
|
|
|
assert.Equal(t, "sampleResult", expectedResponse.MustString())
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestHandleAPIResultFormatError(t *testing.T) {
|
|
expectedResponse, err := handleAPIResult([]byte(`{"result"::"sampleResult"}`))
|
|
|
|
assert.NotNil(t, err)
|
|
assert.Nil(t, expectedResponse)
|
|
}
|
|
|
|
func TestHandleAPIResultError(t *testing.T) {
|
|
expectedResponse, err := handleAPIResult([]byte(`{"result":"sampleResult", "error":{"message":"Message", "data":"Data"}}`))
|
|
|
|
assert.Equal(t, "Message Data", err.Error())
|
|
assert.Nil(t, expectedResponse)
|
|
}
|
|
|
|
func TestGetAllGroups(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "name": "name1"},{"groupid": "46489127", "name":"name2"}]}`, 200)
|
|
resp, err := zabbixDatasource.getAllGroups(context.Background(), basicDatasourceInfo)
|
|
|
|
assert.Equal(t, "46489126", resp.MustArray()[0].(map[string]interface{})["groupid"])
|
|
assert.Equal(t, "46489127", resp.MustArray()[1].(map[string]interface{})["groupid"])
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetAllHosts(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"hostid": "46489126", "name": "hostname1"},{"hostid": "46489127", "name":"hostname2"}]}`, 200)
|
|
resp, err := zabbixDatasource.getAllHosts(context.Background(), basicDatasourceInfo, []string{"46489127", "46489127"})
|
|
|
|
assert.Equal(t, "46489126", resp.MustArray()[0].(map[string]interface{})["hostid"])
|
|
assert.Equal(t, "46489127", resp.MustArray()[1].(map[string]interface{})["hostid"])
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetAllApps(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"applicationid": "46489126", "name": "hostname1"},{"applicationid": "46489127", "name":"hostname2"}]}`, 200)
|
|
resp, err := zabbixDatasource.getAllApps(context.Background(), basicDatasourceInfo, []string{"46489127", "46489127"})
|
|
|
|
assert.Equal(t, "46489126", resp.MustArray()[0].(map[string]interface{})["applicationid"])
|
|
assert.Equal(t, "46489127", resp.MustArray()[1].(map[string]interface{})["applicationid"])
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetAllItems(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"itemid": "46489126", "name": "hostname1"},{"itemid": "46489127", "name":"hostname2"}]}`, 200)
|
|
resp, err := zabbixDatasource.getAllItems(context.Background(), basicDatasourceInfo, []string{"46489127", "46489127"}, []string{"7947934", "9182763"}, "num")
|
|
|
|
assert.Equal(t, "46489126", resp.MustArray()[0].(map[string]interface{})["itemid"])
|
|
assert.Equal(t, "46489127", resp.MustArray()[1].(map[string]interface{})["itemid"])
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetGroups(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "name": "name1"},{"groupid": "46489127", "name":"name2"}]}`, 200)
|
|
resp, err := zabbixDatasource.getGroups(context.Background(), basicDatasourceInfo, "name1")
|
|
|
|
assert.Equal(t, "46489126", resp[0]["groupid"])
|
|
assert.Equal(t, "name1", resp[0]["name"])
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetGroupsError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "name": "name1"},{"groupid": "46489127", "name":"name2"}]}`, 500)
|
|
resp, err := zabbixDatasource.getGroups(context.Background(), basicDatasourceInfo, "name1")
|
|
|
|
assert.Nil(t, resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetHosts(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "hostid": "7468763", "name": "hostname1"},{"groupid": "46489127","hostid": "846586", "name":"hostname2"}]}`, 200)
|
|
resp, err := zabbixDatasource.getHosts(context.Background(), basicDatasourceInfo, "nam", "hostname1")
|
|
|
|
assert.Equal(t, "7468763", resp[0]["hostid"])
|
|
assert.Equal(t, "hostname1", resp[0]["name"])
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetHostsError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "hostid": "7468763", "name": "hostname1"},{"groupid": "46489127","hostid": "846586", "name":"hostname2"}]}`, 500)
|
|
resp, err := zabbixDatasource.getHosts(context.Background(), basicDatasourceInfo, "nam", "hostna")
|
|
|
|
assert.Nil(t, resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetApps(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "hostid": "7468763", "applicationid": "7947934", "name": "appname1"},
|
|
{"groupid": "46489127","hostid": "846586", "applicationid": "9182763", "name": "appname2"}]}`, 200)
|
|
resp, err := zabbixDatasource.getApps(context.Background(), basicDatasourceInfo, "nam", "hostnam", "appname1")
|
|
|
|
assert.Equal(t, "7947934", resp[0]["applicationid"])
|
|
assert.Equal(t, "appname1", resp[0]["name"])
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetAppsError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "hostid": "7468763", "applicationid": "7947934", "name": "appname1"},
|
|
{"groupid": "46489127","hostid": "846586", "applicationid": "9182763", "name": "appname2"}]}`, 500)
|
|
resp, err := zabbixDatasource.getApps(context.Background(), basicDatasourceInfo, "nam", "hostnam", "appname1")
|
|
|
|
assert.Nil(t, resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetItems(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "hostid": "7468763", "applicationid": "7947934", "itemid": "837465", "name": "itemname1", "status": "0"},
|
|
{"groupid": "46489127","hostid": "846586", "applicationid": "9182763", "itemid" : "0288374", "name": "itemname2", "status": "0"}]}`, 200)
|
|
resp, err := zabbixDatasource.getItems(context.Background(), basicDatasourceInfo, "itemname1", "itemname1", "itemname1", "itemname1", "num")
|
|
|
|
assert.Equal(t, "837465", resp[0].ID)
|
|
assert.Equal(t, "itemname1", resp[0].Name)
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestGetItemsError(t *testing.T) {
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":[{"groupid": "46489126", "hostid": "7468763", "applicationid": "7947934", "itemid": "837465", "name": "itemname1", "status": "0"},
|
|
{"groupid": "46489127","hostid": "846586", "applicationid": "9182763", "itemid" : "0288374", "name": "itemname2", "status": "0"}]}`, 500)
|
|
resp, err := zabbixDatasource.getItems(context.Background(), basicDatasourceInfo, "name", "name", "name", "name", "num")
|
|
|
|
assert.Nil(t, resp)
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetTrendValueType(t *testing.T) {
|
|
json1, _ := simplejson.NewJson([]byte(`{"functions":[{"def":{"name":"name1"}},{"def":{"name":"name2"}}]}`))
|
|
json2, _ := simplejson.NewJson([]byte(`{"functions":[{"def":{"name":"name1"}},{"def":{"name":"name2"}}]}`))
|
|
jsonQueries := []*simplejson.Json{json1, json2}
|
|
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp := zabbixDatasource.getTrendValueType(jsonQueries)
|
|
|
|
assert.Equal(t, "avg", resp)
|
|
}
|
|
|
|
func TestGetConsolidateBy(t *testing.T) {
|
|
json1, _ := simplejson.NewJson([]byte(`{"functions":[{"def":{"name":"consolidateBy", "params":["sum"]}},{"def":{"name":"name2"}}]}`))
|
|
json2, _ := simplejson.NewJson([]byte(`{"functions":[{"def":{"name":"name1"}},{"def":{"name":"name2"}}]}`))
|
|
jsonQueries := []*simplejson.Json{json1, json2}
|
|
|
|
zabbixDatasource := mockZabbixDataSource(`{"result":"sampleResult"}`, 200)
|
|
resp := zabbixDatasource.getConsolidateBy(jsonQueries)
|
|
|
|
assert.Equal(t, "sum", resp)
|
|
|
|
}
|
|
|
|
func Test_isUseTrend(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
timeRange *datasource.TimeRange
|
|
want bool
|
|
}{
|
|
{
|
|
name: "History time",
|
|
timeRange: &datasource.TimeRange{
|
|
FromEpochMs: time.Now().Add(-time.Hour*48).Unix() * 1000,
|
|
ToEpochMs: time.Now().Add(-time.Hour*12).Unix() * 1000,
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "Trend time (past 7 days)",
|
|
timeRange: &datasource.TimeRange{
|
|
FromEpochMs: time.Now().Add(-time.Hour*24*14).Unix() * 1000,
|
|
ToEpochMs: time.Now().Add(-time.Hour*24*13).Unix() * 1000,
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
name: "Trend time (longer than 4 days)",
|
|
timeRange: &datasource.TimeRange{
|
|
FromEpochMs: time.Now().Add(-time.Hour*24*8).Unix() * 1000,
|
|
ToEpochMs: time.Now().Add(-time.Hour*24*1).Unix() * 1000,
|
|
},
|
|
want: true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
got := isUseTrend(tt.timeRange)
|
|
assert.Equal(t, tt.want, got, tt.name, tt.timeRange)
|
|
}
|
|
|
|
}
|
|
|
|
func Test_parseFilter(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
filter string
|
|
want *regexp.Regexp
|
|
wantErr string
|
|
}{
|
|
{
|
|
name: "Non-regex filter",
|
|
filter: "foobar",
|
|
want: nil,
|
|
},
|
|
{
|
|
name: "Non-regex filter (would-be invalid regex)",
|
|
filter: "fooba(r",
|
|
want: nil,
|
|
},
|
|
{
|
|
name: "Regex filter",
|
|
filter: "/^foo.+/",
|
|
want: regexp.MustCompile("^foo.+"),
|
|
},
|
|
{
|
|
name: "Regex filter with flags",
|
|
filter: "/^foo.+/s",
|
|
want: regexp.MustCompile("(?s)^foo.+"),
|
|
},
|
|
{
|
|
name: "Invalid regex",
|
|
filter: "/fooba(r/",
|
|
wantErr: "error parsing regexp: missing closing ): `fooba(r`",
|
|
},
|
|
{
|
|
name: "Unsupported flag",
|
|
filter: "/foo.+/z",
|
|
wantErr: "error parsing regexp: unsupported flags `z` (expected [imsU])",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := parseFilter(tt.filter)
|
|
|
|
if tt.wantErr != "" {
|
|
assert.Error(t, err)
|
|
assert.EqualError(t, err, tt.wantErr)
|
|
assert.Nil(t, got)
|
|
return
|
|
}
|
|
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, tt.want, got)
|
|
})
|
|
}
|
|
}
|