Fix fake db implementation

coder · Emyrk · Jun 14, 2022 · Jun 7, 2022 · Jun 8, 2022 · Jun 8, 2022
commit 0f7bb21f651d9b7fd70b555f207d6079c4a18b80
diff --git a/coderd/database/databasefake/databasefake.go b/coderd/database/databasefake/databasefake.go
@@ -327,6 +327,23 @@ func (q *fakeQuerier) GetWorkspacesWithFilter(_ context.Context, arg database.Ge
 		if arg.OwnerID != uuid.Nil && workspace.OwnerID != arg.OwnerID {
 			continue
 		}
+		if arg.OwnerUsername != "" {
+			owner, err := q.GetUserByID(context.Background(), workspace.OwnerID)
+			if err == nil && arg.OwnerUsername != owner.Username {
+				continue
+			}
+		}
+		if arg.TemplateName != "" {
+			templates, err := q.GetTemplatesByName(context.Background(), database.GetTemplatesByNameParams{
+				Name: arg.TemplateName,
+			})
+			// Add to later param
+			if err == nil {
+				for _, t := range templates {
+					arg.TemplateIds = append(arg.TemplateIds, t.ID)
+				}
+			}
+		}
 		if !arg.Deleted && workspace.Deleted {
 			continue
 		}

diff --git a/coderd/httpapi/queryparams.go b/coderd/httpapi/queryparams.go
@@ -89,7 +89,7 @@ func (p *QueryParamParser) ParseUUIDArray(r *http.Request, def []uuid.UUID, quer
 	if err != nil {
 		p.errors = append(p.errors, Error{
 			Field:  queryParam,
-			Detail: fmt.Sprintf("Query param %q has invalid uuids: %q", err.Error()),
+			Detail: fmt.Sprintf("Query param %q has invalid uuids: %q", queryParam, err.Error()),
 		})
 	}
 	return v

diff --git a/coderd/httpapi/search.go b/coderd/httpapi/search.go
@@ -6,17 +6,20 @@ import (
 	"golang.org/x/xerrors"
 )
 
-// WorkspaceSearchQuery takes a query string and breaks it into it's query
-// params as a set of key=value.
+// WorkspaceSearchQuery takes a query string and breaks it into it's queryparams
+// as a set of key=value.
 func WorkspaceSearchQuery(query string) (map[string]string, error) {
 	searchParams := make(map[string]string)
-	elements := queryElements(query)
+	if query == "" {
+		return searchParams, nil
+	}
+	elements := splitElements(query, ' ')
 	for _, element := range elements {
-		parts := strings.Split(element, ":")
+		parts := splitElements(query, ':')
 		switch len(parts) {
 		case 1:
 			// No key:value pair. It is a workspace name, and maybe includes an owner
-			parts = strings.Split(element, "/")
+			parts = splitElements(query, '/')
 			switch len(parts) {
 			case 1:
 				searchParams["name"] = parts[0]
@@ -36,10 +39,16 @@ func WorkspaceSearchQuery(query string) (map[string]string, error) {
 	return searchParams, nil
 }
 
-// queryElements takes a query string and splits it into the individual elements
-// of the query. Each element is separated by a space. All quoted strings are
+// splitElements takes a query string and splits it into the individual elements
+// of the query. Each element is separated by a delimiter. All quoted strings are
 // kept as a single element.
-func queryElements(query string) []string {
+//
+// Although all our names cannot have spaces, that is a validation error.
+// We should still parse the quoted string as a single value so that validation
+// can properly fail on the space. If we do not, a value of `template:"my name"`
+// will search `template:"my name:name"`, which produces an empty list instead of
+// an error.
+func splitElements(query string, delimiter rune) []string {
 	var parts []string
 
 	quoted := false
@@ -48,7 +57,7 @@ func queryElements(query string) []string {
 		switch c {
 		case '"':
 			quoted = !quoted
-		case ' ':
+		case delimiter:
 			if quoted {
 				current.WriteRune(c)
 			} else {

diff --git a/coderd/httpapi/search_test.go b/coderd/httpapi/search_test.go
@@ -0,0 +1,123 @@
+package httpapi_test
+
+import (
+	"testing"
+
+	"github.com/coder/coder/coderd/httpapi"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSearchWorkspace(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		Name                  string
+		Query                 string
+		Expected              map[string]string
+		ExpectedErrorContains string
+	}{
+		{
+			Name:     "Empty",
+			Query:    "",
+			Expected: map[string]string{},
+		},
+		{
+			Name:  "Owner/Name",
+			Query: "Foo/Bar",
+			Expected: map[string]string{
+				"owner": "Foo",
+				"name":  "Bar",
+			},
+		},
+		{
+			Name:  "Name",
+			Query: "workspace-name",
+			Expected: map[string]string{
+				"name": "workspace-name",
+			},
+		},
+		{
+			Name:  "Name+Param",
+			Query: "workspace-name template:docker",
+			Expected: map[string]string{
+				"name":     "workspace-name",
+				"template": "docker",
+			},
+		},
+		{
+			Name:  "OnlyParams",
+			Query: "name:workspace-name template:docker owner:alice",
+			Expected: map[string]string{
+				"owner":    "alice",
+				"name":     "workspace-name",
+				"template": "docker",
+			},
+		},
+		{
+			Name:  "QuotedParam",
+			Query: `name:workspace-name template:"docker template" owner:alice`,
+			Expected: map[string]string{
+				"owner":    "alice",
+				"name":     "workspace-name",
+				"template": "docker template",
+			},
+		},
+		{
+			Name:  "QuotedKey",
+			Query: `"spaced key":"spaced value"`,
+			Expected: map[string]string{
+				"spaced key": "spaced value",
+			},
+		},
+		{
+			// This will not return an error
+			Name:  "ExtraKeys",
+			Query: `foo:bar`,
+			Expected: map[string]string{
+				"foo": "bar",
+			},
+		},
+		{
+			// Quotes keep elements together
+			Name:  "QuotedSpecial",
+			Query: `name:"workspace:name"`,
+			Expected: map[string]string{
+				"name": "workspace:name",
+			},
+		},
+		{
+			Name:  "QuotedMadness",
+			Query: `"key:is:wild/a/b/c":"foo:bar/baz/zoo:zonk"`,
+			Expected: map[string]string{
+				"key:is:wild/a/b/c": "foo:bar/baz/zoo:zonk",
+			},
+		},
+
+		// Failures
+		{
+			Name:                  "ExtraSlashes",
+			Query:                 `foo/bar/baz`,
+			ExpectedErrorContains: "can only contain 1 '/'",
+		},
+		{
+			Name:                  "ExtraColon",
+			Query:                 `owner:name:extra`,
+			ExpectedErrorContains: "can only contain 1 ':'",
+		},
+	}
+
+	for _, c := range testCases {
+		c := c
+		t.Run(c.Name, func(t *testing.T) {
+			t.Parallel()
+			values, err := httpapi.WorkspaceSearchQuery(c.Query)
+			if c.ExpectedErrorContains != "" {
+				require.Error(t, err, "expected error")
+				require.ErrorContains(t, err, c.ExpectedErrorContains)
+			} else {
+				require.NoError(t, err, "expected no error")
+				require.Equal(t, c.Expected, values, "expected values")
+			}
+
+		})
+	}
+}
diff --git a/coderd/workspaces.go b/coderd/workspaces.go
@@ -117,17 +117,19 @@ func (api *API) workspaces(rw http.ResponseWriter, r *http.Request) {
 	}
 
 	// Set all the query params from the "q" field.
+	q := r.URL.Query()
 	for k, v := range values {
 		// Do not allow overriding if the user also set query param fields
 		// outside the query string.
-		if r.URL.Query().Has(k) {
+		if q.Has(k) {
 			httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
 				Message: fmt.Sprintf("Workspace filter %q cannot be set twice. In query params %q and %q", k, k, "q"),
 			})
 			return
 		}
-		r.URL.Query().Set(k, v)
+		q.Set(k, v)
 	}
+	r.URL.RawQuery = q.Encode()
 
 	parser := httpapi.NewQueryParamParser()
 	filter := database.GetWorkspacesWithFilterParams{

diff --git a/coderd/workspaces_test.go b/coderd/workspaces_test.go
@@ -363,6 +363,25 @@ func TestWorkspaceFilter(t *testing.T) {
 		require.Len(t, ws, 1)
 		require.Equal(t, workspace.ID, ws[0].ID)
 	})
+	t.Run("FilterQuery", func(t *testing.T) {
+		t.Parallel()
+		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerD: true})
+		user := coderdtest.CreateFirstUser(t, client)
+		version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
+		coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
+		template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
+		template2 := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
+		workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
+		_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template2.ID)
+
+		// single workspace
+		ws, err := client.Workspaces(context.Background(), codersdk.WorkspaceFilter{
+			FilterQuery: fmt.Sprintf("template:%s %s/%s", template.Name, workspace.OwnerName, workspace.Name),
+		})
+		require.NoError(t, err)
+		require.Len(t, ws, 1)
+		require.Equal(t, workspace.ID, ws[0].ID)
+	})
 }
 
 func TestPostWorkspaceBuild(t *testing.T) {

diff --git a/codersdk/workspaces.go b/codersdk/workspaces.go
@@ -224,6 +224,8 @@ type WorkspaceFilter struct {
 	Template string `json:"template,omitempty"`
 	// Name will return partial matches
 	Name string `json:"name,omitempty"`
+	// FilterQuery supports a raw filter query string
+	FilterQuery string `json:"q,omitempty"`
 }
 
 // asRequestOption returns a function that can be used in (*Client).Request.
@@ -243,6 +245,9 @@ func (f WorkspaceFilter) asRequestOption() requestOption {
 		if f.Template != "" {
 			q.Set("template", f.Template)
 		}
+		if f.FilterQuery != "" {
+			q.Set("q", f.FilterQuery)
+		}
 		r.URL.RawQuery = q.Encode()
 	}
 }