github.com/fastly/go-fastly/v6@v6.8.0/fastly/newrelic_test.go

package fastly

import (
	"testing"
)

func TestClient_NewRelic(t *testing.T) {
	t.Parallel()

	var err error
	var tv *Version
	record(t, "newrelic/version", func(c *Client) {
		tv = testVersion(t, c)
	})

	// Create
	var newRelicResp1, newRelicResp2 *NewRelic
	record(t, "newrelic/create", func(c *Client) {
		newRelicResp1, err = c.CreateNewRelic(&CreateNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "test-newrelic",
			Token:          "abcd1234",
			Format:         "format",
			Placement:      "waf_debug",
			Region:         "us",
		})
	})
	if err != nil {
		t.Fatal(err)
	}

	record(t, "newrelic/create2", func(c *Client) {
		newRelicResp2, err = c.CreateNewRelic(&CreateNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "test-newrelic-2",
			Token:          "abcd1234",
			Format:         "format",
			Placement:      "waf_debug",
			Region:         "eu",
		})
	})
	if err != nil {
		t.Fatal(err)
	}

	// This case is expected to fail due to an invalid region
	record(t, "newrelic/create3", func(c *Client) {
		_, err = c.CreateNewRelic(&CreateNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "test-newrelic-3",
			Token:          "abcd1234",
			Format:         "format",
			Placement:      "waf_debug",
			Region:         "abc",
		})
	})
	if err == nil {
		t.Fatal(err)
	}

	// Ensure deleted
	defer func() {
		record(t, "newrelic/delete", func(c *Client) {
			c.DeleteNewRelic(&DeleteNewRelicInput{
				ServiceID:      testServiceID,
				ServiceVersion: tv.Number,
				Name:           "test-newrelic",
			})

			c.DeleteNewRelic(&DeleteNewRelicInput{
				ServiceID:      testServiceID,
				ServiceVersion: tv.Number,
				Name:           "test-newrelic-2",
			})

			c.DeleteNewRelic(&DeleteNewRelicInput{
				ServiceID:      testServiceID,
				ServiceVersion: tv.Number,
				Name:           "new-test-newrelic",
			})
		})
	}()

	if newRelicResp1.Name != "test-newrelic" {
		t.Errorf("bad name: %q", newRelicResp1.Name)
	}
	if newRelicResp1.Token != "abcd1234" {
		t.Errorf("bad token: %q", newRelicResp1.Token)
	}
	if newRelicResp1.Format != "format" {
		t.Errorf("bad format: %q", newRelicResp1.Format)
	}
	if newRelicResp1.FormatVersion != 2 {
		t.Errorf("bad format_version: %q", newRelicResp1.FormatVersion)
	}
	if newRelicResp1.Placement != "waf_debug" {
		t.Errorf("bad placement: %q", newRelicResp1.Placement)
	}
	if newRelicResp1.Region != "us" {
		t.Errorf("bad region: %q", newRelicResp1.Region)
	}

	if newRelicResp2.Name != "test-newrelic-2" {
		t.Errorf("bad name: %q", newRelicResp2.Name)
	}
	if newRelicResp2.Token != "abcd1234" {
		t.Errorf("bad token: %q", newRelicResp2.Token)
	}
	if newRelicResp2.Format != "format" {
		t.Errorf("bad format: %q", newRelicResp2.Format)
	}
	if newRelicResp2.FormatVersion != 2 {
		t.Errorf("bad format_version: %q", newRelicResp2.FormatVersion)
	}
	if newRelicResp2.Placement != "waf_debug" {
		t.Errorf("bad placement: %q", newRelicResp2.Placement)
	}
	if newRelicResp2.Region != "eu" {
		t.Errorf("bad region: %q", newRelicResp2.Region)
	}

	// List
	var ln []*NewRelic
	record(t, "newrelic/list", func(c *Client) {
		ln, err = c.ListNewRelic(&ListNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
		})
	})
	if err != nil {
		t.Fatal(err)
	}
	if len(ln) < 1 {
		t.Errorf("bad newrelics: %v", ln)
	}

	// Get
	var newRelicGetResp, newRelicGetResp2 *NewRelic
	record(t, "newrelic/get", func(c *Client) {
		newRelicGetResp, err = c.GetNewRelic(&GetNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "test-newrelic",
		})
	})
	if err != nil {
		t.Fatal(err)
	}

	record(t, "newrelic/get2", func(c *Client) {
		newRelicGetResp2, err = c.GetNewRelic(&GetNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "test-newrelic-2",
		})
	})
	if err != nil {
		t.Fatal(err)
	}

	if newRelicResp1.Name != newRelicGetResp.Name {
		t.Errorf("bad name: %q", newRelicResp1.Name)
	}
	if newRelicResp1.Token != newRelicGetResp.Token {
		t.Errorf("bad token: %q", newRelicResp1.Token)
	}
	if newRelicResp1.Format != newRelicGetResp.Format {
		t.Errorf("bad format: %q", newRelicResp1.Format)
	}
	if newRelicResp1.FormatVersion != newRelicGetResp.FormatVersion {
		t.Errorf("bad format_version: %q", newRelicResp1.FormatVersion)
	}
	if newRelicResp1.Placement != newRelicGetResp.Placement {
		t.Errorf("bad placement: %q", newRelicResp1.Placement)
	}
	if newRelicResp1.Region != newRelicGetResp.Region {
		t.Errorf("bad region: %q", newRelicResp1.Region)
	}

	if newRelicResp2.Name != newRelicGetResp2.Name {
		t.Errorf("bad name: %q", newRelicResp2.Name)
	}
	if newRelicResp2.Token != newRelicGetResp2.Token {
		t.Errorf("bad token: %q", newRelicResp2.Token)
	}
	if newRelicResp2.Format != newRelicGetResp2.Format {
		t.Errorf("bad format: %q", newRelicResp2.Format)
	}
	if newRelicResp2.FormatVersion != newRelicGetResp2.FormatVersion {
		t.Errorf("bad format_version: %q", newRelicResp2.FormatVersion)
	}
	if newRelicResp2.Placement != newRelicGetResp2.Placement {
		t.Errorf("bad placement: %q", newRelicResp2.Placement)
	}
	if newRelicResp2.Region != newRelicGetResp2.Region {
		t.Errorf("bad region: %q", newRelicResp2.Region)
	}

	// Update
	var newRelicUpdateResp1 *NewRelic
	record(t, "newrelic/update", func(c *Client) {
		newRelicUpdateResp1, err = c.UpdateNewRelic(&UpdateNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "test-newrelic",
			NewName:        String("new-test-newrelic"),
			FormatVersion:  Uint(2),
			Region:         String("eu"),
		})
	})
	if err != nil {
		t.Fatal(err)
	}

	// This case is expected to fail due to an invalid region.
	record(t, "newrelic/update2", func(c *Client) {
		_, err = c.UpdateNewRelic(&UpdateNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "new-test-newrelic",
			Region:         String("zz"),
		})
	})
	if err == nil {
		t.Fatal(err)
	}

	if newRelicUpdateResp1.Name != "new-test-newrelic" {
		t.Errorf("bad name: %q", newRelicUpdateResp1.Name)
	}
	if newRelicUpdateResp1.FormatVersion != 2 {
		t.Errorf("bad format_version: %q", newRelicUpdateResp1.FormatVersion)
	}
	if newRelicUpdateResp1.Region != "eu" {
		t.Errorf("bad region: %q", newRelicUpdateResp1.Region)
	}

	// Delete
	record(t, "newrelic/delete", func(c *Client) {
		err = c.DeleteNewRelic(&DeleteNewRelicInput{
			ServiceID:      testServiceID,
			ServiceVersion: tv.Number,
			Name:           "new-test-newrelic",
		})
	})
	if err != nil {
		t.Fatal(err)
	}
}

func TestClient_ListNewRelic_validation(t *testing.T) {
	var err error
	_, err = testClient.ListNewRelic(&ListNewRelicInput{
		ServiceID: "",
	})
	if err != ErrMissingServiceID {
		t.Errorf("bad error: %s", err)
	}

	_, err = testClient.ListNewRelic(&ListNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 0,
	})
	if err != ErrMissingServiceVersion {
		t.Errorf("bad error: %s", err)
	}
}

func TestClient_CreateNewRelic_validation(t *testing.T) {
	var err error
	_, err = testClient.CreateNewRelic(&CreateNewRelicInput{
		ServiceID: "",
	})
	if err != ErrMissingServiceID {
		t.Errorf("bad error: %s", err)
	}

	_, err = testClient.CreateNewRelic(&CreateNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 0,
	})
	if err != ErrMissingServiceVersion {
		t.Errorf("bad error: %s", err)
	}
}

func TestClient_GetNewRelic_validation(t *testing.T) {
	var err error
	_, err = testClient.GetNewRelic(&GetNewRelicInput{
		ServiceID: "",
	})
	if err != ErrMissingServiceID {
		t.Errorf("bad error: %s", err)
	}

	_, err = testClient.GetNewRelic(&GetNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 0,
	})
	if err != ErrMissingServiceVersion {
		t.Errorf("bad error: %s", err)
	}

	_, err = testClient.GetNewRelic(&GetNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 1,
		Name:           "",
	})
	if err != ErrMissingName {
		t.Errorf("bad error: %s", err)
	}
}

func TestClient_UpdateNewRelic_validation(t *testing.T) {
	var err error
	_, err = testClient.UpdateNewRelic(&UpdateNewRelicInput{
		ServiceID: "",
	})
	if err != ErrMissingServiceID {
		t.Errorf("bad error: %s", err)
	}

	_, err = testClient.UpdateNewRelic(&UpdateNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 0,
	})
	if err != ErrMissingServiceVersion {
		t.Errorf("bad error: %s", err)
	}

	_, err = testClient.UpdateNewRelic(&UpdateNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 1,
		Name:           "",
	})
	if err != ErrMissingName {
		t.Errorf("bad error: %s", err)
	}
}

func TestClient_DeleteNewRelic_validation(t *testing.T) {
	var err error
	err = testClient.DeleteNewRelic(&DeleteNewRelicInput{
		ServiceID: "",
	})
	if err != ErrMissingServiceID {
		t.Errorf("bad error: %s", err)
	}

	err = testClient.DeleteNewRelic(&DeleteNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 0,
	})
	if err != ErrMissingServiceVersion {
		t.Errorf("bad error: %s", err)
	}

	err = testClient.DeleteNewRelic(&DeleteNewRelicInput{
		ServiceID:      "foo",
		ServiceVersion: 1,
		Name:           "",
	})
	if err != ErrMissingName {
		t.Errorf("bad error: %s", err)
	}
}