WIP: Screenboards Support

integration_test/screen_widgets_test.go

@@ -0,0 +1,150 @@
+package integration_test
+
+import (
+	"testing"
+
+	"github.com/seiffert/go-datadog-api"
+)
+
+func TestFreeTextWidget(t *testing.T) {
+	board := createTestScreenboard(t)
+	widget := datadog.NewFreeTextWidget(
+		1, 1, 10, 10, "Test", 16, "center",
+	)
+	expected := *(widget.(*datadog.FreeTextWidget))
+
+	board.Widgets = append(board.Widgets, widget)
+	if err := client.UpdateScreenboard(board); err != nil {
+		t.Fatalf("Updating a screenboard failed: %s", err)
+	}
+
+	actual, err := client.GetScreenboard(board.Id)
+	if err != nil {
+		t.Fatalf("Retreiving a screenboard failed: %s", err)
+	}
+
+	actualWidget, ok := actual.Widgets[0].(*datadog.FreeTextWidget)
+	if !ok {
+		t.Fatalf("Widget type does not match: %v", actual.Widgets[0])
+	}
+
+	assertEquals(t, "font-size", actualWidget.FontSize, expected.FontSize)
+	assertEquals(t, "height", actualWidget.Height, expected.Height)
+	assertEquals(t, "width", actualWidget.Width, expected.Width)
+	assertEquals(t, "x", actualWidget.X, expected.X)
+	assertEquals(t, "y", actualWidget.Y, expected.Y)
+	assertEquals(t, "text", actualWidget.Text, expected.Text)
+	assertEquals(t, "text-align", actualWidget.TextAlign, expected.TextAlign)
+	assertEquals(t, "type", actualWidget.Type, expected.Type)
+
+	cleanUpScreenboard(t, board.Id)
+}
+
+func TestTimeseriesWidget(t *testing.T) {
+	board := createTestScreenboard(t)
+	widget := datadog.NewTimeseriesWidget(
+		1, 1, 20, 30,
+		true, "center", datadog.TextSize{Size: 16}, "Test",
+		"1m",
+		[]datadog.TimeseriesRequest{
+			datadog.NewTimeseriesRequest("line", "system.cpu.idle"),
+		},
+	)
+	expected := *(widget.(*datadog.TimeseriesWidget))
+
+	board.Widgets = append(board.Widgets, widget)
+	if err := client.UpdateScreenboard(board); err != nil {
+		t.Fatalf("Updating a screenboard failed: %s", err)
+	}
+
+	actual, err := client.GetScreenboard(board.Id)
+	if err != nil {
+		t.Fatalf("Retreiving a screenboard failed: %s", err)
+	}
+
+	actualWidget, ok := actual.Widgets[0].(*datadog.TimeseriesWidget)
+	if !ok {
+		t.Fatalf("Widget type does not match: %v", actual.Widgets[0])
+	}
+
+	assertEquals(t, "height", actualWidget.Height, expected.Height)
+	assertEquals(t, "width", actualWidget.Width, expected.Width)
+	assertEquals(t, "x", actualWidget.X, expected.X)
+	assertEquals(t, "y", actualWidget.Y, expected.Y)
+	assertEquals(t, "title", actualWidget.Title, expected.Title)
+	assertEquals(t, "title-align", actualWidget.TitleAlign, expected.TitleAlign)
+	assertEquals(t, "title-size.size", actualWidget.TitleSize.Size, expected.TitleSize.Size)
+	assertEquals(t, "title-size.auto", actualWidget.TitleSize.Auto, expected.TitleSize.Auto)
+	assertEquals(t, "title-text", actualWidget.TitleText, expected.TitleText)
+	assertEquals(t, "type", actualWidget.Type, expected.Type)
+	assertEquals(t, "timeframe", actualWidget.Timeframe, expected.Timeframe)
+	assertEquals(t, "legend", actualWidget.Legend, expected.Legend)
+	assertTileDefEquals(t, actualWidget.TileDef, expected.TileDef)
+
+	cleanUpScreenboard(t, board.Id)
+}
+
+func TestQueryValueWidget(t *testing.T) {
+	board := createTestScreenboard(t)
+	widget := datadog.NewQueryValueWidget(
+		1, 1, 20, 10,
+		true, "center", datadog.TextSize{Size: 16}, "Test",
+		"left", datadog.TextSize{Size: 32},
+		"1m", "sum",
+		"min", "docker.containers.running",
+	)
+	expected := *(widget.(*datadog.QueryValueWidget))
+
+	board.Widgets = append(board.Widgets, widget)
+	if err := client.UpdateScreenboard(board); err != nil {
+		t.Fatalf("Updating a screenboard failed: %s", err)
+	}
+
+	actual, err := client.GetScreenboard(board.Id)
+	if err != nil {
+		t.Fatalf("Retreiving a screenboard failed: %s", err)
+	}
+
+	actualWidget, ok := actual.Widgets[0].(*datadog.QueryValueWidget)
+	if !ok {
+		t.Fatalf("Widget type does not match: %v", actual.Widgets[0])
+	}
+
+	assertEquals(t, "height", actualWidget.Height, expected.Height)
+	assertEquals(t, "width", actualWidget.Width, expected.Width)
+	assertEquals(t, "x", actualWidget.X, expected.X)
+	assertEquals(t, "y", actualWidget.Y, expected.Y)
+	assertEquals(t, "title", actualWidget.Title, expected.Title)
+	assertEquals(t, "title-align", actualWidget.TitleAlign, expected.TitleAlign)
+	assertEquals(t, "title-size.size", actualWidget.TitleSize.Size, expected.TitleSize.Size)
+	assertEquals(t, "title-size.auto", actualWidget.TitleSize.Auto, expected.TitleSize.Auto)
+	assertEquals(t, "title-text", actualWidget.TitleText, expected.TitleText)
+	assertEquals(t, "type", actualWidget.Type, expected.Type)
+	assertEquals(t, "timeframe", actualWidget.Timeframe, expected.Timeframe)
+	assertEquals(t, "timeframe-aggregator", actualWidget.TimeframeAggregator, expected.TimeframeAggregator)
+	assertEquals(t, "aggregator", actualWidget.Aggregator, expected.Aggregator)
+	assertEquals(t, "query", actualWidget.Query, expected.Query)
+
+	cleanUpScreenboard(t, board.Id)
+}
+
+func assertTileDefEquals(t *testing.T, actual datadog.TileDef, expected datadog.TileDef) {
+	assertEquals(t, "num-events", len(actual.Events), len(expected.Events))
+	assertEquals(t, "num-requests", len(actual.Requests), len(expected.Requests))
+	assertEquals(t, "viz", actual.Viz, expected.Viz)
+
+	for i, event := range actual.Events {
+		assertEquals(t, "event-query", event.Query, expected.Events[i].Query)
+	}
+
+	for i, request := range actual.Requests {
+		assertEquals(t, "request-query", request.Query, expected.Requests[i].Query)
+		assertEquals(t, "request-type", request.Type, expected.Requests[i].Type)
+	}
+}
+
+func assertEquals(t *testing.T, attribute string, a, b interface{}) {
+	if a != b {
+		t.Errorf("The two %s values '%v' and '%v' are not equal", attribute, a, b)
+	}
+}

integration_test/screenboards_test.go

@@ -0,0 +1,152 @@
+package integration_test
+
+import (
+	"log"
+	"os"
+	"testing"
+
+	"github.com/seiffert/go-datadog-api"
+)
+
+var (
+	apiKey string
+	appKey string
+	client *datadog.Client
+)
+
+func init() {
+	apiKey = os.Getenv("DD_API_KEY")
+	appKey = os.Getenv("DD_APP_KEY")
+
+	if apiKey == "" || appKey == "" {
+		log.Fatal("Please make sure to set the env variables 'DD_API_KEY' and 'DD_APP_KEY' before running this test")
+	}
+
+	client = datadog.NewClient(apiKey, appKey)
+}
+
+func TestMain(m *testing.M) {
+	num := countScreenboards()
+
+	result := m.Run()
+
+	if num != countScreenboards() {
+		log.Fatal("Tests didn't clean-up all created screenboards. Manual clean-up required.")
+	}
+
+	os.Exit(result)
+}
+
+func TestCreateAndDeleteScreenboard(t *testing.T) {
+	expected := getTestScreenboard()
+	// create the screenboard and compare it
+	actual, err := client.CreateScreenboard(expected)
+	if err != nil {
+		t.Fatalf("Creating a screenboard failed when it shouldn't. (%s)", err)
+	}
+	assertScreenboardEquals(t, actual, expected)
+
+	// now try to fetch it freshly and compare it again
+	actual, err = client.GetScreenboard(actual.Id)
+	if err != nil {
+		t.Fatalf("Retreiving a screenboard failed when it shouldn't. (%s)", err)
+	}
+	assertScreenboardEquals(t, actual, expected)
+	cleanUpScreenboard(t, actual.Id)
+}
+
+func TestUpdateScreenboard(t *testing.T) {
+	board := createTestScreenboard(t)
+
+	board.Title = "___New-Test-Board___"
+	if err := client.UpdateScreenboard(board); err != nil {
+		t.Fatalf("Updating a screenboard failed when it shouldn't: %s", err)
+	}
+
+	actual, err := client.GetScreenboard(board.Id)
+	if err != nil {
+		t.Fatalf("Retreiving a screenboard failed when it shouldn't: %s", err)
+	}
+
+	assertScreenboardEquals(t, actual, board)
+	cleanUpScreenboard(t, actual.Id)
+}
+
+func TestGetScreenboards(t *testing.T) {
+	boards, err := client.GetScreenboards()
+	if err != nil {
+		t.Fatalf("Retreiving screenboards failed when it shouldn't: %s", err)
+	}
+	num := len(boards)
+
+	board := createTestScreenboard(t)
+
+	boards, err = client.GetScreenboards()
+	if err != nil {
+		t.Fatalf("Retreiving screenboards failed when it shouldn't: %s", err)
+	}
+
+	if num+1 != len(boards) {
+		t.Fatalf("Number of screenboards didn't match expected: %d != %d", len(boards), num+1)
+	}
+
+	cleanUpScreenboard(t, board.Id)
+}
+
+func getTestScreenboard() *datadog.Screenboard {
+	return &datadog.Screenboard{
+		Title:   "___Test-Board___",
+		Height:  600,
+		Width:   800,
+		Widgets: []datadog.Widget{},
+	}
+}
+
+func createTestScreenboard(t *testing.T) *datadog.Screenboard {
+	board := getTestScreenboard()
+	board, err := client.CreateScreenboard(board)
+	if err != nil {
+		t.Fatalf("Creating a screenboard failed when it shouldn't: %s", err)
+	}
+
+	return board
+}
+
+func cleanUpScreenboard(t *testing.T, id int) {
+	if err := client.DeleteScreenboard(id); err != nil {
+		t.Fatalf("Deleting a screenboard failed when it shouldn't. (%s)", err)
+	}
+
+	deletedBoard, err := client.GetScreenboard(id)
+	if deletedBoard != nil {
+		t.Fatal("Screenboard hasn't been deleted when it should have been.")
+	}
+
+	if err == nil {
+		t.Fatal("Fetching deleted screenboard didn't lead to an error.")
+	}
+}
+
+func countScreenboards() int {
+	boards, err := client.GetScreenboards()
+	if err != nil {
+		log.Fatalf("Error retreiving screenboards: %s", err)
+	}
+
+	return len(boards)
+}
+
+func assertScreenboardEquals(t *testing.T, actual, expected *datadog.Screenboard) {
+	if actual.Title != expected.Title {
+		t.Errorf("Screenboard title does not match: %s != %s", actual.Title, expected.Title)
+	}
+	if actual.Width != expected.Width {
+		t.Errorf("Screenboard width does not match: %d != %d", actual.Width, expected.Width)
+	}
+	if actual.Height != expected.Height {
+		t.Errorf("Screenboard width does not match: %d != %d", actual.Height, expected.Height)
+	}
+	if len(actual.Widgets) != len(expected.Widgets) {
+		t.Errorf("Number of Screenboard widgets does not match: %d != %d", len(actual.Widgets), len(expected.Widgets))
+	}
+}