chore: remove dependency on stretchr/testify

ci/integration/envs_test.go

@@ -14,7 +14,6 @@ import (
 	"cdr.dev/slog/sloggers/slogtest"
 	"cdr.dev/slog/sloggers/slogtest/assert"
 	"github.com/google/go-cmp/cmp"
-	"github.com/stretchr/testify/require"
 
 	"cdr.dev/coder-cli/coder-sdk"
 	"cdr.dev/coder-cli/pkg/tcli"
@@ -30,7 +29,7 @@ func cleanupClient(ctx context.Context, t *testing.T) coder.Client {
 		BaseURL: u,
 		Token:   creds.token,
 	})
-	require.NoError(t, err, "failed to create coder.Client")
+	assert.Success(t, "failed to create coder.Client", err)
 	return client
 }
 

coder-sdk/activity_test.go

@@ -8,7 +8,7 @@ import (
 	"net/url"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"cdr.dev/slog/sloggers/slogtest/assert"
 
 	"cdr.dev/coder-cli/coder-sdk"
 )
@@ -19,17 +19,17 @@ func TestPushActivity(t *testing.T) {
 	const source = "test"
 	const envID = "602d377a-e6b8d763cae7561885c5f1b2"
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, http.MethodPost, r.Method, "PushActivity is a POST")
-		require.Equal(t, "/api/private/metrics/usage/push", r.URL.Path)
+		assert.Equal(t, "PushActivity is a POST", http.MethodPost, r.Method)
+		assert.Equal(t, "URL matches", "/api/private/metrics/usage/push", r.URL.Path)
 
 		expected := map[string]interface{}{
 			"source":         source,
 			"environment_id": envID,
 		}
 		var request map[string]interface{}
 		err := json.NewDecoder(r.Body).Decode(&request)
-		require.NoError(t, err, "error decoding JSON")
-		require.EqualValues(t, expected, request, "unexpected request data")
+		assert.Success(t, "error decoding JSON", err)
+		assert.Equal(t, "unexpected request data", expected, request)
 
 		w.WriteHeader(http.StatusOK)
 	}))
@@ -38,14 +38,14 @@ func TestPushActivity(t *testing.T) {
 	})
 
 	u, err := url.Parse(server.URL)
-	require.NoError(t, err, "failed to parse test server URL")
+	assert.Success(t, "failed to parse test server URL", err)
 
 	client, err := coder.NewClient(coder.ClientOptions{
 		BaseURL: u,
 		Token:   "SwdcSoq5Jc-0C1r8wfwm7h6h9i0RDk7JT",
 	})
-	require.NoError(t, err, "failed to create coder.Client")
+	assert.Success(t, "failed to create coder.Client", err)
 
 	err = client.PushActivity(context.Background(), source, envID)
-	require.NoError(t, err)
+	assert.Success(t, "expected successful response from PushActivity", err)
 }

coder-sdk/client_test.go

@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	"cdr.dev/slog/sloggers/slogtest/assert"
 
 	"cdr.dev/coder-cli/coder-sdk"
 )
@@ -21,7 +21,7 @@ func TestAuthentication(t *testing.T) {
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		gotToken := r.Header.Get("Session-Token")
-		require.Equal(t, token, gotToken, "token does not match")
+		assert.Equal(t, "token does not match", token, gotToken)
 
 		w.WriteHeader(http.StatusServiceUnavailable)
 	}))
@@ -30,19 +30,19 @@ func TestAuthentication(t *testing.T) {
 	})
 
 	u, err := url.Parse(server.URL)
-	require.NoError(t, err, "failed to parse test server URL")
+	assert.Success(t, "failed to parse test server URL", err)
 
 	client, err := coder.NewClient(coder.ClientOptions{
 		BaseURL: u,
 		Token:   token,
 	})
-	require.NoError(t, err, "failed to create coder.Client")
+	assert.Success(t, "failed to create coder.Client", err)
 
-	require.Equal(t, token, client.Token(), "expected Token to match")
-	require.EqualValues(t, *u, client.BaseURL(), "expected BaseURL to match")
+	assert.Equal(t, "expected Token to match", token, client.Token())
+	assert.Equal(t, "expected BaseURL to match", *u, client.BaseURL())
 
 	_, err = client.APIVersion(context.Background())
-	require.NoError(t, err, "failed to get API version information")
+	assert.Success(t, "failed to get API version information", err)
 }
 
 func TestPasswordAuthentication(t *testing.T) {
@@ -54,29 +54,30 @@ func TestPasswordAuthentication(t *testing.T) {
 
 	mux := http.NewServeMux()
 	mux.HandleFunc("/auth/basic/login", func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, r.Method, http.MethodPost, "login is a POST")
+		assert.Equal(t, "login is a POST", http.MethodPost, r.Method)
 
 		expected := map[string]interface{}{
 			"email":    email,
 			"password": password,
 		}
 		var request map[string]interface{}
 		err := json.NewDecoder(r.Body).Decode(&request)
-		require.NoError(t, err, "error decoding JSON")
-		require.EqualValues(t, expected, request, "unexpected request data")
+		assert.Success(t, "error decoding JSON", err)
+		assert.Equal(t, "unexpected request data", expected, request)
 
 		response := map[string]interface{}{
 			"session_token": token,
 		}
 
 		w.WriteHeader(http.StatusOK)
 		err = json.NewEncoder(w).Encode(response)
-		require.NoError(t, err, "error encoding JSON")
+		assert.Success(t, "error encoding JSON", err)
 	})
 	mux.HandleFunc("/api/v0/users/me", func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, http.MethodGet, r.Method, "Users is a GET")
+		assert.Equal(t, "Users is a GET", http.MethodGet, r.Method)
 
-		require.Equal(t, token, r.Header.Get("Session-Token"), "expected session token to match return of login")
+		gotToken := r.Header.Get("Session-Token")
+		assert.Equal(t, "expected session token to match return of login", token, gotToken)
 
 		user := map[string]interface{}{
 			"id":                 "default",
@@ -93,37 +94,37 @@ func TestPasswordAuthentication(t *testing.T) {
 
 		w.WriteHeader(http.StatusOK)
 		err := json.NewEncoder(w).Encode(user)
-		require.NoError(t, err, "error encoding JSON")
+		assert.Success(t, "error encoding JSON", err)
 	})
 	server := httptest.NewTLSServer(mux)
 	t.Cleanup(func() {
 		server.Close()
 	})
 
 	u, err := url.Parse(server.URL)
-	require.NoError(t, err, "failed to parse test server URL")
-	require.Equal(t, "https", u.Scheme, "expected HTTPS base URL")
+	assert.Success(t, "failed to parse test server URL", err)
+	assert.Equal(t, "expected HTTPS base URL", "https", u.Scheme)
 
 	client, err := coder.NewClient(coder.ClientOptions{
 		BaseURL:    u,
 		HTTPClient: server.Client(),
 		Email:      email,
 		Password:   password,
 	})
-	require.NoError(t, err, "failed to create Client")
-	require.Equal(t, token, client.Token(), "expected token to match")
+	assert.Success(t, "failed to create Client", err)
+	assert.Equal(t, "expected token to match", token, client.Token())
 
 	user, err := client.Me(context.Background())
-	require.NoError(t, err, "failed to get information about current user")
-	require.Equal(t, email, user.Email, "expected test user")
+	assert.Success(t, "failed to get information about current user", err)
+	assert.Equal(t, "expected test user", email, user.Email)
 }
 
 func TestContextRoot(t *testing.T) {
 	t.Parallel()
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, r.Method, http.MethodGet, "Users is a GET")
-		require.Equal(t, r.URL.Path, "/context-root/api/v0/users")
+		assert.Equal(t, "Users is a GET", http.MethodGet, r.Method)
+		assert.Equal(t, "expected context root", "/context-root/api/v0/users", r.URL.Path)
 
 		w.WriteHeader(http.StatusServiceUnavailable)
 	}))
@@ -137,7 +138,7 @@ func TestContextRoot(t *testing.T) {
 	}
 
 	u, err := url.Parse(server.URL)
-	require.NoError(t, err, "failed to parse test server URL")
+	assert.Success(t, "failed to parse test server URL", err)
 
 	for _, prefix := range contextRoots {
 		u.Path = prefix
@@ -146,9 +147,9 @@ func TestContextRoot(t *testing.T) {
 			BaseURL: u,
 			Token:   "FrOgA6xhpM-p5nTfsupmvzYJA6DJSOUoE",
 		})
-		require.NoError(t, err, "failed to create coder.Client")
+		assert.Success(t, "failed to create coder.Client", err)
 
 		_, err = client.Users(context.Background())
-		require.Error(t, err, "expected 503 error")
+		assert.Error(t, "expected 503 error", err)
 	}
 }

coder-sdk/users_test.go

@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	"cdr.dev/slog/sloggers/slogtest/assert"
 
 	"cdr.dev/coder-cli/coder-sdk"
 )
@@ -21,8 +21,8 @@ func TestUsers(t *testing.T) {
 	const name = "Charlie Root"
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, http.MethodGet, r.Method, "Users is a GET")
-		require.Equal(t, "/api/v0/users", r.URL.Path)
+		assert.Equal(t, "Users is a GET", http.MethodGet, r.Method)
+		assert.Equal(t, "Path matches", "/api/v0/users", r.URL.Path)
 
 		users := []map[string]interface{}{
 			{
@@ -41,26 +41,26 @@ func TestUsers(t *testing.T) {
 
 		w.WriteHeader(http.StatusOK)
 		err := json.NewEncoder(w).Encode(users)
-		require.NoError(t, err, "error encoding JSON")
+		assert.Success(t, "error encoding JSON", err)
 	}))
 	t.Cleanup(func() {
 		server.Close()
 	})
 
 	u, err := url.Parse(server.URL)
-	require.NoError(t, err, "failed to parse test server URL")
+	assert.Success(t, "failed to parse test server URL", err)
 
 	client, err := coder.NewClient(coder.ClientOptions{
 		BaseURL: u,
 		Token:   "JcmErkJjju-KSrztst0IJX7xGJhKQPtfv",
 	})
-	require.NoError(t, err, "failed to create coder.Client")
+	assert.Success(t, "failed to create coder.Client", err)
 
 	users, err := client.Users(context.Background())
-	require.NoError(t, err, "error getting Users")
-	require.Len(t, users, 1, "users should return a single user")
-	require.Equal(t, name, users[0].Name)
-	require.Equal(t, username, users[0].Username)
+	assert.Success(t, "error getting Users", err)
+	assert.True(t, "users should return a single user", len(users) == 1)
+	assert.Equal(t, "expected user's name to match", name, users[0].Name)
+	assert.Equal(t, "expected user's username to match", username, users[0].Username)
 }
 
 func TestUserUpdatePassword(t *testing.T) {
@@ -70,17 +70,17 @@ func TestUserUpdatePassword(t *testing.T) {
 	const newPassword = "wmf39jw2f7pk"
 
 	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, http.MethodPatch, r.Method, "Users is a PATCH")
-		require.Equal(t, "/api/v0/users/me", r.URL.Path)
+		assert.Equal(t, "Users is a PATCH", http.MethodPatch, r.Method)
+		assert.Equal(t, "Path matches", "/api/v0/users/me", r.URL.Path)
 
 		expected := map[string]interface{}{
 			"old_password": oldPassword,
 			"password":     newPassword,
 		}
 		var request map[string]interface{}
 		err := json.NewDecoder(r.Body).Decode(&request)
-		require.NoError(t, err, "error decoding JSON")
-		require.EqualValues(t, expected, request, "unexpected request data")
+		assert.Success(t, "error decoding JSON", err)
+		assert.Equal(t, "unexpected request data", expected, request)
 
 		w.WriteHeader(http.StatusOK)
 	}))
@@ -89,14 +89,14 @@ func TestUserUpdatePassword(t *testing.T) {
 	})
 
 	u, err := url.Parse(server.URL)
-	require.NoError(t, err, "failed to parse test server URL")
+	assert.Success(t, "failed to parse test server URL", err)
 
 	client, err := coder.NewClient(coder.ClientOptions{
 		BaseURL:    u,
 		HTTPClient: server.Client(),
 		Token:      "JcmErkJjju-KSrztst0IJX7xGJhKQPtfv",
 	})
-	require.NoError(t, err, "failed to create coder.Client")
+	assert.Success(t, "failed to create coder.Client", err)
 
 	err = client.UpdateUser(context.Background(), "me", coder.UpdateUserReq{
 		UserPasswordSettings: &coder.UserPasswordSettings{
@@ -105,5 +105,5 @@ func TestUserUpdatePassword(t *testing.T) {
 			Temporary:   false,
 		},
 	})
-	require.NoError(t, err, "error when updating password")
+	assert.Success(t, "error when updating password", err)
 }

go.mod

@@ -16,7 +16,7 @@ require (
 	github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4
 	github.com/rjeczalik/notify v0.9.2
 	github.com/spf13/cobra v1.1.1
-	github.com/stretchr/testify v1.6.1
+	github.com/stretchr/testify v1.6.1 // indirect
 	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
 	golang.org/x/net v0.0.0-20200822124328-c89045814202 // indirect
 	golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208

internal/loginsrv/input_test.go

@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	"cdr.dev/slog/sloggers/slogtest/assert"
 
 	"cdr.dev/coder-cli/internal/loginsrv"
 )
@@ -62,14 +62,14 @@ func TestReadLine(t *testing.T) {
 			case err := <-errChan:
 				t.Fatalf("ReadLine returned before we got the token (%v).", err)
 			case actualToken := <-tokenChan:
-				require.Equal(t, testToken, actualToken, "Unexpected token received from readline.")
+				assert.Equal(t, "Unexpected token received from readline.", testToken, actualToken)
 			}
 
 			select {
 			case <-ctx.Done():
 				t.Fatal("Timeout waiting for readline to finish.")
 			case err := <-errChan:
-				require.NoError(t, err, "Error reading the line.")
+				assert.Success(t, "Error reading the line.", err)
 			}
 		})
 	}
@@ -119,7 +119,7 @@ func TestReadLineMissingToken(t *testing.T) {
 	case <-ctx.Done():
 		t.Fatal("Timeout waiting for readline to finish.")
 	case err := <-errChan:
-		require.NoError(t, err, "Error reading the line.")
+		assert.Success(t, "Error reading the line.", err)
 	case token, ok := <-tokenChan:
 		t.Fatalf("Token channel unexpectedly unblocked. Data: %q, state: %t.", token, ok)
 	}