Lookup: Make namespace optional

acceptance/lookup_test.go

@@ -81,3 +81,55 @@ func TestLookupMetadata(t *testing.T) {
 	expected := fixtures.LookupMetadataResult
 	assert.Equal(t, expected, *actual)
 }
+
+func TestLookupNamespaceless(t *testing.T) {
+	if v := os.Getenv("JERAKIA_ACC"); v == "" {
+		t.Skip("JERAKIA_ACC not set")
+	}
+
+	client, err := NewClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	lookupOpts := &jerakia.LookupOpts{
+		Metadata: map[string]string{
+			"env": "dev",
+		},
+	}
+
+	actual, err := jerakia.Lookup(client, "biscuits", lookupOpts)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := fixtures.LookupNamespacelessResult
+	assert.Equal(t, expected, *actual)
+}
+
+func TestLookupNamespacelessCascade(t *testing.T) {
+	if v := os.Getenv("JERAKIA_ACC"); v == "" {
+		t.Skip("JERAKIA_ACC not set")
+	}
+
+	client, err := NewClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	lookupOpts := &jerakia.LookupOpts{
+		LookupType: "cascade",
+		Merge:      "array",
+		Metadata: map[string]string{
+			"env": "dev",
+		},
+	}
+
+	actual, err := jerakia.Lookup(client, "biscuits", lookupOpts)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := fixtures.LookupNamespacelessCascadeResult
+	assert.Equal(t, expected, *actual)
+}

lookup.go

@@ -38,12 +38,10 @@ type LookupOpts struct {
 func (opts LookupOpts) ToLookupQuery() (string, error) {
 	params := url.Values{}
 
-	if opts.Namespace == "" {
-		return "", fmt.Errorf("Namespace is required")
+	if opts.Namespace != "" {
+		params.Add("namespace", opts.Namespace)
 	}
 
-	params.Add("namespace", opts.Namespace)
-
 	if opts.Policy != "" {
 		params.Add("policy", opts.Policy)
 	}
@@ -56,6 +54,10 @@ func (opts LookupOpts) ToLookupQuery() (string, error) {
 		params.Add("scope", opts.Scope)
 	}
 
+	if opts.Merge != "" {
+		params.Add("merge", opts.Merge)
+	}
+
 	for k, v := range opts.ScopeOptions {
 		s := fmt.Sprintf("scope_%s", k)
 		params.Add(s, v)

testing/lookup_fixtures.go

@@ -110,3 +110,75 @@ func HandleLookupMetadata(t *testing.T) {
 		fmt.Fprintf(w, LookupMetadataResponse)
 	})
 }
+
+// LookupNamespacelessResponse is the expected response of a namespace-less lookup.
+const LookupNamespacelessResponse = `
+{
+    "found": true,
+    "payload": [
+        "gingernuts",
+        "jammiedodgers",
+        "custardcreams"
+    ],
+    "status": "ok"
+}
+`
+
+// LookupNamespacelessResult is the expected result of a namespace-less lookup.
+var LookupNamespacelessResult = jerakia.LookupResult{
+	Status: "ok",
+	Found:  true,
+	Payload: []interface{}{
+		"gingernuts", "jammiedodgers", "custardcreams",
+	},
+}
+
+// HandleLookupNamespaceless tests a namespace-less lookup.
+func HandleLookupNamespaceless(t *testing.T) {
+	th.Mux.HandleFunc("/lookup/biscuits", func(w http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, r.Method, "GET")
+		assert.Equal(t, r.Header.Get("X-Authentication"), fake.Token)
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		fmt.Fprintf(w, LookupNamespacelessResponse)
+	})
+}
+
+// LookupNamespacelessCascadeResponse is the expected response of a cascading
+// namespace-less lookup.
+const LookupNamespacelessCascadeResponse = `
+{
+    "found": true,
+    "payload": [
+        "gingernuts",
+        "jammiedodgers",
+        "custardcreams",
+        "richtea",
+        "digestive"
+    ],
+    "status": "ok"
+}
+`
+
+// LookupNamespacelessCascadeResult is the expected result of a cascading
+// namespace-less lookup.
+var LookupNamespacelessCascadeResult = jerakia.LookupResult{
+	Status: "ok",
+	Found:  true,
+	Payload: []interface{}{
+		"gingernuts", "jammiedodgers", "custardcreams", "richtea", "digestive",
+	},
+}
+
+// HandleLookupNamespacelessCascade tests a cascading namespace-less lookup.
+func HandleLookupNamespacelessCascade(t *testing.T) {
+	th.Mux.HandleFunc("/lookup/biscuits", func(w http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, r.Method, "GET")
+		assert.Equal(t, r.Header.Get("X-Authentication"), fake.Token)
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		fmt.Fprintf(w, LookupNamespacelessCascadeResponse)
+	})
+}

testing/lookup_requests_test.go

@@ -66,3 +66,45 @@ func TestLookupMetadata(t *testing.T) {
 	expected := LookupMetadataResult
 	assert.Equal(t, expected, *actual)
 }
+
+func TestLookupNamespaceless(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+	HandleLookupNamespaceless(t)
+
+	lookupOpts := &jerakia.LookupOpts{
+		Metadata: map[string]string{
+			"env": "dev",
+		},
+	}
+
+	actual, err := jerakia.Lookup(fake.FakeClient(), "biscuits", lookupOpts)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := LookupNamespacelessResult
+	assert.Equal(t, expected, *actual)
+}
+
+func TestLookupNamespacelessCascade(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+	HandleLookupNamespacelessCascade(t)
+
+	lookupOpts := &jerakia.LookupOpts{
+		LookupType: "cascade",
+		Merge:      "array",
+		Metadata: map[string]string{
+			"env": "dev",
+		},
+	}
+
+	actual, err := jerakia.Lookup(fake.FakeClient(), "biscuits", lookupOpts)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := LookupNamespacelessCascadeResult
+	assert.Equal(t, expected, *actual)
+}