Add support for extensions/extension schemas

extension.go

@@ -0,0 +1,85 @@
+package pagerduty
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/google/go-querystring/query"
+)
+
+type Extension struct {
+	APIObject
+	Name             string      `json:"name"`
+	EndpointURL      string      `json:"endpoint_url"`
+	ExtensionObjects []APIObject `json:"extension_objects"`
+	ExtensionSchema  APIObject   `json:"extension_schema"`
+	Config           interface{} `json:"config"`
+}
+
+type ListExtensionResponse struct {
+	APIListObject
+	Extensions []Extension `json:"extensions"`
+}
+
+type ListExtensionOptions struct {
+	APIListObject
+	ExtensionObjectID string `url:"extension_object_id,omitempty"`
+	ExtensionSchemaID string `url:"extension_schema_id,omitempty"`
+	Query             string `url:"query,omitempty"`
+}
+
+func (c *Client) ListExtensions(o ListExtensionOptions) (*ListExtensionResponse, error) {
+	v, err := query.Values(o)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.get("/extensions?" + v.Encode())
+	if err != nil {
+		return nil, err
+	}
+
+	var result ListExtensionResponse
+
+	return &result, c.decodeJSON(resp, &result)
+}
+
+func (c *Client) CreateExtension(e *Extension) (*Extension, error) {
+	resp, err := c.post("/extensions", e, nil)
+	return getExtensionFromResponse(c, resp, err)
+}
+
+func (c *Client) DeleteExtension(id string) error {
+	_, err := c.delete("/extensions/" + id)
+	return err
+}
+
+func (c *Client) GetExtension(id string) (*Extension, error) {
+	resp, err := c.get("/extensions/" + id)
+	return getExtensionFromResponse(c, resp, err)
+}
+
+func (c *Client) UpdateExtension(id string, e *Extension) (*Extension, error) {
+	resp, err := c.put("/extensions/"+id, e, nil)
+	return getExtensionFromResponse(c, resp, err)
+}
+
+func getExtensionFromResponse(c *Client, resp *http.Response, err error) (*Extension, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	var target map[string]Extension
+	if dErr := c.decodeJSON(resp, &target); dErr != nil {
+		return nil, fmt.Errorf("Could not decode JSON response: %v", dErr)
+	}
+
+	rootNode := "extension"
+
+	t, nodeOK := target[rootNode]
+	if !nodeOK {
+		return nil, fmt.Errorf("JSON response does not have %s field", rootNode)
+	}
+
+	return &t, nil
+}

extension_schema.go

@@ -0,0 +1,70 @@
+package pagerduty
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/google/go-querystring/query"
+)
+
+type ExtensionSchema struct {
+	APIObject
+	IconURL     string   `json:"icon_url"`
+	LogoURL     string   `json:"logo_url"`
+	Label       string   `json:"label"`
+	Key         string   `json:"key"`
+	Description string   `json:"description"`
+	GuideURL    string   `json:"guide_url"`
+	SendTypes   []string `json:"send_types"`
+	URL         string   `json:"url"`
+}
+
+type ListExtensionSchemaResponse struct {
+	APIListObject
+	ExtensionSchemas []ExtensionSchema `json:"extension_schemas"`
+}
+
+type ListExtensionSchemaOptions struct {
+	APIListObject
+	Query string `url:"query,omitempty"`
+}
+
+func (c *Client) ListExtensionSchemas(o ListExtensionSchemaOptions) (*ListExtensionSchemaResponse, error) {
+	v, err := query.Values(o)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.get("/extension_schemas?" + v.Encode())
+	if err != nil {
+		return nil, err
+	}
+
+	var result ListExtensionSchemaResponse
+
+	return &result, c.decodeJSON(resp, &result)
+}
+
+func (c *Client) GetExtensionSchema(id string) (*ExtensionSchema, error) {
+	resp, err := c.get("/extension_schemas/" + id)
+	return getExtensionSchemaFromResponse(c, resp, err)
+}
+
+func getExtensionSchemaFromResponse(c *Client, resp *http.Response, err error) (*ExtensionSchema, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	var target map[string]ExtensionSchema
+	if dErr := c.decodeJSON(resp, &target); dErr != nil {
+		return nil, fmt.Errorf("Could not decode JSON response: %v", dErr)
+	}
+
+	rootNode := "extension_schema"
+	t, nodeOK := target[rootNode]
+	if !nodeOK {
+		return nil, fmt.Errorf("JSON response does not have %s field", rootNode)
+	}
+
+	return &t, nil
+}

extension_schema_test.go

@@ -0,0 +1,78 @@
+package pagerduty
+
+import (
+	"net/http"
+	"testing"
+)
+
+func TestExtensionSchema_List(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/extension_schemas", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		w.Write([]byte(`{"extension_schemas":[{"id":"1","summary":"foo","send_types":["trigger", "acknowledge", "resolve"]}]}`))
+
+	})
+
+	var listObj = APIListObject{Limit: 0, Offset: 0, More: false, Total: 0}
+	var client = &Client{apiEndpoint: server.URL, authToken: "foo", HTTPClient: defaultHTTPClient}
+	var opts = ListExtensionSchemaOptions{
+		APIListObject: listObj,
+		Query:         "foo",
+	}
+
+	res, err := client.ListExtensionSchemas(opts)
+
+	want := &ListExtensionSchemaResponse{
+		APIListObject: listObj,
+		ExtensionSchemas: []ExtensionSchema{
+			{
+				APIObject: APIObject{
+					ID:      "1",
+					Summary: "foo",
+				},
+				SendTypes: []string{
+					"trigger",
+					"acknowledge",
+					"resolve",
+				},
+			},
+		},
+	}
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	testEqual(t, want, res)
+}
+
+func TestExtensionSchema_Get(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/extension_schemas/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		w.Write([]byte(`{"extension_schema": {"name": "foo", "id": "1", "send_types": ["trigger", "acknowledge", "resolve"]}}`))
+	})
+
+	var client = &Client{apiEndpoint: server.URL, authToken: "foo", HTTPClient: defaultHTTPClient}
+
+	res, err := client.GetExtensionSchema("1")
+
+	want := &ExtensionSchema{
+		APIObject: APIObject{
+			ID: "1",
+		},
+		SendTypes: []string{
+			"trigger",
+			"acknowledge",
+			"resolve",
+		},
+	}
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	testEqual(t, want, res)
+}

extension_test.go

@@ -0,0 +1,150 @@
+package pagerduty
+
+import (
+	"net/http"
+	"testing"
+)
+
+func TestExtension_List(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		w.Write([]byte(`{"extensions":[{"id":"1","summary":"foo","config": {"restrict": "any"}, "extension_objects":[{"id":"foo","summary":"foo"}]}]}`))
+
+	})
+
+	var listObj = APIListObject{Limit: 0, Offset: 0, More: false, Total: 0}
+	var client = &Client{apiEndpoint: server.URL, authToken: "foo", HTTPClient: defaultHTTPClient}
+	var opts = ListExtensionOptions{
+		APIListObject: listObj,
+		Query:         "foo",
+	}
+
+	res, err := client.ListExtensions(opts)
+
+	want := &ListExtensionResponse{
+		APIListObject: listObj,
+		Extensions: []Extension{
+			{
+				APIObject: APIObject{
+					ID:      "1",
+					Summary: "foo",
+				},
+				Config: map[string]interface{}{
+					"restrict": "any",
+				},
+				ExtensionObjects: []APIObject{
+					{
+						ID:      "foo",
+						Summary: "foo",
+					},
+				},
+			},
+		},
+	}
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	testEqual(t, want, res)
+}
+
+func TestExtension_Create(t *testing.T) {
+	setup()
+	defer teardown()
+
+	input := &Extension{Name: "foo"}
+
+	mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		w.Write([]byte(`{"extension": {"name": "foo", "id": "1"}}`))
+	})
+
+	var client = &Client{apiEndpoint: server.URL, authToken: "foo", HTTPClient: defaultHTTPClient}
+
+	res, err := client.CreateExtension(input)
+
+	want := &Extension{
+		Name: "foo",
+		APIObject: APIObject{
+			ID: "1",
+		},
+	}
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	testEqual(t, want, res)
+}
+
+func TestExtension_Delete(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/extensions/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "DELETE")
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	var client = &Client{apiEndpoint: server.URL, authToken: "foo", HTTPClient: defaultHTTPClient}
+
+	if err := client.DeleteExtension("1"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestExtension_Get(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/extensions/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		w.Write([]byte(`{"extension": {"name": "foo", "id": "1"}}`))
+	})
+
+	var client = &Client{apiEndpoint: server.URL, authToken: "foo", HTTPClient: defaultHTTPClient}
+
+	res, err := client.GetExtension("1")
+
+	want := &Extension{
+		Name: "foo",
+		APIObject: APIObject{
+			ID: "1",
+		},
+	}
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	testEqual(t, want, res)
+}
+
+func TestExtension_Update(t *testing.T) {
+	setup()
+	defer teardown()
+
+	input := &Extension{Name: "foo"}
+
+	mux.HandleFunc("/extensions/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PUT")
+		w.Write([]byte(`{"extension": {"name": "foo", "id": "1"}}`))
+	})
+
+	var client = &Client{apiEndpoint: server.URL, authToken: "foo", HTTPClient: defaultHTTPClient}
+
+	res, err := client.UpdateExtension("1", input)
+
+	want := &Extension{
+		Name: "foo",
+		APIObject: APIObject{
+			ID: "1",
+		},
+	}
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	testEqual(t, want, res)
+}