instRouter := router.PathPrefix("/v1").Subrouter()
instRouter.HandleFunc("/instance", instHandler.createHandler).Methods("POST")
instRouter.HandleFunc("/instance", instHandler.listHandler).Methods("GET")
+ // Match rb-names, versions or profiles
+ instRouter.HandleFunc("/instance", instHandler.listHandler).
+ Queries("rb-name", "{rb-name}",
+ "rb-version", "{rb-version}",
+ "profile-name", "{profile-name}").Methods("GET")
+
instRouter.HandleFunc("/instance/{instID}", instHandler.getHandler).Methods("GET")
instRouter.HandleFunc("/instance/{instID}", instHandler.deleteHandler).Methods("DELETE")
// (TODO): Fix update method
},
},
instClient: &mockInstanceClient{
- items: []app.InstanceResponse{
+ miniitems: []app.InstanceMiniResponse{
{
ID: "HaKpys8e",
Request: app.InstanceRequest{
CloudRegion: "region1",
},
Namespace: "testnamespace",
- Resources: []helm.KubernetesResource{
- {
- GVK: schema.GroupVersionKind{
- Group: "apps",
- Version: "v1",
- Kind: "Deployment"},
- Name: "test-deployment",
- },
- {
- GVK: schema.GroupVersionKind{
- Group: "",
- Version: "v1",
- Kind: "Service"},
- Name: "test-service",
- },
- },
},
},
},
}
}
-// getHandler retrieves information about an instance via the ID
+// listHandler retrieves information about an instance via the ID
func (i instanceHandler) listHandler(w http.ResponseWriter, r *http.Request) {
- resp, err := i.client.List()
+ //If parameters are not provided, they are sent as empty strings
+ //Which will list all instances
+ rbName := r.FormValue("rb-name")
+ rbVersion := r.FormValue("rb-version")
+ ProfileName := r.FormValue("profile-name")
+
+ resp, err := i.client.List(rbName, rbVersion, ProfileName)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
return m.items[0], nil
}
-func (m *mockInstanceClient) List() ([]app.InstanceMiniResponse, error) {
+func (m *mockInstanceClient) List(rbname, rbversion, profilename string) ([]app.InstanceMiniResponse, error) {
if m.err != nil {
return []app.InstanceMiniResponse{}, m.err
}
return m.miniitems, nil
}
-func (m *mockInstanceClient) Find(rbName string, ver string, profile string, labelKeys map[string]string) ([]app.InstanceResponse, error) {
+func (m *mockInstanceClient) Find(rbName string, ver string, profile string, labelKeys map[string]string) ([]app.InstanceMiniResponse, error) {
if m.err != nil {
return nil, m.err
}
- return m.items, nil
+ return m.miniitems, nil
}
func (m *mockInstanceClient) Delete(id string) error {
label string
input string
expectedCode int
+ queryParams bool
+ queryParamsMap map[string]string
expectedResponse []app.InstanceMiniResponse
instClient *mockInstanceClient
}{
},
},
},
+ {
+ label: "List Instances Based on Query Parameters",
+ queryParams: true,
+ queryParamsMap: map[string]string{
+ "rb-name": "test-rbdef1",
+ },
+ expectedCode: http.StatusOK,
+ expectedResponse: []app.InstanceMiniResponse{
+ {
+ ID: "HaKpys8e",
+ Request: app.InstanceRequest{
+ RBName: "test-rbdef",
+ RBVersion: "v1",
+ ProfileName: "profile1",
+ CloudRegion: "region1",
+ },
+ Namespace: "testnamespace",
+ },
+ },
+ instClient: &mockInstanceClient{
+ miniitems: []app.InstanceMiniResponse{
+ {
+ ID: "HaKpys8e",
+ Request: app.InstanceRequest{
+ RBName: "test-rbdef",
+ RBVersion: "v1",
+ ProfileName: "profile1",
+ CloudRegion: "region1",
+ },
+ Namespace: "testnamespace",
+ },
+ },
+ },
+ },
}
for _, testCase := range testCases {
t.Run(testCase.label, func(t *testing.T) {
request := httptest.NewRequest("GET", "/v1/instance", nil)
+ if testCase.queryParams {
+ q := request.URL.Query()
+ for k, v := range testCase.queryParamsMap {
+ q.Add(k, v)
+ }
+ request.URL.RawQuery = q.Encode()
+ }
resp := executeRequest(request, NewRouter(nil, nil, testCase.instClient, nil, nil, nil))
if testCase.expectedCode != resp.StatusCode {
type InstanceManager interface {
Create(i InstanceRequest) (InstanceResponse, error)
Get(id string) (InstanceResponse, error)
- List() ([]InstanceMiniResponse, error)
- Find(rbName string, ver string, profile string, labelKeys map[string]string) ([]InstanceResponse, error)
+ List(rbname, rbversion, profilename string) ([]InstanceMiniResponse, error)
+ Find(rbName string, ver string, profile string, labelKeys map[string]string) ([]InstanceMiniResponse, error)
Delete(id string) error
}
// List returns the instance for corresponding ID
// Empty string returns all
-func (v *InstanceClient) List() ([]InstanceMiniResponse, error) {
+func (v *InstanceClient) List(rbname, rbversion, profilename string) ([]InstanceMiniResponse, error) {
dbres, err := db.DBconn.ReadAll(v.storeName, v.tagInst)
if err != nil || len(dbres) == 0 {
}
var results []InstanceMiniResponse
+
for key, value := range dbres {
//value is a byte array
if value != nil {
Request: resp.Request,
Namespace: resp.Namespace,
}
+
+ //Filter based on the accepted keys
+ if len(rbname) != 0 &&
+ miniresp.Request.RBName != rbname {
+ continue
+ }
+ if len(rbversion) != 0 &&
+ miniresp.Request.RBVersion != rbversion {
+ continue
+ }
+ if len(profilename) != 0 &&
+ miniresp.Request.ProfileName != profilename {
+ continue
+ }
+
results = append(results, miniresp)
}
}
// If profile is empty, it will return all instances for a given rbName+version
// If labelKeys are provided, the results are filtered based on that.
// It is an AND operation for labelkeys.
-func (v *InstanceClient) Find(rbName string, version string, profile string, labelKeys map[string]string) ([]InstanceResponse, error) {
+func (v *InstanceClient) Find(rbName string, version string, profile string, labelKeys map[string]string) ([]InstanceMiniResponse, error) {
if rbName == "" && len(labelKeys) == 0 {
- return []InstanceResponse{}, pkgerrors.New("rbName or labelkeys is required and cannot be empty")
+ return []InstanceMiniResponse{}, pkgerrors.New("rbName or labelkeys is required and cannot be empty")
}
- values, err := db.DBconn.ReadAll(v.storeName, v.tagInst)
- if err != nil || len(values) == 0 {
- return []InstanceResponse{}, pkgerrors.Wrap(err, "Find Instance")
+ responses, err := v.List(rbName, version, profile)
+ if err != nil {
+ return []InstanceMiniResponse{}, pkgerrors.Wrap(err, "Listing Instances")
}
- response := []InstanceResponse{}
- //values is a map[string][]byte
-InstanceResponseLoop:
- for _, value := range values {
- resp := InstanceResponse{}
- db.DBconn.Unmarshal(value, &resp)
- if err != nil {
- return []InstanceResponse{}, pkgerrors.Wrap(err, "Unmarshaling Instance Value")
- }
+ ret := []InstanceMiniResponse{}
- // Filter by labels provided
- if len(labelKeys) != 0 {
- for lkey, lvalue := range labelKeys {
- //Check if label key exists and get its value
- if val, ok := resp.Request.Labels[lkey]; ok {
- if lvalue != val {
- continue InstanceResponseLoop
- }
- } else {
- continue InstanceResponseLoop
- }
- }
- }
+ //filter the list by labelKeys now
+ for _, resp := range responses {
- if rbName != "" {
- if resp.Request.RBName == rbName {
-
- //Check if a version is provided and if it matches
- if version != "" {
- if resp.Request.RBVersion == version {
- //Check if a profilename matches or if it is not provided
- if profile == "" || resp.Request.ProfileName == profile {
- response = append(response, resp)
- }
- }
- } else {
- //Append all versions as version is not provided
- response = append(response, resp)
- }
+ add := true
+ for k, v := range labelKeys {
+ if resp.Request.Labels[k] != v {
+ add = false
+ break
}
- } else {
- response = append(response, resp)
}
- }
-
- //filter the list by labelKeys now
- for _, value := range response {
- for _, label := range labelKeys {
- if _, ok := value.Request.Labels[label]; ok {
- }
+ // If label was not found in the response, don't add it
+ if add {
+ ret = append(ret, resp)
}
+
}
- return response, nil
+ return ret, nil
}
// Delete the Instance from database
Items: items,
}
- expected := []InstanceResponse{
+ expected := []InstanceMiniResponse{
{
ID: "HaKpys8e",
Request: InstanceRequest{
},
},
Namespace: "testnamespace",
- Resources: []helm.KubernetesResource{
- {
- GVK: schema.GroupVersionKind{
- Group: "apps",
- Version: "v1",
- Kind: "Deployment"},
- Name: "deployment-1",
- },
- {
- GVK: schema.GroupVersionKind{
- Group: "",
- Version: "v1",
- Kind: "Service"},
- Name: "service-1",
- },
- },
},
{
ID: "HaKpys8f",
CloudRegion: "region1",
},
Namespace: "testnamespace",
- Resources: []helm.KubernetesResource{
- {
- GVK: schema.GroupVersionKind{
- Group: "apps",
- Version: "v1",
- Kind: "Deployment"},
- Name: "deployment-1",
- },
- {
- GVK: schema.GroupVersionKind{
- Group: "",
- Version: "v1",
- Kind: "Service"},
- Name: "service-1",
- },
- },
},
{
ID: "HaKpys8g",
CloudRegion: "region1",
},
Namespace: "testnamespace",
- Resources: []helm.KubernetesResource{
- {
- GVK: schema.GroupVersionKind{
- Group: "apps",
- Version: "v1",
- Kind: "Deployment"},
- Name: "deployment-1",
- },
- {
- GVK: schema.GroupVersionKind{
- Group: "",
- Version: "v1",
- Kind: "Service"},
- Name: "service-1",
- },
- },
},
}
ic := NewInstanceClient()
}
})
- t.Run("Successfully Find Instance By Name Version", func(t *testing.T) {
+ t.Run("Successfully Find Instance By Name and Label", func(t *testing.T) {
db.DBconn = &db.MockDB{
Items: items,
}
- expected := []InstanceResponse{
+ expected := []InstanceMiniResponse{
{
ID: "HaKpys8e",
Request: InstanceRequest{
},
},
Namespace: "testnamespace",
+ },
+ }
+ ic := NewInstanceClient()
+ name := "test-rbdef"
+ labels := map[string]string{
+ "vf_module_id": "test-vf-module-id",
+ }
+ data, err := ic.Find(name, "", "", labels)
+ if err != nil {
+ t.Fatalf("TestInstanceFind returned an error (%s)", err)
+ }
- Resources: []helm.KubernetesResource{
- {
- GVK: schema.GroupVersionKind{
- Group: "apps",
- Version: "v1",
- Kind: "Deployment"},
- Name: "deployment-1",
- },
- {
- GVK: schema.GroupVersionKind{
- Group: "",
- Version: "v1",
- Kind: "Service"},
- Name: "service-1",
+ // Since the order of returned slice is not guaranteed
+ // Check both and return error if both don't match
+ sort.Slice(data, func(i, j int) bool {
+ return data[i].ID < data[j].ID
+ })
+ // Sort both as it is not expected that testCase.expected
+ // is sorted
+ sort.Slice(expected, func(i, j int) bool {
+ return expected[i].ID < expected[j].ID
+ })
+
+ if !reflect.DeepEqual(expected, data) {
+ t.Fatalf("TestInstanceFind returned:\n result=%v\n expected=%v",
+ data, expected)
+ }
+ })
+
+ t.Run("Successfully Find Instance By Name Version", func(t *testing.T) {
+ db.DBconn = &db.MockDB{
+ Items: items,
+ }
+
+ expected := []InstanceMiniResponse{
+ {
+ ID: "HaKpys8e",
+ Request: InstanceRequest{
+ RBName: "test-rbdef",
+ RBVersion: "v1",
+ ProfileName: "profile1",
+ CloudRegion: "region1",
+ Labels: map[string]string{
+ "vf_module_id": "test-vf-module-id",
},
},
+ Namespace: "testnamespace",
},
{
ID: "HaKpys8f",
CloudRegion: "region1",
},
Namespace: "testnamespace",
-
- Resources: []helm.KubernetesResource{
- {
- GVK: schema.GroupVersionKind{
- Group: "apps",
- Version: "v1",
- Kind: "Deployment"},
- Name: "deployment-1",
- },
- {
- GVK: schema.GroupVersionKind{
- Group: "",
- Version: "v1",
- Kind: "Service"},
- Name: "service-1",
- },
- },
},
}
ic := NewInstanceClient()
Items: items,
}
- expected := []InstanceResponse{
+ expected := []InstanceMiniResponse{
{
ID: "HaKpys8e",
Request: InstanceRequest{
},
},
Namespace: "testnamespace",
-
- Resources: []helm.KubernetesResource{
- {
- GVK: schema.GroupVersionKind{
- Group: "apps",
- Version: "v1",
- Kind: "Deployment"},
- Name: "deployment-1",
- },
- {
- GVK: schema.GroupVersionKind{
- Group: "",
- Version: "v1",
- Kind: "Service"},
- Name: "service-1",
- },
- },
},
}
ic := NewInstanceClient()
Code Review / multicloud / k8s.git / commitdiff