hookdeck-cli 0.6.2

package/pkg/config/profile_test.go

@@ -0,0 +1,109 @@
+package config
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWriteProfile(t *testing.T) {
+	profilesFile := filepath.Join(os.TempDir(), "hookdeck", "config.toml")
+	p := Profile{
+		DeviceName:  "st-testing",
+		ProfileName: "tests",
+		APIKey:      "sk_test_123",
+		DisplayName: "test-account-display-name",
+	}
+
+	c := &Config{
+		Color:        "auto",
+		LogLevel:     "info",
+		Profile:      p,
+		ProfilesFile: profilesFile,
+	}
+	c.InitConfig()
+
+	v := viper.New()
+
+	fmt.Println(profilesFile)
+
+	err := p.writeProfile(v)
+	require.NoError(t, err)
+
+	require.FileExists(t, c.ProfilesFile)
+
+	configValues := helperLoadBytes(t, c.ProfilesFile)
+	expectedConfig := `
+[tests]
+  api_key = "sk_test_123"
+  device_name = "st-testing"
+  display_name = "test-account-display-name"
+`
+	require.EqualValues(t, expectedConfig, string(configValues))
+
+	cleanUp(c.ProfilesFile)
+}
+
+func TestWriteProfilesMerge(t *testing.T) {
+	profilesFile := filepath.Join(os.TempDir(), "hookdeck", "config.toml")
+	p := Profile{
+		ProfileName: "tests",
+		DeviceName:  "st-testing",
+		APIKey:      "sk_test_123",
+		DisplayName: "test-account-display-name",
+	}
+
+	c := &Config{
+		Color:        "auto",
+		LogLevel:     "info",
+		Profile:      p,
+		ProfilesFile: profilesFile,
+	}
+	c.InitConfig()
+
+	v := viper.New()
+	writeErr := p.writeProfile(v)
+
+	require.NoError(t, writeErr)
+	require.FileExists(t, c.ProfilesFile)
+
+	p.ProfileName = "tests-merge"
+	writeErrTwo := p.writeProfile(v)
+	require.NoError(t, writeErrTwo)
+	require.FileExists(t, c.ProfilesFile)
+
+	configValues := helperLoadBytes(t, c.ProfilesFile)
+	expectedConfig := `
+[tests]
+  api_key = "sk_test_123"
+  device_name = "st-testing"
+  display_name = "test-account-display-name"
+
+[tests-merge]
+  api_key = "sk_test_123"
+  device_name = "st-testing"
+  display_name = "test-account-display-name"
+`
+
+	require.EqualValues(t, expectedConfig, string(configValues))
+
+	cleanUp(c.ProfilesFile)
+}
+
+func helperLoadBytes(t *testing.T, name string) []byte {
+	bytes, err := ioutil.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return bytes
+}
+
+func cleanUp(file string) {
+	os.Remove(file)
+}

package/pkg/hookdeck/client.go

@@ -0,0 +1,210 @@
+package hookdeck
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"time"
+
+	"github.com/hookdeck/hookdeck-cli/pkg/useragent"
+)
+
+// DefaultAPIBaseURL is the default base URL for API requests
+const DefaultAPIBaseURL = "https://api.hookdeck.com"
+
+// DefaultDashboardURL is the default base URL for web links
+const DefaultDashboardURL = "https://dashboard.hookdeck.com"
+
+// DefaultDashboardBaseURL is the default base URL for dashboard requests
+const DefaultDashboardBaseURL = "http://dashboard.hookdeck.com"
+
+const DefaultConsoleBaseURL = "http://console.hookdeck.com"
+
+const DefaultWebsocektURL = "wss://ws.hookdeck.com"
+
+// Client is the API client used to sent requests to Hookdeck.
+type Client struct {
+	// The base URL (protocol + hostname) used for all requests sent by this
+	// client.
+	BaseURL *url.URL
+
+	// API key used to authenticate requests sent by this client. If left
+	// empty, the `Authorization` header will be omitted.
+	APIKey string
+
+	// When this is enabled, request and response headers will be printed to
+	// stdout.
+	Verbose bool
+
+	// Cached HTTP client, lazily created the first time the Client is used to
+	// send a request.
+	httpClient *http.Client
+}
+
+type ErrorResponse struct {
+	Handled bool   `json:"Handled"`
+	Message string `json:"message"`
+}
+
+// PerformRequest sends a request to Hookdeck and returns the response.
+func (c *Client) PerformRequest(ctx context.Context, req *http.Request) (*http.Response, error) {
+	if req.Header == nil {
+		req.Header = http.Header{}
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", useragent.GetEncodedUserAgent())
+	req.Header.Set("X-Hookdeck-Client-User-Agent", useragent.GetEncodedHookdeckUserAgent())
+
+	if !telemetryOptedOut(os.Getenv("HOOKDECK_CLI_TELEMETRY_OPTOUT")) {
+		telemetryHdr, err := getTelemetryHeader()
+		if err == nil {
+			req.Header.Set("Hookdeck-CLI-Telemetry", telemetryHdr)
+		}
+	}
+
+	if c.APIKey != "" {
+		req.SetBasicAuth(c.APIKey, "")
+	}
+
+	if c.httpClient == nil {
+		c.httpClient = newHTTPClient(c.Verbose, os.Getenv("HOOKDECK_CLI_UNIX_SOCKET"))
+	}
+
+	if ctx != nil {
+		req = req.WithContext(ctx)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	err = checkAndPrintError(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func (c *Client) Get(ctx context.Context, path string, params string, configure func(*http.Request)) (*http.Response, error) {
+	url, err := url.Parse(path)
+	if err != nil {
+		return nil, err
+	}
+
+	url = c.BaseURL.ResolveReference(url)
+
+	url.RawQuery = params
+
+	req, err := http.NewRequest(http.MethodGet, url.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PerformRequest(ctx, req)
+}
+
+func (c *Client) Post(ctx context.Context, path string, data []byte, configure func(*http.Request)) (*http.Response, error) {
+	url, err := url.Parse(path)
+	if err != nil {
+		return nil, err
+	}
+	url = c.BaseURL.ResolveReference(url)
+	req, err := http.NewRequest(http.MethodPost, url.String(), bytes.NewBuffer(data))
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PerformRequest(ctx, req)
+}
+
+func (c *Client) Put(ctx context.Context, path string, data []byte, configure func(*http.Request)) (*http.Response, error) {
+	url, err := url.Parse(path)
+	if err != nil {
+		return nil, err
+	}
+	url = c.BaseURL.ResolveReference(url)
+	req, err := http.NewRequest(http.MethodPut, url.String(), bytes.NewBuffer(data))
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PerformRequest(ctx, req)
+}
+
+func checkAndPrintError(res *http.Response) error {
+	if res.StatusCode != http.StatusOK {
+		defer res.Body.Close()
+		body, err := ioutil.ReadAll(res.Body)
+		if err != nil {
+			return err
+		}
+		response := &ErrorResponse{}
+		err = json.Unmarshal(body, &response)
+		if err != nil {
+			// Not a valid JSON response, just use body
+			return fmt.Errorf("unexpected http status code: %d %s", res.StatusCode, body)
+		}
+		if response.Message != "" {
+			return fmt.Errorf("error: %s", response.Message)
+		}
+		return fmt.Errorf("unexpected http status code: %d %s", res.StatusCode, body)
+	}
+	return nil
+}
+
+func postprocessJsonResponse(res *http.Response, target interface{}) (interface{}, error) {
+	defer res.Body.Close()
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal(body, target)
+	return target, err
+}
+
+func newHTTPClient(verbose bool, unixSocket string) *http.Client {
+	var httpTransport *http.Transport
+
+	if unixSocket != "" {
+		dialFunc := func(network, addr string) (net.Conn, error) {
+			return net.Dial("unix", unixSocket)
+		}
+		dialContext := func(_ context.Context, _, _ string) (net.Conn, error) {
+			return net.Dial("unix", unixSocket)
+		}
+		httpTransport = &http.Transport{
+			DialContext:           dialContext,
+			DialTLS:               dialFunc,
+			ResponseHeaderTimeout: 30 * time.Second,
+			ExpectContinueTimeout: 10 * time.Second,
+			TLSHandshakeTimeout:   10 * time.Second,
+		}
+	} else {
+		httpTransport = &http.Transport{
+			Proxy: http.ProxyFromEnvironment,
+			DialContext: (&net.Dialer{
+				Timeout:   30 * time.Second,
+				KeepAlive: 30 * time.Second,
+			}).DialContext,
+			TLSHandshakeTimeout: 10 * time.Second,
+		}
+	}
+
+	tr := &verboseTransport{
+		Transport: httpTransport,
+		Verbose:   verbose,
+		Out:       os.Stderr,
+	}
+
+	return &http.Client{
+		Transport: tr,
+	}
+}

package/pkg/hookdeck/client_test.go

@@ -0,0 +1,203 @@
+package hookdeck
+
+import (
+	"context"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPerformRequest_ParamsEncoding_Delete(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, "/delete", r.URL.Path)
+		require.Equal(t, "key_a=value_a&key_b=value_b", r.URL.RawQuery)
+
+		body, err := ioutil.ReadAll(r.Body)
+		require.NoError(t, err)
+		require.Equal(t, "", string(body))
+	}))
+	defer ts.Close()
+
+	baseURL, _ := url.Parse(ts.URL)
+	client := Client{
+		BaseURL: baseURL,
+	}
+
+	params := url.Values{}
+	params.Add("key_a", "value_a")
+	params.Add("key_b", "value_b")
+
+	req := &http.Request{
+		Method: http.MethodDelete,
+		URL: &url.URL{
+			Scheme:   baseURL.Scheme,
+			Host:     baseURL.Host,
+			Path:     "/delete",
+			RawQuery: params.Encode(),
+		},
+	}
+	resp, err := client.PerformRequest(context.TODO(), req)
+	require.NoError(t, err)
+
+	defer resp.Body.Close()
+}
+
+func TestPerformRequest_ParamsEncoding_Get(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, "/get", r.URL.Path)
+		require.Equal(t, "key_a=value_a&key_b=value_b", r.URL.RawQuery)
+
+		body, err := ioutil.ReadAll(r.Body)
+		require.NoError(t, err)
+		require.Equal(t, "", string(body))
+	}))
+	defer ts.Close()
+
+	baseURL, _ := url.Parse(ts.URL)
+	client := Client{
+		BaseURL: baseURL,
+	}
+
+	params := url.Values{}
+	params.Add("key_a", "value_a")
+	params.Add("key_b", "value_b")
+
+	req := &http.Request{
+		Method: http.MethodGet,
+		URL: &url.URL{
+			Scheme:   baseURL.Scheme,
+			Host:     baseURL.Host,
+			Path:     "/get",
+			RawQuery: params.Encode(),
+		},
+	}
+
+	resp, err := client.PerformRequest(context.TODO(), req)
+	require.NoError(t, err)
+
+	defer resp.Body.Close()
+}
+
+func TestPerformRequest_ParamsEncoding_Post(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, "/post", r.URL.Path)
+		require.Equal(t, "", r.URL.RawQuery)
+
+		body, err := ioutil.ReadAll(r.Body)
+		require.NoError(t, err)
+		require.Equal(t, "key_a=value_a&key_b=value_b", string(body))
+	}))
+	defer ts.Close()
+
+	baseURL, _ := url.Parse(ts.URL)
+	client := Client{
+		BaseURL: baseURL,
+	}
+
+	params := url.Values{}
+	params.Add("key_a", "value_a")
+	params.Add("key_b", "value_b")
+
+	req := &http.Request{
+		Method: http.MethodPost,
+		URL: &url.URL{
+			Scheme: baseURL.Scheme,
+			Host:   baseURL.Host,
+			Path:   "/post",
+		},
+		Body: io.NopCloser(strings.NewReader(params.Encode())),
+	}
+
+	resp, err := client.PerformRequest(context.TODO(), req)
+	require.NoError(t, err)
+
+	defer resp.Body.Close()
+}
+
+func TestPerformRequest_ApiKey_Provided(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, "Basic c2tfdGVzdF8xMjM0Og==", r.Header.Get("Authorization"))
+	}))
+	defer ts.Close()
+
+	baseURL, _ := url.Parse(ts.URL)
+	client := Client{
+		BaseURL: baseURL,
+		APIKey:  "sk_test_1234",
+	}
+
+	req := &http.Request{
+		Method: http.MethodGet,
+		URL: &url.URL{
+			Scheme: baseURL.Scheme,
+			Host:   baseURL.Host,
+			Path:   "/get",
+		},
+	}
+
+	resp, err := client.PerformRequest(context.TODO(), req)
+	require.NoError(t, err)
+
+	defer resp.Body.Close()
+}
+
+func TestPerformRequest_ApiKey_Omitted(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, "", r.Header.Get("Authorization"))
+	}))
+	defer ts.Close()
+
+	baseURL, _ := url.Parse(ts.URL)
+	client := Client{
+		BaseURL: baseURL,
+	}
+
+	req := &http.Request{
+		Method: http.MethodGet,
+		URL: &url.URL{
+			Scheme: baseURL.Scheme,
+			Host:   baseURL.Host,
+			Path:   "/get",
+		},
+	}
+
+	resp, err := client.PerformRequest(context.TODO(), req)
+	require.NoError(t, err)
+
+	defer resp.Body.Close()
+}
+
+func TestPerformRequest_ConfigureFunc(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, "2019-07-10", r.Header.Get("Hookdeck-Version"))
+	}))
+	defer ts.Close()
+
+	baseURL, _ := url.Parse(ts.URL)
+	client := Client{
+		BaseURL: baseURL,
+	}
+
+	req := &http.Request{
+		Method: http.MethodGet,
+		Header: http.Header{
+			"Hookdeck-Version": []string{"2019-07-10"},
+		},
+		URL: &url.URL{
+			Scheme: baseURL.Scheme,
+			Host:   baseURL.Host,
+			Path:   "/get",
+		},
+	}
+
+	resp, err := client.PerformRequest(context.TODO(), req)
+	require.NoError(t, err)
+
+	defer resp.Body.Close()
+}

package/pkg/hookdeck/connections.go

@@ -0,0 +1,61 @@
+package hookdeck
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+)
+
+type Connection struct {
+	Id          string
+	Alias       string
+	Label       string
+	Destination Destination
+}
+
+type CreateConnectionInput struct {
+	Alias       string                 `json:"alias"`
+	Label       string                 `json:"label"`
+	SourceId    string                 `json:"source_id"`
+	Destination CreateDestinationInput `json:"destination"`
+}
+
+type ConnectionList struct {
+	Count  int
+	Models []Connection
+}
+
+func (c *Client) ListConnectionsBySource(source_id string) ([]Connection, error) {
+	res, err := c.Get(context.Background(), "/connections", "source_id="+source_id, nil)
+	if err != nil {
+		return []Connection{}, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return []Connection{}, fmt.Errorf("unexpected http status code: %d %s", res.StatusCode, err)
+	}
+	sources := ConnectionList{}
+	postprocessJsonResponse(res, &sources)
+
+	return sources.Models, nil
+}
+
+func (c *Client) CreateConnection(input CreateConnectionInput) (Connection, error) {
+	input_bytes, err := json.Marshal(input)
+	if err != nil {
+		return Connection{}, err
+	}
+	res, err := c.Post(context.Background(), "/connections", input_bytes, nil)
+	if err != nil {
+		return Connection{}, err
+	}
+	if res.StatusCode != http.StatusOK {
+		defer res.Body.Close()
+		body, _ := ioutil.ReadAll(res.Body)
+		return Connection{}, fmt.Errorf("Unexpected http status code: %d %s", res.StatusCode, string(body))
+	}
+	source := Connection{}
+	postprocessJsonResponse(res, &source)
+	return source, nil
+}

package/pkg/hookdeck/destinations.go

@@ -0,0 +1,14 @@
+package hookdeck
+
+type Destination struct {
+	Id      string `json:"id"`
+	Alias   string `json:"alias"`
+	Label   string `json:"label"`
+	CliPath string `json:"cli_path"`
+}
+
+type CreateDestinationInput struct {
+	Alias   string `json:"alias"`
+	Label   string `json:"label"`
+	CliPath string `json:"cli_path"`
+}

package/pkg/hookdeck/guest.go

@@ -0,0 +1,37 @@
+package hookdeck
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+type GuestUser struct {
+	Id         string `json:"id"`
+	APIKey     string `json:"key"`
+	Url        string `json:"link"`
+	BrowserURL string `json:"browser_url"`
+	PollURL    string `json:"poll_url"`
+}
+
+type CreateGuestUserInput struct {
+	DeviceName string `json:"device_name"`
+}
+
+func (c *Client) CreateGuestUser(input CreateGuestUserInput) (GuestUser, error) {
+	input_bytes, err := json.Marshal(input)
+	if err != nil {
+		return GuestUser{}, err
+	}
+	res, err := c.Post(context.Background(), "/cli/guest", input_bytes, nil)
+	if err != nil {
+		return GuestUser{}, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return GuestUser{}, fmt.Errorf("unexpected http status code: %d %s", res.StatusCode, err)
+	}
+	guest_user := GuestUser{}
+	postprocessJsonResponse(res, &guest_user)
+	return guest_user, nil
+}

package/pkg/hookdeck/session.go

@@ -0,0 +1,37 @@
+package hookdeck
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+)
+
+type Session struct {
+	Id string
+}
+
+type CreateSessionInput struct {
+	SourceId      string   `json:"source_id"`
+	ConnectionIds []string `json:"webhook_ids"`
+}
+
+func (c *Client) CreateSession(input CreateSessionInput) (Session, error) {
+	input_bytes, err := json.Marshal(input)
+	if err != nil {
+		return Session{}, err
+	}
+	res, err := c.Post(context.Background(), "/cli-sessions", input_bytes, nil)
+	if err != nil {
+		return Session{}, err
+	}
+	if res.StatusCode != http.StatusOK {
+		defer res.Body.Close()
+		body, _ := ioutil.ReadAll(res.Body)
+		return Session{}, fmt.Errorf("Unexpected http status code: %d %s", res.StatusCode, string(body))
+	}
+	session := Session{}
+	postprocessJsonResponse(res, &session)
+	return session, nil
+}