From bcf4eca8f67c4ea92067d4970c852bdbd818a426 Mon Sep 17 00:00:00 2001 From: Steven Collins Date: Wed, 4 Aug 2021 09:46:43 -0500 Subject: [PATCH 1/3] Add SubscriptionIdsForCluster(). --- .../subscriptions/add_subscription_test.go | 2 +- .../subscriptions/subscription_client.go | 1 + .../subscription_ids_for_cluster.go | 73 ++++++ .../subscription_ids_for_cluster_test.go | 126 ++++++++++ .../fake_subscription_service.go | 81 +++++++ client/types/types.go | 4 + test/integration/subscriptions_test.go | 225 ++++++++++++------ 7 files changed, 443 insertions(+), 69 deletions(-) create mode 100644 client/actions/subscriptions/subscription_ids_for_cluster.go create mode 100644 client/actions/subscriptions/subscription_ids_for_cluster_test.go diff --git a/client/actions/subscriptions/add_subscription_test.go b/client/actions/subscriptions/add_subscription_test.go index 34c73c8..fda0e6c 100644 --- a/client/actions/subscriptions/add_subscription_test.go +++ b/client/actions/subscriptions/add_subscription_test.go @@ -58,7 +58,7 @@ var _ = Describe("AddSubscription", func() { }) }) - Describe("AddSubcription", func() { + Describe("AddSubscription", func() { var ( addSubscriptionResponse AddSubscriptionResponse diff --git a/client/actions/subscriptions/subscription_client.go b/client/actions/subscriptions/subscription_client.go index b95c710..2b8b693 100644 --- a/client/actions/subscriptions/subscription_client.go +++ b/client/actions/subscriptions/subscription_client.go @@ -17,6 +17,7 @@ type SubscriptionService interface { SetSubscription(orgID string, subscriptionUuid string, versionUuid string) (*SetSubscriptionResponseDataDetails, error) RemoveSubscription(orgID, uuid string) (*RemoveSubscriptionResponseDataDetails, error) Subscriptions(orgID string) (types.SubscriptionList, error) + SubscriptionIdsForCluster(orgID string, clusterID string) ([]string, error) } // Client is an implementation of a satcon client. diff --git a/client/actions/subscriptions/subscription_ids_for_cluster.go b/client/actions/subscriptions/subscription_ids_for_cluster.go new file mode 100644 index 0000000..97951d9 --- /dev/null +++ b/client/actions/subscriptions/subscription_ids_for_cluster.go @@ -0,0 +1,73 @@ +package subscriptions + +import ( + "github.com/IBM/satcon-client-go/client/actions" + "github.com/IBM/satcon-client-go/client/types" +) + +const ( + //QuerySubscriptionIdsForCluster specifies the query + QuerySubscriptionIdsForCluster = "subscriptionsForCluster" + //SubscriptionIdsForClusterVarTemplate is the template used to create the graphql query + SubscriptionIdsForClusterVarTemplate = `{{define "vars"}}"orgId":{{json .OrgID}},"clusterId":{{json .ClusterID}}{{end}}` +) + +//SubscriptionIdsForClusterVariables are the variables used for the subscription query +type SubscriptionIdsForClusterVariables struct { + actions.GraphQLQuery + OrgID string + ClusterID string +} + +//NewSubscriptionIdsForClusterVariables generates variables used for query +func NewSubscriptionIdsForClusterVariables(orgID string, clusterID string) SubscriptionIdsForClusterVariables { + vars := SubscriptionIdsForClusterVariables{ + OrgID: orgID, + ClusterID: clusterID, + } + + vars.Type = actions.QueryTypeQuery + vars.QueryName = QuerySubscriptionIdsForCluster + vars.Args = map[string]string{ + "orgId": "String!", + "clusterId": "String!", + } + vars.Returns = []string{ + "uuid", + } + + return vars +} + +//SubscriptionIdsForClusterResponse response from query +type SubscriptionIdsForClusterResponse struct { + Data *SubscriptionIdsForClusterResponseData `json:"data,omitempty"` +} + +// SubscriptionIdsForClusterResponseData data response from query +type SubscriptionIdsForClusterResponseData struct { + SubscriptionIdsForCluster []types.UuidOnly `json:"subscriptionsForCluster,omitempty"` +} + +func (c *Client) SubscriptionIdsForCluster(orgID string, clusterID string) ([]string, error) { + var response SubscriptionIdsForClusterResponse + + vars := NewSubscriptionIdsForClusterVariables(orgID, clusterID) + + err := c.DoQuery(SubscriptionIdsForClusterVarTemplate, vars, nil, &response) + + if err != nil { + return nil, err + } + + if response.Data != nil { + uuidResponses := response.Data.SubscriptionIdsForCluster + uuids := make([]string, len(uuidResponses)) + for i := 0; i < len(uuidResponses); i++ { + uuids[i] = uuidResponses[i].UUID + } + return uuids, nil + } + + return nil, err +} diff --git a/client/actions/subscriptions/subscription_ids_for_cluster_test.go b/client/actions/subscriptions/subscription_ids_for_cluster_test.go new file mode 100644 index 0000000..e54e966 --- /dev/null +++ b/client/actions/subscriptions/subscription_ids_for_cluster_test.go @@ -0,0 +1,126 @@ +package subscriptions_test + +import ( + "bytes" + "encoding/json" + "errors" + "io/ioutil" + "net/http" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "github.com/IBM/satcon-client-go/client/actions" + . "github.com/IBM/satcon-client-go/client/actions/subscriptions" + "github.com/IBM/satcon-client-go/client/auth/authfakes" + "github.com/IBM/satcon-client-go/client/types" + "github.com/IBM/satcon-client-go/client/web/webfakes" +) + +var _ = Describe("SubscriptionIdsForCluster", func() { + + var ( + orgID, clusterID string + fakeAuthClient authfakes.FakeAuthClient + ) + + BeforeEach(func() { + orgID = "project-jupiter" + clusterID = "some-cluster" + }) + + Describe("NewSubscriptionIdsForClusterVariables", func() { + It("Returns a correctly populated instance of SubscriptionIdsForClusterVariables", func() { + vars := NewSubscriptionIdsForClusterVariables(orgID, clusterID) + Expect(vars.Type).To(Equal(actions.QueryTypeQuery)) + Expect(vars.QueryName).To(Equal(QuerySubscriptionIdsForCluster)) + Expect(vars.OrgID).To(Equal(orgID)) + Expect(vars.Args).To(Equal(map[string]string{ + "orgId": "String!", + "clusterId": "String!", + })) + Expect(vars.Returns).To(ConsistOf( + "uuid", + )) + }) + }) + + Describe("SubscriptionIdsForCluster", func() { + + var ( + subscriptionsResponse SubscriptionIdsForClusterResponse + subscriptionIds []string + c SubscriptionService + httpClient *webfakes.FakeHTTPClient + response *http.Response + ) + + BeforeEach(func() { + + subscriptionIds = []string{ + "hal", + "9000", + "2001", + } + responseDataField := make([]types.UuidOnly, len(subscriptionIds)) + for i := 0; i < len(subscriptionIds); i++ { + responseDataField[i] = types.UuidOnly{UUID: subscriptionIds[i]} + } + subscriptionsResponse = SubscriptionIdsForClusterResponse{ + Data: &SubscriptionIdsForClusterResponseData{ + SubscriptionIdsForCluster: responseDataField, + }, + } + + respBodyBytes, err := json.Marshal(subscriptionsResponse) + Expect(err).NotTo(HaveOccurred()) + response = &http.Response{ + Body: ioutil.NopCloser(bytes.NewReader(respBodyBytes)), + } + + httpClient = &webfakes.FakeHTTPClient{} + Expect(httpClient.DoCallCount()).To(Equal(0)) + httpClient.DoReturns(response, nil) + + c, _ = NewClient("https://foo.bar", httpClient, &fakeAuthClient) + + }) + + It("Makes a valid http request", func() { + _, err := c.SubscriptionIdsForCluster(orgID, clusterID) + Expect(err).NotTo(HaveOccurred()) + Expect(httpClient.DoCallCount()).To(Equal(1)) + }) + + It("Returns the list of subscriptions", func() { + subscriptions, _ := c.SubscriptionIdsForCluster(orgID, clusterID) + Expect(subscriptions).To(Equal(subscriptionIds)) + }) + + Context("When query execution errors", func() { + BeforeEach(func() { + httpClient.DoReturns(response, errors.New("None whatsoever, Frank.")) + }) + + It("Bubbles up the error", func() { + _, err := c.SubscriptionIdsForCluster(orgID, clusterID) + Expect(err).To(MatchError(MatchRegexp("None whatsoever, Frank."))) + }) + }) + + Context("When the response is empty for some reason", func() { + BeforeEach(func() { + respBodyBytes, _ := json.Marshal(SubscriptionIdsForClusterResponse{}) + response.Body = ioutil.NopCloser(bytes.NewReader(respBodyBytes)) + }) + + It("Returns nil", func() { + subscriptions, err := c.SubscriptionIdsForCluster(orgID, clusterID) + Expect(err).NotTo(HaveOccurred()) + Expect(subscriptions).To(BeNil()) + }) + }) + + }) + +}) diff --git a/client/actions/subscriptions/subscriptionsfakes/fake_subscription_service.go b/client/actions/subscriptions/subscriptionsfakes/fake_subscription_service.go index c7a29d9..82e92db 100644 --- a/client/actions/subscriptions/subscriptionsfakes/fake_subscription_service.go +++ b/client/actions/subscriptions/subscriptionsfakes/fake_subscription_service.go @@ -55,6 +55,20 @@ type FakeSubscriptionService struct { result1 *subscriptions.SetSubscriptionResponseDataDetails result2 error } + SubscriptionIdsForClusterStub func(string, string) ([]string, error) + subscriptionIdsForClusterMutex sync.RWMutex + subscriptionIdsForClusterArgsForCall []struct { + arg1 string + arg2 string + } + subscriptionIdsForClusterReturns struct { + result1 []string + result2 error + } + subscriptionIdsForClusterReturnsOnCall map[int]struct { + result1 []string + result2 error + } SubscriptionsStub func(string) (types.SubscriptionList, error) subscriptionsMutex sync.RWMutex subscriptionsArgsForCall []struct { @@ -276,6 +290,71 @@ func (fake *FakeSubscriptionService) SetSubscriptionReturnsOnCall(i int, result1 }{result1, result2} } +func (fake *FakeSubscriptionService) SubscriptionIdsForCluster(arg1 string, arg2 string) ([]string, error) { + fake.subscriptionIdsForClusterMutex.Lock() + ret, specificReturn := fake.subscriptionIdsForClusterReturnsOnCall[len(fake.subscriptionIdsForClusterArgsForCall)] + fake.subscriptionIdsForClusterArgsForCall = append(fake.subscriptionIdsForClusterArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.SubscriptionIdsForClusterStub + fakeReturns := fake.subscriptionIdsForClusterReturns + fake.recordInvocation("SubscriptionIdsForCluster", []interface{}{arg1, arg2}) + fake.subscriptionIdsForClusterMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeSubscriptionService) SubscriptionIdsForClusterCallCount() int { + fake.subscriptionIdsForClusterMutex.RLock() + defer fake.subscriptionIdsForClusterMutex.RUnlock() + return len(fake.subscriptionIdsForClusterArgsForCall) +} + +func (fake *FakeSubscriptionService) SubscriptionIdsForClusterCalls(stub func(string, string) ([]string, error)) { + fake.subscriptionIdsForClusterMutex.Lock() + defer fake.subscriptionIdsForClusterMutex.Unlock() + fake.SubscriptionIdsForClusterStub = stub +} + +func (fake *FakeSubscriptionService) SubscriptionIdsForClusterArgsForCall(i int) (string, string) { + fake.subscriptionIdsForClusterMutex.RLock() + defer fake.subscriptionIdsForClusterMutex.RUnlock() + argsForCall := fake.subscriptionIdsForClusterArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeSubscriptionService) SubscriptionIdsForClusterReturns(result1 []string, result2 error) { + fake.subscriptionIdsForClusterMutex.Lock() + defer fake.subscriptionIdsForClusterMutex.Unlock() + fake.SubscriptionIdsForClusterStub = nil + fake.subscriptionIdsForClusterReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *FakeSubscriptionService) SubscriptionIdsForClusterReturnsOnCall(i int, result1 []string, result2 error) { + fake.subscriptionIdsForClusterMutex.Lock() + defer fake.subscriptionIdsForClusterMutex.Unlock() + fake.SubscriptionIdsForClusterStub = nil + if fake.subscriptionIdsForClusterReturnsOnCall == nil { + fake.subscriptionIdsForClusterReturnsOnCall = make(map[int]struct { + result1 []string + result2 error + }) + } + fake.subscriptionIdsForClusterReturnsOnCall[i] = struct { + result1 []string + result2 error + }{result1, result2} +} + func (fake *FakeSubscriptionService) Subscriptions(arg1 string) (types.SubscriptionList, error) { fake.subscriptionsMutex.Lock() ret, specificReturn := fake.subscriptionsReturnsOnCall[len(fake.subscriptionsArgsForCall)] @@ -349,6 +428,8 @@ func (fake *FakeSubscriptionService) Invocations() map[string][][]interface{} { defer fake.removeSubscriptionMutex.RUnlock() fake.setSubscriptionMutex.RLock() defer fake.setSubscriptionMutex.RUnlock() + fake.subscriptionIdsForClusterMutex.RLock() + defer fake.subscriptionIdsForClusterMutex.RUnlock() fake.subscriptionsMutex.RLock() defer fake.subscriptionsMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} diff --git a/client/types/types.go b/client/types/types.go index f9fa9dc..5a30035 100644 --- a/client/types/types.go +++ b/client/types/types.go @@ -199,3 +199,7 @@ type User struct { Email string `json:"email,omitempty"` Role string `json:"role,omitempty"` } + +type UuidOnly struct { + UUID string `json:"uuid,omitempty"` +} \ No newline at end of file diff --git a/test/integration/subscriptions_test.go b/test/integration/subscriptions_test.go index 83ef912..19667f4 100644 --- a/test/integration/subscriptions_test.go +++ b/test/integration/subscriptions_test.go @@ -8,7 +8,10 @@ import ( . "github.com/onsi/gomega" "github.com/IBM/satcon-client-go/client" + "github.com/IBM/satcon-client-go/client/actions/channels" + "github.com/IBM/satcon-client-go/client/actions/versions" "github.com/IBM/satcon-client-go/client/auth/iam" + "github.com/IBM/satcon-client-go/client/types" . "github.com/IBM/satcon-client-go/test/integration" ) @@ -35,49 +38,93 @@ var _ = Describe("Subscriptions", func() { Describe("Subscription Lifecycle", func() { var ( - channelName string - version1Name string - version2Name string - subscriptionName string - description string - groups []string + channelName, + version1Name, + version2Name, + subscriptionName, + description string + + groupNames, + groupIds, + clusterNames, + clusterIds []string + + groupCount, + clusterCount int + + channelDetails *channels.AddChannelResponseDataDetails + version1Details, version2Details *versions.AddChannelVersionResponseDataDetails ) BeforeEach(func() { channelName = RandStringBytes(8) version1Name = RandStringBytes(8) version2Name = RandStringBytes(8) - group1 := RandStringBytes(8) - group2 := RandStringBytes(8) + clusterCount = 3 + clusterNames = make([]string, clusterCount) + clusterIds = make([]string, clusterCount) + for i := 0; i < clusterCount; i++ { + clusterNames[i] = RandStringBytes(8) + } + groupCount = 2 + groupNames = make([]string, groupCount) + groupIds = make([]string, groupCount) + for i := 0; i < groupCount; i++ { + groupNames[i] = RandStringBytes(8) + } subscriptionName = RandStringBytes(8) fmt.Println("Using channel name: ", channelName) fmt.Println("Using version1 name: ", version1Name) fmt.Println("Using version2 name: ", version2Name) fmt.Println("Using subscription name: ", subscriptionName) description = fmt.Sprintf("Integration test version: %s for channel: %s", version1Name, channelName) - groups = []string{group1, group2} - }) - It("Lists the subscriptions, creates our new subscription, lists again and finds it, deletes it, and finally lists to see that it's gone", func() { - // Verify that our subscription does not already exist - subscriptionList, err := c.Subscriptions.Subscriptions(testConfig.OrgID) + for i, name := range clusterNames { + details, err := c.Clusters.RegisterCluster(testConfig.OrgID, types.Registration{Name: name}) + Expect(err).NotTo(HaveOccurred()) + Expect(details).NotTo(BeNil()) + for _, clusterId := range clusterIds { + Expect(clusterId).NotTo(Equal(details.ClusterID)) + } + clusterIds[i] = details.ClusterID + } + + // create groups + for i, groupName := range groupNames { + newGroupDetails, err := c.Groups.AddGroup(testConfig.OrgID, groupName) + Expect(newGroupDetails.UUID).NotTo(BeEmpty()) + Expect(err).NotTo(HaveOccurred()) + groupIds[i] = newGroupDetails.UUID + } + + // list groups again and find our new groups + currentGroups, err := c.Groups.Groups(testConfig.OrgID) Expect(err).NotTo(HaveOccurred()) - for _, e := range subscriptionList { - Expect(e.Name).NotTo(Equal(subscriptionName)) + currentGroupNames := make([]string, len(currentGroups)) + for i, group := range currentGroups { + currentGroupNames[i] = group.Name + } + Expect(currentGroupNames).To(ContainElements(groupNames)) + + // Group clusters: Clusters 0 and 1 in Group 0, Clusters 1 and 2 in Group 1 + for i, groupId := range groupIds { + response, err := c.Groups.GroupClusters(testConfig.OrgID, groupId, clusterIds[i:i+2]) + Expect(response).NotTo(BeNil()) + Expect(response.Modified > 0).To(BeTrue()) + Expect(err).NotTo(HaveOccurred()) } - // TODO before we can add a subscription, we need to be able to add a new channel and version so that we can pass channelUuid and versionUuid as arguments // Demonstrate channel version does not exist for the arguments of the current channelName and versionName version, err := c.Versions.ChannelVersionByName(testConfig.OrgID, channelName, version1Name) Expect(err).To(HaveOccurred()) - Expect(version).NotTo(Equal(version1Name)) + Expect(version).To(BeNil()) version, err = c.Versions.ChannelVersionByName(testConfig.OrgID, channelName, version2Name) Expect(err).To(HaveOccurred()) - Expect(version).NotTo(Equal(version2Name)) + Expect(version).To(BeNil()) // Create a channel - channelDetails, err := c.Channels.AddChannel(testConfig.OrgID, channelName) + channelDetails, err = c.Channels.AddChannel(testConfig.OrgID, channelName) Expect(err).NotTo(HaveOccurred()) Expect(channelDetails).NotTo(BeNil()) @@ -93,7 +140,7 @@ var _ = Describe("Subscriptions", func() { Expect(found).To(BeTrue()) // Create a channel version using the previously created channel - version1Details, err := c.Versions.AddChannelVersion(testConfig.OrgID, channelDetails.UUID, version1Name, content, description) + version1Details, err = c.Versions.AddChannelVersion(testConfig.OrgID, channelDetails.UUID, version1Name, content, description) Expect(err).NotTo(HaveOccurred()) Expect(version1Details).NotTo(BeNil()) @@ -101,25 +148,8 @@ var _ = Describe("Subscriptions", func() { getVersionDetails, err := c.Versions.ChannelVersionByName(testConfig.OrgID, channelName, version1Name) Expect(err).NotTo(HaveOccurred()) Expect(getVersionDetails).NotTo(BeNil()) - - // Create a new subscription using this channel and version - subscriptionDetails, err := c.Subscriptions.AddSubscription(testConfig.OrgID, subscriptionName, channelDetails.UUID, version1Details.VersionUUID, groups) - Expect(err).NotTo(HaveOccurred()) - Expect(subscriptionDetails).NotTo(BeNil()) - - // Verify that our newly created subscription exists - subscriptionList, err = c.Subscriptions.Subscriptions(testConfig.OrgID) - Expect(err).NotTo(HaveOccurred()) - found = false - for _, subscription := range subscriptionList { - if subscription.UUID == subscriptionDetails.UUID { - found = true - } - } - Expect(found).To(BeTrue()) - // Create a new channel version - version2Details, err := c.Versions.AddChannelVersion(testConfig.OrgID, channelDetails.UUID, version2Name, content, description) + version2Details, err = c.Versions.AddChannelVersion(testConfig.OrgID, channelDetails.UUID, version2Name, content, description) Expect(err).NotTo(HaveOccurred()) Expect(version2Details).NotTo(BeNil()) @@ -128,45 +158,92 @@ var _ = Describe("Subscriptions", func() { Expect(err).NotTo(HaveOccurred()) Expect(getVersion2Details).NotTo(BeNil()) - // Set existing subscription to new version - setSubscriptionDetail, err := c.Subscriptions.SetSubscription(testConfig.OrgID, subscriptionDetails.UUID, version2Details.VersionUUID) - Expect(err).NotTo(HaveOccurred()) - Expect(setSubscriptionDetail).NotTo(BeNil()) + }) - // Verify that our newly updated subscription is up to date - subscriptionList, err = c.Subscriptions.Subscriptions(testConfig.OrgID) - Expect(err).NotTo(HaveOccurred()) - found = false - for _, subscription := range subscriptionList { - if subscription.UUID == setSubscriptionDetail.UUID && subscription.Version == version2Name { - found = true + FWhen("using both Subscriptions APIs", func() { + It("Lists the subscriptions, creates our new subscription, lists again and finds it, deletes it, and finally lists to see that it's gone", func() { + // Verify that our subscription does not already exist + // Can't use SubscriptionIdsForCluster here, we don't have an id yet + subscriptionList, err := c.Subscriptions.Subscriptions(testConfig.OrgID) + Expect(err).NotTo(HaveOccurred()) + for _, e := range subscriptionList { + Expect(e.Name).NotTo(Equal(subscriptionName)) } - } - Expect(found).To(BeTrue()) - // Remove Subscription - removeSubscriptionDetails, err := c.Subscriptions.RemoveSubscription(testConfig.OrgID, subscriptionDetails.UUID) - Expect(err).NotTo(HaveOccurred()) - Expect(removeSubscriptionDetails).NotTo(BeNil()) + // Create a new subscription using this channel and version + subscriptionDetails, err := c.Subscriptions.AddSubscription(testConfig.OrgID, subscriptionName, channelDetails.UUID, version1Details.VersionUUID, groupNames) + Expect(err).NotTo(HaveOccurred()) + Expect(subscriptionDetails).NotTo(BeNil()) - //Verify Subscription have been removed - subscriptionList, err = c.Subscriptions.Subscriptions(testConfig.OrgID) - Expect(err).NotTo(HaveOccurred()) - found = false - for _, subscription := range subscriptionList { - if subscription.UUID == subscriptionDetails.UUID { - found = true + // Verify that our newly created subscription exists, first using Subscriptions API... + subscriptionList, err = c.Subscriptions.Subscriptions(testConfig.OrgID) + Expect(err).NotTo(HaveOccurred()) + found := false + for _, subscription := range subscriptionList { + if subscription.UUID == subscriptionDetails.UUID { + found = true + } + } + Expect(found).To(BeTrue()) + // ...then with SubscriptionIdsForCluster API. Should be on all clusters + for _, clusterId := range clusterIds { + subscriptionIds, err := c.Subscriptions.SubscriptionIdsForCluster(testConfig.OrgID, clusterId) + Expect(err).NotTo(HaveOccurred()) + Expect(subscriptionIds).To(ContainElement(subscriptionDetails.UUID)) + // fmt.Println(subscriptionDetails.UUID, " is present on cluster ", clusterId) } - } - Expect(found).To(BeFalse()) + // Set existing subscription to new version + setSubscriptionDetail, err := c.Subscriptions.SetSubscription(testConfig.OrgID, subscriptionDetails.UUID, version2Details.VersionUUID) + Expect(err).NotTo(HaveOccurred()) + Expect(setSubscriptionDetail).NotTo(BeNil()) + + // Verify that our newly updated subscription is up to date + subscriptionList, err = c.Subscriptions.Subscriptions(testConfig.OrgID) + Expect(err).NotTo(HaveOccurred()) + found = false + for _, subscription := range subscriptionList { + if subscription.UUID == setSubscriptionDetail.UUID && subscription.Version == version2Name { + found = true + } + } + Expect(found).To(BeTrue()) + + // Remove Subscription + removeSubscriptionDetails, err := c.Subscriptions.RemoveSubscription(testConfig.OrgID, subscriptionDetails.UUID) + Expect(err).NotTo(HaveOccurred()) + Expect(removeSubscriptionDetails).NotTo(BeNil()) + + //Verify Subscription have been removed, first with Subscriptions API... + subscriptionList, err = c.Subscriptions.Subscriptions(testConfig.OrgID) + Expect(err).NotTo(HaveOccurred()) + found = false + for _, subscription := range subscriptionList { + if subscription.UUID == subscriptionDetails.UUID { + found = true + } + } + Expect(found).To(BeFalse()) + // ...then with SubscriptionIdsForCluster API. Should not be on any clusters + for _, clusterId := range clusterIds { + subscriptionIds, err := c.Subscriptions.SubscriptionIdsForCluster(testConfig.OrgID, clusterId) + Expect(err).NotTo(HaveOccurred()) + Expect(subscriptionIds).NotTo(ContainElement(subscriptionDetails.UUID)) + } + + }) + }) + + When("using SubscriptonIdsForCluster()", func() {}) + + AfterEach(func() { // Remove channel version 1 removeVersionDetails, err := c.Versions.RemoveChannelVersion(testConfig.OrgID, version1Details.VersionUUID) Expect(err).NotTo(HaveOccurred()) Expect(removeVersionDetails).NotTo(BeNil()) // Verify that channel version 1 has been removed - getVersionDetails, err = c.Versions.ChannelVersionByName(testConfig.OrgID, channelName, version1Name) + getVersionDetails, err := c.Versions.ChannelVersionByName(testConfig.OrgID, channelName, version1Name) Expect(err).To(HaveOccurred()) Expect(getVersionDetails).To(BeNil()) @@ -186,9 +263,9 @@ var _ = Describe("Subscriptions", func() { Expect(removeChannelDetails).NotTo(BeNil()) // Verify that channel has been removed - channelList, err = c.Channels.Channels(testConfig.OrgID) + channelList, err := c.Channels.Channels(testConfig.OrgID) Expect(err).NotTo(HaveOccurred()) - found = false + found := false for _, channel := range channelList { if channel.UUID == channelDetails.UUID { found = true @@ -197,12 +274,24 @@ var _ = Describe("Subscriptions", func() { Expect(found).To(BeFalse()) // Remove the groups - for _, g := range groups { + for _, g := range groupNames { rg, err := c.Groups.RemoveGroupByName(testConfig.OrgID, g) Expect(rg.UUID).NotTo(BeEmpty()) Expect(err).NotTo(HaveOccurred()) } + // Remove clusters + for _, clusterId := range clusterIds { + delDetails, err := c.Clusters.DeleteClusterByClusterID(testConfig.OrgID, clusterId) + Expect(err).NotTo(HaveOccurred()) + Expect(delDetails.DeletedClusterCount).To(Equal(1)) + } + clusterList, err := c.Clusters.ClustersByOrgID(testConfig.OrgID) + Expect(err).NotTo(HaveOccurred()) + for _, details := range clusterList { + Expect(clusterIds).NotTo(ContainElement(details.ClusterID)) + } + }) }) }) From 5935efdd1de5248707f24a1d122ef5cb0cd75a99 Mon Sep 17 00:00:00 2001 From: Steven Collins Date: Wed, 4 Aug 2021 09:51:34 -0500 Subject: [PATCH 2/3] fix missing EOL at end of file --- client/types/types.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/types/types.go b/client/types/types.go index 5a30035..8d273ac 100644 --- a/client/types/types.go +++ b/client/types/types.go @@ -202,4 +202,4 @@ type User struct { type UuidOnly struct { UUID string `json:"uuid,omitempty"` -} \ No newline at end of file +} From 0c7f16168cefd39aa1c167dd83b632118c19b3c7 Mon Sep 17 00:00:00 2001 From: Steven Collins Date: Wed, 4 Aug 2021 10:29:57 -0500 Subject: [PATCH 3/3] Remove test focus --- test/integration/subscriptions_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/integration/subscriptions_test.go b/test/integration/subscriptions_test.go index 19667f4..f76cbfb 100644 --- a/test/integration/subscriptions_test.go +++ b/test/integration/subscriptions_test.go @@ -160,7 +160,7 @@ var _ = Describe("Subscriptions", func() { }) - FWhen("using both Subscriptions APIs", func() { + When("using both Subscriptions APIs", func() { It("Lists the subscriptions, creates our new subscription, lists again and finds it, deletes it, and finally lists to see that it's gone", func() { // Verify that our subscription does not already exist // Can't use SubscriptionIdsForCluster here, we don't have an id yet