diff --git a/test/access_control_records_test.go b/test/access_control_records_test.go index 3c699ac4..8d9baaee 100644 --- a/test/access_control_records_test.go +++ b/test/access_control_records_test.go @@ -3,12 +3,13 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) type ACRWorkflowSuite struct { @@ -22,27 +23,40 @@ type ACRWorkflowSuite struct { func (suite *ACRWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.volumeService = groupService.GetVolumeService() suite.igService = groupService.GetInitiatorGroupService() suite.acrService = groupService.GetAccessControlRecordService() _, err = createDefaultVolume(suite.volumeService) - assert.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) _, err = createDefaultInitiatorGrp(suite.igService) - assert.Nilf(suite.T(), err, "Unable to create default initiator group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create default initiator group, err: %v", err) suite.createACR() } func (suite *ACRWorkflowSuite) TearDownSuite() { + var accessControlTestResult string + if len(testStarted) == len(testCompleted) { + accessControlTestResult = "PASS" + } else { + accessControlTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(accessControlTestResult, "C545074", "Access Control Records workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil if suite.acr != nil { err := suite.acrService.DeleteAccessControlRecord(*suite.acr.ID) - assert.Nilf(suite.T(), err, "Unable to delete Access control record, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete Access control record, err: %v", err) } err := deleteDefaultVolume(suite.volumeService) - assert.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) err = deleteDefaultInitiatorGroup(suite.igService) - assert.Nilf(suite.T(), err, "Unable to delete default initiator group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete default initiator group, err: %v", err) suite.groupService.LogoutService() } @@ -54,22 +68,26 @@ func (suite *ACRWorkflowSuite) createACR() { VolId: vol.ID, } acr, err := suite.acrService.CreateAccessControlRecord(newACR) - assert.Nilf(suite.T(), err, "Unable to create Access Control Record, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create Access Control Record, err: %v", err) suite.acr = acr } func (suite *ACRWorkflowSuite) TestModifyACR() { + testStarted = append(testStarted, true) updateACR := &nimbleos.AccessControlRecord{ ApplyTo: nimbleos.NsAccessApplyToVolume, } _, err := suite.acrService.UpdateAccessControlRecord(*suite.acr.ID, updateACR) - assert.NotNilf(suite.T(), err, "Access Control Record update should have failed") + require.NotNilf(suite.T(), err, "Access Control Record update should have failed") + testCompleted = append(testCompleted, true) } func (suite *ACRWorkflowSuite) TestDeleteIGAssociated() { + testStarted = append(testStarted, true) ig, _ := suite.igService.GetInitiatorGroupByName(defaultInitiatorGrpName) err := suite.igService.DeleteInitiatorGroup(*ig.ID) - assert.NotNilf(suite.T(), err, "Deletion of Initiator Group associated with volume should have failed") + require.NotNilf(suite.T(), err, "Deletion of Initiator Group associated with volume should have failed") + testCompleted = append(testCompleted, true) } func TestACRWorkflowSuite(t *testing.T) { diff --git a/test/chapuser_test.go b/test/chapuser_test.go index ad0a933c..8f534c2f 100644 --- a/test/chapuser_test.go +++ b/test/chapuser_test.go @@ -20,7 +20,7 @@ import ( "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" ) @@ -39,7 +39,7 @@ type ChapuserWorkflowSuite struct { func (suite *ChapuserWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Could not connect to array %v", arrayIP) + require.Nilf(suite.T(), err, "Could not connect to array %v", arrayIP) suite.groupService = groupService suite.chapuserService = groupService.GetChapUserService() suite.initiatorGrpService = groupService.GetInitiatorGroupService() @@ -47,6 +47,19 @@ func (suite *ChapuserWorkflowSuite) SetupSuite() { } func (suite *ChapuserWorkflowSuite) TearDownSuite() { + var chapTestResult string + if len(testStarted) == len(testCompleted) { + chapTestResult = "PASS" + } else { + chapTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(chapTestResult, "C545226", "Chapuser workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.groupService.LogoutService() } @@ -64,11 +77,12 @@ func (suite *ChapuserWorkflowSuite) CreateIGIscsiInitiators(iqnLabel string, iqn IscsiInitiators: initiatorList, } igResp, err := suite.initiatorGrpService.CreateInitiatorGroup(newIG) - assert.Nilf(suite.T(), err, "Initiator group creation failed: %v", initiatorGroupNameChap) + require.Nilf(suite.T(), err, "Initiator group creation failed: %v", initiatorGroupNameChap) return *igResp.ID } func (suite *ChapuserWorkflowSuite) TestCreateModifyDeleteChapuser() { + testStarted = append(testStarted, true) // Skipping for FC array, test with iscsi initiators if isFCEnabled(suite.arrayGroupService) { suite.T().Skip() @@ -81,10 +95,10 @@ func (suite *ChapuserWorkflowSuite) TestCreateModifyDeleteChapuser() { Description: &chapUserDescription, } _, err := suite.chapuserService.CreateChapUser(newChapUser) - assert.Nilf(suite.T(), err, "Chap User %v creation failed", chapUserName) + require.Nilf(suite.T(), err, "Chap User %v creation failed", chapUserName) chapuserResp, err := suite.chapuserService.GetChapUserByName(chapUserName) - assert.Nilf(suite.T(), err, "Failed to get chap user by name %v", chapUserName) - assert.Equal(suite.T(), chapUserDescription, *chapuserResp.Description, "In-correct Description for Chap user") + require.Nilf(suite.T(), err, "Failed to get chap user by name %v", chapUserName) + require.Equal(suite.T(), chapUserDescription, *chapuserResp.Description, "In-correct Description for Chap user") chapuserID := *chapuserResp.ID arrayVersion := getArrayVersion(suite.arrayGroupService) @@ -103,22 +117,23 @@ func (suite *ChapuserWorkflowSuite) TestCreateModifyDeleteChapuser() { InitiatorIqns: initiatorList, } _, err = suite.chapuserService.UpdateChapUser(chapuserID, updateChapUser) - assert.Nilf(suite.T(), err, "Failed to update chap user: %v", chapUserName) + require.Nilf(suite.T(), err, "Failed to update chap user: %v", chapUserName) _, err = suite.chapuserService.GetChapUserByName(chapUserName) - assert.Nilf(suite.T(), err, "Failed to get chap user by name: %v", chapUserName) + require.Nilf(suite.T(), err, "Failed to get chap user by name: %v", chapUserName) // Delete Chap user with initiators associated err = suite.chapuserService.DeleteChapUser(chapuserID) - assert.NotNilf(suite.T(), err, "Deleted chap user %v with initiators", chapUserName) + require.NotNilf(suite.T(), err, "Deleted chap user %v with initiators", chapUserName) // Delete Initiatorgroup err = suite.initiatorGrpService.DeleteInitiatorGroup(igID) - assert.Nilf(suite.T(), err, "Failed to delete initiator group: %v", initiatorGroupNameChap) + require.Nilf(suite.T(), err, "Failed to delete initiator group: %v", initiatorGroupNameChap) } // Delete Chap user err = suite.chapuserService.DeleteChapUser(chapuserID) - assert.Nilf(suite.T(), err, "Failed to delete chap user: %v", chapUserName) + require.Nilf(suite.T(), err, "Failed to delete chap user: %v", chapUserName) + testCompleted = append(testCompleted, true) } diff --git a/test/disk_test.go b/test/disk_test.go index 9dacc8e7..94feb126 100644 --- a/test/disk_test.go +++ b/test/disk_test.go @@ -20,7 +20,7 @@ import ( "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" ) @@ -32,19 +32,33 @@ type DiskWorkflowSuite struct { func (suite *DiskWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Could not connect to array: %v", arrayIP) + require.Nilf(suite.T(), err, "Could not connect to array: %v", arrayIP) suite.groupService = groupService suite.diskService = groupService.GetDiskService() } func (suite *DiskWorkflowSuite) TearDownSuite() { + var diskTestResult string + if len(testStarted) == len(testCompleted) { + diskTestResult = "PASS" + } else { + diskTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(diskTestResult, "C545227", "Disk Workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.groupService.LogoutService() } func (suite *DiskWorkflowSuite) TestAddRemoveDisk() { + testStarted = append(testStarted, true) filter := ¶m.GetParams{} diskResp, err := suite.diskService.GetDisks(filter) - assert.Nil(suite.T(), err, "Failed to get disk details") + require.Nil(suite.T(), err, "Failed to get disk details") fmt.Print(*diskResp[0].State) // Get a disk which is in use @@ -55,30 +69,31 @@ func (suite *DiskWorkflowSuite) TestAddRemoveDisk() { break } } - assert.NotEmpty(suite.T(), diskID, "No Disk found which are 'in-use'") + require.NotEmpty(suite.T(), diskID, "No Disk found which are 'in-use'") // Remove Disk removeDisk := &nimbleos.Disk{ DiskOp: nimbleos.NsDiskOpRemove, } _, err = suite.diskService.UpdateDisk(diskID, removeDisk) - assert.Nil(suite.T(), err, "Failed to Remove Disk") + require.Nil(suite.T(), err, "Failed to Remove Disk") getDiskResp, err := suite.diskService.GetDiskById(diskID) - assert.Nil(suite.T(), err, "Failed to Get Disk details") - assert.Equal(suite.T(), nimbleos.NsDiskState("removed"), *getDiskResp.State, "Failed to Remove Disk") + require.Nil(suite.T(), err, "Failed to Get Disk details") + require.Equal(suite.T(), nimbleos.NsDiskState("removed"), *getDiskResp.State, "Failed to Remove Disk") // Add Disk addDisk := &nimbleos.Disk{ DiskOp: nimbleos.NsDiskOpAdd, } _, err = suite.diskService.UpdateDisk(diskID, addDisk) - assert.Nil(suite.T(), err, "Failed to Add Disk") + require.Nil(suite.T(), err, "Failed to Add Disk") // Wait till the state changes from 'valid' to 'in use' time.Sleep(2 * time.Second) getDiskResp, err = suite.diskService.GetDiskById(diskID) - assert.Nil(suite.T(), err, "Failed to Get Disk details") - assert.Equal(suite.T(), nimbleos.NsDiskState("in use"), *getDiskResp.State, "Failed to Add Disk") + require.Nil(suite.T(), err, "Failed to Get Disk details") + require.Equal(suite.T(), nimbleos.NsDiskState("in use"), *getDiskResp.State, "Failed to Add Disk") + testCompleted = append(testCompleted, true) } diff --git a/test/encryption_test.go b/test/encryption_test.go index e0c39a89..27f450f6 100644 --- a/test/encryption_test.go +++ b/test/encryption_test.go @@ -3,12 +3,13 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) const passphrase = "passphrase-91" @@ -23,7 +24,7 @@ type EncryptionWorkflowSuite struct { func (suite *EncryptionWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.keyManagerService = groupService.GetKeyManagerService() suite.masterKeyService = groupService.GetMasterKeyService() @@ -32,6 +33,19 @@ func (suite *EncryptionWorkflowSuite) SetupSuite() { } func (suite *EncryptionWorkflowSuite) TearDownSuite() { + var encryptionTestResult string + if len(testStarted) == len(testCompleted) { + encryptionTestResult = "PASS" + } else { + encryptionTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(encryptionTestResult, "C545078", "Encryption workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.deleteMasterKey() suite.groupService.LogoutService() } @@ -42,7 +56,7 @@ func (suite *EncryptionWorkflowSuite) createMasterKey() { Passphrase: passphrase, } _, err := suite.masterKeyService.CreateMasterKey(key) - assert.Nilf(suite.T(), err, "Master key creation failed, err: %v", err) + require.Nilf(suite.T(), err, "Master key creation failed, err: %v", err) } func (suite *EncryptionWorkflowSuite) deleteMasterKey() { @@ -50,19 +64,22 @@ func (suite *EncryptionWorkflowSuite) deleteMasterKey() { key, _ := suite.masterKeyService.GetMasterKeys(filter) if len(key) != 0 { err := suite.masterKeyService.DeleteMasterKey(*key[0].ID) - assert.Nilf(suite.T(), err, "Unable to delete key, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete key, err: %v", err) } } func (suite *EncryptionWorkflowSuite) TestCreateMasterKeyDuplicate() { + testStarted = append(testStarted, true) key := &nimbleos.MasterKey{ Passphrase: param.NewString("passphrase1"), } _, err := suite.masterKeyService.CreateMasterKey(key) - assert.NotNil(suite.T(), err, "Master key creation when one exists should have failed") + require.NotNil(suite.T(), err, "Master key creation when one exists should have failed") + testCompleted = append(testCompleted, true) } func (suite *EncryptionWorkflowSuite) TestMasterKeyChangePassphrase() { + testStarted = append(testStarted, true) var newPassphrase *string = param.NewString(newPassphrase) filter := ¶m.GetParams{} key, _ := suite.masterKeyService.GetMasterKeys(filter) @@ -71,10 +88,12 @@ func (suite *EncryptionWorkflowSuite) TestMasterKeyChangePassphrase() { NewPassphrase: newPassphrase, } _, err := suite.masterKeyService.UpdateMasterKey(*key[0].ID, updateKey) - assert.Nilf(suite.T(), err, "Unable to update master key, err: %v", err) + require.Nilf(suite.T(), err, "Unable to update master key, err: %v", err) + testCompleted = append(testCompleted, true) } func (suite *EncryptionWorkflowSuite) TestMasterKeyUpdateInactive() { + testStarted = append(testStarted, true) filter := ¶m.GetParams{} key, _ := suite.masterKeyService.GetMasterKeys(filter) updateKey := &nimbleos.MasterKey{ @@ -82,15 +101,18 @@ func (suite *EncryptionWorkflowSuite) TestMasterKeyUpdateInactive() { Active: param.NewBool(false), } _, err := suite.masterKeyService.UpdateMasterKey(*key[0].ID, updateKey) - assert.Nilf(suite.T(), err, "Unable to set master key to inactive, err: %v", err) + require.Nilf(suite.T(), err, "Unable to set master key to inactive, err: %v", err) + testCompleted = append(testCompleted, true) } func (suite *EncryptionWorkflowSuite) TestPurgeKey() { + testStarted = append(testStarted, true) filter := ¶m.GetParams{} key, _ := suite.masterKeyService.GetMasterKeys(filter) var age int = 0 err := suite.masterKeyService.PurgeInactiveMasterKey(*key[0].ID, &age) - assert.Nilf(suite.T(), err, "Unable to purge inactive key, err: %v", err) + require.Nilf(suite.T(), err, "Unable to purge inactive key, err: %v", err) + testCompleted = append(testCompleted, true) } func TestEncryptionWorkflowSuite(t *testing.T) { diff --git a/test/fibre_channel_test.go b/test/fibre_channel_test.go index 315d36d5..1701c26d 100644 --- a/test/fibre_channel_test.go +++ b/test/fibre_channel_test.go @@ -3,12 +3,13 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) type FiberChannelWorkflowSuite struct { @@ -21,7 +22,7 @@ type FiberChannelWorkflowSuite struct { func (suite *FiberChannelWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.fcConfigService = groupService.GetFibreChannelConfigService() suite.fcInterfaceService = groupService.GetFibreChannelInterfaceService() @@ -32,10 +33,24 @@ func (suite *FiberChannelWorkflowSuite) SetupSuite() { } func (suite *FiberChannelWorkflowSuite) TearDownSuite() { + var fibreChannelTestResult string + if len(testStarted) == len(testCompleted) { + fibreChannelTestResult = "PASS" + } else { + fibreChannelTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(fibreChannelTestResult, "C545228", "Fibre Channel workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.groupService.LogoutService() } func (suite *FiberChannelWorkflowSuite) TestFiberChannelOfflineOnline() { + testStarted = append(testStarted, true) filter := ¶m.GetParams{} interfaces, _ := suite.fcInterfaceService.GetFibreChannelInterfaces(filter) var interfaceID *string = nil @@ -50,25 +65,28 @@ func (suite *FiberChannelWorkflowSuite) TestFiberChannelOfflineOnline() { Online: param.NewBool(false), } _, err := suite.fcInterfaceService.UpdateFibreChannelInterface(*interfaceID, offlineInterface) - assert.Nilf(suite.T(), err, "Unable to set interface offline, err: %v", err) + require.Nilf(suite.T(), err, "Unable to set interface offline, err: %v", err) onlineInterface := &nimbleos.FibreChannelInterface{ Online: param.NewBool(true), } _, err = suite.fcInterfaceService.UpdateFibreChannelInterface(*interfaces[0].ID, onlineInterface) - assert.Nilf(suite.T(), err, "Unable to set interface to online, err: %v", err) + require.Nilf(suite.T(), err, "Unable to set interface to online, err: %v", err) } + testCompleted = append(testCompleted, true) } func (suite *FiberChannelWorkflowSuite) TestRegenerateOnlineInterfaces() { + testStarted = append(testStarted, true) filter := ¶m.GetParams{} fcs, _ := suite.fcConfigService.GetFibreChannelConfigs(filter) interfaces, _ := suite.fcInterfaceService.GetFibreChannelInterfaces(filter) for i := 0; i < len(interfaces); i++ { if *interfaces[i].Online == true { _, err := suite.fcConfigService.RegenerateFibreChannelConfig(*fcs[0].ID, "af:32:f1", true) - assert.NotNil(suite.T(), err, "Regenerating Fiber channel config with online interfaces should have failed") + require.NotNil(suite.T(), err, "Regenerating Fiber channel config with online interfaces should have failed") } } + testCompleted = append(testCompleted, true) } func TestFiberChannelWorkflowSuite(t *testing.T) { diff --git a/test/initiator_group_test.go b/test/initiator_group_test.go index 324e00b9..75ac70ee 100644 --- a/test/initiator_group_test.go +++ b/test/initiator_group_test.go @@ -3,13 +3,14 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) const initiatorGroupName = "InitiatorGroupTest" @@ -24,18 +25,31 @@ type IGWorkflowSuite struct { func (suite *IGWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.initiatorGrpService = groupService.GetInitiatorGroupService() suite.volumeService = groupService.GetVolumeService() _, err = createDefaultVolume(suite.volumeService) - assert.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) suite.arrayGroupService = groupService.GetGroupService() } func (suite *IGWorkflowSuite) TearDownSuite() { + var initiatorGroupTestResult string + if len(testStarted) == len(testCompleted) { + initiatorGroupTestResult = "PASS" + } else { + initiatorGroupTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(initiatorGroupTestResult, "C545073", "Initiator Group workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil err := deleteDefaultVolume(suite.volumeService) - assert.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) suite.groupService.LogoutService() } @@ -43,19 +57,23 @@ func (suite *IGWorkflowSuite) deleteInitiatorGroup(igName string) { ig, _ := suite.initiatorGrpService.GetInitiatorGroupByName(igName) if ig != nil { err := suite.initiatorGrpService.DeleteInitiatorGroup(*ig.ID) - assert.Nilf(suite.T(), err, "Unable to delete Initiator group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete Initiator group, err: %v", err) } } func (suite *IGWorkflowSuite) TestCreateIGMissingParam() { + testStarted = append(testStarted, true) newIG := &nimbleos.InitiatorGroup{ Name: param.NewString(initiatorGroupName), } _, err := suite.initiatorGrpService.CreateInitiatorGroup(newIG) - assert.NotNil(suite.T(), err, "Initiator group creation should have failed with error missing param") + require.NotNil(suite.T(), err, "Initiator group creation should have failed with error missing param") + testCompleted = append(testCompleted, true) + } func (suite *IGWorkflowSuite) TestCreateIG() { + testStarted = append(testStarted, true) if !isIscsiEnabled(suite.arrayGroupService) { suite.T().Skip() } @@ -66,17 +84,17 @@ func (suite *IGWorkflowSuite) TestCreateIG() { AccessProtocol: nimbleos.NsAccessProtocolIscsi, } _, err := suite.initiatorGrpService.CreateInitiatorGroup(newIG) - assert.Nilf(suite.T(), err, "Unable to create initiator group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create initiator group, err: %v", err) ig, _ := suite.initiatorGrpService.GetInitiatorGroupByName(initiatorGroupName) - assert.Equal(suite.T(), *desc, *ig.Description, "Initiator group creation does not have expected description.") + require.Equal(suite.T(), *desc, *ig.Description, "Initiator group creation does not have expected description.") var newDesc *string = param.NewString("Workflow tests for initiator group") updateIG := &nimbleos.InitiatorGroup{ Description: newDesc, } _, err = suite.initiatorGrpService.UpdateInitiatorGroup(*ig.ID, updateIG) - assert.Nilf(suite.T(), err, "Unable to update initiator group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to update initiator group, err: %v", err) ig, _ = suite.initiatorGrpService.GetInitiatorGroupByName(initiatorGroupName) - assert.Equal(suite.T(), *newDesc, *ig.Description, "Unable to update Initiator Group") + require.Equal(suite.T(), *newDesc, *ig.Description, "Unable to update Initiator Group") // Create duplicate - should fail dupIG := &nimbleos.InitiatorGroup{ @@ -85,13 +103,15 @@ func (suite *IGWorkflowSuite) TestCreateIG() { AccessProtocol: nimbleos.NsAccessProtocolIscsi, } _, err = suite.initiatorGrpService.CreateInitiatorGroup(dupIG) - assert.NotNil(suite.T(), err, "Initiator group creation should have failed") + require.NotNil(suite.T(), err, "Initiator group creation should have failed") // Clean up suite.deleteInitiatorGroup(initiatorGroupName) + testCompleted = append(testCompleted, true) } func (suite *IGWorkflowSuite) TestCreateIGIscsiInitiators() { + testStarted = append(testStarted, true) if !isIscsiEnabled(suite.arrayGroupService) { suite.T().Skip() } @@ -109,7 +129,7 @@ func (suite *IGWorkflowSuite) TestCreateIGIscsiInitiators() { IscsiInitiators: initiatorList, } _, err := suite.initiatorGrpService.CreateInitiatorGroup(newIG) - assert.Nilf(suite.T(), err, "Unable to create initiator group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create initiator group, err: %v", err) // Update initiator group ipAdd := "10.1.0.0" updateIscsiInitiator := &nimbleos.NsISCSIInitiator{ @@ -123,14 +143,17 @@ func (suite *IGWorkflowSuite) TestCreateIGIscsiInitiators() { } currentIG, _ := suite.initiatorGrpService.GetInitiatorGroupByName("TestIGIscsi") _, err = suite.initiatorGrpService.UpdateInitiatorGroup(*currentIG.ID, updateIG) - assert.Nilf(suite.T(), err, "Modifying IP address of initiator failed: %v", err) - assert.Equal(suite.T(), ipAdd, *updateIG.IscsiInitiators[0].IpAddress, "Updating iscsi initiators failed") + require.Nilf(suite.T(), err, "Modifying IP address of initiator failed: %v", err) + require.Equal(suite.T(), ipAdd, *updateIG.IscsiInitiators[0].IpAddress, "Updating iscsi initiators failed") // Clean up suite.deleteInitiatorGroup("TestIGIscsi") + testCompleted = append(testCompleted, true) } func (suite *IGWorkflowSuite) TestCreateFCInitiators() { + testStarted = append(testStarted, true) if !isFCEnabled(suite.arrayGroupService) { + testCompleted = append(testCompleted, true) suite.T().Skip() } fcInitiator := &nimbleos.NsFCInitiator{ @@ -145,12 +168,15 @@ func (suite *IGWorkflowSuite) TestCreateFCInitiators() { FcInitiators: fcList, } _, err := suite.initiatorGrpService.CreateInitiatorGroup(newIG) - assert.Nilf(suite.T(), err, "Unable to create initiator group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create initiator group, err: %v", err) suite.deleteInitiatorGroup("TestIGFC") + testCompleted = append(testCompleted, true) } func (suite *IGWorkflowSuite) TestCreateIGInvalidIscsi() { + testStarted = append(testStarted, true) if !isIscsiEnabled(suite.arrayGroupService) { + testCompleted = append(testCompleted, true) suite.T().Skip() } iscsiInitiator := &nimbleos.NsISCSIInitiator{ @@ -167,7 +193,8 @@ func (suite *IGWorkflowSuite) TestCreateIGInvalidIscsi() { IscsiInitiators: initiatorList, } _, err := suite.initiatorGrpService.CreateInitiatorGroup(newIG) - assert.NotNil(suite.T(), err, "Initiator group creation with invalid iscsi initiators should have failed") + require.NotNil(suite.T(), err, "Initiator group creation with invalid iscsi initiators should have failed") + testCompleted = append(testCompleted, true) } func TestInitiatorGroupSuite(t *testing.T) { diff --git a/test/network_test.go b/test/network_test.go index 1b6ffe14..7b5d79aa 100644 --- a/test/network_test.go +++ b/test/network_test.go @@ -22,7 +22,7 @@ import ( "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" ) @@ -34,19 +34,33 @@ type NetworkWorkflowSuite struct { func (suite *NetworkWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Could not connect to array %v", arrayIP) + require.Nilf(suite.T(), err, "Could not connect to array %v", arrayIP) suite.groupService = groupService suite.networkConfigService = groupService.GetNetworkConfigService() } func (suite *NetworkWorkflowSuite) TearDownSuite() { + var networkTestResult string + if len(testStarted) == len(testCompleted) { + networkTestResult = "PASS" + } else { + networkTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(networkTestResult, "C545230", "Network workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.groupService.LogoutService() } func (suite *NetworkWorkflowSuite) TestCreateUpdateDeleteDraft() { + testStarted = append(testStarted, true) filter := ¶m.GetParams{} getNetworkResp, err := suite.networkConfigService.GetNetworkConfigs(filter) - assert.Nil(suite.T(), err, "Failed to get Network Config Details") + require.Nil(suite.T(), err, "Failed to get Network Config Details") var draftConfigID string = "" var activeConfigID string = "" @@ -62,7 +76,7 @@ func (suite *NetworkWorkflowSuite) TestCreateUpdateDeleteDraft() { } if draftConfigID != "" { err := suite.networkConfigService.DeleteNetworkConfig(draftConfigID) - assert.Nil(suite.T(), err, "Failed to Delete Draft Config") + require.Nil(suite.T(), err, "Failed to Delete Draft Config") } // Create Draft config (Use Active Config to create Draft config) @@ -133,7 +147,7 @@ func (suite *NetworkWorkflowSuite) TestCreateUpdateDeleteDraft() { // Create Draft Network Config draftConfigResp, err := suite.networkConfigService.CreateNetworkConfig(draftNetworkConfig) - assert.Nil(suite.T(), err, "Failed to Create Draft Network Config") + require.Nil(suite.T(), err, "Failed to Create Draft Network Config") draftConfigID = *draftConfigResp.ID // Update Draft Network Config - Array API expects all the mandatory params to be passed for update @@ -148,18 +162,19 @@ func (suite *NetworkWorkflowSuite) TestCreateUpdateDeleteDraft() { } draftConfigResp, err = suite.networkConfigService.UpdateNetworkConfig(draftConfigID, updateDraftNetworkConfig) - assert.Nil(suite.T(), err, "Failed to update drfat network config") - assert.Equal(suite.T(), *draftConfigResp.IscsiConnectionRebalancing, true, "Failed to update IscsiConnectionRebalancing value in draft network config") - assert.Equal(suite.T(), *draftConfigResp.IscsiAutomaticConnectionMethod, true, "Failed to update IscsiAutomaticConnectionMethod value in draft network config") + require.Nil(suite.T(), err, "Failed to update drfat network config") + require.Equal(suite.T(), *draftConfigResp.IscsiConnectionRebalancing, true, "Failed to update IscsiConnectionRebalancing value in draft network config") + require.Equal(suite.T(), *draftConfigResp.IscsiAutomaticConnectionMethod, true, "Failed to update IscsiAutomaticConnectionMethod value in draft network config") // Validate Draft Config - Expected to fail as we did not add draft with accurate data var ignoreValidationMask uint64 = 0 err = suite.networkConfigService.ValidateNetconfigNetworkConfig(draftConfigID, ignoreValidationMask) - assert.Nil(suite.T(), err, "Validation failed for Draft Config") + require.Nil(suite.T(), err, "Validation failed for Draft Config") // Delete Draft Config err = suite.networkConfigService.DeleteNetworkConfig(draftConfigID) - assert.Nil(suite.T(), err, "Failed to Delete Draft Config") + require.Nil(suite.T(), err, "Failed to Delete Draft Config") + testCompleted = append(testCompleted, true) } diff --git a/test/perf_policy_test.go b/test/perf_policy_test.go index 2c5d3b35..49315b60 100644 --- a/test/perf_policy_test.go +++ b/test/perf_policy_test.go @@ -3,13 +3,14 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) const perfPolicyName = "PerformancePolicyTest" @@ -23,7 +24,7 @@ type PerformancePolicyWorkflowSuite struct { func (suite *PerformancePolicyWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.perfpolicyService = groupService.GetPerformancePolicyService() suite.volumeService = groupService.GetVolumeService() @@ -31,8 +32,21 @@ func (suite *PerformancePolicyWorkflowSuite) SetupSuite() { } func (suite *PerformancePolicyWorkflowSuite) TearDownSuite() { + var perfPolicyTestResult string + if len(testStarted) == len(testCompleted) { + perfPolicyTestResult = "PASS" + } else { + perfPolicyTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(perfPolicyTestResult, "C560652", "Performance Policy workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil err := deleteDefaultVolume(suite.volumeService) - assert.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) suite.deletePerfPolicy(perfPolicyName) suite.groupService.LogoutService() } @@ -42,20 +56,21 @@ func (suite *PerformancePolicyWorkflowSuite) createPerfPolicy(perfPolicyName str Name: param.NewString(perfPolicyName), } _, err := suite.perfpolicyService.CreatePerformancePolicy(perfPolicy) - assert.Nilf(suite.T(), err, "Unable to create Performance Policy, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create Performance Policy, err: %v", err) } func (suite *PerformancePolicyWorkflowSuite) deletePerfPolicy(perfPolicyName string) { perfPolicy, _ := suite.perfpolicyService.GetPerformancePolicyByName(perfPolicyName) if perfPolicy != nil { err := suite.perfpolicyService.DeletePerformancePolicy(*perfPolicy.ID) - assert.Nilf(suite.T(), err, "Unable to delete performance policy, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete performance policy, err: %v", err) } } func (suite *PerformancePolicyWorkflowSuite) TestAssociateVolumePerfPolicy() { + testStarted = append(testStarted, true) perfPolicy, err := suite.perfpolicyService.GetPerformancePolicyByName(perfPolicyName) - assert.Nilf(suite.T(), err, "Unable to find performance policy, err: %v", err) + require.Nilf(suite.T(), err, "Unable to find performance policy, err: %v", err) var sizeField int64 = 5120 newVolume := &nimbleos.Volume{ Name: param.NewString(defaultVolumeName), @@ -63,22 +78,25 @@ func (suite *PerformancePolicyWorkflowSuite) TestAssociateVolumePerfPolicy() { DedupeEnabled: param.NewBool(false), } vol, err := suite.volumeService.CreateVolume(newVolume) - assert.Nilf(suite.T(), err, "Unable to create volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create volume, err: %v", err) updateVol := &nimbleos.Volume{ PerfpolicyId: perfPolicy.ID, } _, err = suite.volumeService.UpdateVolume(*vol.ID, updateVol) - assert.Nilf(suite.T(), err, "Unable to update volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to update volume, err: %v", err) // Verify performance policy cannot be deleted when volume is associated err = suite.perfpolicyService.DeletePerformancePolicy(*perfPolicy.ID) - assert.NotNil(suite.T(), err, "Deleting performance policy should have failed when volume is associated") + require.NotNil(suite.T(), err, "Deleting performance policy should have failed when volume is associated") + testCompleted = append(testCompleted, true) } func (suite *PerformancePolicyWorkflowSuite) TestPreDefinedPolicy() { + testStarted = append(testStarted, true) perfPolicy, err := suite.perfpolicyService.GetPerformancePolicyByName("default") - assert.Nilf(suite.T(), err, "Unable to find performance policy, err: %v", err) + require.Nilf(suite.T(), err, "Unable to find performance policy, err: %v", err) err = suite.perfpolicyService.DeletePerformancePolicy(*perfPolicy.ID) - assert.NotNil(suite.T(), err, "Deleting pre defined performance policy should have failed") + require.NotNil(suite.T(), err, "Deleting pre defined performance policy should have failed") + testCompleted = append(testCompleted, true) } func TestPerfPolicyWorkflowSuite(t *testing.T) { diff --git a/test/protection_template_test.go b/test/protection_template_test.go index beea50ee..a0825cd5 100644 --- a/test/protection_template_test.go +++ b/test/protection_template_test.go @@ -3,12 +3,13 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) const protectionTemplateName = "ProtectionTemplateTest" @@ -23,7 +24,7 @@ type ProtectionTemplateWorkflowSuite struct { func (suite *ProtectionTemplateWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group: %v", err) suite.groupService = groupService suite.protectionTemplateService = groupService.GetProtectionTemplateService() suite.protectionScheduleService = groupService.GetProtectionScheduleService() @@ -31,6 +32,19 @@ func (suite *ProtectionTemplateWorkflowSuite) SetupSuite() { } func (suite *ProtectionTemplateWorkflowSuite) TearDownSuite() { + var protectionTemplateTestResult string + if len(testStarted) == len(testCompleted) { + protectionTemplateTestResult = "PASS" + } else { + protectionTemplateTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(protectionTemplateTestResult, "C545077", "Protection Template workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.deleteProtectionTemplate(protectionTemplateName) suite.deleteProtectionSchedule(protectionScheduleName) suite.groupService.LogoutService() @@ -41,14 +55,14 @@ func (suite *ProtectionTemplateWorkflowSuite) createProtectionTemplate(ptName st Name: param.NewString(ptName), } _, err := suite.protectionTemplateService.CreateProtectionTemplate(newPT) - assert.Nilf(suite.T(), err, "Unable to create Protection template, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create Protection template, err: %v", err) } func (suite *ProtectionTemplateWorkflowSuite) deleteProtectionTemplate(ptName string) { pt, _ := suite.protectionTemplateService.GetProtectionTemplateByName(ptName) if pt != nil { err := suite.protectionTemplateService.DeleteProtectionTemplate(*pt.ID) - assert.Nilf(suite.T(), err, "Unable to delete Protection Template, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete Protection Template, err: %v", err) } } @@ -56,13 +70,14 @@ func (suite *ProtectionTemplateWorkflowSuite) deleteProtectionSchedule(psName st ps, _ := suite.protectionScheduleService.GetProtectionScheduleByName(psName) if ps != nil { err := suite.protectionScheduleService.DeleteProtectionSchedule(*ps.ID) - assert.Nilf(suite.T(), err, "Unable to delete Protection Schedule, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete Protection Schedule, err: %v", err) } } func (suite *ProtectionTemplateWorkflowSuite) TestCreateProtectionTemplate() { + testStarted = append(testStarted, true) pt, err := suite.protectionTemplateService.GetProtectionTemplateByName(protectionTemplateName) - assert.Nilf(suite.T(), err, "Unable to get protection template, err: %v", err) + require.Nilf(suite.T(), err, "Unable to get protection template, err: %v", err) var numRetain *int64 = param.NewInt64(1234) newPS := &nimbleos.ProtectionSchedule{ Name: param.NewString(protectionScheduleName), @@ -71,7 +86,7 @@ func (suite *ProtectionTemplateWorkflowSuite) TestCreateProtectionTemplate() { NumRetain: numRetain, } _, err = suite.protectionScheduleService.CreateProtectionSchedule(newPS) - assert.Nilf(suite.T(), err, "Unable to create protection schedule, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create protection schedule, err: %v", err) // Update protecion template app sync updatePT := &nimbleos.ProtectionTemplate{ AppSync: nimbleos.NsAppSyncTypeVss, @@ -79,16 +94,19 @@ func (suite *ProtectionTemplateWorkflowSuite) TestCreateProtectionTemplate() { AppId: nimbleos.NsAppIdTypeExchangeDag, } updatedPT, err := suite.protectionTemplateService.UpdateProtectionTemplate(*pt.ID, updatePT) - assert.Nilf(suite.T(), err, "Unable to update app syn of protection template, err: %v", err) - assert.Equal(suite.T(), *nimbleos.NsAppSyncTypeVss, *updatedPT.AppSync, "Update failed") + require.Nilf(suite.T(), err, "Unable to update app syn of protection template, err: %v", err) + require.Equal(suite.T(), *nimbleos.NsAppSyncTypeVss, *updatedPT.AppSync, "Update failed") + testCompleted = append(testCompleted, true) } func (suite *ProtectionTemplateWorkflowSuite) TestCreateProtectionTemplateDup() { + testStarted = append(testStarted, true) newPT := &nimbleos.ProtectionTemplate{ Name: param.NewString(protectionTemplateName), } _, err := suite.protectionTemplateService.CreateProtectionTemplate(newPT) - assert.NotNil(suite.T(), err, "Creating duplicate protection template should have failed") + require.NotNil(suite.T(), err, "Creating duplicate protection template should have failed") + testCompleted = append(testCompleted, true) } func TestProtectionTemplateWorkflowSuite(t *testing.T) { diff --git a/test/replication_partner_test.go b/test/replication_partner_test.go index 86b48279..fe995631 100644 --- a/test/replication_partner_test.go +++ b/test/replication_partner_test.go @@ -2,13 +2,14 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) const repPartner = "ReplcationPartnerTest" @@ -31,7 +32,7 @@ type ReplicationPartnerWorkflowSuite struct { func (suite *ReplicationPartnerWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.volumeService = groupService.GetVolumeService() suite.upstreamRepPartnerService = groupService.GetReplicationPartnerService() @@ -45,7 +46,7 @@ func (suite *ReplicationPartnerWorkflowSuite) SetupSuite() { } // Downstream Array groupService2, err := service.NewNsGroupService(*downstreamArrayIP, "admin", "admin", "v1", true) - assert.Nilf(suite.T(), err, "Unable to connect to the downstream partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to the downstream partner, err: %v", err) suite.downstreamGroupService = groupService2 suite.downstreamRepPartnerService = groupService2.GetReplicationPartnerService() suite.downstreamArrayGrpService = groupService2.GetGroupService() @@ -55,6 +56,19 @@ func (suite *ReplicationPartnerWorkflowSuite) SetupSuite() { } func (suite *ReplicationPartnerWorkflowSuite) TearDownSuite() { + var replicationPartnerTestResult string + if len(testStarted) == len(testCompleted) { + replicationPartnerTestResult = "PASS" + } else { + replicationPartnerTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(replicationPartnerTestResult, "C545231", "Replication Partner workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.deleteReplicationPartner() suite.groupService.LogoutService() suite.downstreamGroupService.LogoutService() @@ -69,7 +83,7 @@ func (suite *ReplicationPartnerWorkflowSuite) createReplicationPartner() { SubnetLabel: param.NewString("mgmt-data"), } upstreamRP, err := suite.upstreamRepPartnerService.CreateReplicationPartner(upstream) - assert.Nilf(suite.T(), err, "Unable to set replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to set replication partner, err: %v", err) // Downstream downstream := &nimbleos.ReplicationPartner{ Name: param.NewString(suite.upstreamGroupName), @@ -78,47 +92,51 @@ func (suite *ReplicationPartnerWorkflowSuite) createReplicationPartner() { SubnetLabel: param.NewString("mgmt-data"), } downstreamRP, err := suite.downstreamRepPartnerService.CreateReplicationPartner(downstream) - assert.Nilf(suite.T(), err, "Unable to set replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to set replication partner, err: %v", err) // Test replication partner err = suite.upstreamRepPartnerService.TestReplicationPartner(*upstreamRP.ID) - assert.Nilf(suite.T(), err, "Unable to test replication partners, err: %v", err) + require.Nilf(suite.T(), err, "Unable to test replication partners, err: %v", err) err = suite.downstreamRepPartnerService.TestReplicationPartner(*downstreamRP.ID) - assert.Nilf(suite.T(), err, "Unable to test replication partners, err: %v", err) + require.Nilf(suite.T(), err, "Unable to test replication partners, err: %v", err) } func (suite *ReplicationPartnerWorkflowSuite) deleteReplicationPartner() { upstreamRP, err := suite.upstreamRepPartnerService.GetReplicationPartnerByName(suite.downstreamGroupName) - assert.Nilf(suite.T(), err, "Unable to find the replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to find the replication partner, err: %v", err) err = suite.upstreamRepPartnerService.DeleteReplicationPartner(*upstreamRP.ID) - assert.Nilf(suite.T(), err, "Unable to delete upstream replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete upstream replication partner, err: %v", err) downstreamRP, err := suite.downstreamRepPartnerService.GetReplicationPartnerByName(suite.upstreamGroupName) - assert.Nilf(suite.T(), err, "Unable to find the replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to find the replication partner, err: %v", err) err = suite.downstreamRepPartnerService.DeleteReplicationPartner(*downstreamRP.ID) - assert.Nilf(suite.T(), err, "Unable to delete downstram replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete downstram replication partner, err: %v", err) } func (suite *ReplicationPartnerWorkflowSuite) TestPauseResumeRP() { + testStarted = append(testStarted, true) upstreamRP, err := suite.upstreamRepPartnerService.GetReplicationPartnerByName(suite.downstreamGroupName) - assert.Nilf(suite.T(), err, "Unable to find replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to find replication partner, err: %v", err) // Pause Replication Partner err = suite.upstreamRepPartnerService.PauseReplicationPartner(*upstreamRP.ID) - assert.Nilf(suite.T(), err, "Unable to pause replication parner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to pause replication parner, err: %v", err) // Resume replication partner err = suite.upstreamRepPartnerService.ResumeReplicationPartner(*upstreamRP.ID) - assert.Nilf(suite.T(), err, "Unable to resume replication partner") + require.Nilf(suite.T(), err, "Unable to resume replication partner") + testCompleted = append(testCompleted, true) } func (suite *ReplicationPartnerWorkflowSuite) TestUpdateRP() { + testStarted = append(testStarted, true) upstreamRP, err := suite.upstreamRepPartnerService.GetReplicationPartnerByName(suite.downstreamGroupName) - assert.Nilf(suite.T(), err, "Unable to find replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to find replication partner, err: %v", err) updateRP := &nimbleos.ReplicationPartner{ Description: param.NewString("Testing replication partner"), } _, err = suite.upstreamRepPartnerService.UpdateReplicationPartner(*upstreamRP.ID, updateRP) - assert.Nilf(suite.T(), err, "Unable to update replication partner, err: %v", err) + require.Nilf(suite.T(), err, "Unable to update replication partner, err: %v", err) + testCompleted = append(testCompleted, true) } func TestReplicationPartnerWorkflowSuite(t *testing.T) { diff --git a/test/snapshot_collection_test.go b/test/snapshot_collection_test.go index 13d757fb..040c1188 100644 --- a/test/snapshot_collection_test.go +++ b/test/snapshot_collection_test.go @@ -3,13 +3,14 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) const snapcollName = "SnapshotCollectionTest" @@ -25,23 +26,36 @@ type SnapCollWorkflowSuite struct { func (suite *SnapCollWorkflowSuite) SetupTest() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.snapcollService = groupService.GetSnapshotCollectionService() suite.volumeService = groupService.GetVolumeService() suite.volcollService = groupService.GetVolumeCollectionService() suite.protectionScheduleService = groupService.GetProtectionScheduleService() _, err = createDefaultVolume(suite.volumeService) - assert.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) _, err = createDefaultVolColl(suite.volcollService) - assert.Nilf(suite.T(), err, "Unable to create default volume collection, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create default volume collection, err: %v", err) } func (suite *SnapCollWorkflowSuite) TearDownSuite() { + var snapshotCollectionTestResult string + if len(testStarted) == len(testCompleted) { + snapshotCollectionTestResult = "PASS" + } else { + snapshotCollectionTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(snapshotCollectionTestResult, "C545076", "Snapshot Collection workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil err := deleteDefaultVolume(suite.volumeService) - assert.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) err = deleteDefaultVolColl(suite.volcollService) - assert.Nilf(suite.T(), err, "Unable to delete default volume collection, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete default volume collection, err: %v", err) suite.deleteSnapColl(snapcollName) suite.groupService.LogoutService() } @@ -50,16 +64,17 @@ func (suite *SnapCollWorkflowSuite) deleteSnapColl(snapcollName string) { snapcoll, _ := suite.snapcollService.GetSnapshotCollectionByName(snapcollName) if snapcoll != nil { err := suite.snapcollService.DeleteSnapshotCollection(*snapcoll.ID) - assert.Nilf(suite.T(), err, "Unable to delete snapshot collection, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete snapshot collection, err: %v", err) } } func (suite *SnapCollWorkflowSuite) TestCreateSnapshotCollection() { + testStarted = append(testStarted, true) // Create volume collection & associate volumes volcoll, _ := suite.volcollService.GetVolumeCollectionByName(defaultVolCollName) vol, _ := suite.volumeService.GetVolumeByName(defaultVolumeName) err := suite.volumeService.AssociateVolume(*vol.ID, *volcoll.ID) - assert.Nilf(suite.T(), err, "Unable to associate volume to volume collection, err: %v", err) + require.Nilf(suite.T(), err, "Unable to associate volume to volume collection, err: %v", err) // Create snapshot schedule and set frequency to 1 min var period *int64 = param.NewInt64(1) var numRetain *int64 = param.NewInt64(12) @@ -72,7 +87,7 @@ func (suite *SnapCollWorkflowSuite) TestCreateSnapshotCollection() { NumRetain: numRetain, } _, err = suite.protectionScheduleService.CreateProtectionSchedule(newPS) - assert.Nilf(suite.T(), err, "Unable to create protection schedule", err) + require.Nilf(suite.T(), err, "Unable to create protection schedule", err) filter := ¶m.GetParams{} snapcollBefore, _ := suite.snapcollService.GetSnapshotCollections(filter) @@ -82,16 +97,17 @@ func (suite *SnapCollWorkflowSuite) TestCreateSnapshotCollection() { VolcollId: volcoll.ID, } _, err = suite.snapcollService.CreateSnapshotCollection(snapcoll) - assert.Nilf(suite.T(), err, "Unable to create snapshot collection, err: %v ", err) + require.Nilf(suite.T(), err, "Unable to create snapshot collection, err: %v ", err) snapcollCreate, _ := suite.snapcollService.GetSnapshotCollections(filter) - assert.Greater(suite.T(), len(snapcollCreate), len(snapcollBefore), "Unable to create snapshot collection") + require.Greater(suite.T(), len(snapcollCreate), len(snapcollBefore), "Unable to create snapshot collection") _ = suite.volumeService.DisassociateVolume(*vol.ID) updateSnapcoll := &nimbleos.SnapshotCollection{ Description: param.NewString("Updated snapshot collection"), } currSnapcoll, _ := suite.snapcollService.GetSnapshotCollectionByName(snapcollName) _, err = suite.snapcollService.UpdateSnapshotCollection(*currSnapcoll.ID, updateSnapcoll) - assert.Nilf(suite.T(), err, "Unable to update snapshot collection, err: %v") + require.Nilf(suite.T(), err, "Unable to update snapshot collection, err: %v") + testCompleted = append(testCompleted, true) } func TestSnapCollWorkflowSuite(t *testing.T) { diff --git a/test/snapshot_test.go b/test/snapshot_test.go index b0793f31..1a6255f5 100644 --- a/test/snapshot_test.go +++ b/test/snapshot_test.go @@ -29,7 +29,7 @@ import ( "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" ) @@ -51,6 +51,19 @@ func (suite *SnapshotWorkflowSuite) SetupSuite() { } func (suite *SnapshotWorkflowSuite) TearDownSuite() { + var snapshotTestResult string + if len(testStarted) == len(testCompleted) { + snapshotTestResult = "PASS" + } else { + snapshotTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(snapshotTestResult, "C560653", "Snapshot workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.groupService.LogoutService() } @@ -68,7 +81,7 @@ func (suite *SnapshotWorkflowSuite) createVolume(volumeName string, baseSnapshot newVolume.Clone = param.NewBool(true) } volResp, err := suite.volumeService.CreateVolume(newVolume) - assert.Nilf(suite.T(), err, "Unable to create volume: %v", volumeName) + require.Nilf(suite.T(), err, "Unable to create volume: %v", volumeName) return *volResp.ID } @@ -79,6 +92,7 @@ func (suite *SnapshotWorkflowSuite) deleteVolume(volumeID string) error { // Creat an offline/online snapshot for the volume. Delete volume func (suite *SnapshotWorkflowSuite) TestCreateUpdateSnapshot() { + testStarted = append(testStarted, true) // Create, Get, Delete Offline Snapshot volumeName := "testvolumesnap1" volumeID := suite.createVolume(volumeName, "") @@ -88,13 +102,13 @@ func (suite *SnapshotWorkflowSuite) TestCreateUpdateSnapshot() { VolId: &volumeID, } _, err := suite.snapshotService.CreateSnapshot(newOfflineSnapshot) - assert.Nilf(suite.T(), err, "Failed to create snapshot: %v", offlineSnapshotName) + require.Nilf(suite.T(), err, "Failed to create snapshot: %v", offlineSnapshotName) getSnapResp, err := suite.snapshotService.GetSnapshotByName(volumeName) - assert.Nilf(suite.T(), err, "Failed to get snapshot(s) by volume name: %v", volumeName) + require.Nilf(suite.T(), err, "Failed to get snapshot(s) by volume name: %v", volumeName) err = suite.snapshotService.DeleteSnapshot(*getSnapResp[0].ID) - assert.Nilf(suite.T(), err, "Failed to delete snapshot: %v", offlineSnapshotName) + require.Nilf(suite.T(), err, "Failed to delete snapshot: %v", offlineSnapshotName) // Create Online Snapshot onlineSnapshotName := "snaponline" @@ -105,12 +119,12 @@ func (suite *SnapshotWorkflowSuite) TestCreateUpdateSnapshot() { Writable: param.NewBool(true), } snapResp, err := suite.snapshotService.CreateSnapshot(newOnlineSnapshot) - assert.Nilf(suite.T(), err, "Failed to create snapshot: %v", newOnlineSnapshot) + require.Nilf(suite.T(), err, "Failed to create snapshot: %v", newOnlineSnapshot) onlineSnapshotID := *snapResp.ID // Delete Volume with online snapshot err = suite.deleteVolume(volumeID) - assert.NotNil(suite.T(), err, "Volume deletion expected to throw error, as there are online snapshots") + require.NotNil(suite.T(), err, "Volume deletion expected to throw error, as there are online snapshots") // Offline the Snapshot & update name, description newOnlineSnapshotName := "updatesnaponline" @@ -121,20 +135,22 @@ func (suite *SnapshotWorkflowSuite) TestCreateUpdateSnapshot() { Description: &newSnapshotDescription, } _, err = suite.snapshotService.UpdateSnapshot(onlineSnapshotID, updateSnapshot) - assert.Nil(suite.T(), err, "Failed to update snapshot") + require.Nil(suite.T(), err, "Failed to update snapshot") getSnapIDResp, err := suite.snapshotService.GetSnapshotById(onlineSnapshotID) - assert.Nil(suite.T(), err, "Failed to get snapshot by ID") - assert.Equal(suite.T(), newSnapshotDescription, *getSnapIDResp.Description, "In-correct Description for Snapshot") - assert.Equal(suite.T(), newOnlineSnapshotName, *getSnapIDResp.Name, "Name not updated") - assert.Equal(suite.T(), false, *getSnapIDResp.Online, "Name not updated") + require.Nil(suite.T(), err, "Failed to get snapshot by ID") + require.Equal(suite.T(), newSnapshotDescription, *getSnapIDResp.Description, "In-correct Description for Snapshot") + require.Equal(suite.T(), newOnlineSnapshotName, *getSnapIDResp.Name, "Name not updated") + require.Equal(suite.T(), false, *getSnapIDResp.Online, "Name not updated") err = suite.deleteVolume(volumeID) - assert.Nilf(suite.T(), err, "Failed to delete volume: %v", volumeName) + require.Nilf(suite.T(), err, "Failed to delete volume: %v", volumeName) + testCompleted = append(testCompleted, true) } // Snapshot Clone Volume test func (suite *SnapshotWorkflowSuite) TestCloneVolumeSnapshot() { + testStarted = append(testStarted, true) volumeName := "testvolumesnap2" parentVolumeID := suite.createVolume(volumeName, "") baseSnapshotName := "snapoffline" @@ -144,7 +160,7 @@ func (suite *SnapshotWorkflowSuite) TestCloneVolumeSnapshot() { Online: param.NewBool(true), } snapResp, err := suite.snapshotService.CreateSnapshot(newOfflineSnapshot) - assert.Nil(suite.T(), err, "Failed to create snapshot") + require.Nil(suite.T(), err, "Failed to create snapshot") baseSnapshotID := *snapResp.ID // Create clone volume @@ -153,19 +169,20 @@ func (suite *SnapshotWorkflowSuite) TestCloneVolumeSnapshot() { // Delete Snapshot with Clone Volume err = suite.snapshotService.DeleteSnapshot(baseSnapshotID) - assert.NotNil(suite.T(), err, "Snapshot deletion should have thrown error") + require.NotNil(suite.T(), err, "Snapshot deletion should have thrown error") // Delete clone volume err = suite.deleteVolume(cloneVolumeID) - assert.Nil(suite.T(), err, "Failed to delete volume") + require.Nil(suite.T(), err, "Failed to delete volume") // Delete Snapshot after deleting Clone Volume err = suite.snapshotService.DeleteSnapshot(baseSnapshotID) - assert.Nil(suite.T(), err, "Failed to delete snapshot") + require.Nil(suite.T(), err, "Failed to delete snapshot") // Delete parent volume err = suite.deleteVolume(parentVolumeID) - assert.Nil(suite.T(), err, "Failed to delete volume") + require.Nil(suite.T(), err, "Failed to delete volume") + testCompleted = append(testCompleted, true) } diff --git a/test/user_test.go b/test/user_test.go index 402a4c11..9f3c4899 100644 --- a/test/user_test.go +++ b/test/user_test.go @@ -22,7 +22,7 @@ import ( "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" ) @@ -40,7 +40,7 @@ type UserWorkflowSuite struct { func (suite *UserWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Could not connect to array") + require.Nilf(suite.T(), err, "Could not connect to array") suite.groupService = groupService suite.userService = groupService.GetUserService() suite.userPolicyService = groupService.GetUserPolicyService() @@ -48,13 +48,26 @@ func (suite *UserWorkflowSuite) SetupSuite() { } func (suite *UserWorkflowSuite) TearDownSuite() { + var userTestResult string + if len(testStarted) == len(testCompleted) { + userTestResult = "PASS" + } else { + userTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(userTestResult, "C545232", "User workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil suite.groupService.LogoutService() } // Delete User func (suite *UserWorkflowSuite) deleteUser(userName string) error { userObj, err := suite.userService.GetUserByName(userName) - assert.NotNilf(suite.T(), userObj, "Failed to get user details") + require.NotNilf(suite.T(), userObj, "Failed to get user details") err = suite.userService.DeleteUser(*userObj.ID) return err } @@ -62,13 +75,14 @@ func (suite *UserWorkflowSuite) deleteUser(userName string) error { // Connect to array with different user func (suite *UserWorkflowSuite) connectArray(arrayIP string, username string, password string) *service.NsGroupService { srcgroupService, err := service.NewNsGroupService(arrayIP, username, password, "v1", true) - assert.Nilf(suite.T(), err, "Could not connect to array") + require.Nilf(suite.T(), err, "Could not connect to array") srcgroupService.SetDebug() return srcgroupService } // Create Power User func (suite *UserWorkflowSuite) TestCreateModifyDeletePowerUser() { + testStarted = append(testStarted, true) powerUserPassword := "testpowerauth" powerUserRole := nimbleos.NsUserRolesPoweruser powerUserFullName := "Test Power User" @@ -85,14 +99,14 @@ func (suite *UserWorkflowSuite) TestCreateModifyDeletePowerUser() { InactivityTimeout: param.NewInt64(powerUserInactivityTimeout), } _, err := suite.userService.CreateUser(newPowerUser) - assert.Nilf(suite.T(), err, "Power User creation failed") + require.Nilf(suite.T(), err, "Power User creation failed") userResp, err := suite.userService.GetUserByName(powerUserName) - assert.Nilf(suite.T(), err, "Get user detail failed") - assert.Equal(suite.T(), nimbleos.NsUserRoles("poweruser"), *userResp.Role, "User created with in-correct Role") - assert.Equal(suite.T(), powerUserDescription, *userResp.Description, "Description not updated for Power user") - assert.Equal(suite.T(), powerUserEmailAddr, *userResp.EmailAddr, "EmailAddr not updated for Power user") - assert.Equal(suite.T(), powerUserFullName, *userResp.FullName, "FullName not updated for Power user") - assert.Equal(suite.T(), powerUserInactivityTimeout, *userResp.InactivityTimeout, "Inactive timeoue not updated for Power user") + require.Nilf(suite.T(), err, "Get user detail failed") + require.Equal(suite.T(), nimbleos.NsUserRoles("poweruser"), *userResp.Role, "User created with in-correct Role") + require.Equal(suite.T(), powerUserDescription, *userResp.Description, "Description not updated for Power user") + require.Equal(suite.T(), powerUserEmailAddr, *userResp.EmailAddr, "EmailAddr not updated for Power user") + require.Equal(suite.T(), powerUserFullName, *userResp.FullName, "FullName not updated for Power user") + require.Equal(suite.T(), powerUserInactivityTimeout, *userResp.InactivityTimeout, "Inactive timeoue not updated for Power user") powerUserID := *userResp.ID // Create a volume using power user @@ -106,13 +120,13 @@ func (suite *UserWorkflowSuite) TestCreateModifyDeletePowerUser() { Online: param.NewBool(false), } _, err = poweruserVolumeService.CreateVolume(newVolume) - assert.Nilf(suite.T(), err, "Unable to create volume %v using power user", volumeName) + require.Nilf(suite.T(), err, "Unable to create volume %v using power user", volumeName) // Delete volume volObj, _ := poweruserVolumeService.GetVolumeByName(volumeName) fmt.Printf("%v", volObj) err = poweruserVolumeService.DeleteVolume(*volObj.ID) - assert.Nilf(suite.T(), err, "Failed to delete volume") + require.Nilf(suite.T(), err, "Failed to delete volume") // Modify Power user role to Guest user guestUserRole := nimbleos.NsUserRolesGuest @@ -120,15 +134,17 @@ func (suite *UserWorkflowSuite) TestCreateModifyDeletePowerUser() { Role: guestUserRole, } userResp, err = suite.userService.UpdateUser(powerUserID, updateGuestUser) - assert.Nilf(suite.T(), err, "Unable to modify user role") - assert.Equal(suite.T(), nimbleos.NsUserRoles("guest"), *userResp.Role, "User Role not updated") + require.Nilf(suite.T(), err, "Unable to modify user role") + require.Equal(suite.T(), nimbleos.NsUserRoles("guest"), *userResp.Role, "User Role not updated") // Delete User err = suite.deleteUser(powerUserName) - assert.Nilf(suite.T(), err, "Unable to delete User %v", powerUserName) + require.Nilf(suite.T(), err, "Unable to delete User %v", powerUserName) + testCompleted = append(testCompleted, true) } func (suite *UserWorkflowSuite) TestCreateDeleteGuestUser() { + testStarted = append(testStarted, true) guestUserName := "testguestuser" guestUserPassword := "testguestauth" guestUserRole := nimbleos.NsUserRolesGuest @@ -146,21 +162,23 @@ func (suite *UserWorkflowSuite) TestCreateDeleteGuestUser() { InactivityTimeout: param.NewInt64(guestUserInactivityTimeout), } _, err := suite.userService.CreateUser(newguestUser) - assert.Nilf(suite.T(), err, "Guest User creation failed") + require.Nilf(suite.T(), err, "Guest User creation failed") userResp, err := suite.userService.GetUserByName(guestUserName) - assert.Nilf(suite.T(), err, "Get user detail failed") - assert.Equal(suite.T(), nimbleos.NsUserRoles("guest"), *userResp.Role, "In-correct User Role") - assert.Equal(suite.T(), guestUserDescription, *userResp.Description, "Description not updated for Guest user") - assert.Equal(suite.T(), guestUserEmailAddr, *userResp.EmailAddr, "EmailAddr not updated for Guest user") - assert.Equal(suite.T(), guestUserFullName, *userResp.FullName, "FullName not updated for Guest user") - assert.Equal(suite.T(), guestUserInactivityTimeout, *userResp.InactivityTimeout, "Inactivity timeout not updated for Guest user") + require.Nilf(suite.T(), err, "Get user detail failed") + require.Equal(suite.T(), nimbleos.NsUserRoles("guest"), *userResp.Role, "In-correct User Role") + require.Equal(suite.T(), guestUserDescription, *userResp.Description, "Description not updated for Guest user") + require.Equal(suite.T(), guestUserEmailAddr, *userResp.EmailAddr, "EmailAddr not updated for Guest user") + require.Equal(suite.T(), guestUserFullName, *userResp.FullName, "FullName not updated for Guest user") + require.Equal(suite.T(), guestUserInactivityTimeout, *userResp.InactivityTimeout, "Inactivity timeout not updated for Guest user") // Delete User err = suite.deleteUser(guestUserName) - assert.Nilf(suite.T(), err, "Unable to Guest delete User %v", guestUserName) + require.Nilf(suite.T(), err, "Unable to Guest delete User %v", guestUserName) + testCompleted = append(testCompleted, true) } func (suite *UserWorkflowSuite) TestUpdateUserPolicy() { + testStarted = append(testStarted, true) arrayVersion := getArrayVersion(suite.arrayGroupService) if arrayVersion < 5.1 { suite.T().Skip() @@ -184,15 +202,16 @@ func (suite *UserWorkflowSuite) TestUpdateUserPolicy() { userPolicyResp, err := suite.userPolicyService.GetUserPolicies(filter) userPolicyID := *userPolicyResp[0].ID _, err = suite.userPolicyService.UpdateUserPolicy(userPolicyID, updateUserPolicy) - assert.Nilf(suite.T(), err, "Failed to create userpolicy") + require.Nilf(suite.T(), err, "Failed to create userpolicy") userPolicyResp, err = suite.userPolicyService.GetUserPolicies(filter) - assert.Nilf(suite.T(), err, "Get user policy detail failed") - assert.Equal(suite.T(), allowedAttempts, *userPolicyResp[0].AllowedAttempts, "Wrong allowedAttempts count") - assert.Equal(suite.T(), minLength, *userPolicyResp[0].MinLength, "Wrong minLength count") - assert.Equal(suite.T(), upperCaseCount, *userPolicyResp[0].Upper, "Wrong upperCaseCount count") - assert.Equal(suite.T(), lowerCaseCount, *userPolicyResp[0].Lower, "Wrong lowerCaseCount count") - assert.Equal(suite.T(), digitCount, *userPolicyResp[0].Digit, "Wrong digitCount count") - assert.Equal(suite.T(), specialCharCount, *userPolicyResp[0].Special, "Wrong specialCharCount count") + require.Nilf(suite.T(), err, "Get user policy detail failed") + require.Equal(suite.T(), allowedAttempts, *userPolicyResp[0].AllowedAttempts, "Wrong allowedAttempts count") + require.Equal(suite.T(), minLength, *userPolicyResp[0].MinLength, "Wrong minLength count") + require.Equal(suite.T(), upperCaseCount, *userPolicyResp[0].Upper, "Wrong upperCaseCount count") + require.Equal(suite.T(), lowerCaseCount, *userPolicyResp[0].Lower, "Wrong lowerCaseCount count") + require.Equal(suite.T(), digitCount, *userPolicyResp[0].Digit, "Wrong digitCount count") + require.Equal(suite.T(), specialCharCount, *userPolicyResp[0].Special, "Wrong specialCharCount count") + testCompleted = append(testCompleted, true) } func TestUserWorkflowSuite(t *testing.T) { diff --git a/test/volume_collection_test.go b/test/volume_collection_test.go index eae71327..95f3fb9c 100644 --- a/test/volume_collection_test.go +++ b/test/volume_collection_test.go @@ -3,13 +3,14 @@ package test import ( + "testing" + "github.com/hpe-storage/nimble-golang-sdk/pkg/client/v1/nimbleos" "github.com/hpe-storage/nimble-golang-sdk/pkg/param" "github.com/hpe-storage/nimble-golang-sdk/pkg/sdkprovider" "github.com/hpe-storage/nimble-golang-sdk/pkg/service" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "testing" ) const volcollName = "VolumeCollectionTest" @@ -23,18 +24,31 @@ type VolCollWorkflowSuite struct { func (suite *VolCollWorkflowSuite) SetupSuite() { groupService, err := config() - assert.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) + require.Nilf(suite.T(), err, "Unable to connect to group, err: %v", err) suite.groupService = groupService suite.volcollService = groupService.GetVolumeCollectionService() suite.volService = groupService.GetVolumeService() _, err = createDefaultVolume(suite.volService) - assert.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create default volume, err: %v", err) suite.createVolColl(volcollName) } func (suite *VolCollWorkflowSuite) TearDownSuite() { + var volumeCollectionTestResult string + if len(testStarted) == len(testCompleted) { + volumeCollectionTestResult = "PASS" + } else { + volumeCollectionTestResult = "FAIL" + } + var postResult = *postResultToDashboard + if postResult == "true" { + pushResultToDashboard(volumeCollectionTestResult, "C545075", "Volume Collection workflow") + } + //cleanup test result + testStarted = nil + testCompleted = nil err := deleteDefaultVolume(suite.volService) - assert.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) + require.Nilf(suite.T(), err, "Unable to delete default volume, err: %v", err) suite.deleteVolColl(volcollName) suite.groupService.LogoutService() } @@ -44,29 +58,32 @@ func (suite *VolCollWorkflowSuite) createVolColl(volcollName string) { Name: param.NewString(volcollName), } volcoll, err := suite.volcollService.CreateVolumeCollection(newVolColl) - assert.Nilf(suite.T(), err, "Unable to create volume collection, err: %v", err) + require.Nilf(suite.T(), err, "Unable to create volume collection, err: %v", err) vol, _ := suite.volService.GetVolumeByName(defaultVolumeName) err = suite.volService.AssociateVolume(*vol.ID, *volcoll.ID) - assert.Nilf(suite.T(), err, "Associating volume to volume collection failed, err: %v", err) + require.Nilf(suite.T(), err, "Associating volume to volume collection failed, err: %v", err) } func (suite *VolCollWorkflowSuite) deleteVolColl(volcollName string) { volcoll, _ := suite.volcollService.GetVolumeCollectionByName(volcollName) if volcoll != nil { err := suite.volcollService.DeleteVolumeCollection(*volcoll.ID) - assert.Nilf(suite.T(), err, "Unable to delete volume collection, err: %v", defaultVolCollName) + require.Nilf(suite.T(), err, "Unable to delete volume collection, err: %v", defaultVolCollName) } } func (suite *VolCollWorkflowSuite) TestCreateVolCollDuplicate() { + testStarted = append(testStarted, true) newVolColl := &nimbleos.VolumeCollection{ Name: param.NewString(volcollName), } _, err := suite.volcollService.CreateVolumeCollection(newVolColl) - assert.NotNil(suite.T(), err, "Duplicate Volume collection should have failed.") + require.NotNil(suite.T(), err, "Duplicate Volume collection should have failed.") + testCompleted = append(testCompleted, true) } func (suite *VolCollWorkflowSuite) TestCreateGenericVolCol() { + testStarted = append(testStarted, true) newVolColl := &nimbleos.VolumeCollection{ Name: param.NewString("VolColGeneric"), AppSync: nimbleos.NsAppSyncTypeGeneric, @@ -75,12 +92,14 @@ func (suite *VolCollWorkflowSuite) TestCreateGenericVolCol() { AgentPassword: param.NewString("xxx"), } volcoll, err := suite.volcollService.CreateVolumeCollection(newVolColl) - assert.Nilf(suite.T(), err, "Unable to create VOlColl for generic app sync, err: %v", err) - assert.Equal(suite.T(), *nimbleos.NsAppSyncTypeGeneric, *volcoll.AppSync, "VolColl app sync type not set correctly.") + require.Nilf(suite.T(), err, "Unable to create VOlColl for generic app sync, err: %v", err) + require.Equal(suite.T(), *nimbleos.NsAppSyncTypeGeneric, *volcoll.AppSync, "VolColl app sync type not set correctly.") suite.deleteVolColl(*volcoll.Name) + testCompleted = append(testCompleted, true) } func (suite *VolCollWorkflowSuite) TestCreateVssVolCol() { + testStarted = append(testStarted, true) newVolColl := &nimbleos.VolumeCollection{ Name: param.NewString("VolColVss"), AppSync: nimbleos.NsAppSyncTypeVss, @@ -88,12 +107,14 @@ func (suite *VolCollWorkflowSuite) TestCreateVssVolCol() { AppId: nimbleos.NsAppIdTypeExchangeDag, } volcoll, err := suite.volcollService.CreateVolumeCollection(newVolColl) - assert.Nilf(suite.T(), err, "Unable to create VolColl for VSS, err: %v", err) - assert.Equal(suite.T(), *nimbleos.NsAppSyncTypeVss, *volcoll.AppSync, "VolColl app sync type not set correctly.") + require.Nilf(suite.T(), err, "Unable to create VolColl for VSS, err: %v", err) + require.Equal(suite.T(), *nimbleos.NsAppSyncTypeVss, *volcoll.AppSync, "VolColl app sync type not set correctly.") suite.deleteVolColl(*volcoll.Name) + testCompleted = append(testCompleted, true) } func (suite *VolCollWorkflowSuite) TestCreateVmwareVolColl() { + testStarted = append(testStarted, true) newVolColl := &nimbleos.VolumeCollection{ Name: param.NewString("VolCollVmare"), AppSync: nimbleos.NsAppSyncTypeVmware, @@ -102,27 +123,33 @@ func (suite *VolCollWorkflowSuite) TestCreateVmwareVolColl() { VcenterPassword: param.NewString("xxx"), } volcoll, err := suite.volcollService.CreateVolumeCollection(newVolColl) - assert.Nilf(suite.T(), err, "Unable to create VolColl with VMWare app sync, err: %v", err) - assert.Equal(suite.T(), *nimbleos.NsAppSyncTypeVmware, *volcoll.AppSync, "VolColl app sync type not set correctly.") + require.Nilf(suite.T(), err, "Unable to create VolColl with VMWare app sync, err: %v", err) + require.Equal(suite.T(), *nimbleos.NsAppSyncTypeVmware, *volcoll.AppSync, "VolColl app sync type not set correctly.") suite.deleteVolColl(*volcoll.Name) + testCompleted = append(testCompleted, true) } func (suite *VolCollWorkflowSuite) TestDeleteProtectedVolume() { + testStarted = append(testStarted, true) vol, _ := suite.volService.GetVolumeByName(defaultVolumeName) if vol != nil { err := suite.volService.DeleteVolume(*vol.ID) - assert.NotNil(suite.T(), err, "Delete volume should have failed") + require.NotNil(suite.T(), err, "Delete volume should have failed") } + testCompleted = append(testCompleted, true) } func (suite *VolCollWorkflowSuite) TestDissassociateVol() { + testStarted = append(testStarted, true) vol, _ := suite.volService.GetVolumeByName(defaultVolumeName) err := suite.volService.DisassociateVolume(*vol.ID) - assert.Nilf(suite.T(), err, "Disassociating volume from volume collection failed, err: %v", err) + require.Nilf(suite.T(), err, "Disassociating volume from volume collection failed, err: %v", err) + testCompleted = append(testCompleted, true) } func (suite *VolCollWorkflowSuite) TestVolCollSchedule() { + testStarted = append(testStarted, true) var numRetain *int64 = param.NewInt64(123) volcoll, _ := suite.volcollService.GetVolumeCollectionByName(volcollName) protectionScheduleService := suite.groupService.GetProtectionScheduleService() @@ -133,7 +160,8 @@ func (suite *VolCollWorkflowSuite) TestVolCollSchedule() { NumRetain: numRetain, } _, err := protectionScheduleService.CreateProtectionSchedule(ps) - assert.Nilf(suite.T(), err, "Unable to associated protection schedule", err) + require.Nilf(suite.T(), err, "Unable to associated protection schedule", err) + testCompleted = append(testCompleted, true) } diff --git a/test/volume_test.go b/test/volume_test.go index e28d0073..b98e776f 100644 --- a/test/volume_test.go +++ b/test/volume_test.go @@ -53,8 +53,8 @@ func (suite *VolumeWorkflowSuite) TearDownSuite() { pushResultToDashboard(volumeTestResult, "C545072", "Volume workflow") } //cleanup test result - testStarted = testStarted[:0] - testCompleted = testCompleted[:0] + testStarted = nil + testCompleted = nil suite.deleteVolume(volumeName) err := deleteDefaultInitiatorGroup(suite.initiatorGrpService) require.Nilf(suite.T(), err, "Unable to delete default initiator group, err: %v", err)