Use tester suite wrapper in connector package (#2613)

## Does this PR need a docs update or release note?

- [ ] ✅ Yes, it's included
- [ ] 🕐 Yes, but in a later PR
- [x] ⛔ No 

## Type of change

- [ ] 🌻 Feature
- [ ] 🐛 Bugfix
- [ ] 🗺️ Documentation
- [ ] 🤖 Test
- [ ] 💻 CI/Deployment
- [x] 🧹 Tech Debt/Cleanup

## Issue(s)

* #2373

## Test Plan

- [x] 💪 Manual
- [ ] ⚡ Unit test
- [ ] 💚 E2E

src/internal/connector/data_collections_test.go

@@ -24,27 +24,26 @@ import (
 // ---------------------------------------------------------------------------
 
 type ConnectorDataCollectionIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	connector *GraphConnector
 	user      string
 	site      string
 }
 
 func TestConnectorDataCollectionIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(t,
-		tester.CorsoCITests,
-		tester.CorsoConnectorDataCollectionTests,
-	)
-
-	suite.Run(t, new(ConnectorDataCollectionIntegrationSuite))
+	suite.Run(t, &ConnectorDataCollectionIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoConnectorDataCollectionTests),
+	})
 }
 
 func (suite *ConnectorDataCollectionIntegrationSuite) SetupSuite() {
 	ctx, flush := tester.NewContext()
 	defer flush()
 
-	tester.MustGetEnvVars(suite.T(), tester.M365AcctCredEnvs...)
-
 	suite.connector = loadConnector(ctx, suite.T(), graph.HTTPClient(graph.NoTimeout()), AllResources)
 	suite.user = tester.M365UserID(suite.T())
 	suite.site = tester.M365SiteID(suite.T())
@@ -99,7 +98,9 @@ func (suite *ConnectorDataCollectionIntegrationSuite) TestExchangeDataCollection
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			collections, excludes, err := exchange.DataCollections(
 				ctx,
 				test.getSelector(t),
@@ -201,7 +202,9 @@ func (suite *ConnectorDataCollectionIntegrationSuite) TestDataCollections_invali
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			collections, excludes, err := connector.DataCollections(
 				ctx,
 				test.getSelector(t),
@@ -250,7 +253,9 @@ func (suite *ConnectorDataCollectionIntegrationSuite) TestSharePointDataCollecti
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			collections, excludes, err := sharepoint.DataCollections(
 				ctx,
 				graph.HTTPClient(graph.NoTimeout()),
@@ -292,26 +297,25 @@ func (suite *ConnectorDataCollectionIntegrationSuite) TestSharePointDataCollecti
 // ---------------------------------------------------------------------------
 
 type ConnectorCreateSharePointCollectionIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	connector *GraphConnector
 	user      string
 }
 
 func TestConnectorCreateSharePointCollectionIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoConnectorCreateSharePointCollectionTests)
-
-	suite.Run(t, new(ConnectorCreateSharePointCollectionIntegrationSuite))
+	suite.Run(t, &ConnectorCreateSharePointCollectionIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoConnectorCreateSharePointCollectionTests),
+	})
 }
 
 func (suite *ConnectorCreateSharePointCollectionIntegrationSuite) SetupSuite() {
 	ctx, flush := tester.NewContext()
 	defer flush()
 
-	tester.MustGetEnvSets(suite.T(), tester.M365AcctCredEnvs)
-
 	suite.connector = loadConnector(ctx, suite.T(), graph.HTTPClient(graph.NoTimeout()), Sites)
 	suite.user = tester.M365UserID(suite.T())
 

src/internal/connector/exchange/api/api_test.go

@@ -16,24 +16,23 @@ import (
 )
 
 type ExchangeServiceSuite struct {
-	suite.Suite
+	tester.Suite
 	gs          graph.Servicer
 	credentials account.M365Config
 }
 
 func TestExchangeServiceSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorExchangeTests)
-
-	suite.Run(t, new(ExchangeServiceSuite))
+	suite.Run(t, &ExchangeServiceSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorExchangeTests),
+	})
 }
 
 func (suite *ExchangeServiceSuite) SetupSuite() {
 	t := suite.T()
-	tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
 
 	a := tester.NewM365Account(t)
 	m365, err := a.M365Config()
@@ -78,9 +77,9 @@ func (suite *ExchangeServiceSuite) TestOptionsForCalendars() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			_, err := optionsForCalendars(test.params)
-			test.checkError(t, err)
+			test.checkError(suite.T(), err)
 		})
 	}
 }
@@ -114,11 +113,13 @@ func (suite *ExchangeServiceSuite) TestOptionsForFolders() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			config, err := optionsForMailFolders(test.params)
 			test.checkError(t, err)
 			if err == nil {
-				suite.Equal(test.expected, len(config.QueryParameters.Select))
+				assert.Equal(t, test.expected, len(config.QueryParameters.Select))
 			}
 		})
 	}
@@ -151,11 +152,13 @@ func (suite *ExchangeServiceSuite) TestOptionsForContacts() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			options, err := optionsForContacts(test.params)
 			test.checkError(t, err)
 			if err == nil {
-				suite.Equal(test.expected, len(options.QueryParameters.Select))
+				assert.Equal(t, test.expected, len(options.QueryParameters.Select))
 			}
 		})
 	}
@@ -208,7 +211,9 @@ func (suite *ExchangeServiceSuite) TestHasAttachments() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			found := HasAttachments(test.getBodyable(t))
 			test.hasAttachment(t, found)
 		})

src/internal/connector/exchange/api/contacts_test.go

@@ -8,15 +8,16 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 
+	"github.com/alcionai/corso/src/internal/tester"
 	"github.com/alcionai/corso/src/pkg/backup/details"
 )
 
 type ContactsAPIUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestContactsAPIUnitSuite(t *testing.T) {
-	suite.Run(t, new(ContactsAPIUnitSuite))
+	suite.Run(t, &ContactsAPIUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *ContactsAPIUnitSuite) TestContactInfo() {
@@ -59,9 +60,9 @@ func (suite *ContactsAPIUnitSuite) TestContactInfo() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			contact, expected := test.contactAndRP()
-			assert.Equal(t, expected, ContactInfo(contact))
+			assert.Equal(suite.T(), expected, ContactInfo(contact))
 		})
 	}
 }

src/internal/connector/exchange/api/events_test.go

@@ -12,15 +12,16 @@ import (
 	"github.com/alcionai/corso/src/internal/common"
 	"github.com/alcionai/corso/src/internal/connector/mockconnector"
 	"github.com/alcionai/corso/src/internal/connector/support"
+	"github.com/alcionai/corso/src/internal/tester"
 	"github.com/alcionai/corso/src/pkg/backup/details"
 )
 
 type EventsAPIUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestEventsAPIUnitSuite(t *testing.T) {
-	suite.Run(t, new(EventsAPIUnitSuite))
+	suite.Run(t, &EventsAPIUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 // TestEventInfo verifies that searchable event metadata
@@ -141,7 +142,9 @@ func (suite *EventsAPIUnitSuite) TestEventInfo() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			event, expected := test.evtAndRP()
 			result := EventInfo(event)
 

src/internal/connector/exchange/api/mail_test.go

@@ -5,17 +5,19 @@ import (
 	"time"
 
 	"github.com/microsoftgraph/msgraph-sdk-go/models"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 
+	"github.com/alcionai/corso/src/internal/tester"
 	"github.com/alcionai/corso/src/pkg/backup/details"
 )
 
 type MailAPIUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestMailAPIUnitSuite(t *testing.T) {
-	suite.Run(t, new(MailAPIUnitSuite))
+	suite.Run(t, &MailAPIUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *MailAPIUnitSuite) TestMailInfo() {
@@ -124,9 +126,9 @@ func (suite *MailAPIUnitSuite) TestMailInfo() {
 		},
 	}
 	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
+		suite.Run(tt.name, func() {
 			msg, expected := tt.msgAndRP()
-			suite.Equal(expected, MailInfo(msg))
+			assert.Equal(suite.T(), expected, MailInfo(msg))
 		})
 	}
 }

src/internal/connector/exchange/container_resolver_test.go

@@ -51,11 +51,11 @@ func strPtr(s string) *string {
 // ---------------------------------------------------------------------------
 
 type FolderCacheUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestFolderCacheUnitSuite(t *testing.T) {
-	suite.Run(t, new(FolderCacheUnitSuite))
+	suite.Run(t, &FolderCacheUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 type containerCheckTestInfo struct {
@@ -121,8 +121,8 @@ var (
 
 func (suite *FolderCacheUnitSuite) TestCheckIDAndName() {
 	for _, test := range containerCheckTests {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.check(t, checkIDAndName(test.c))
+		suite.Run(test.name, func() {
+			test.check(suite.T(), checkIDAndName(test.c))
 		})
 	}
 }
@@ -152,8 +152,8 @@ func (suite *FolderCacheUnitSuite) TestCheckRequiredValues() {
 	table = append(table, containerCheckTests...)
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.check(t, checkRequiredValues(test.c))
+		suite.Run(test.name, func() {
+			test.check(suite.T(), checkRequiredValues(test.c))
 		})
 	}
 }
@@ -227,9 +227,9 @@ func (suite *FolderCacheUnitSuite) TestAddFolder() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			fc := newContainerResolver()
-			test.check(t, fc.addFolder(test.cf))
+			test.check(suite.T(), fc.addFolder(test.cf))
 		})
 	}
 }
@@ -311,7 +311,7 @@ func resolverWithContainers(numContainers int, useIDInPath bool) (*containerReso
 
 // TestConfiguredFolderCacheUnitSuite cannot run its tests in parallel.
 type ConfiguredFolderCacheUnitSuite struct {
-	suite.Suite
+	tester.Suite
 
 	fc       *containerResolver
 	fcWithID *containerResolver
@@ -326,7 +326,7 @@ func (suite *ConfiguredFolderCacheUnitSuite) SetupTest() {
 }
 
 func TestConfiguredFolderCacheUnitSuite(t *testing.T) {
-	suite.Run(t, new(ConfiguredFolderCacheUnitSuite))
+	suite.Run(t, &ConfiguredFolderCacheUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *ConfiguredFolderCacheUnitSuite) TestDepthLimit() {
@@ -351,10 +351,10 @@ func (suite *ConfiguredFolderCacheUnitSuite) TestDepthLimit() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			resolver, containers := resolverWithContainers(test.numContainers, false)
 			_, _, err := resolver.IDToPath(ctx, containers[len(containers)-1].id, false)
-			test.check(t, err)
+			test.check(suite.T(), err)
 		})
 	}
 }
@@ -387,7 +387,9 @@ func (suite *ConfiguredFolderCacheUnitSuite) TestLookupCachedFolderNoPathsCached
 	defer flush()
 
 	for _, c := range suite.allContainers {
-		suite.T().Run(*c.GetDisplayName(), func(t *testing.T) {
+		suite.Run(*c.GetDisplayName(), func() {
+			t := suite.T()
+
 			p, l, err := suite.fc.IDToPath(ctx, c.id, false)
 			require.NoError(t, err)
 			assert.Equal(t, c.expectedPath, p.String())
@@ -401,7 +403,9 @@ func (suite *ConfiguredFolderCacheUnitSuite) TestLookupCachedFolderNoPathsCached
 	defer flush()
 
 	for _, c := range suite.containersWithID {
-		suite.T().Run(*c.GetDisplayName(), func(t *testing.T) {
+		suite.Run(*c.GetDisplayName(), func() {
+			t := suite.T()
+
 			p, l, err := suite.fcWithID.IDToPath(ctx, c.id, true)
 			require.NoError(t, err)
 			assert.Equal(t, c.expectedPath, p.String())
@@ -505,23 +509,24 @@ func (suite *ConfiguredFolderCacheUnitSuite) TestAddToCache() {
 // ---------------------------------------------------------------------------
 
 type FolderCacheIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	credentials account.M365Config
 	gs          graph.Servicer
 }
 
 func TestFolderCacheIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoConnectorExchangeFolderCacheTests)
-
-	suite.Run(t, new(FolderCacheIntegrationSuite))
+	suite.Run(t, &FolderCacheIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorExchangeTests,
+			tester.CorsoConnectorExchangeFolderCacheTests),
+	})
 }
 
 func (suite *FolderCacheIntegrationSuite) SetupSuite() {
 	t := suite.T()
-	tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
 
 	a := tester.NewM365Account(t)
 	m365, err := a.M365Config()
@@ -652,7 +657,9 @@ func (suite *FolderCacheIntegrationSuite) TestCreateContainerDestination() {
 	)
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			folderID, err := CreateContainerDestination(
 				ctx,
 				m365,

src/internal/connector/exchange/data_collections_test.go

@@ -25,11 +25,11 @@ import (
 // ---------------------------------------------------------------------------
 
 type DataCollectionsUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestDataCollectionsUnitSuite(t *testing.T) {
-	suite.Run(t, new(DataCollectionsUnitSuite))
+	suite.Run(t, &DataCollectionsUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *DataCollectionsUnitSuite) TestParseMetadataCollections() {
@@ -155,7 +155,9 @@ func (suite *DataCollectionsUnitSuite) TestParseMetadataCollections() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -207,23 +209,23 @@ func newStatusUpdater(t *testing.T, wg *sync.WaitGroup) func(status *support.Con
 }
 
 type DataCollectionsIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	user string
 	site string
 }
 
 func TestDataCollectionsIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoConnectorCreateExchangeCollectionTests)
-
-	suite.Run(t, new(DataCollectionsIntegrationSuite))
+	suite.Run(t, &DataCollectionsIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorExchangeTests,
+			tester.CorsoConnectorCreateExchangeCollectionTests),
+	})
 }
 
 func (suite *DataCollectionsIntegrationSuite) SetupSuite() {
-	tester.MustGetEnvSets(suite.T(), tester.M365AcctCredEnvs)
-
 	suite.user = tester.M365UserID(suite.T())
 	suite.site = tester.M365SiteID(suite.T())
 
@@ -260,7 +262,9 @@ func (suite *DataCollectionsIntegrationSuite) TestMailFetch() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			collections, err := createCollections(
 				ctx,
 				acct,
@@ -327,7 +331,9 @@ func (suite *DataCollectionsIntegrationSuite) TestDelta() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			// get collections without providing any delta history (ie: full backup)
 			collections, err := createCollections(
 				ctx,
@@ -420,7 +426,9 @@ func (suite *DataCollectionsIntegrationSuite) TestMailSerializationRegression()
 	wg.Add(len(collections))
 
 	for _, edc := range collections {
-		t.Run(edc.FullPath().String(), func(t *testing.T) {
+		suite.Run(edc.FullPath().String(), func() {
+			t := suite.T()
+
 			isMetadata := edc.FullPath().Service() == path.ExchangeMetadataService
 			streamChannel := edc.Items(ctx, fault.New(true))
 
@@ -471,8 +479,11 @@ func (suite *DataCollectionsIntegrationSuite) TestContactSerializationRegression
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
-			var wg sync.WaitGroup
+		suite.Run(test.name, func() {
+			var (
+				wg sync.WaitGroup
+				t  = suite.T()
+			)
 
 			edcs, err := createCollections(
 				ctx,
@@ -579,8 +590,11 @@ func (suite *DataCollectionsIntegrationSuite) TestEventsSerializationRegression(
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
-			var wg sync.WaitGroup
+		suite.Run(test.name, func() {
+			var (
+				wg sync.WaitGroup
+				t  = suite.T()
+			)
 
 			collections, err := createCollections(
 				ctx,

src/internal/connector/exchange/exchange_data_collection_test.go

@@ -46,11 +46,11 @@ func (mi *mockItemer) Serialize(
 }
 
 type ExchangeDataCollectionSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestExchangeDataCollectionSuite(t *testing.T) {
-	suite.Run(t, new(ExchangeDataCollectionSuite))
+	suite.Run(t, &ExchangeDataCollectionSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *ExchangeDataCollectionSuite) TestExchangeDataReader_Valid() {
@@ -70,14 +70,15 @@ func (suite *ExchangeDataCollectionSuite) TestExchangeDataReader_Empty() {
 	var (
 		empty    []byte
 		expected int64
+		t        = suite.T()
 	)
 
 	ed := &Stream{message: empty}
 	buf := &bytes.Buffer{}
 	received, err := buf.ReadFrom(ed.ToReader())
 
-	suite.Equal(expected, received)
-	assert.Nil(suite.T(), err, "received buf.Readfrom error ")
+	assert.Equal(t, expected, received)
+	assert.Nil(t, err, "received buf.Readfrom error ")
 }
 
 func (suite *ExchangeDataCollectionSuite) TestExchangeData_FullPath() {
@@ -103,6 +104,8 @@ func (suite *ExchangeDataCollectionSuite) TestExchangeData_FullPath() {
 }
 
 func (suite *ExchangeDataCollectionSuite) TestExchangeDataCollection_NewExchangeDataCollection() {
+	t := suite.T()
+
 	tenant := "a-tenant"
 	user := "a-user"
 	folder := "a-folder"
@@ -114,14 +117,14 @@ func (suite *ExchangeDataCollectionSuite) TestExchangeDataCollection_NewExchange
 		path.EmailCategory,
 		false,
 	)
-	require.NoError(suite.T(), err)
+	require.NoError(t, err)
 
 	edc := Collection{
 		user:     name,
 		fullPath: fullPath,
 	}
-	suite.Equal(name, edc.user)
-	suite.Equal(fullPath, edc.FullPath())
+	assert.Equal(t, name, edc.user)
+	assert.Equal(t, fullPath, edc.FullPath())
 }
 
 func (suite *ExchangeDataCollectionSuite) TestNewCollection_state() {
@@ -172,7 +175,9 @@ func (suite *ExchangeDataCollectionSuite) TestNewCollection_state() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			c := NewCollection(
 				"u",
 				test.curr, test.prev, test.loc,
@@ -225,13 +230,13 @@ func (suite *ExchangeDataCollectionSuite) TestGetItemWithRetries() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			ctx, flush := tester.NewContext()
 			defer flush()
 
 			// itemer is mocked, so only the errors are configured atm.
 			_, _, err := getItemWithRetries(ctx, "userID", "itemID", test.items, fault.New(true))
-			test.expectErr(t, err)
+			test.expectErr(suite.T(), err)
 		})
 	}
 }

src/internal/connector/exchange/folder_resolver_test.go

@@ -15,25 +15,23 @@ import (
 )
 
 type CacheResolverSuite struct {
-	suite.Suite
+	tester.Suite
 	credentials account.M365Config
 }
 
 func TestCacheResolverIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorExchangeTests)
-
-	suite.Run(t, new(CacheResolverSuite))
+	suite.Run(t, &CacheResolverSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorExchangeTests),
+	})
 }
 
 func (suite *CacheResolverSuite) SetupSuite() {
 	t := suite.T()
 
-	tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
-
 	a := tester.NewM365Account(t)
 	m365, err := a.M365Config()
 	require.NoError(t, err)
@@ -118,7 +116,9 @@ func (suite *CacheResolverSuite) TestPopulate() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			resolver := test.resolverFunc(t)
 			require.NoError(t, resolver.Populate(ctx, fault.New(true), test.root, test.basePath))
 

src/internal/connector/exchange/iterators_test.go

@@ -14,17 +14,11 @@ import (
 )
 
 type ExchangeIteratorSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestExchangeIteratorSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorExchangeTests)
-
-	suite.Run(t, new(ExchangeIteratorSuite))
+	suite.Run(t, &ExchangeIteratorSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *ExchangeIteratorSuite) TestDisplayable() {

src/internal/connector/exchange/mail_folder_cache_test.go

@@ -27,25 +27,23 @@ const (
 )
 
 type MailFolderCacheIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	credentials account.M365Config
 }
 
 func TestMailFolderCacheIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorExchangeTests)
-
-	suite.Run(t, new(MailFolderCacheIntegrationSuite))
+	suite.Run(t, &MailFolderCacheIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorExchangeTests),
+	})
 }
 
 func (suite *MailFolderCacheIntegrationSuite) SetupSuite() {
 	t := suite.T()
 
-	tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
-
 	a := tester.NewM365Account(t)
 	m365, err := a.M365Config()
 	require.NoError(t, err)
@@ -81,7 +79,9 @@ func (suite *MailFolderCacheIntegrationSuite) TestDeltaFetch() {
 	userID := tester.M365UserID(suite.T())
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ac, err := api.NewClient(suite.credentials)
 			require.NoError(t, err)
 

src/internal/connector/exchange/restore_test.go

@@ -22,24 +22,25 @@ import (
 )
 
 type ExchangeRestoreSuite struct {
-	suite.Suite
+	tester.Suite
 	gs          graph.Servicer
 	credentials account.M365Config
 	ac          api.Client
 }
 
 func TestExchangeRestoreSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoConnectorRestoreExchangeCollectionTests)
-
-	suite.Run(t, new(ExchangeRestoreSuite))
+	suite.Run(t, &ExchangeRestoreSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorExchangeTests,
+			tester.CorsoConnectorRestoreExchangeCollectionTests),
+	})
 }
 
 func (suite *ExchangeRestoreSuite) SetupSuite() {
 	t := suite.T()
-	tester.MustGetEnvSets(t, tester.AWSStorageCredEnvs, tester.M365AcctCredEnvs)
 
 	a := tester.NewM365Account(t)
 	m365, err := a.M365Config()
@@ -335,7 +336,9 @@ func (suite *ExchangeRestoreSuite) TestRestoreExchangeObject() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 

src/internal/connector/exchange/service_iterators_test.go

@@ -99,12 +99,12 @@ func (m mockResolver) Populate(context.Context, *fault.Errors, string, ...string
 // ---------------------------------------------------------------------------
 
 type ServiceIteratorsSuite struct {
-	suite.Suite
+	tester.Suite
 	creds account.M365Config
 }
 
 func TestServiceIteratorsSuite(t *testing.T) {
-	suite.Run(t, new(ServiceIteratorsSuite))
+	suite.Run(t, &ServiceIteratorsSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *ServiceIteratorsSuite) SetupSuite() {
@@ -289,7 +289,9 @@ func (suite *ServiceIteratorsSuite) TestFilterContainersAndFillCollections() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -424,7 +426,9 @@ func (suite *ServiceIteratorsSuite) TestFilterContainersAndFillCollections_repea
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -794,7 +798,9 @@ func (suite *ServiceIteratorsSuite) TestFilterContainersAndFillCollections_incre
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 

src/internal/connector/graph/api/api_test.go

@@ -94,7 +94,9 @@ func (suite *APIUnitSuite) TestNextAndDeltaLink() {
 		for _, delta := range deltaTable {
 			name := strings.Join([]string{next.name, "next", delta.name, "delta"}, "_")
 
-			suite.T().Run(name, func(t *testing.T) {
+			suite.Run(name, func() {
+				t := suite.T()
+
 				l := mockDeltaNextLink{
 					mockNextLink: mockNextLink{nextLink: next.inputLink},
 					deltaLink:    delta.inputLink,
@@ -137,9 +139,9 @@ func (suite *APIUnitSuite) TestIsLinkValid() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			got := api.IsNextLinkValid(test.inputString)
-			test.isValid(t, got)
+			test.isValid(suite.T(), got)
 		})
 	}
 }

src/internal/connector/graph/betasdk/beta_client_test.go

@@ -13,18 +13,17 @@ import (
 )
 
 type BetaClientSuite struct {
-	suite.Suite
+	tester.Suite
 	credentials account.M365Config
 }
 
 func TestBetaClientSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-	)
-
-	suite.Run(t, new(BetaClientSuite))
+	suite.Run(t, &BetaClientSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests),
+	})
 }
 
 func (suite *BetaClientSuite) SetupSuite() {

src/internal/connector/graph/errors_test.go

@@ -9,14 +9,15 @@ import (
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/internal/common"
+	"github.com/alcionai/corso/src/internal/tester"
 )
 
 type GraphErrorsUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestGraphErrorsUnitSuite(t *testing.T) {
-	suite.Run(t, new(GraphErrorsUnitSuite))
+	suite.Run(t, &GraphErrorsUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func odErr(code string) *odataerrors.ODataError {
@@ -66,8 +67,8 @@ func (suite *GraphErrorsUnitSuite) TestIsErrDeletedInFlight() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.expect(t, IsErrDeletedInFlight(test.err))
+		suite.Run(test.name, func() {
+			test.expect(suite.T(), IsErrDeletedInFlight(test.err))
 		})
 	}
 }
@@ -105,8 +106,8 @@ func (suite *GraphErrorsUnitSuite) TestIsErrInvalidDelta() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.expect(t, IsErrInvalidDelta(test.err))
+		suite.Run(test.name, func() {
+			test.expect(suite.T(), IsErrInvalidDelta(test.err))
 		})
 	}
 }
@@ -139,8 +140,8 @@ func (suite *GraphErrorsUnitSuite) TestIsErrTimeout() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.expect(t, IsErrTimeout(test.err))
+		suite.Run(test.name, func() {
+			test.expect(suite.T(), IsErrTimeout(test.err))
 		})
 	}
 }
@@ -173,8 +174,8 @@ func (suite *GraphErrorsUnitSuite) TestIsErrThrottled() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.expect(t, IsErrThrottled(test.err))
+		suite.Run(test.name, func() {
+			test.expect(suite.T(), IsErrThrottled(test.err))
 		})
 	}
 }
@@ -207,8 +208,8 @@ func (suite *GraphErrorsUnitSuite) TestIsErrUnauthorized() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.expect(t, IsErrUnauthorized(test.err))
+		suite.Run(test.name, func() {
+			test.expect(suite.T(), IsErrUnauthorized(test.err))
 		})
 	}
 }
@@ -241,8 +242,8 @@ func (suite *GraphErrorsUnitSuite) TestIsInternalServerError() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
-			test.expect(t, IsInternalServerError(test.err))
+		suite.Run(test.name, func() {
+			test.expect(suite.T(), IsInternalServerError(test.err))
 		})
 	}
 }

src/internal/connector/graph/metadata_collection_test.go

@@ -17,11 +17,11 @@ import (
 )
 
 type MetadataCollectionUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestMetadataCollectionUnitSuite(t *testing.T) {
-	suite.Run(t, new(MetadataCollectionUnitSuite))
+	suite.Run(t, &MetadataCollectionUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *MetadataCollectionUnitSuite) TestFullPath() {
@@ -156,7 +156,9 @@ func (suite *MetadataCollectionUnitSuite) TestMakeMetadataCollection() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 

src/internal/connector/graph/service_test.go

@@ -15,12 +15,12 @@ import (
 )
 
 type GraphUnitSuite struct {
-	suite.Suite
+	tester.Suite
 	credentials account.M365Config
 }
 
 func TestGraphUnitSuite(t *testing.T) {
-	suite.Run(t, new(GraphUnitSuite))
+	suite.Run(t, &GraphUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *GraphUnitSuite) SetupSuite() {
@@ -65,7 +65,9 @@ func (suite *GraphUnitSuite) TestHTTPClient() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			cli := HTTPClient(test.opts...)
 			assert.NotNil(t, cli)
 			test.check(t, cli)

src/internal/connector/graph_connector_disconnected_test.go

@@ -225,7 +225,9 @@ func (suite *DisconnectedGraphConnectorSuite) TestVerifyBackupInputs_allServices
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			err := verifyBackupInputs(test.excludes(t), sites)
 			test.checkError(t, err)
 			err = verifyBackupInputs(test.filters(t), sites)

src/internal/connector/graph_connector_onedrive_test.go

@@ -84,7 +84,7 @@ func onedriveMetadata(
 }
 
 type GraphConnectorOneDriveIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	connector     *GraphConnector
 	user          string
 	secondaryUser string
@@ -92,21 +92,19 @@ type GraphConnectorOneDriveIntegrationSuite struct {
 }
 
 func TestGraphConnectorOneDriveIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorExchangeTests)
-
-	suite.Run(t, new(GraphConnectorOneDriveIntegrationSuite))
+	suite.Run(t, &GraphConnectorOneDriveIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorOneDriveTests),
+	})
 }
 
 func (suite *GraphConnectorOneDriveIntegrationSuite) SetupSuite() {
 	ctx, flush := tester.NewContext()
 	defer flush()
 
-	tester.MustGetEnvSets(suite.T(), tester.M365AcctCredEnvs)
-
 	suite.connector = loadConnector(ctx, suite.T(), graph.HTTPClient(graph.NoTimeout()), Users)
 	suite.user = tester.M365UserID(suite.T())
 	suite.secondaryUser = tester.SecondaryM365UserID(suite.T())
@@ -465,7 +463,8 @@ func (suite *GraphConnectorOneDriveIntegrationSuite) TestRestoreAndBackup_Multip
 		expected := testDataForInfo(suite.T(), test.cols, version.Backup)
 
 		for vn := test.startVersion; vn <= version.Backup; vn++ {
-			suite.T().Run(fmt.Sprintf("%s_Version%d", test.name, vn), func(t *testing.T) {
+			suite.Run(fmt.Sprintf("%s_Version%d", test.name, vn), func() {
+				t := suite.T()
 				input := testDataForInfo(t, test.cols, vn)
 
 				testData := restoreBackupInfoMultiVersion{
@@ -689,7 +688,8 @@ func (suite *GraphConnectorOneDriveIntegrationSuite) TestPermissionsRestoreAndBa
 		expected := testDataForInfo(suite.T(), test.cols, version.Backup)
 
 		for vn := test.startVersion; vn <= version.Backup; vn++ {
-			suite.T().Run(fmt.Sprintf("%s_Version%d", test.name, vn), func(t *testing.T) {
+			suite.Run(fmt.Sprintf("%s_Version%d", test.name, vn), func() {
+				t := suite.T()
 				input := testDataForInfo(t, test.cols, vn)
 
 				testData := restoreBackupInfoMultiVersion{
@@ -762,7 +762,8 @@ func (suite *GraphConnectorOneDriveIntegrationSuite) TestPermissionsBackupAndNoR
 		expected := testDataForInfo(suite.T(), test.cols, version.Backup)
 
 		for vn := test.startVersion; vn <= version.Backup; vn++ {
-			suite.T().Run(fmt.Sprintf("Version%d", vn), func(t *testing.T) {
+			suite.Run(fmt.Sprintf("Version%d", vn), func() {
+				t := suite.T()
 				input := testDataForInfo(t, test.cols, vn)
 
 				testData := restoreBackupInfoMultiVersion{

src/internal/connector/graph_connector_test.go

@@ -30,11 +30,11 @@ import (
 // ---------------------------------------------------------------------------
 
 type GraphConnectorUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestGraphConnectorUnitSuite(t *testing.T) {
-	suite.Run(t, new(GraphConnectorUnitSuite))
+	suite.Run(t, &GraphConnectorUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *GraphConnectorUnitSuite) TestUnionSiteIDsAndWebURLs() {
@@ -121,7 +121,9 @@ func (suite *GraphConnectorUnitSuite) TestUnionSiteIDsAndWebURLs() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -137,7 +139,7 @@ func (suite *GraphConnectorUnitSuite) TestUnionSiteIDsAndWebURLs() {
 // ---------------------------------------------------------------------------
 
 type GraphConnectorIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	connector     *GraphConnector
 	user          string
 	secondaryUser string
@@ -145,21 +147,19 @@ type GraphConnectorIntegrationSuite struct {
 }
 
 func TestGraphConnectorIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorExchangeTests)
-
-	suite.Run(t, new(GraphConnectorIntegrationSuite))
+	suite.Run(t, &GraphConnectorIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorExchangeTests),
+	})
 }
 
 func (suite *GraphConnectorIntegrationSuite) SetupSuite() {
 	ctx, flush := tester.NewContext()
 	defer flush()
 
-	tester.MustGetEnvSets(suite.T(), tester.M365AcctCredEnvs)
-
 	suite.connector = loadConnector(ctx, suite.T(), graph.HTTPClient(graph.NoTimeout()), Users)
 	suite.user = tester.M365UserID(suite.T())
 	suite.secondaryUser = tester.SecondaryM365UserID(suite.T())
@@ -171,6 +171,7 @@ func (suite *GraphConnectorIntegrationSuite) SetupSuite() {
 // TestSetTenantUsers verifies GraphConnector's ability to query
 // the users associated with the credentials
 func (suite *GraphConnectorIntegrationSuite) TestSetTenantUsers() {
+	t := suite.T()
 	newConnector := GraphConnector{
 		tenant:      "test_tenant",
 		Users:       make(map[string]string, 0),
@@ -181,16 +182,16 @@ func (suite *GraphConnectorIntegrationSuite) TestSetTenantUsers() {
 	defer flush()
 
 	owners, err := api.NewClient(suite.connector.credentials)
-	require.NoError(suite.T(), err)
+	require.NoError(t, err)
 
 	newConnector.Owners = owners
-	suite.Empty(len(newConnector.Users))
+	assert.Empty(t, len(newConnector.Users))
 
 	errs := fault.New(true)
 
 	err = newConnector.setTenantUsers(ctx, errs)
-	suite.NoError(err)
-	suite.Less(0, len(newConnector.Users))
+	assert.NoError(t, err)
+	assert.Less(t, 0, len(newConnector.Users))
 }
 
 // TestSetTenantUsers verifies GraphConnector's ability to query
@@ -308,7 +309,9 @@ func (suite *GraphConnectorIntegrationSuite) TestEmptyCollections() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -825,9 +828,9 @@ func (suite *GraphConnectorIntegrationSuite) TestRestoreAndBackup() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			runRestoreBackupTest(
-				t,
+				suite.T(),
 				suite.acct,
 				test,
 				suite.connector.tenant,
@@ -903,7 +906,9 @@ func (suite *GraphConnectorIntegrationSuite) TestMultiFolderBackupDifferentNames
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 

src/internal/connector/mockconnector/mock_data_collection_test.go

@@ -19,11 +19,11 @@ import (
 )
 
 type MockExchangeCollectionSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestMockExchangeCollectionSuite(t *testing.T) {
-	suite.Run(t, new(MockExchangeCollectionSuite))
+	suite.Run(t, &MockExchangeCollectionSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *MockExchangeCollectionSuite) TestMockExchangeCollection() {
@@ -82,11 +82,11 @@ func (suite *MockExchangeCollectionSuite) TestMockExchangeCollection_NewExchange
 }
 
 type MockExchangeDataSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestMockExchangeDataSuite(t *testing.T) {
-	suite.Run(t, new(MockExchangeDataSuite))
+	suite.Run(t, &MockExchangeDataSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *MockExchangeDataSuite) TestMockExchangeData() {
@@ -117,7 +117,9 @@ func (suite *MockExchangeDataSuite) TestMockExchangeData() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			assert.Equal(t, id, test.reader.UUID())
 			buf, err := io.ReadAll(test.reader.ToReader())
 
@@ -223,7 +225,9 @@ func (suite *MockExchangeDataSuite) TestMockByteHydration() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			err := test.transformation(t)
 			assert.NoError(t, err)
 		})

src/internal/connector/onedrive/collection_test.go

@@ -28,7 +28,7 @@ import (
 )
 
 type CollectionUnitTestSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 // Allows `*CollectionUnitTestSuite` to be used as a graph.Servicer
@@ -43,7 +43,7 @@ func (suite *CollectionUnitTestSuite) Adapter() *msgraphsdk.GraphRequestAdapter
 }
 
 func TestCollectionUnitTestSuite(t *testing.T) {
-	suite.Run(t, new(CollectionUnitTestSuite))
+	suite.Run(t, &CollectionUnitTestSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 // Returns a status update function that signals the specified WaitGroup when it is done
@@ -151,11 +151,12 @@ func (suite *CollectionUnitTestSuite) TestCollection() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			ctx, flush := tester.NewContext()
 			defer flush()
 
 			var (
+				t          = suite.T()
 				wg         = sync.WaitGroup{}
 				collStatus = support.ConnectorOperationStatus{}
 				readItems  = []data.Stream{}
@@ -289,11 +290,12 @@ func (suite *CollectionUnitTestSuite) TestCollectionReadError() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			ctx, flush := tester.NewContext()
 			defer flush()
 
 			var (
+				t          = suite.T()
 				testItemID = "fakeItemID"
 				collStatus = support.ConnectorOperationStatus{}
 				wg         = sync.WaitGroup{}
@@ -364,11 +366,12 @@ func (suite *CollectionUnitTestSuite) TestCollectionPermissionBackupLatestModTim
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			ctx, flush := tester.NewContext()
 			defer flush()
 
 			var (
+				t            = suite.T()
 				testItemID   = "fakeItemID"
 				testItemName = "Fake Item"
 				testItemSize = int64(10)

src/internal/connector/onedrive/collections_test.go

@@ -87,11 +87,11 @@ func getExpectedPathGenerator(t *testing.T,
 }
 
 type OneDriveCollectionsSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestOneDriveCollectionsSuite(t *testing.T) {
-	suite.Run(t, new(OneDriveCollectionsSuite))
+	suite.Run(t, &OneDriveCollectionsSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *OneDriveCollectionsSuite) TestGetCanonicalPath() {
@@ -126,7 +126,9 @@ func (suite *OneDriveCollectionsSuite) TestGetCanonicalPath() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			p := strings.Join(test.dir, "/")
 			result, err := GetCanonicalPath(p, tenant, resourceOwner, test.source)
 			test.expectErr(t, err)
@@ -712,7 +714,9 @@ func (suite *OneDriveCollectionsSuite) TestUpdateCollections() {
 	}
 
 	for _, tt := range tests {
-		suite.T().Run(tt.testCase, func(t *testing.T) {
+		suite.Run(tt.testCase, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -1076,7 +1080,8 @@ func (suite *OneDriveCollectionsSuite) TestDeserializeMetadata() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -1721,7 +1726,9 @@ func (suite *OneDriveCollectionsSuite) TestGet() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -1997,7 +2004,9 @@ func (suite *OneDriveCollectionsSuite) TestCollectItems() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -2028,9 +2037,9 @@ func (suite *OneDriveCollectionsSuite) TestCollectItems() {
 				test.prevDelta,
 			)
 
-			require.ErrorIs(suite.T(), err, test.err, "delta fetch err")
-			require.Equal(suite.T(), test.deltaURL, delta.URL, "delta url")
-			require.Equal(suite.T(), !test.prevDeltaSuccess, delta.Reset, "delta reset")
+			require.ErrorIs(t, err, test.err, "delta fetch err")
+			require.Equal(t, test.deltaURL, delta.URL, "delta url")
+			require.Equal(t, !test.prevDeltaSuccess, delta.Reset, "delta reset")
 		})
 	}
 }

src/internal/connector/onedrive/drive_test.go

@@ -70,11 +70,11 @@ func (p *mockDrivePager) ValuesIn(api.PageLinker) ([]models.Driveable, error) {
 
 // Unit tests
 type OneDriveUnitSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestOneDriveUnitSuite(t *testing.T) {
-	suite.Run(t, new(OneDriveUnitSuite))
+	suite.Run(t, &OneDriveUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func odErr(code string) *odataerrors.ODataError {
@@ -302,7 +302,9 @@ func (suite *OneDriveUnitSuite) TestDrives() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -321,17 +323,18 @@ func (suite *OneDriveUnitSuite) TestDrives() {
 // Integration tests
 
 type OneDriveSuite struct {
-	suite.Suite
+	tester.Suite
 	userID string
 }
 
 func TestOneDriveDriveSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoOneDriveTests)
-
-	suite.Run(t, new(OneDriveSuite))
+	suite.Run(t, &OneDriveSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorOneDriveTests),
+	})
 }
 
 func (suite *OneDriveSuite) SetupSuite() {
@@ -395,7 +398,9 @@ func (suite *OneDriveSuite) TestCreateGetDeleteFolder() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			pager, err := PagerForSource(OneDriveSource, gs, suite.userID, nil)
 			require.NoError(t, err)
 
@@ -451,7 +456,9 @@ func (suite *OneDriveSuite) TestOneDriveNewCollections() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			service := loadTestService(t)
 			scope := selectors.
 				NewOneDriveBackup([]string{test.user}).

src/internal/connector/onedrive/item_test.go

@@ -18,7 +18,7 @@ import (
 )
 
 type ItemIntegrationSuite struct {
-	suite.Suite
+	tester.Suite
 	// site        string
 	// siteDriveID string
 	user        string
@@ -36,13 +36,13 @@ func (suite *ItemIntegrationSuite) Adapter() *msgraphsdk.GraphRequestAdapter {
 }
 
 func TestItemIntegrationSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorOneDriveTests)
-
-	suite.Run(t, new(ItemIntegrationSuite))
+	suite.Run(t, &ItemIntegrationSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorOneDriveTests),
+	})
 }
 
 func (suite *ItemIntegrationSuite) SetupSuite() {
@@ -51,8 +51,6 @@ func (suite *ItemIntegrationSuite) SetupSuite() {
 	ctx, flush := tester.NewContext()
 	defer flush()
 
-	tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
-
 	a := tester.NewM365Account(t)
 	m365, err := a.M365Config()
 	require.NoError(t, err)
@@ -174,43 +172,45 @@ func (suite *ItemIntegrationSuite) TestItemWriter() {
 		// },
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
 			root, err := suite.Client().DrivesById(test.driveID).Root().Get(ctx, nil)
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 
 			// Test Requirement 2: "Test Folder" should exist
 			folder, err := getFolder(ctx, suite, test.driveID, *root.GetId(), "Test Folder")
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 
 			newFolderName := "testfolder_" + common.FormatNow(common.SimpleTimeTesting)
-			suite.T().Logf("Test will create folder %s", newFolderName)
+			t.Logf("Test will create folder %s", newFolderName)
 
 			newFolder, err := createItem(ctx, suite, test.driveID, *folder.GetId(), newItem(newFolderName, true))
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 
-			require.NotNil(suite.T(), newFolder.GetId())
+			require.NotNil(t, newFolder.GetId())
 
 			newItemName := "testItem_" + common.FormatNow(common.SimpleTimeTesting)
-			suite.T().Logf("Test will create item %s", newItemName)
+			t.Logf("Test will create item %s", newItemName)
 
 			newItem, err := createItem(ctx, suite, test.driveID, *newFolder.GetId(), newItem(newItemName, false))
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 
-			require.NotNil(suite.T(), newItem.GetId())
+			require.NotNil(t, newItem.GetId())
 
 			// HACK: Leveraging this to test getFolder behavior for a file. `getFolder()` on the
 			// newly created item should fail because it's a file not a folder
 			_, err = getFolder(ctx, suite, test.driveID, *newFolder.GetId(), newItemName)
-			require.ErrorIs(suite.T(), err, errFolderNotFound)
+			require.ErrorIs(t, err, errFolderNotFound)
 
 			// Initialize a 100KB mockDataProvider
 			td, writeSize := mockDataReader(int64(100 * 1024))
 
 			w, err := driveItemWriter(ctx, suite, test.driveID, *newItem.GetId(), writeSize)
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 
 			// Using a 32 KB buffer for the copy allows us to validate the
 			// multi-part upload. `io.CopyBuffer` will only write 32 KB at
@@ -218,9 +218,9 @@ func (suite *ItemIntegrationSuite) TestItemWriter() {
 			copyBuffer := make([]byte, 32*1024)
 
 			size, err := io.CopyBuffer(w, td, copyBuffer)
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 
-			require.Equal(suite.T(), writeSize, size)
+			require.Equal(t, writeSize, size)
 		})
 	}
 }
@@ -245,20 +245,22 @@ func (suite *ItemIntegrationSuite) TestDriveGetFolder() {
 		// },
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
 			root, err := suite.Client().DrivesById(test.driveID).Root().Get(ctx, nil)
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 
 			// Lookup a folder that doesn't exist
 			_, err = getFolder(ctx, suite, test.driveID, *root.GetId(), "FolderDoesNotExist")
-			require.ErrorIs(suite.T(), err, errFolderNotFound)
+			require.ErrorIs(t, err, errFolderNotFound)
 
 			// Lookup a folder that does exist
 			_, err = getFolder(ctx, suite, test.driveID, *root.GetId(), "")
-			require.NoError(suite.T(), err)
+			require.NoError(t, err)
 		})
 	}
 }

src/internal/connector/sharepoint/api/pages_test.go

@@ -20,7 +20,7 @@ import (
 )
 
 type SharePointPageSuite struct {
-	suite.Suite
+	tester.Suite
 	siteID  string
 	creds   account.M365Config
 	service *discover.BetaService
@@ -28,7 +28,6 @@ type SharePointPageSuite struct {
 
 func (suite *SharePointPageSuite) SetupSuite() {
 	t := suite.T()
-	tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
 
 	suite.siteID = tester.M365SiteID(t)
 	a := tester.NewM365Account(t)
@@ -40,11 +39,13 @@ func (suite *SharePointPageSuite) SetupSuite() {
 }
 
 func TestSharePointPageSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorSharePointTests)
-	suite.Run(t, new(SharePointPageSuite))
+	suite.Run(t, &SharePointPageSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorSharePointTests),
+	})
 }
 
 func (suite *SharePointPageSuite) TestFetchPages() {

src/internal/connector/sharepoint/collection_test.go

@@ -25,14 +25,13 @@ import (
 )
 
 type SharePointCollectionSuite struct {
-	suite.Suite
+	tester.Suite
 	siteID string
 	creds  account.M365Config
 }
 
 func (suite *SharePointCollectionSuite) SetupSuite() {
 	t := suite.T()
-	tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
 
 	suite.siteID = tester.M365SiteID(t)
 	a := tester.NewM365Account(t)
@@ -43,13 +42,13 @@ func (suite *SharePointCollectionSuite) SetupSuite() {
 }
 
 func TestSharePointCollectionSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorSharePointTests)
-
-	suite.Run(t, new(SharePointCollectionSuite))
+	suite.Run(t, &SharePointCollectionSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorSharePointTests),
+	})
 }
 
 func (suite *SharePointCollectionSuite) TestCollection_Item_Read() {
@@ -70,7 +69,6 @@ func (suite *SharePointCollectionSuite) TestCollection_Item_Read() {
 // TestListCollection tests basic functionality to create
 // SharePoint collection and to use the data stream channel.
 func (suite *SharePointCollectionSuite) TestCollection_Items() {
-	t := suite.T()
 	tenant := "some"
 	user := "user"
 	dirRoot := "directory"
@@ -147,7 +145,9 @@ func (suite *SharePointCollectionSuite) TestCollection_Items() {
 	}
 
 	for _, test := range tables {
-		t.Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 

src/internal/connector/sharepoint/data_collections_test.go

@@ -41,11 +41,11 @@ func (fm testFolderMatcher) Matches(path string) bool {
 // ---------------------------------------------------------------------------
 
 type SharePointLibrariesSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestSharePointLibrariesSuite(t *testing.T) {
-	suite.Run(t, new(SharePointLibrariesSuite))
+	suite.Run(t, &SharePointLibrariesSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *SharePointLibrariesSuite) TestUpdateCollections() {
@@ -89,7 +89,9 @@ func (suite *SharePointLibrariesSuite) TestUpdateCollections() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.testCase, func(t *testing.T) {
+		suite.Run(test.testCase, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -159,16 +161,17 @@ func driveRootItem(id string) models.DriveItemable {
 }
 
 type SharePointPagesSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestSharePointPagesSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorTests,
-		tester.CorsoGraphConnectorSharePointTests)
-	suite.Run(t, new(SharePointPagesSuite))
+	suite.Run(t, &SharePointPagesSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorSharePointTests),
+	})
 }
 
 func (suite *SharePointPagesSuite) TestCollectPages() {

src/internal/connector/sharepoint/listInfo_test.go

@@ -7,15 +7,16 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 
+	"github.com/alcionai/corso/src/internal/tester"
 	"github.com/alcionai/corso/src/pkg/backup/details"
 )
 
 type SharePointInfoSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestSharePointInfoSuite(t *testing.T) {
-	suite.Run(t, new(SharePointInfoSuite))
+	suite.Run(t, &SharePointInfoSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *SharePointInfoSuite) TestSharePointInfo() {
@@ -45,7 +46,9 @@ func (suite *SharePointInfoSuite) TestSharePointInfo() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			list, expected := test.listAndDeets()
 			info := sharePointListInfo(list, 10)
 			assert.Equal(t, expected.ItemType, info.ItemType)

src/internal/connector/sharepoint/list_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 type SharePointSuite struct {
-	suite.Suite
+	tester.Suite
 	creds account.M365Config
 }
 
@@ -27,11 +27,13 @@ func (suite *SharePointSuite) SetupSuite() {
 }
 
 func TestSharePointSuite(t *testing.T) {
-	tester.RunOnAny(
-		t,
-		tester.CorsoCITests,
-		tester.CorsoGraphConnectorSharePointTests)
-	suite.Run(t, new(SharePointSuite))
+	suite.Run(t, &SharePointSuite{
+		Suite: tester.NewIntegrationSuite(
+			t,
+			[][]string{tester.M365AcctCredEnvs},
+			tester.CorsoGraphConnectorTests,
+			tester.CorsoGraphConnectorSharePointTests),
+	})
 }
 
 // Test LoadList --> Retrieves all data from backStore

src/internal/connector/support/errors_test.go

@@ -9,26 +9,30 @@ import (
 	multierror "github.com/hashicorp/go-multierror"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
+
+	"github.com/alcionai/corso/src/internal/tester"
 )
 
 type GraphConnectorErrorSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestGraphConnectorErrorSuite(t *testing.T) {
-	suite.Run(t, new(GraphConnectorErrorSuite))
+	suite.Run(t, &GraphConnectorErrorSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *GraphConnectorErrorSuite) TestWrapAndAppend() {
+	t := suite.T()
+
 	err1 := fmt.Errorf("New Error")
 	err2 := errors.New("I have two")
 	returnErr := WrapAndAppend("arc376", err2, err1)
-	suite.True(strings.Contains(returnErr.Error(), "arc376"))
-	suite.Error(returnErr)
+	assert.True(t, strings.Contains(returnErr.Error(), "arc376"))
+	assert.Error(t, returnErr)
 
 	multi := &multierror.Error{Errors: []error{err1, err2}}
-	suite.True(strings.Contains(ListErrors(*multi), "two")) // Does not contain the wrapped information
-	suite.T().Log(ListErrors(*multi))
+	assert.True(t, strings.Contains(ListErrors(*multi), "two")) // Does not contain the wrapped information
+	t.Log(ListErrors(*multi))
 }
 
 func (suite *GraphConnectorErrorSuite) TestWrapAndAppend_OnVar() {
@@ -38,23 +42,25 @@ func (suite *GraphConnectorErrorSuite) TestWrapAndAppend_OnVar() {
 	)
 
 	received := WrapAndAppend(id, errors.New("network error"), err1)
-	suite.True(strings.Contains(received.Error(), id))
+	assert.True(suite.T(), strings.Contains(received.Error(), id))
 }
 
 func (suite *GraphConnectorErrorSuite) TestWrapAndAppend_Add3() {
+	t := suite.T()
+
 	errOneTwo := WrapAndAppend("user1", assert.AnError, assert.AnError)
 	combined := WrapAndAppend("unix36", assert.AnError, errOneTwo)
 	allErrors := WrapAndAppend("fxi92874", assert.AnError, combined)
-	suite.True(strings.Contains(combined.Error(), "unix36"))
-	suite.True(strings.Contains(combined.Error(), "user1"))
-	suite.True(strings.Contains(allErrors.Error(), "fxi92874"))
+	assert.True(t, strings.Contains(combined.Error(), "unix36"))
+	assert.True(t, strings.Contains(combined.Error(), "user1"))
+	assert.True(t, strings.Contains(allErrors.Error(), "fxi92874"))
 }
 
 func (suite *GraphConnectorErrorSuite) TestWrapAndAppendf() {
 	err1 := assert.AnError
 	err2 := assert.AnError
 	combined := WrapAndAppendf(134323, err2, err1)
-	suite.True(strings.Contains(combined.Error(), "134323"))
+	assert.True(suite.T(), strings.Contains(combined.Error(), "134323"))
 }
 
 func (suite *GraphConnectorErrorSuite) TestConcatenateStringFromPointers() {
@@ -65,11 +71,12 @@ func (suite *GraphConnectorErrorSuite) TestConcatenateStringFromPointers() {
 		s1        = &v1
 		s2        *string
 		s3        = &v3
+		t         = suite.T()
 	)
 
 	outString = concatenateStringFromPointers(outString, []*string{s1, s2, s3})
-	suite.True(strings.Contains(outString, v1))
-	suite.True(strings.Contains(outString, v3))
+	assert.True(t, strings.Contains(outString, v1))
+	assert.True(t, strings.Contains(outString, v3))
 }
 
 func (suite *GraphConnectorErrorSuite) TestGetNumberOfErrors() {
@@ -95,9 +102,9 @@ func (suite *GraphConnectorErrorSuite) TestGetNumberOfErrors() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			result := GetNumberOfErrors(test.errs)
-			suite.Equal(result, test.expected)
+			assert.Equal(suite.T(), result, test.expected)
 		})
 	}
 }

src/internal/connector/support/m365Support_test.go

@@ -11,14 +11,15 @@ import (
 
 	bmodels "github.com/alcionai/corso/src/internal/connector/graph/betasdk/models"
 	"github.com/alcionai/corso/src/internal/connector/mockconnector"
+	"github.com/alcionai/corso/src/internal/tester"
 )
 
 type DataSupportSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestDataSupportSuite(t *testing.T) {
-	suite.Run(t, new(DataSupportSuite))
+	suite.Run(t, &DataSupportSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 var (
@@ -49,7 +50,9 @@ func (suite *DataSupportSuite) TestCreateMessageFromBytes() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			result, err := CreateMessageFromBytes(test.byteArray)
 			test.checkError(t, err)
 			test.checkObject(t, result)
@@ -86,7 +89,9 @@ func (suite *DataSupportSuite) TestCreateContactFromBytes() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			result, err := CreateContactFromBytes(test.byteArray)
 			test.checkError(t, err)
 			test.isNil(t, result)
@@ -121,7 +126,9 @@ func (suite *DataSupportSuite) TestCreateEventFromBytes() {
 		},
 	}
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			result, err := CreateEventFromBytes(test.byteArray)
 			test.checkError(t, err)
 			test.isNil(t, result)
@@ -160,7 +167,9 @@ func (suite *DataSupportSuite) TestCreateListFromBytes() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			result, err := CreateListFromBytes(test.byteArray)
 			test.checkError(t, err)
 			test.isNil(t, result)
@@ -215,7 +224,9 @@ func (suite *DataSupportSuite) TestCreatePageFromBytes() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			result, err := CreatePageFromBytes(test.getBytes(t))
 			test.checkError(t, err)
 			test.isNil(t, result)
@@ -269,7 +280,9 @@ func (suite *DataSupportSuite) TestHasAttachments() {
 	}
 
 	for _, test := range tests {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			found := HasAttachments(test.getBodyable(t))
 			test.hasAttachment(t, found)
 		})

src/internal/connector/support/m365Transform_test.go

@@ -9,27 +9,30 @@ import (
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/internal/connector/mockconnector"
+	"github.com/alcionai/corso/src/internal/tester"
 )
 
 type SupportTestSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestSupportTestSuite(t *testing.T) {
-	suite.Run(t, new(SupportTestSuite))
+	suite.Run(t, &SupportTestSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *SupportTestSuite) TestToMessage() {
+	t := suite.T()
+
 	bytes := mockconnector.GetMockMessageBytes("m365 mail support test")
 	message, err := CreateMessageFromBytes(bytes)
 	require.NoError(suite.T(), err)
 
 	clone := ToMessage(message)
-	suite.Equal(message.GetBccRecipients(), clone.GetBccRecipients())
-	suite.Equal(message.GetSubject(), clone.GetSubject())
-	suite.Equal(message.GetSender(), clone.GetSender())
-	suite.Equal(message.GetSentDateTime(), clone.GetSentDateTime())
-	suite.NotEqual(message.GetId(), clone.GetId())
+	assert.Equal(t, message.GetBccRecipients(), clone.GetBccRecipients())
+	assert.Equal(t, message.GetSubject(), clone.GetSubject())
+	assert.Equal(t, message.GetSender(), clone.GetSender())
+	assert.Equal(t, message.GetSentDateTime(), clone.GetSentDateTime())
+	assert.NotEqual(t, message.GetId(), clone.GetId())
 }
 
 func (suite *SupportTestSuite) TestToEventSimplified() {
@@ -139,9 +142,9 @@ func (suite *SupportTestSuite) TestInsertStringToBody() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
 			result := insertStringToBody(test.input, test.content)
-			assert.Equal(t, test.expect, result)
+			assert.Equal(suite.T(), test.expect, result)
 		})
 	}
 }

src/internal/connector/support/status_test.go

@@ -12,11 +12,11 @@ import (
 )
 
 type GCStatusTestSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestGraphConnectorStatus(t *testing.T) {
-	suite.Run(t, &GCStatusTestSuite{})
+	suite.Run(t, &GCStatusTestSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 // 			operationType, objects, success, folders, errCount int, errStatus string
@@ -51,7 +51,9 @@ func (suite *GCStatusTestSuite) TestCreateStatus() {
 		},
 	}
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			ctx, flush := tester.NewContext()
 			defer flush()
 
@@ -144,12 +146,14 @@ func (suite *GCStatusTestSuite) TestMergeStatus() {
 	}
 
 	for _, test := range table {
-		suite.T().Run(test.name, func(t *testing.T) {
+		suite.Run(test.name, func() {
+			t := suite.T()
+
 			returned := MergeStatus(test.one, test.two)
-			suite.Equal(returned.FolderCount, test.expected.folders)
-			suite.Equal(returned.ObjectCount, test.expected.objects)
-			suite.Equal(returned.lastOperation, test.expected.operationType)
-			suite.Equal(returned.Successful, test.expected.success)
+			assert.Equal(t, returned.FolderCount, test.expected.folders)
+			assert.Equal(t, returned.ObjectCount, test.expected.objects)
+			assert.Equal(t, returned.lastOperation, test.expected.operationType)
+			assert.Equal(t, returned.Successful, test.expected.success)
 			test.isIncomplete(t, returned.incomplete)
 		})
 	}

src/internal/connector/uploadsession/uploadsession_test.go

@@ -13,14 +13,16 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
+
+	"github.com/alcionai/corso/src/internal/tester"
 )
 
 type UploadSessionSuite struct {
-	suite.Suite
+	tester.Suite
 }
 
 func TestUploadSessionSuite(t *testing.T) {
-	suite.Run(t, new(UploadSessionSuite))
+	suite.Run(t, &UploadSessionSuite{Suite: tester.NewUnitSuite(t)})
 }
 
 func (suite *UploadSessionSuite) TestWriter() {