From 3e27032578d027850e573aca7118ac49452cd79d Mon Sep 17 00:00:00 2001 From: Joe Topjian Date: Thu, 15 Feb 2018 03:17:59 +0000 Subject: [PATCH 1/2] Lookup: Make namespace optional --- acceptance/lookup_test.go | 25 ++++++++++++++++++++++++ lookup.go | 6 ++---- testing/lookup_fixtures.go | 34 +++++++++++++++++++++++++++++++++ testing/lookup_requests_test.go | 20 +++++++++++++++++++ 4 files changed, 81 insertions(+), 4 deletions(-) diff --git a/acceptance/lookup_test.go b/acceptance/lookup_test.go index 939e767..56c0d28 100644 --- a/acceptance/lookup_test.go +++ b/acceptance/lookup_test.go @@ -81,3 +81,28 @@ 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) +} diff --git a/lookup.go b/lookup.go index 1d04623..07dfab4 100644 --- a/lookup.go +++ b/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) } diff --git a/testing/lookup_fixtures.go b/testing/lookup_fixtures.go index a6e55d2..17cbe84 100644 --- a/testing/lookup_fixtures.go +++ b/testing/lookup_fixtures.go @@ -110,3 +110,37 @@ 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) + }) +} diff --git a/testing/lookup_requests_test.go b/testing/lookup_requests_test.go index 126bde9..b2fcb03 100644 --- a/testing/lookup_requests_test.go +++ b/testing/lookup_requests_test.go @@ -66,3 +66,23 @@ 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) +} From 95026f872f3640b19a650b29d7b5fbd5a1b6723b Mon Sep 17 00:00:00 2001 From: Joe Topjian Date: Thu, 15 Feb 2018 03:31:11 +0000 Subject: [PATCH 2/2] add cascade test and add merge to query params --- acceptance/lookup_test.go | 27 +++++++++++++++++++++++ lookup.go | 4 ++++ testing/lookup_fixtures.go | 38 +++++++++++++++++++++++++++++++++ testing/lookup_requests_test.go | 22 +++++++++++++++++++ 4 files changed, 91 insertions(+) diff --git a/acceptance/lookup_test.go b/acceptance/lookup_test.go index 56c0d28..3a721c0 100644 --- a/acceptance/lookup_test.go +++ b/acceptance/lookup_test.go @@ -106,3 +106,30 @@ func TestLookupNamespaceless(t *testing.T) { 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) +} diff --git a/lookup.go b/lookup.go index 07dfab4..e2dd052 100644 --- a/lookup.go +++ b/lookup.go @@ -54,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) diff --git a/testing/lookup_fixtures.go b/testing/lookup_fixtures.go index 17cbe84..2c59c95 100644 --- a/testing/lookup_fixtures.go +++ b/testing/lookup_fixtures.go @@ -144,3 +144,41 @@ func HandleLookupNamespaceless(t *testing.T) { 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) + }) +} diff --git a/testing/lookup_requests_test.go b/testing/lookup_requests_test.go index b2fcb03..aa703f2 100644 --- a/testing/lookup_requests_test.go +++ b/testing/lookup_requests_test.go @@ -86,3 +86,25 @@ func TestLookupNamespaceless(t *testing.T) { 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) +}