larryh/corso
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use tester suite wrapper in connector package (#2613)

Browse Source 
## 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
This commit is contained in:
ashmrtn 2023-02-23 10:41:36 -08:00 committed by GitHub
parent 74eacd2ef8
commit b1dce98710
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
36 changed files with 470 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/internal/connector/data_collections_test.go
View File

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

37
src/internal/connector/exchange/api/api_test.go
View File

@ -16,24 +16,23 @@ import (
) )
type ExchangeServiceSuite struct { type ExchangeServiceSuite struct {
suite.Suite tester.Suite
gs graph.Servicer gs graph.Servicer
credentials account.M365Config credentials account.M365Config
} }
func TestExchangeServiceSuite(t *testing.T) { func TestExchangeServiceSuite(t *testing.T) {
tester.RunOnAny( suite.Run(t, &ExchangeServiceSuite{
t, Suite: tester.NewIntegrationSuite(
tester.CorsoCITests, t,
tester.CorsoGraphConnectorTests, [][]string{tester.M365AcctCredEnvs},
tester.CorsoGraphConnectorExchangeTests) tester.CorsoGraphConnectorTests,
tester.CorsoGraphConnectorExchangeTests),
suite.Run(t, new(ExchangeServiceSuite)) })
} }
func (suite *ExchangeServiceSuite) SetupSuite() { func (suite *ExchangeServiceSuite) SetupSuite() {
t := suite.T() t := suite.T()
tester.MustGetEnvSets(t, tester.M365AcctCredEnvs)
a := tester.NewM365Account(t) a := tester.NewM365Account(t)
m365, err := a.M365Config() m365, err := a.M365Config()
@ -78,9 +77,9 @@ func (suite *ExchangeServiceSuite) TestOptionsForCalendars() {
}, },
} }
for _, test := range tests { for _, test := range tests {
suite.T().Run(test.name, func(t *testing.T) { suite.Run(test.name, func() {
_, err := optionsForCalendars(test.params) _, 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 { 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) config, err := optionsForMailFolders(test.params)
test.checkError(t, err) test.checkError(t, err)
if err == nil { 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 { 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) options, err := optionsForContacts(test.params)
test.checkError(t, err) test.checkError(t, err)
if err == nil { 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 { 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)) found := HasAttachments(test.getBodyable(t))
test.hasAttachment(t, found) test.hasAttachment(t, found)
}) })

9
src/internal/connector/exchange/api/contacts_test.go
View File

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

9
src/internal/connector/exchange/api/events_test.go
View File

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

10
src/internal/connector/exchange/api/mail_test.go
View File

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

53
src/internal/connector/exchange/container_resolver_test.go
View File

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

52
src/internal/connector/exchange/data_collections_test.go
View File

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

25
src/internal/connector/exchange/exchange_data_collection_test.go
View File

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

22
src/internal/connector/exchange/folder_resolver_test.go
View File

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

10
src/internal/connector/exchange/iterators_test.go
View File

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

22
src/internal/connector/exchange/mail_folder_cache_test.go
View File

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

21
src/internal/connector/exchange/restore_test.go
View File

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

16
src/internal/connector/exchange/service_iterators_test.go
View File

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

8
src/internal/connector/graph/api/api_test.go
View File

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

15
src/internal/connector/graph/betasdk/beta_client_test.go
View File

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

29
src/internal/connector/graph/errors_test.go
View File

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

8
src/internal/connector/graph/metadata_collection_test.go
View File

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

8
src/internal/connector/graph/service_test.go
View File

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

4
src/internal/connector/graph_connector_disconnected_test.go
View File

@ -225,7 +225,9 @@ func (suite *DisconnectedGraphConnectorSuite) TestVerifyBackupInputs_allServices
} }
for _, test := range tests { 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) err := verifyBackupInputs(test.excludes(t), sites)
test.checkError(t, err) test.checkError(t, err)
err = verifyBackupInputs(test.filters(t), sites) err = verifyBackupInputs(test.filters(t), sites)

27
src/internal/connector/graph_connector_onedrive_test.go
View File

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

47
src/internal/connector/graph_connector_test.go
View File

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

16
src/internal/connector/mockconnector/mock_data_collection_test.go
View File

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

13
src/internal/connector/onedrive/collection_test.go
View File

@ -28,7 +28,7 @@ import (
) )
type CollectionUnitTestSuite struct { type CollectionUnitTestSuite struct {
suite.Suite tester.Suite
} }
// Allows `*CollectionUnitTestSuite` to be used as a graph.Servicer // Allows `*CollectionUnitTestSuite` to be used as a graph.Servicer
@ -43,7 +43,7 @@ func (suite *CollectionUnitTestSuite) Adapter() *msgraphsdk.GraphRequestAdapter
} }
func TestCollectionUnitTestSuite(t *testing.T) { 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 // 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 { for _, test := range table {
suite.T().Run(test.name, func(t *testing.T) { suite.Run(test.name, func() {
ctx, flush := tester.NewContext() ctx, flush := tester.NewContext()
defer flush() defer flush()
var ( var (
t = suite.T()
wg = sync.WaitGroup{} wg = sync.WaitGroup{}
collStatus = support.ConnectorOperationStatus{} collStatus = support.ConnectorOperationStatus{}
readItems = []data.Stream{} readItems = []data.Stream{}
@ -289,11 +290,12 @@ func (suite *CollectionUnitTestSuite) TestCollectionReadError() {
}, },
} }
for _, test := range table { for _, test := range table {
suite.T().Run(test.name, func(t *testing.T) { suite.Run(test.name, func() {
ctx, flush := tester.NewContext() ctx, flush := tester.NewContext()
defer flush() defer flush()
var ( var (
t = suite.T()
testItemID = "fakeItemID" testItemID = "fakeItemID"
collStatus = support.ConnectorOperationStatus{} collStatus = support.ConnectorOperationStatus{}
wg = sync.WaitGroup{} wg = sync.WaitGroup{}
@ -364,11 +366,12 @@ func (suite *CollectionUnitTestSuite) TestCollectionPermissionBackupLatestModTim
}, },
} }
for _, test := range table { for _, test := range table {
suite.T().Run(test.name, func(t *testing.T) { suite.Run(test.name, func() {
ctx, flush := tester.NewContext() ctx, flush := tester.NewContext()
defer flush() defer flush()
var ( var (
t = suite.T()
testItemID = "fakeItemID" testItemID = "fakeItemID"
testItemName = "Fake Item" testItemName = "Fake Item"
testItemSize = int64(10) testItemSize = int64(10)

29
src/internal/connector/onedrive/collections_test.go
View File

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

31
src/internal/connector/onedrive/drive_test.go
View File

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

56
src/internal/connector/onedrive/item_test.go
View File

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

15
src/internal/connector/sharepoint/api/pages_test.go
View File

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

22
src/internal/connector/sharepoint/collection_test.go
View File

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

23
src/internal/connector/sharepoint/data_collections_test.go
View File

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

9
src/internal/connector/sharepoint/listInfo_test.go
View File

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

14
src/internal/connector/sharepoint/list_test.go
View File

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

37
src/internal/connector/support/errors_test.go
View File

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

29
src/internal/connector/support/m365Support_test.go
View File

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

21
src/internal/connector/support/m365Transform_test.go
View File

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

20
src/internal/connector/support/status_test.go
View File

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

6
src/internal/connector/uploadsession/uploadsession_test.go
View File

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