From 7a0d9149eb27fb591140b8cde2e1c5fc8112f89a Mon Sep 17 00:00:00 2001 From: Abado Jack Mtulla Date: Thu, 10 Oct 2019 14:54:40 +0300 Subject: [PATCH] Migrate app/import_functions_test.go to testify (#12495) - Use 'require' and 'assert' methods instead of 't.Fatal' --- app/import_functions_test.go | 1219 ++++++++++++++-------------------- 1 file changed, 501 insertions(+), 718 deletions(-) diff --git a/app/import_functions_test.go b/app/import_functions_test.go index d01d837136..8712746ec1 100644 --- a/app/import_functions_test.go +++ b/app/import_functions_test.go @@ -61,180 +61,157 @@ func TestImportImportScheme(t *testing.T) { Description: ptrStr("description"), } - if err := th.App.ImportScheme(&data, true); err == nil { - t.Fatalf("Should have failed to import.") - } + err := th.App.ImportScheme(&data, true) + require.NotNil(t, err, "Should have failed to import.") - if _, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err == nil { - t.Fatalf("Scheme should not have imported.") - } + _, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.NotNil(t, err, "Scheme should not have imported.") // Try importing a valid scheme in dryRun mode. data.DisplayName = ptrStr("display name") - if err := th.App.ImportScheme(&data, true); err != nil { - t.Fatalf("Should have succeeded.") - } + err = th.App.ImportScheme(&data, true) + require.Nil(t, err, "Should have succeeded.") - if _, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err == nil { - t.Fatalf("Scheme should not have imported.") - } + _, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.NotNil(t, err, "Scheme should not have imported.") // Try importing an invalid scheme. data.DisplayName = nil - if err := th.App.ImportScheme(&data, false); err == nil { - t.Fatalf("Should have failed to import.") - } + err = th.App.ImportScheme(&data, false) + require.NotNil(t, err, "Should have failed to import.") - if _, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err == nil { - t.Fatalf("Scheme should not have imported.") - } + _, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.NotNil(t, err, "Scheme should not have imported.") // Try importing a valid scheme with all params set. data.DisplayName = ptrStr("display name") - if err := th.App.ImportScheme(&data, false); err != nil { - t.Fatalf("Should have succeeded.") - } + err = th.App.ImportScheme(&data, false) + require.Nil(t, err, "Should have succeeded.") - if scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err != nil { - t.Fatalf("Failed to import scheme: %v", err) - } else { - assert.Equal(t, *data.Name, scheme.Name) - assert.Equal(t, *data.DisplayName, scheme.DisplayName) - assert.Equal(t, *data.Description, scheme.Description) - assert.Equal(t, *data.Scope, scheme.Scope) + scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.Nil(t, err, "Failed to import scheme: %v", err) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.Name, scheme.Name) + assert.Equal(t, *data.DisplayName, scheme.DisplayName) + assert.Equal(t, *data.Description, scheme.Description) + assert.Equal(t, *data.Scope, scheme.Scope) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) // Try modifying all the fields and re-importing. data.DisplayName = ptrStr("new display name") data.Description = ptrStr("new description") - if err := th.App.ImportScheme(&data, false); err != nil { - t.Fatalf("Should have succeeded: %v", err) - } + err = th.App.ImportScheme(&data, false) + require.Nil(t, err, "Should have succeeded: %v", err) - if scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err != nil { - t.Fatalf("Failed to import scheme: %v", err) - } else { - assert.Equal(t, *data.Name, scheme.Name) - assert.Equal(t, *data.DisplayName, scheme.DisplayName) - assert.Equal(t, *data.Description, scheme.Description) - assert.Equal(t, *data.Scope, scheme.Scope) + scheme, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.Nil(t, err, "Failed to import scheme: %v", err) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.Name, scheme.Name) + assert.Equal(t, *data.DisplayName, scheme.DisplayName) + assert.Equal(t, *data.Description, scheme.Description) + assert.Equal(t, *data.Scope, scheme.Scope) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) // Try changing the scope of the scheme and reimporting. data.Scope = ptrStr("channel") - if err := th.App.ImportScheme(&data, false); err == nil { - t.Fatalf("Should have failed to import.") - } + err = th.App.ImportScheme(&data, false) + require.NotNil(t, err, "Should have failed to import.") + + scheme, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.Nil(t, err, "Failed to import scheme: %v", err) + + assert.Equal(t, *data.Name, scheme.Name) + assert.Equal(t, *data.DisplayName, scheme.DisplayName) + assert.Equal(t, *data.Description, scheme.Description) + assert.Equal(t, "team", scheme.Scope) - if scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err != nil { - t.Fatalf("Failed to import scheme: %v", err) - } else { - assert.Equal(t, *data.Name, scheme.Name) - assert.Equal(t, *data.DisplayName, scheme.DisplayName) - assert.Equal(t, *data.Description, scheme.Description) - assert.Equal(t, "team", scheme.Scope) - } } func TestImportImportSchemeWithoutGuestRoles(t *testing.T) { @@ -271,180 +248,156 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) { Description: ptrStr("description"), } - if err := th.App.ImportScheme(&data, true); err == nil { - t.Fatalf("Should have failed to import.") - } + err := th.App.ImportScheme(&data, true) + require.NotNil(t, err, "Should have failed to import.") - if _, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err == nil { - t.Fatalf("Scheme should not have imported.") - } + _, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.NotNil(t, err, "Scheme should not have imported.") // Try importing a valid scheme in dryRun mode. data.DisplayName = ptrStr("display name") - if err := th.App.ImportScheme(&data, true); err != nil { - t.Fatalf("Should have succeeded.") - } + err = th.App.ImportScheme(&data, true) + require.Nil(t, err, "Should have succeeded.") - if _, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err == nil { - t.Fatalf("Scheme should not have imported.") - } + _, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.NotNil(t, err, "Scheme should not have imported.") // Try importing an invalid scheme. data.DisplayName = nil - if err := th.App.ImportScheme(&data, false); err == nil { - t.Fatalf("Should have failed to import.") - } + err = th.App.ImportScheme(&data, false) + require.NotNil(t, err, "Should have failed to import.") - if _, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err == nil { - t.Fatalf("Scheme should not have imported.") - } + _, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.NotNil(t, err, "Scheme should not have imported.") // Try importing a valid scheme with all params set. data.DisplayName = ptrStr("display name") - if err := th.App.ImportScheme(&data, false); err != nil { - t.Fatalf("Should have succeeded.") - } + err = th.App.ImportScheme(&data, false) + require.Nil(t, err, "Should have succeeded.") - if scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err != nil { - t.Fatalf("Failed to import scheme: %v", err) - } else { - assert.Equal(t, *data.Name, scheme.Name) - assert.Equal(t, *data.DisplayName, scheme.DisplayName) - assert.Equal(t, *data.Description, scheme.Description) - assert.Equal(t, *data.Scope, scheme.Scope) + scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.Nil(t, err, "Failed to import scheme: %v", err) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.Name, scheme.Name) + assert.Equal(t, *data.DisplayName, scheme.DisplayName) + assert.Equal(t, *data.Description, scheme.Description) + assert.Equal(t, *data.Scope, scheme.Scope) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) // Try modifying all the fields and re-importing. data.DisplayName = ptrStr("new display name") data.Description = ptrStr("new description") - if err := th.App.ImportScheme(&data, false); err != nil { - t.Fatalf("Should have succeeded: %v", err) - } + err = th.App.ImportScheme(&data, false) + require.Nil(t, err, "Should have succeeded: %v", err) - if scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err != nil { - t.Fatalf("Failed to import scheme: %v", err) - } else { - assert.Equal(t, *data.Name, scheme.Name) - assert.Equal(t, *data.DisplayName, scheme.DisplayName) - assert.Equal(t, *data.Description, scheme.Description) - assert.Equal(t, *data.Scope, scheme.Scope) + scheme, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.Nil(t, err, "Failed to import scheme: %v", err) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.Name, scheme.Name) + assert.Equal(t, *data.DisplayName, scheme.DisplayName) + assert.Equal(t, *data.Description, scheme.Description) + assert.Equal(t, *data.Scope, scheme.Scope) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole) + require.Nil(t, err, "Should have found the imported role.") - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) - if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } - } + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) + + role, err = th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) // Try changing the scope of the scheme and reimporting. data.Scope = ptrStr("channel") - if err := th.App.ImportScheme(&data, false); err == nil { - t.Fatalf("Should have failed to import.") - } + err = th.App.ImportScheme(&data, false) + require.NotNil(t, err, "Should have failed to import.") - if scheme, err := th.App.Srv.Store.Scheme().GetByName(*data.Name); err != nil { - t.Fatalf("Failed to import scheme: %v", err) - } else { - assert.Equal(t, *data.Name, scheme.Name) - assert.Equal(t, *data.DisplayName, scheme.DisplayName) - assert.Equal(t, *data.Description, scheme.Description) - assert.Equal(t, "team", scheme.Scope) - } + scheme, err = th.App.Srv.Store.Scheme().GetByName(*data.Name) + require.Nil(t, err, "Failed to import scheme: %v", err) + + assert.Equal(t, *data.Name, scheme.Name) + assert.Equal(t, *data.DisplayName, scheme.DisplayName) + assert.Equal(t, *data.Description, scheme.Description) + assert.Equal(t, "team", scheme.Scope) } func TestImportImportRole(t *testing.T) { @@ -457,75 +410,65 @@ func TestImportImportRole(t *testing.T) { Name: &rid1, } - if err := th.App.ImportRole(&data, true, false); err == nil { - t.Fatalf("Should have failed to import.") - } + err := th.App.ImportRole(&data, true, false) + require.NotNil(t, err, "Should have failed to import.") - if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil { - t.Fatalf("Role should not have imported.") - } + _, err = th.App.Srv.Store.Role().GetByName(rid1) + require.NotNil(t, err, "Should have failed to import.") // Try importing the valid role in dryRun mode. data.DisplayName = ptrStr("display name") - if err := th.App.ImportRole(&data, true, false); err != nil { - t.Fatalf("Should have succeeded.") - } + err = th.App.ImportRole(&data, true, false) + require.Nil(t, err, "Should have succeeded.") - if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil { - t.Fatalf("Role should not have imported as we are in dry run mode.") - } + _, err = th.App.Srv.Store.Role().GetByName(rid1) + require.NotNil(t, err, "Role should not have imported as we are in dry run mode.") // Try importing an invalid role. data.DisplayName = nil - if err := th.App.ImportRole(&data, false, false); err == nil { - t.Fatalf("Should have failed to import.") - } + err = th.App.ImportRole(&data, false, false) + require.NotNil(t, err, "Should have failed to import.") - if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil { - t.Fatalf("Role should not have imported.") - } + _, err = th.App.Srv.Store.Role().GetByName(rid1) + require.NotNil(t, err, "Role should not have imported.") // Try importing a valid role with all params set. data.DisplayName = ptrStr("display name") data.Description = ptrStr("description") data.Permissions = &[]string{"invite_user", "add_user_to_team"} - if err := th.App.ImportRole(&data, false, false); err != nil { - t.Fatalf("Should have succeeded.") - } + err = th.App.ImportRole(&data, false, false) + require.Nil(t, err, "Should have succeeded.") - if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.Name, role.Name) - assert.Equal(t, *data.DisplayName, role.DisplayName) - assert.Equal(t, *data.Description, role.Description) - assert.Equal(t, *data.Permissions, role.Permissions) - assert.False(t, role.BuiltIn) - assert.False(t, role.SchemeManaged) - } + role, err := th.App.Srv.Store.Role().GetByName(rid1) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.Name, role.Name) + assert.Equal(t, *data.DisplayName, role.DisplayName) + assert.Equal(t, *data.Description, role.Description) + assert.Equal(t, *data.Permissions, role.Permissions) + assert.False(t, role.BuiltIn) + assert.False(t, role.SchemeManaged) // Try changing all the params and reimporting. data.DisplayName = ptrStr("new display name") data.Description = ptrStr("description") data.Permissions = &[]string{"use_slash_commands"} - if err := th.App.ImportRole(&data, false, true); err != nil { - t.Fatalf("Should have succeeded. %v", err) - } + err = th.App.ImportRole(&data, false, true) + require.Nil(t, err, "Should have succeeded. %v", err) - if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data.Name, role.Name) - assert.Equal(t, *data.DisplayName, role.DisplayName) - assert.Equal(t, *data.Description, role.Description) - assert.Equal(t, *data.Permissions, role.Permissions) - assert.False(t, role.BuiltIn) - assert.True(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(rid1) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data.Name, role.Name) + assert.Equal(t, *data.DisplayName, role.DisplayName) + assert.Equal(t, *data.Description, role.Description) + assert.Equal(t, *data.Permissions, role.Permissions) + assert.False(t, role.BuiltIn) + assert.True(t, role.SchemeManaged) // Check that re-importing with only required fields doesn't update the others. data2 := RoleImportData{ @@ -533,20 +476,18 @@ func TestImportImportRole(t *testing.T) { DisplayName: ptrStr("new display name again"), } - if err := th.App.ImportRole(&data2, false, false); err != nil { - t.Fatalf("Should have succeeded.") - } + err = th.App.ImportRole(&data2, false, false) + require.Nil(t, err, "Should have succeeded.") - if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil { - t.Fatalf("Should have found the imported role.") - } else { - assert.Equal(t, *data2.Name, role.Name) - assert.Equal(t, *data2.DisplayName, role.DisplayName) - assert.Equal(t, *data.Description, role.Description) - assert.Equal(t, *data.Permissions, role.Permissions) - assert.False(t, role.BuiltIn) - assert.False(t, role.SchemeManaged) - } + role, err = th.App.Srv.Store.Role().GetByName(rid1) + require.Nil(t, err, "Should have found the imported role.") + + assert.Equal(t, *data2.Name, role.Name) + assert.Equal(t, *data2.DisplayName, role.DisplayName) + assert.Equal(t, *data.Description, role.Description) + assert.Equal(t, *data.Permissions, role.Permissions) + assert.False(t, role.BuiltIn) + assert.False(t, role.SchemeManaged) } func TestImportImportTeam(t *testing.T) { @@ -565,9 +506,7 @@ func TestImportImportTeam(t *testing.T) { // Check how many teams are in the database. teamsCount, err := th.App.Srv.Store.Team().AnalyticsTeamCount() - if err != nil { - t.Fatalf("Failed to get team count.") - } + require.Nil(t, err, "Failed to get team count.") data := TeamImportData{ Name: ptrStr(model.NewId()), @@ -579,47 +518,42 @@ func TestImportImportTeam(t *testing.T) { } // Try importing an invalid team in dryRun mode. - if err := th.App.ImportTeam(&data, true); err == nil { - t.Fatalf("Should have received an error importing an invalid team.") - } + err = th.App.ImportTeam(&data, true) + require.NotNil(t, err, "Should have received an error importing an invalid team.") // Do a valid team in dry-run mode. data.Type = ptrStr("O") - if err := th.App.ImportTeam(&data, true); err != nil { - t.Fatalf("Received an error validating valid team.") - } + err = th.App.ImportTeam(&data, true) + require.Nil(t, err, "Received an error validating valid team.") // Check that no more teams are in the DB. th.CheckTeamCount(t, teamsCount) // Do an invalid team in apply mode, check db changes. data.Type = ptrStr("XYZ") - if err := th.App.ImportTeam(&data, false); err == nil { - t.Fatalf("Import should have failed on invalid team.") - } + err = th.App.ImportTeam(&data, false) + require.NotNil(t, err, "Import should have failed on invalid team.") // Check that no more teams are in the DB. th.CheckTeamCount(t, teamsCount) // Do a valid team in apply mode, check db changes. data.Type = ptrStr("O") - if err := th.App.ImportTeam(&data, false); err != nil { - t.Fatalf("Received an error importing valid team: %v", err) - } + err = th.App.ImportTeam(&data, false) + require.Nil(t, err, "Received an error importing valid team: %v", err) // Check that one more team is in the DB. th.CheckTeamCount(t, teamsCount+1) // Get the team and check that all the fields are correct. - if team, err := th.App.GetTeamByName(*data.Name); err != nil { - t.Fatalf("Failed to get team from database.") - } else { - assert.Equal(t, *data.DisplayName, team.DisplayName) - assert.Equal(t, *data.Type, team.Type) - assert.Equal(t, *data.Description, team.Description) - assert.Equal(t, *data.AllowOpenInvite, team.AllowOpenInvite) - assert.Equal(t, scheme1.Id, *team.SchemeId) - } + team, err := th.App.GetTeamByName(*data.Name) + require.Nil(t, err, "Failed to get team from database.") + + assert.Equal(t, *data.DisplayName, team.DisplayName) + assert.Equal(t, *data.Type, team.Type) + assert.Equal(t, *data.Description, team.Description) + assert.Equal(t, *data.AllowOpenInvite, team.AllowOpenInvite) + assert.Equal(t, scheme1.Id, *team.SchemeId) // Alter all the fields of that team (apart from unique identifier) and import again. data.DisplayName = ptrStr("Display Name 2") @@ -630,22 +564,20 @@ func TestImportImportTeam(t *testing.T) { // Check that the original number of teams are again in the DB (because this query doesn't include deleted). data.Type = ptrStr("O") - if err := th.App.ImportTeam(&data, false); err != nil { - t.Fatalf("Received an error importing updated valid team.") - } + err = th.App.ImportTeam(&data, false) + require.Nil(t, err, "Received an error importing updated valid team.") th.CheckTeamCount(t, teamsCount+1) // Get the team and check that all fields are correct. - if team, err := th.App.GetTeamByName(*data.Name); err != nil { - t.Fatalf("Failed to get team from database.") - } else { - assert.Equal(t, *data.DisplayName, team.DisplayName) - assert.Equal(t, *data.Type, team.Type) - assert.Equal(t, *data.Description, team.Description) - assert.Equal(t, *data.AllowOpenInvite, team.AllowOpenInvite) - assert.Equal(t, scheme2.Id, *team.SchemeId) - } + team, err = th.App.GetTeamByName(*data.Name) + require.Nil(t, err, "Failed to get team from database.") + + assert.Equal(t, *data.DisplayName, team.DisplayName) + assert.Equal(t, *data.Type, team.Type) + assert.Equal(t, *data.Description, team.Description) + assert.Equal(t, *data.AllowOpenInvite, team.AllowOpenInvite) + assert.Equal(t, scheme2.Id, *team.SchemeId) } func TestImportImportChannel(t *testing.T) { @@ -670,9 +602,7 @@ func TestImportImportChannel(t *testing.T) { Type: ptrStr("O"), }, false) team, err := th.App.GetTeamByName(teamName) - if err != nil { - t.Fatalf("Failed to get team from database.") - } + require.Nil(t, err, "Failed to get team from database.") // Check how many channels are in the database. channelCount, err := th.App.Srv.Store.Channel().AnalyticsTypeCount("", model.CHANNEL_OPEN) @@ -687,9 +617,8 @@ func TestImportImportChannel(t *testing.T) { Purpose: ptrStr("Channel Purpose"), Scheme: &scheme1.Name, } - if err := th.App.ImportChannel(&data, true); err == nil { - t.Fatalf("Expected error due to invalid name.") - } + err = th.App.ImportChannel(&data, true) + require.NotNil(t, err, "Expected error due to invalid name.") // Check that no more channels are in the DB. th.CheckChannelsCount(t, channelCount) @@ -697,27 +626,24 @@ func TestImportImportChannel(t *testing.T) { // Do a valid channel with a nonexistent team in dry-run mode. data.Name = ptrStr("channelname") data.Team = ptrStr(model.NewId()) - if err := th.App.ImportChannel(&data, true); err != nil { - t.Fatalf("Expected success as cannot validate channel name in dry run mode.") - } + err = th.App.ImportChannel(&data, true) + require.Nil(t, err, "Expected success as cannot validate channel name in dry run mode.") // Check that no more channels are in the DB. th.CheckChannelsCount(t, channelCount) // Do a valid channel in dry-run mode. data.Team = &teamName - if err := th.App.ImportChannel(&data, true); err != nil { - t.Fatalf("Expected success as valid team.") - } + err = th.App.ImportChannel(&data, true) + require.Nil(t, err, "Expected success as valid team.") // Check that no more channels are in the DB. th.CheckChannelsCount(t, channelCount) // Do an invalid channel in apply mode. data.Name = nil - if err := th.App.ImportChannel(&data, false); err == nil { - t.Fatalf("Expected error due to invalid name (apply mode).") - } + err = th.App.ImportChannel(&data, false) + require.NotNil(t, err, "Expected error due to invalid name (apply mode).") // Check that no more channels are in the DB. th.CheckChannelsCount(t, channelCount) @@ -725,33 +651,30 @@ func TestImportImportChannel(t *testing.T) { // Do a valid channel in apply mode with a non-existent team. data.Name = ptrStr("channelname") data.Team = ptrStr(model.NewId()) - if err := th.App.ImportChannel(&data, false); err == nil { - t.Fatalf("Expected error due to non-existent team (apply mode).") - } + err = th.App.ImportChannel(&data, false) + require.NotNil(t, err, "Expected error due to non-existent team (apply mode).") // Check that no more channels are in the DB. th.CheckChannelsCount(t, channelCount) // Do a valid channel in apply mode. data.Team = &teamName - if err := th.App.ImportChannel(&data, false); err != nil { - t.Fatalf("Expected success in apply mode: %v", err.Error()) - } + err = th.App.ImportChannel(&data, false) + require.Nil(t, err, "Expected success in apply mode") // Check that 1 more channel is in the DB. th.CheckChannelsCount(t, channelCount+1) // Get the Channel and check all the fields are correct. - if channel, err := th.App.GetChannelByName(*data.Name, team.Id, false); err != nil { - t.Fatalf("Failed to get channel from database.") - } else { - assert.Equal(t, *data.Name, channel.Name) - assert.Equal(t, *data.DisplayName, channel.DisplayName) - assert.Equal(t, *data.Type, channel.Type) - assert.Equal(t, *data.Header, channel.Header) - assert.Equal(t, *data.Purpose, channel.Purpose) - assert.Equal(t, scheme1.Id, *channel.SchemeId) - } + channel, err := th.App.GetChannelByName(*data.Name, team.Id, false) + require.Nil(t, err, "Failed to get channel from database.") + + assert.Equal(t, *data.Name, channel.Name) + assert.Equal(t, *data.DisplayName, channel.DisplayName) + assert.Equal(t, *data.Type, channel.Type) + assert.Equal(t, *data.Header, channel.Header) + assert.Equal(t, *data.Purpose, channel.Purpose) + assert.Equal(t, scheme1.Id, *channel.SchemeId) // Alter all the fields of that channel. data.DisplayName = ptrStr("Chaned Disp Name") @@ -759,25 +682,22 @@ func TestImportImportChannel(t *testing.T) { data.Header = ptrStr("New Header") data.Purpose = ptrStr("New Purpose") data.Scheme = &scheme2.Name - if err := th.App.ImportChannel(&data, false); err != nil { - t.Fatalf("Expected success in apply mode: %v", err.Error()) - } + err = th.App.ImportChannel(&data, false) + require.Nil(t, err, "Expected success in apply mode") // Check channel count the same. th.CheckChannelsCount(t, channelCount) // Get the Channel and check all the fields are correct. - if channel, err := th.App.GetChannelByName(*data.Name, team.Id, false); err != nil { - t.Fatalf("Failed to get channel from database.") - } else { - assert.Equal(t, *data.Name, channel.Name) - assert.Equal(t, *data.DisplayName, channel.DisplayName) - assert.Equal(t, *data.Type, channel.Type) - assert.Equal(t, *data.Header, channel.Header) - assert.Equal(t, *data.Purpose, channel.Purpose) - assert.Equal(t, scheme2.Id, *channel.SchemeId) - } + channel, err = th.App.GetChannelByName(*data.Name, team.Id, false) + require.Nil(t, err, "Failed to get channel from database.") + assert.Equal(t, *data.Name, channel.Name) + assert.Equal(t, *data.DisplayName, channel.DisplayName) + assert.Equal(t, *data.Type, channel.Type) + assert.Equal(t, *data.Header, channel.Header) + assert.Equal(t, *data.Purpose, channel.Purpose) + assert.Equal(t, scheme2.Id, *channel.SchemeId) } func TestImportImportUser(t *testing.T) { @@ -795,9 +715,8 @@ func TestImportImportUser(t *testing.T) { data := UserImportData{ Username: ptrStr(model.NewId()), } - if err = th.App.ImportUser(&data, true); err == nil { - t.Fatalf("Should have failed to import invalid user.") - } + err = th.App.ImportUser(&data, true) + require.NotNil(t, err, "Should have failed to import invalid user.") // Check that no more users are in the DB. userCount2, err := th.App.Srv.Store.User().Count(model.UserCountOptions{ @@ -812,9 +731,8 @@ func TestImportImportUser(t *testing.T) { Username: ptrStr(model.NewId()), Email: ptrStr(model.NewId() + "@example.com"), } - if err = th.App.ImportUser(&data, true); err != nil { - t.Fatalf("Should have succeeded to import valid user.") - } + err = th.App.ImportUser(&data, true) + require.Nil(t, err, "Should have succeeded to import valid user.") // Check that no more users are in the DB. userCount3, err := th.App.Srv.Store.User().Count(model.UserCountOptions{ @@ -828,9 +746,8 @@ func TestImportImportUser(t *testing.T) { data = UserImportData{ Username: ptrStr(model.NewId()), } - if err = th.App.ImportUser(&data, false); err == nil { - t.Fatalf("Should have failed to import invalid user.") - } + err = th.App.ImportUser(&data, false) + require.NotNil(t, err, "Should have failed to import invalid user.") // Check that no more users are in the DB. userCount4, err := th.App.Srv.Store.User().Count(model.UserCountOptions{ @@ -852,9 +769,8 @@ func TestImportImportUser(t *testing.T) { LastName: ptrStr(model.NewId()), Position: ptrStr(model.NewId()), } - if err = th.App.ImportUser(&data, false); err != nil { - t.Fatalf("Should have succeeded to import valid user.") - } + err = th.App.ImportUser(&data, false) + require.Nil(t, err, "Should have succeeded to import valid user.") // Check that one more user is in the DB. userCount5, err := th.App.Srv.Store.User().Count(model.UserCountOptions{ @@ -865,37 +781,24 @@ func TestImportImportUser(t *testing.T) { assert.Equal(t, userCount+1, userCount5, "Unexpected number of users") // Get the user and check all the fields are correct. - if user, err2 := th.App.GetUserByUsername(username); err2 != nil { - t.Fatalf("Failed to get user from database.") - } else { - if user.Email != *data.Email || user.Nickname != *data.Nickname || user.FirstName != *data.FirstName || user.LastName != *data.LastName || user.Position != *data.Position { - t.Fatalf("User properties do not match Import Data.") - } - // Check calculated properties. - if user.AuthService != "" { - t.Fatalf("Expected Auth Service to be empty.") - } + user, err2 := th.App.GetUserByUsername(username) + require.Nil(t, err2, "Failed to get user from database.") - if !(user.AuthData == nil || *user.AuthData == "") { - t.Fatalf("Expected AuthData to be empty.") - } + userBool := user.Email != *data.Email || user.Nickname != *data.Nickname || user.FirstName != *data.FirstName || user.LastName != *data.LastName || user.Position != *data.Position + require.False(t, userBool, "User properties do not match Import Data.") - if len(user.Password) == 0 { - t.Fatalf("Expected password to be set.") - } + // Check calculated properties. + require.Empty(t, user.AuthService, "Expected Auth Service to be empty.") - if !user.EmailVerified { - t.Fatalf("Expected EmailVerified to be true.") - } + require.Empty(t, user.AuthData, "Expected AuthData to be empty.") - if user.Locale != *th.App.Config().LocalizationSettings.DefaultClientLocale { - t.Fatalf("Expected Locale to be the default.") - } + require.NotEmpty(t, user.Password, "Expected password to be set.") - if user.Roles != "system_user" { - t.Fatalf("Expected roles to be system_user") - } - } + require.True(t, user.EmailVerified, "Expected EmailVerified to be true.") + + require.Equal(t, user.Locale, *th.App.Config().LocalizationSettings.DefaultClientLocale, "Expected Locale to be the default.") + + require.Equal(t, user.Roles, "system_user", "Expected roles to be system_user") // Alter all the fields of that user. data.Email = ptrStr(model.NewId() + "@example.com") @@ -908,9 +811,9 @@ func TestImportImportUser(t *testing.T) { data.Position = ptrStr(model.NewId()) data.Roles = ptrStr("system_admin system_user") data.Locale = ptrStr("zh_CN") - if err = th.App.ImportUser(&data, false); err != nil { - t.Fatalf("Should have succeeded to update valid user %v", err) - } + + err = th.App.ImportUser(&data, false) + require.Nil(t, err, "Should have succeeded to update valid user %v", err) // Check user count the same. userCount6, err := th.App.Srv.Store.User().Count(model.UserCountOptions{ @@ -921,58 +824,40 @@ func TestImportImportUser(t *testing.T) { assert.Equal(t, userCount+1, userCount6, "Unexpected number of users") // Get the user and check all the fields are correct. - if user, err2 := th.App.GetUserByUsername(username); err2 != nil { - t.Fatalf("Failed to get user from database.") - } else { - if user.Email != *data.Email || user.Nickname != *data.Nickname || user.FirstName != *data.FirstName || user.LastName != *data.LastName || user.Position != *data.Position { - t.Fatalf("Updated User properties do not match Import Data.") - } - // Check calculated properties. - if user.AuthService != "ldap" { - t.Fatalf("Expected Auth Service to be ldap \"%v\"", user.AuthService) - } + user, err2 = th.App.GetUserByUsername(username) + require.Nil(t, err2, "Failed to get user from database.") - if !(user.AuthData == data.AuthData || *user.AuthData == *data.AuthData) { - t.Fatalf("Expected AuthData to be set.") - } + userBool = user.Email != *data.Email || user.Nickname != *data.Nickname || user.FirstName != *data.FirstName || user.LastName != *data.LastName || user.Position != *data.Position + require.False(t, userBool, "Updated User properties do not match Import Data.") - if len(user.Password) != 0 { - t.Fatalf("Expected password to be empty.") - } + require.Equal(t, "ldap", user.AuthService, "Expected Auth Service to be ldap \"%v\"", user.AuthService) - if !user.EmailVerified { - t.Fatalf("Expected EmailVerified to be true.") - } + require.Equal(t, user.AuthData, data.AuthData, "Expected AuthData to be set.") - if user.Locale != *data.Locale { - t.Fatalf("Expected Locale to be the set.") - } + require.Len(t, user.Password, 0, "Expected password to be empty.") - if user.Roles != *data.Roles { - t.Fatalf("Expected roles to be set: %v", user.Roles) - } - } + require.True(t, user.EmailVerified, "Expected EmailVerified to be true.") + + require.Equal(t, *data.Locale, user.Locale, "Expected Locale to be the set.") + + require.Equal(t, *data.Roles, user.Roles, "Expected roles to be set: %v", user.Roles) // Check Password and AuthData together. data.Password = ptrStr("PasswordTest") - if err = th.App.ImportUser(&data, false); err == nil { - t.Fatalf("Should have failed to import invalid user.") - } + err = th.App.ImportUser(&data, false) + require.NotNil(t, err, "Should have failed to import invalid user.") data.AuthData = nil - if err = th.App.ImportUser(&data, false); err != nil { - t.Fatalf("Should have succeeded to update valid user %v", err) - } + err = th.App.ImportUser(&data, false) + require.Nil(t, err, "Should have succeeded to update valid user %v", err) data.Password = ptrStr("") - if err = th.App.ImportUser(&data, false); err == nil { - t.Fatalf("Should have failed to import invalid user.") - } + err = th.App.ImportUser(&data, false) + require.NotNil(t, err, "Should have failed to import invalid user.") data.Password = ptrStr(strings.Repeat("0123456789", 10)) - if err = th.App.ImportUser(&data, false); err == nil { - t.Fatalf("Should have failed to import invalid user.") - } + err = th.App.ImportUser(&data, false) + require.NotNil(t, err, "Should have failed to import invalid user.") data.Password = ptrStr("TestPassword") @@ -984,9 +869,7 @@ func TestImportImportUser(t *testing.T) { Type: ptrStr("O"), }, false) team, err := th.App.GetTeamByName(teamName) - if err != nil { - t.Fatalf("Failed to get team from database.") - } + require.Nil(t, err, "Failed to get team from database.") channelName := model.NewId() th.App.ImportChannel(&ChannelImportData{ @@ -996,9 +879,7 @@ func TestImportImportUser(t *testing.T) { Type: ptrStr("O"), }, false) channel, err := th.App.GetChannelByName(channelName, team.Id, false) - if err != nil { - t.Fatalf("Failed to get channel from database.") - } + require.Nil(t, err, "Failed to get channel from database.") username = model.NewId() data = UserImportData{ @@ -1011,15 +892,11 @@ func TestImportImportUser(t *testing.T) { } teamMembers, err := th.App.GetTeamMembers(team.Id, 0, 1000, nil) - if err != nil { - t.Fatalf("Failed to get team member count") - } + require.Nil(t, err, "Failed to get team member count") teamMemberCount := len(teamMembers) channelMemberCount, err := th.App.GetChannelMemberCount(channel.Id) - if err != nil { - t.Fatalf("Failed to get channel member count") - } + require.Nil(t, err, "Failed to get channel member count") // Test with an invalid team & channel membership in dry-run mode. data.Teams = &[]UserTeamImportData{ @@ -1175,10 +1052,8 @@ func TestImportImportUser(t *testing.T) { require.Equal(t, channelMemberCount, cmc) // Check team member properties. - user, err := th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + user, err = th.App.GetUserByUsername(username) + require.Nil(t, err, "Failed to get user from database.") teamMember, err := th.App.GetTeamMember(team.Id, user.Id) require.Nil(t, err, "Failed to get team member from database.") @@ -1283,9 +1158,7 @@ func TestImportImportUser(t *testing.T) { // Check their values. user, err = th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") checkPreference(t, th.App, user.Id, model.PREFERENCE_CATEGORY_THEME, "", *data.Theme) checkPreference(t, th.App, user.Id, model.PREFERENCE_CATEGORY_DISPLAY_SETTINGS, model.PREFERENCE_NAME_USE_MILITARY_TIME, *data.UseMilitaryTime) @@ -1336,9 +1209,7 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") checkNotifyProp(t, user, model.DESKTOP_NOTIFY_PROP, model.USER_NOTIFY_ALL) checkNotifyProp(t, user, model.DESKTOP_SOUND_NOTIFY_PROP, "true") @@ -1364,9 +1235,7 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") checkNotifyProp(t, user, model.DESKTOP_NOTIFY_PROP, model.USER_NOTIFY_ALL) checkNotifyProp(t, user, model.DESKTOP_SOUND_NOTIFY_PROP, "true") @@ -1392,9 +1261,7 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") checkNotifyProp(t, user, model.DESKTOP_NOTIFY_PROP, model.USER_NOTIFY_MENTION) checkNotifyProp(t, user, model.DESKTOP_SOUND_NOTIFY_PROP, "false") @@ -1419,9 +1286,7 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") checkNotifyProp(t, user, model.DESKTOP_NOTIFY_PROP, model.USER_NOTIFY_MENTION) checkNotifyProp(t, user, model.DESKTOP_SOUND_NOTIFY_PROP, "false") @@ -1453,9 +1318,7 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") checkNotifyProp(t, user, model.DESKTOP_NOTIFY_PROP, model.USER_NOTIFY_MENTION) checkNotifyProp(t, user, model.DESKTOP_SOUND_NOTIFY_PROP, "false") @@ -1525,9 +1388,7 @@ func TestImportImportUser(t *testing.T) { err = th.App.ImportTeam(teamData, false) assert.Nil(t, err) team, err = th.App.GetTeamByName(teamName) - if err != nil { - t.Fatalf("Failed to get team from database.") - } + require.Nil(t, err, "Failed to get team from database.") channelData := &ChannelImportData{ Team: &teamName, @@ -1540,9 +1401,7 @@ func TestImportImportUser(t *testing.T) { err = th.App.ImportChannel(channelData, false) assert.Nil(t, err) channel, err = th.App.GetChannelByName(*channelData.Name, team.Id, false) - if err != nil { - t.Fatalf("Failed to get channel from database: %v", err.Error()) - } + require.Nil(t, err, "Failed to get channel from database") // Test with a valid team & valid channel name in apply mode. userData := &UserImportData{ @@ -1565,23 +1424,19 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(*userData.Username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") teamMember, err = th.App.GetTeamMember(team.Id, user.Id) - if err != nil { - t.Fatalf("Failed to get the team member") - } + require.Nil(t, err, "Failed to get the team member") + assert.True(t, teamMember.SchemeAdmin) assert.True(t, teamMember.SchemeUser) assert.False(t, teamMember.SchemeGuest) assert.Equal(t, "", teamMember.ExplicitRoles) channelMember, err = th.App.GetChannelMember(channel.Id, user.Id) - if err != nil { - t.Fatalf("Failed to get the channel member") - } + require.Nil(t, err, "Failed to get the channel member") + assert.True(t, channelMember.SchemeAdmin) assert.True(t, channelMember.SchemeUser) assert.False(t, channelMember.SchemeGuest) @@ -1611,14 +1466,10 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(*deletedUserData.Username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") teamMember, err = th.App.GetTeamMember(team.Id, user.Id) - if err != nil { - t.Fatalf("Failed to get the team member") - } + require.Nil(t, err, "Failed to get the team member") assert.False(t, teamMember.SchemeAdmin) assert.True(t, teamMember.SchemeUser) @@ -1626,9 +1477,7 @@ func TestImportImportUser(t *testing.T) { assert.Equal(t, "", teamMember.ExplicitRoles) channelMember, err = th.App.GetChannelMember(channel.Id, user.Id) - if err != nil { - t.Fatalf("Failed to get the channel member") - } + require.Nil(t, err, "Failed to get the channel member") assert.False(t, teamMember.SchemeAdmin) assert.True(t, channelMember.SchemeUser) @@ -1659,14 +1508,10 @@ func TestImportImportUser(t *testing.T) { assert.Nil(t, err) user, err = th.App.GetUserByUsername(*deletedGuestData.Username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") teamMember, err = th.App.GetTeamMember(team.Id, user.Id) - if err != nil { - t.Fatalf("Failed to get the team member") - } + require.Nil(t, err, "Failed to get the team member") assert.False(t, teamMember.SchemeAdmin) assert.False(t, teamMember.SchemeUser) @@ -1674,9 +1519,7 @@ func TestImportImportUser(t *testing.T) { assert.Equal(t, "", teamMember.ExplicitRoles) channelMember, err = th.App.GetChannelMember(channel.Id, user.Id) - if err != nil { - t.Fatalf("Failed to get the channel member") - } + require.Nil(t, err, "Failed to get the channel member") assert.False(t, teamMember.SchemeAdmin) assert.False(t, channelMember.SchemeUser) @@ -1734,9 +1577,7 @@ func TestImportImportPost(t *testing.T) { Type: ptrStr("O"), }, false) team, err := th.App.GetTeamByName(teamName) - if err != nil { - t.Fatalf("Failed to get team from database.") - } + require.Nil(t, err, "Failed to get team from database.") // Create a Channel. channelName := model.NewId() @@ -1747,9 +1588,7 @@ func TestImportImportPost(t *testing.T) { Type: ptrStr("O"), }, false) channel, err := th.App.GetChannelByName(channelName, team.Id, false) - if err != nil { - t.Fatalf("Failed to get channel from database.") - } + require.Nil(t, err, "Failed to get channel from database.") // Create a user. username := model.NewId() @@ -1758,15 +1597,11 @@ func TestImportImportPost(t *testing.T) { Email: ptrStr(model.NewId() + "@example.com"), }, false) user, err := th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") // Count the number of posts in the testing team. initialPostCount, err := th.App.Srv.Store.Post().AnalyticsPostCount(team.Id, false, false) - if err != nil { - t.Fatal(err) - } + require.Nil(t, err) // Try adding an invalid post in dry run mode. data := &PostImportData{ @@ -1852,17 +1687,13 @@ func TestImportImportPost(t *testing.T) { // Check the post values. posts, err := th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, time) - if err != nil { - t.Fatal(err.Error()) - } else { - if len(posts) != 1 { - t.Fatal("Unexpected number of posts found.") - } - post := posts[0] - if post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id { - t.Fatal("Post properties not as expected") - } - } + require.Nil(t, err) + + require.Len(t, posts, 1, "Unexpected number of posts found.") + + post := posts[0] + postBool := post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id + require.False(t, postBool, "Post properties not as expected") // Update the post. data = &PostImportData{ @@ -1878,17 +1709,13 @@ func TestImportImportPost(t *testing.T) { // Check the post values. posts, err = th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, time) - if err != nil { - t.Fatal(err.Error()) - } else { - if len(posts) != 1 { - t.Fatal("Unexpected number of posts found.") - } - post := posts[0] - if post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id { - t.Fatal("Post properties not as expected") - } - } + require.Nil(t, err) + + require.Len(t, posts, 1, "Unexpected number of posts found.") + + post = posts[0] + postBool = post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id + require.False(t, postBool, "Post properties not as expected") // Save the post with a different time. newTime := time + 1 @@ -1929,20 +1756,15 @@ func TestImportImportPost(t *testing.T) { AssertAllPostsCount(t, th.App, initialPostCount, 4, team.Id) posts, err = th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, hashtagTime) - if err != nil { - t.Fatal(err.Error()) - } else { - if len(posts) != 1 { - t.Fatal("Unexpected number of posts found.") - } - post := posts[0] - if post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id { - t.Fatal("Post properties not as expected") - } - if post.Hashtags != "#hashtagmashupcity" { - t.Fatalf("Hashtags not as expected: %s", post.Hashtags) - } - } + require.Nil(t, err) + + require.Len(t, posts, 1, "Unexpected number of posts found.") + + post = posts[0] + postBool = post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id + require.False(t, postBool, "Post properties not as expected") + + require.Equal(t, "#hashtagmashupcity", post.Hashtags, "Hashtags not as expected: %s", post.Hashtags) // Post with flags. username2 := model.NewId() @@ -1951,9 +1773,7 @@ func TestImportImportPost(t *testing.T) { Email: ptrStr(model.NewId() + "@example.com"), }, false) user2, err := th.App.GetUserByUsername(username2) - if err != nil { - t.Fatalf("Failed to get user from database.") - } + require.Nil(t, err, "Failed to get user from database.") flagsTime := hashtagTime + 1 data = &PostImportData{ @@ -1967,26 +1787,24 @@ func TestImportImportPost(t *testing.T) { username2, }, } - if err := th.App.ImportPost(data, false); err != nil { - t.Fatalf("Expected success.") - } + + err = th.App.ImportPost(data, false) + require.Nil(t, err, "Expected success.") + AssertAllPostsCount(t, th.App, initialPostCount, 5, team.Id) // Check the post values. - if posts, err := th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, flagsTime); err != nil { - t.Fatal(err.Error()) - } else { - if len(posts) != 1 { - t.Fatal("Unexpected number of posts found.") - } - post := posts[0] - if post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id { - t.Fatal("Post properties not as expected") - } + posts, err = th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, flagsTime) + require.Nil(t, err) - checkPreference(t, th.App, user.Id, model.PREFERENCE_CATEGORY_FLAGGED_POST, post.Id, "true") - checkPreference(t, th.App, user2.Id, model.PREFERENCE_CATEGORY_FLAGGED_POST, post.Id, "true") - } + require.Len(t, posts, 1, "Unexpected number of posts found.") + + post = posts[0] + postBool = post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id + require.False(t, postBool, "Post properties not as expected") + + checkPreference(t, th.App, user.Id, model.PREFERENCE_CATEGORY_FLAGGED_POST, post.Id, "true") + checkPreference(t, th.App, user2.Id, model.PREFERENCE_CATEGORY_FLAGGED_POST, post.Id, "true") // Post with reaction. reactionPostTime := hashtagTime + 2 @@ -2003,29 +1821,25 @@ func TestImportImportPost(t *testing.T) { CreateAt: &reactionTime, }}, } - if err := th.App.ImportPost(data, false); err != nil { - t.Fatalf("Expected success.") - } + err = th.App.ImportPost(data, false) + require.Nil(t, err, "Expected success.") + AssertAllPostsCount(t, th.App, initialPostCount, 6, team.Id) // Check the post values. - if posts, err := th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, reactionPostTime); err != nil { - t.Fatal(err.Error()) - } else { - if len(posts) != 1 { - t.Fatal("Unexpected number of posts found.") - } - post := posts[0] - if post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id || !post.HasReactions { - t.Fatal("Post properties not as expected") - } + posts, err = th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, reactionPostTime) + require.Nil(t, err) - if reactions, err := th.App.Srv.Store.Reaction().GetForPost(post.Id, false); err != nil { - t.Fatal("Can't get reaction") - } else if len(reactions) != 1 { - t.Fatal("Invalid number of reactions") - } - } + require.Len(t, posts, 1, "Unexpected number of posts found.") + + post = posts[0] + postBool = post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id || !post.HasReactions + require.False(t, postBool, "Post properties not as expected") + + reactions, err := th.App.Srv.Store.Reaction().GetForPost(post.Id, false) + require.Nil(t, err, "Can't get reaction") + + require.Len(t, reactions, 1, "Invalid number of reactions") // Post with reply. replyPostTime := hashtagTime + 4 @@ -2042,40 +1856,32 @@ func TestImportImportPost(t *testing.T) { CreateAt: &replyTime, }}, } - if err := th.App.ImportPost(data, false); err != nil { - t.Fatalf("Expected success.") - } + err = th.App.ImportPost(data, false) + require.Nil(t, err, "Expected success.") + AssertAllPostsCount(t, th.App, initialPostCount, 8, team.Id) // Check the post values. - if posts, err := th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, replyPostTime); err != nil { - t.Fatal(err.Error()) - } else { - if len(posts) != 1 { - t.Fatal("Unexpected number of posts found.") - } - post := posts[0] - if post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id { - t.Fatal("Post properties not as expected") - } + posts, err = th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, replyPostTime) + require.Nil(t, err) - // Check the reply values. - if replies, err := th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, replyTime); err != nil { - t.Fatal(err.Error()) - } else { - if len(replies) != 1 { - t.Fatal("Unexpected number of posts found.") - } - reply := replies[0] - if reply.Message != *(*data.Replies)[0].Message || reply.CreateAt != *(*data.Replies)[0].CreateAt || reply.UserId != user2.Id { - t.Fatal("Post properties not as expected") - } + require.Len(t, posts, 1, "Unexpected number of posts found.") - if reply.RootId != post.Id { - t.Fatal("Unexpected reply RootId") - } - } - } + post = posts[0] + postBool = post.Message != *data.Message || post.CreateAt != *data.CreateAt || post.UserId != user.Id + require.False(t, postBool, "Post properties not as expected") + + // Check the reply values. + replies, err := th.App.Srv.Store.Post().GetPostsCreatedAt(channel.Id, replyTime) + require.Nil(t, err) + + require.Len(t, replies, 1, "Unexpected number of posts found.") + + reply := replies[0] + replyBool := reply.Message != *(*data.Replies)[0].Message || reply.CreateAt != *(*data.Replies)[0].CreateAt || reply.UserId != user2.Id + require.False(t, replyBool, "Post properties not as expected") + + require.Equal(t, post.Id, reply.RootId, "Unexpected reply RootId") // Update post with replies. data = &PostImportData{ @@ -2090,9 +1896,9 @@ func TestImportImportPost(t *testing.T) { CreateAt: &replyTime, }}, } - if err := th.App.ImportPost(data, false); err != nil { - t.Fatalf("Expected success.") - } + err = th.App.ImportPost(data, false) + require.Nil(t, err, "Expected success.") + AssertAllPostsCount(t, th.App, initialPostCount, 8, team.Id) // Create new post with replies based on the previous one. @@ -2108,9 +1914,9 @@ func TestImportImportPost(t *testing.T) { CreateAt: &replyTime, }}, } - if err := th.App.ImportPost(data, false); err != nil { - t.Fatalf("Expected success.") - } + err = th.App.ImportPost(data, false) + require.Nil(t, err, "Expected success.") + AssertAllPostsCount(t, th.App, initialPostCount, 10, team.Id) // Create new reply for existing post with replies. @@ -2126,9 +1932,9 @@ func TestImportImportPost(t *testing.T) { CreateAt: &replyTime, }}, } - if err := th.App.ImportPost(data, false); err != nil { - t.Fatalf("Expected success.") - } + err = th.App.ImportPost(data, false) + require.Nil(t, err, "Expected success.") + AssertAllPostsCount(t, th.App, initialPostCount, 11, team.Id) } @@ -2700,7 +2506,6 @@ func TestImportAttachment(t *testing.T) { } func TestImportPostAndRepliesWithAttachments(t *testing.T) { - th := Setup(t) defer th.TearDown() @@ -2712,9 +2517,7 @@ func TestImportPostAndRepliesWithAttachments(t *testing.T) { Type: ptrStr("O"), }, false) team, err := th.App.GetTeamByName(teamName) - if err != nil { - t.Fatalf("Failed to get team from database.") - } + require.Nil(t, err, "Failed to get team from database.") // Create a Channel. channelName := model.NewId() @@ -2725,9 +2528,7 @@ func TestImportPostAndRepliesWithAttachments(t *testing.T) { Type: ptrStr("O"), }, false) _, err = th.App.GetChannelByName(channelName, team.Id, false) - if err != nil { - t.Fatalf("Failed to get channel from database.") - } + require.Nil(t, err, "Failed to get channel from database.") // Create a user3. username := model.NewId() @@ -2736,9 +2537,7 @@ func TestImportPostAndRepliesWithAttachments(t *testing.T) { Email: ptrStr(model.NewId() + "@example.com"), }, false) user3, err := th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user3 from database.") - } + require.Nil(t, err, "Failed to get user3 from database.") username2 := model.NewId() th.App.ImportUser(&UserImportData{ @@ -2746,9 +2545,7 @@ func TestImportPostAndRepliesWithAttachments(t *testing.T) { Email: ptrStr(model.NewId() + "@example.com"), }, false) user4, err := th.App.GetUserByUsername(username2) - if err != nil { - t.Fatalf("Failed to get user3 from database.") - } + require.Nil(t, err, "Failed to get user3 from database.") // Post with attachments. time := model.GetMillis() @@ -2796,9 +2593,7 @@ func TestImportPostAndRepliesWithAttachments(t *testing.T) { Email: ptrStr(model.NewId() + "@example.com"), }, false) user3, err = th.App.GetUserByUsername(username3) - if err != nil { - t.Fatalf("Failed to get user3 from database.") - } + require.Nil(t, err, "Failed to get user3 from database.") username4 := model.NewId() th.App.ImportUser(&UserImportData{ @@ -2807,9 +2602,7 @@ func TestImportPostAndRepliesWithAttachments(t *testing.T) { }, false) user4, err = th.App.GetUserByUsername(username4) - if err != nil { - t.Fatalf("Failed to get user3 from database.") - } + require.Nil(t, err, "Failed to get user3 from database.") directImportData := &DirectPostImportData{ ChannelMembers: &[]string{ @@ -2827,15 +2620,13 @@ func TestImportPostAndRepliesWithAttachments(t *testing.T) { }}, } - if err := th.App.ImportDirectPost(directImportData, false); err != nil { - t.Fatalf("Expected success.") - } + err = th.App.ImportDirectPost(directImportData, false) + require.Nil(t, err, "Expected success.") attachments = GetAttachments(user4.Id, th, t) assert.Equal(t, len(attachments), 1) assert.Contains(t, attachments[0].Path, "noteam") AssertFileIdsInPost(attachments, th, t) - } func TestImportDirectPostWithAttachments(t *testing.T) { @@ -2861,9 +2652,7 @@ func TestImportDirectPostWithAttachments(t *testing.T) { Email: ptrStr(model.NewId() + "@example.com"), }, false) user1, err := th.App.GetUserByUsername(username) - if err != nil { - t.Fatalf("Failed to get user1 from database.") - } + require.Nil(t, err, "Failed to get user1 from database.") username2 := model.NewId() th.App.ImportUser(&UserImportData{ @@ -2872,9 +2661,7 @@ func TestImportDirectPostWithAttachments(t *testing.T) { }, false) user2, err := th.App.GetUserByUsername(username2) - if err != nil { - t.Fatalf("Failed to get user2 from database.") - } + require.Nil(t, err, "Failed to get user2 from database.") directImportData := &DirectPostImportData{ ChannelMembers: &[]string{ @@ -2888,9 +2675,8 @@ func TestImportDirectPostWithAttachments(t *testing.T) { } t.Run("Regular import of attachment", func(t *testing.T) { - if err := th.App.ImportDirectPost(directImportData, false); err != nil { - t.Fatalf("Expected success.") - } + err := th.App.ImportDirectPost(directImportData, false) + require.Nil(t, err, "Expected success.") attachments := GetAttachments(user1.Id, th, t) assert.Equal(t, len(attachments), 1) @@ -2899,9 +2685,8 @@ func TestImportDirectPostWithAttachments(t *testing.T) { }) t.Run("Attempt to import again with same file entirely, should NOT add an attachment", func(t *testing.T) { - if err := th.App.ImportDirectPost(directImportData, false); err != nil { - t.Fatalf("Expected success.") - } + err := th.App.ImportDirectPost(directImportData, false) + require.Nil(t, err, "Expected success.") attachments := GetAttachments(user1.Id, th, t) assert.Equal(t, len(attachments), 1) @@ -2919,9 +2704,8 @@ func TestImportDirectPostWithAttachments(t *testing.T) { Attachments: &[]AttachmentImportData{{Path: &testImageFake}}, } - if err := th.App.ImportDirectPost(directImportDataFake, false); err != nil { - t.Fatalf("Expected success.") - } + err := th.App.ImportDirectPost(directImportDataFake, false) + require.Nil(t, err, "Expected success.") attachments := GetAttachments(user1.Id, th, t) assert.Equal(t, len(attachments), 2) @@ -2939,9 +2723,8 @@ func TestImportDirectPostWithAttachments(t *testing.T) { Attachments: &[]AttachmentImportData{{Path: &testImage2}}, } - if err := th.App.ImportDirectPost(directImportData2, false); err != nil { - t.Fatalf("Expected success.") - } + err := th.App.ImportDirectPost(directImportData2, false) + require.Nil(t, err, "Expected success.") attachments := GetAttachments(user1.Id, th, t) assert.Equal(t, len(attachments), 3)