diff --git a/.golangci.yml b/.golangci.yml index 24c9e5b035a..69e9782115c 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -6,7 +6,6 @@ linters: enable: - megacheck - govet - - goconst - gocritic - gocyclo - goerr113 @@ -18,6 +17,7 @@ linters: disable: - scopelint # Obsolete, using exportloopref instead - durationcheck + - goconst presets: - bugs - unused @@ -54,7 +54,6 @@ issues: - path: pkg/migration/* linters: - exhaustive - - goconst - goerr113 - path: pkg/models/task_collection_filter\.go linters: @@ -97,12 +96,6 @@ issues: - musttag - path: pkg/models/task_collection.go text: 'append result not assigned to the same slice' - - text: 'string `label_id` has 3 occurrences, make it a constant' + - path: pkg/modules/migration/ticktick/ticktick_test.go linters: - - goconst - - text: 'string `labels` has 3 occurrences, make it a constant' - linters: - - goconst - - text: 'string `off` has 6 occurrences, make it a constant' - linters: - - goconst + - testifylint diff --git a/magefile.go b/magefile.go index c7b9bf20603..f60700f4afb 100644 --- a/magefile.go +++ b/magefile.go @@ -412,7 +412,7 @@ func checkGolangCiLintInstalled() { mg.Deps(initVars) if err := exec.Command("golangci-lint").Run(); err != nil && strings.Contains(err.Error(), "executable file not found") { fmt.Println("Please manually install golangci-lint by running") - fmt.Println("curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.54.2") + fmt.Println("curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.55.2") os.Exit(1) } } diff --git a/pkg/db/test.go b/pkg/db/test.go index a375d42187d..4ca27c86e58 100644 --- a/pkg/db/test.go +++ b/pkg/db/test.go @@ -26,6 +26,7 @@ import ( "code.vikunja.io/api/pkg/log" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "xorm.io/builder" "xorm.io/xorm" "xorm.io/xorm/names" @@ -93,14 +94,14 @@ func AssertExists(t *testing.T, table string, values map[string]interface{}, cus } else { exists, err = x.Table(table).Where(values).Get(&v) } - assert.NoError(t, err, fmt.Sprintf("Failed to assert entries exist in db, error was: %s", err)) + require.NoError(t, err, fmt.Sprintf("Failed to assert entries exist in db, error was: %s", err)) if !exists { all := []map[string]interface{}{} err = x.Table(table).Find(&all) - assert.NoError(t, err, fmt.Sprintf("Failed to assert entries exist in db, error was: %s", err)) + require.NoError(t, err, fmt.Sprintf("Failed to assert entries exist in db, error was: %s", err)) pretty, err := json.MarshalIndent(all, "", " ") - assert.NoError(t, err, fmt.Sprintf("Failed to assert entries exist in db, error was: %s", err)) + require.NoError(t, err, fmt.Sprintf("Failed to assert entries exist in db, error was: %s", err)) t.Errorf(fmt.Sprintf("Entries %v do not exist in table %s\n\nFound entries instead: %v", values, table, string(pretty))) } @@ -110,13 +111,13 @@ func AssertExists(t *testing.T, table string, values map[string]interface{}, cus func AssertMissing(t *testing.T, table string, values map[string]interface{}) { v := make(map[string]interface{}) exists, err := x.Table(table).Where(values).Exist(&v) - assert.NoError(t, err, fmt.Sprintf("Failed to assert entries don't exist in db, error was: %s", err)) + require.NoError(t, err, fmt.Sprintf("Failed to assert entries don't exist in db, error was: %s", err)) assert.False(t, exists, fmt.Sprintf("Entries %v exist in table %s", values, table)) } // AssertCount checks if a number of entries exists in the database func AssertCount(t *testing.T, table string, where builder.Cond, count int64) { dbCount, err := x.Table(table).Where(where).Count() - assert.NoError(t, err, fmt.Sprintf("Failed to assert count in db, error was: %s", err)) + require.NoError(t, err, fmt.Sprintf("Failed to assert count in db, error was: %s", err)) assert.Equal(t, count, dbCount, fmt.Sprintf("Found %d entries instead of expected %d in table %s", dbCount, count, table)) } diff --git a/pkg/db/test_fixtures.go b/pkg/db/test_fixtures.go index 8b6c1c408df..3b9100b131a 100644 --- a/pkg/db/test_fixtures.go +++ b/pkg/db/test_fixtures.go @@ -22,8 +22,9 @@ import ( "testing" "code.vikunja.io/api/pkg/config" + "github.com/go-testfixtures/testfixtures/v3" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "xorm.io/xorm/schemas" ) @@ -108,5 +109,5 @@ func LoadFixtures() error { // LoadAndAssertFixtures loads all fixtures defined before and asserts they are correctly loaded func LoadAndAssertFixtures(t *testing.T) { err := LoadFixtures() - assert.NoError(t, err) + require.NoError(t, err) } diff --git a/pkg/events/testing.go b/pkg/events/testing.go index d9f84c0524c..cd33959e468 100644 --- a/pkg/events/testing.go +++ b/pkg/events/testing.go @@ -22,8 +22,8 @@ import ( "github.com/ThreeDotsLabs/watermill" "github.com/ThreeDotsLabs/watermill/message" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) var ( @@ -55,9 +55,9 @@ func AssertDispatched(t *testing.T, event Event) { // TestListener takes an event and a listener and calls the listener's Handle method. func TestListener(t *testing.T, event Event, listener Listener) { content, err := json.Marshal(event) - assert.NoError(t, err) + require.NoError(t, err) msg := message.NewMessage(watermill.NewUUID(), content) err = listener.Handle(msg) - assert.NoError(t, err) + require.NoError(t, err) } diff --git a/pkg/files/filehandling.go b/pkg/files/filehandling.go index d98e030379f..91f0d55e6a5 100644 --- a/pkg/files/filehandling.go +++ b/pkg/files/filehandling.go @@ -26,7 +26,7 @@ import ( "code.vikunja.io/api/pkg/modules/keyvalue" "github.com/spf13/afero" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // This file handles storing and retrieving a file for different backends @@ -57,7 +57,7 @@ func InitTestFileFixtures(t *testing.T) { // Init fixture files filename := config.FilesBasePath.GetString() + "/1" err := afero.WriteFile(afs, filename, []byte("testfile1"), 0644) - assert.NoError(t, err) + require.NoError(t, err) } // InitTests handles the actual bootstrapping of the test env diff --git a/pkg/files/files_test.go b/pkg/files/files_test.go index 40ea347eafe..22af6fe437a 100644 --- a/pkg/files/files_test.go +++ b/pkg/files/files_test.go @@ -22,6 +22,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) type testfile struct { @@ -58,12 +59,12 @@ func TestCreate(t *testing.T) { } ta := &testauth{id: 1} createdFile, err := Create(tf, "testfile", 100, ta) - assert.NoError(t, err) + require.NoError(t, err) // Check the file was created correctly file := &File{ID: createdFile.ID} err = file.LoadFileMetaByID() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, int64(1), file.CreatedByID) assert.Equal(t, "testfile", file.Name) assert.Equal(t, uint64(100), file.Size) @@ -76,7 +77,7 @@ func TestCreate(t *testing.T) { } ta := &testauth{id: 1} _, err := Create(tf, "testfile", 99999999999, ta) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrFileIsTooLarge(err)) }) } @@ -86,13 +87,13 @@ func TestFile_Delete(t *testing.T) { initFixtures(t) f := &File{ID: 1} err := f.Delete() - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("Nonexisting", func(t *testing.T) { initFixtures(t) f := &File{ID: 9999} err := f.Delete() - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrFileDoesNotExist(err)) }) } @@ -102,13 +103,13 @@ func TestFile_LoadFileByID(t *testing.T) { initFixtures(t) f := &File{ID: 1} err := f.LoadFileByID() - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("Nonexisting", func(t *testing.T) { initFixtures(t) f := &File{ID: 9999} err := f.LoadFileByID() - assert.Error(t, err) + require.Error(t, err) assert.True(t, os.IsNotExist(err)) }) } @@ -118,14 +119,14 @@ func TestFile_LoadFileMetaByID(t *testing.T) { initFixtures(t) f := &File{ID: 1} err := f.LoadFileMetaByID() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "test", f.Name) }) t.Run("Nonexisting", func(t *testing.T) { initFixtures(t) f := &File{ID: 9999} err := f.LoadFileMetaByID() - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrFileDoesNotExist(err)) }) } diff --git a/pkg/integrations/api_tokens_test.go b/pkg/integrations/api_tokens_test.go index 4ccde721f59..7fde9e00141 100644 --- a/pkg/integrations/api_tokens_test.go +++ b/pkg/integrations/api_tokens_test.go @@ -28,12 +28,13 @@ import ( "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestAPIToken(t *testing.T) { t.Run("valid token", func(t *testing.T) { e, err := setupTestEnv() - assert.NoError(t, err) + require.NoError(t, err) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) res := httptest.NewRecorder() c := e.NewContext(req, res) @@ -47,13 +48,13 @@ func TestAPIToken(t *testing.T) { }) req.Header.Set(echo.HeaderAuthorization, "Bearer tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e") // Token 1 - assert.NoError(t, h(c)) + require.NoError(t, h(c)) // check if the request handlers "see" the request as if it came directly from that user assert.Contains(t, res.Body.String(), `"username":"user1"`) }) t.Run("invalid token", func(t *testing.T) { e, err := setupTestEnv() - assert.NoError(t, err) + require.NoError(t, err) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) res := httptest.NewRecorder() c := e.NewContext(req, res) @@ -62,11 +63,11 @@ func TestAPIToken(t *testing.T) { }) req.Header.Set(echo.HeaderAuthorization, "Bearer tk_loremipsumdolorsitamet") - assert.Error(t, h(c)) + require.Error(t, h(c)) }) t.Run("expired token", func(t *testing.T) { e, err := setupTestEnv() - assert.NoError(t, err) + require.NoError(t, err) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) res := httptest.NewRecorder() c := e.NewContext(req, res) @@ -75,11 +76,11 @@ func TestAPIToken(t *testing.T) { }) req.Header.Set(echo.HeaderAuthorization, "Bearer tk_a5e6f92ddbad68f49ee2c63e52174db0235008c8") // Token 2 - assert.Error(t, h(c)) + require.Error(t, h(c)) }) t.Run("valid token, invalid scope", func(t *testing.T) { e, err := setupTestEnv() - assert.NoError(t, err) + require.NoError(t, err) req := httptest.NewRequest(http.MethodGet, "/api/v1/projects", nil) res := httptest.NewRecorder() c := e.NewContext(req, res) @@ -88,11 +89,11 @@ func TestAPIToken(t *testing.T) { }) req.Header.Set(echo.HeaderAuthorization, "Bearer tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e") - assert.Error(t, h(c)) + require.Error(t, h(c)) }) t.Run("jwt", func(t *testing.T) { e, err := setupTestEnv() - assert.NoError(t, err) + require.NoError(t, err) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) res := httptest.NewRecorder() c := e.NewContext(req, res) @@ -103,11 +104,11 @@ func TestAPIToken(t *testing.T) { s := db.NewSession() defer s.Close() u, err := user.GetUserByID(s, 1) - assert.NoError(t, err) + require.NoError(t, err) jwt, err := auth.NewUserJWTAuthtoken(u, false) - assert.NoError(t, err) + require.NoError(t, err) req.Header.Set(echo.HeaderAuthorization, "Bearer "+jwt) - assert.NoError(t, h(c)) + require.NoError(t, h(c)) }) } diff --git a/pkg/integrations/archived_test.go b/pkg/integrations/archived_test.go index c9e3b355805..86559259dbe 100644 --- a/pkg/integrations/archived_test.go +++ b/pkg/integrations/archived_test.go @@ -21,7 +21,9 @@ import ( "code.vikunja.io/api/pkg/models" "code.vikunja.io/web/handler" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // This tests the following behaviour: @@ -96,47 +98,47 @@ func TestArchived(t *testing.T) { t.Run("task", func(t *testing.T) { t.Run("edit task", func(t *testing.T) { _, err := testTaskHandler.testUpdateWithUser(nil, map[string]string{"projecttask": taskID}, `{"title":"TestIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("delete", func(t *testing.T) { _, err := testTaskHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("add new labels", func(t *testing.T) { _, err := testLabelHandler.testCreateWithUser(nil, map[string]string{"projecttask": taskID}, `{"label_id":1}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("remove lables", func(t *testing.T) { _, err := testLabelHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID, "label": "4"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("add assignees", func(t *testing.T) { _, err := testAssigneeHandler.testCreateWithUser(nil, map[string]string{"projecttask": taskID}, `{"user_id":3}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("remove assignees", func(t *testing.T) { _, err := testAssigneeHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID, "user": "2"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("add relation", func(t *testing.T) { _, err := testRelationHandler.testCreateWithUser(nil, map[string]string{"task": taskID}, `{"other_task_id":1,"relation_kind":"related"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("remove relation", func(t *testing.T) { _, err := testRelationHandler.testDeleteWithUser(nil, map[string]string{"task": taskID}, `{"other_task_id":2,"relation_kind":"related"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("add comment", func(t *testing.T) { _, err := testCommentHandler.testCreateWithUser(nil, map[string]string{"task": taskID}, `{"comment":"Lorem"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) t.Run("remove comment", func(t *testing.T) { @@ -145,7 +147,7 @@ func TestArchived(t *testing.T) { commentID = "16" } _, err := testCommentHandler.testDeleteWithUser(nil, map[string]string{"task": taskID, "commentid": commentID}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, errCode) }) }) @@ -155,17 +157,17 @@ func TestArchived(t *testing.T) { t.Run("archived parent project", func(t *testing.T) { t.Run("not editable", func(t *testing.T) { _, err := testProjectHandler.testUpdateWithUser(nil, map[string]string{"project": "21"}, `{"title":"TestIpsum","is_archived":true}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived) }) t.Run("no new tasks", func(t *testing.T) { _, err := testTaskHandler.testCreateWithUser(nil, map[string]string{"project": "21"}, `{"title":"Lorem"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived) }) t.Run("not unarchivable", func(t *testing.T) { _, err := testProjectHandler.testUpdateWithUser(nil, map[string]string{"project": "21"}, `{"title":"LoremIpsum","is_archived":false}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived) }) @@ -175,17 +177,17 @@ func TestArchived(t *testing.T) { t.Run("archived individually", func(t *testing.T) { t.Run("not editable", func(t *testing.T) { _, err := testProjectHandler.testUpdateWithUser(nil, map[string]string{"project": "22"}, `{"title":"TestIpsum","is_archived":true}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived) }) t.Run("no new tasks", func(t *testing.T) { _, err := testTaskHandler.testCreateWithUser(nil, map[string]string{"project": "22"}, `{"title":"Lorem"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived) }) t.Run("unarchivable", func(t *testing.T) { rec, err := testProjectHandler.testUpdateWithUser(nil, map[string]string{"project": "22"}, `{"title":"LoremIpsum","is_archived":false}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"is_archived":false`) }) diff --git a/pkg/integrations/caldav_test.go b/pkg/integrations/caldav_test.go index a1cc8e68ec9..671de1c06c1 100644 --- a/pkg/integrations/caldav_test.go +++ b/pkg/integrations/caldav_test.go @@ -21,14 +21,16 @@ import ( "testing" "code.vikunja.io/api/pkg/routes/caldav" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestCaldav(t *testing.T) { t.Run("Delivers VTODO for project", func(t *testing.T) { e, _ := setupTestEnv() rec, err := newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.ProjectHandler, &testuser15, ``, nil, map[string]string{"project": "36"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), "BEGIN:VCALENDAR") assert.Contains(t, rec.Body.String(), "PRODID:-//Vikunja Todo App//EN") assert.Contains(t, rec.Body.String(), "X-WR-CALNAME:Project 36 for Caldav tests") @@ -59,13 +61,13 @@ END:VCALENDAR` e, _ := setupTestEnv() rec, err := newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, vtodo, nil, map[string]string{"project": "36", "task": "uid"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 201, rec.Result().StatusCode) }) t.Run("Export VTODO", func(t *testing.T) { e, _ := setupTestEnv() rec, err := newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), "BEGIN:VCALENDAR") assert.Contains(t, rec.Body.String(), "SUMMARY:Title Caldav Test") assert.Contains(t, rec.Body.String(), "DESCRIPTION:Description Caldav Test") @@ -123,21 +125,21 @@ END:VTODO` const parentVTODO = vtodoHeader + vtodoParentTaskStub + vtodoFooter rec, err := newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, parentVTODO, nil, map[string]string{"project": "36", "task": "uid_parent_import"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 201, rec.Result().StatusCode) const childVTODO = vtodoHeader + vtodoChildTaskStub + vtodoFooter rec, err = newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, childVTODO, nil, map[string]string{"project": "36", "task": "uid_child_import"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 201, rec.Result().StatusCode) const grandChildVTODO = vtodoHeader + vtodoGrandChildTaskStub + vtodoFooter rec, err = newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, grandChildVTODO, nil, map[string]string{"project": "36", "task": "uid_grand_child_import"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 201, rec.Result().StatusCode) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.ProjectHandler, &testuser15, ``, nil, map[string]string{"project": "36"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 200, rec.Result().StatusCode) assert.Contains(t, rec.Body.String(), "UID:uid_parent_import") @@ -164,7 +166,7 @@ END:VTODO` const grandChildVTODO = vtodoHeader + vtodoGrandChildTaskStub + vtodoFooter rec, err := newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, grandChildVTODO, nil, map[string]string{"project": "36", "task": "uid_grand_child_import"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 201, rec.Result().StatusCode) const vtodoChildTaskStub = `BEGIN:VTODO @@ -179,7 +181,7 @@ END:VTODO` const childVTODO = vtodoHeader + vtodoChildTaskStub + vtodoFooter rec, err = newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, childVTODO, nil, map[string]string{"project": "36", "task": "uid_child_import"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 201, rec.Result().StatusCode) const vtodoParentTaskStub = `BEGIN:VTODO @@ -193,11 +195,11 @@ END:VTODO` const parentVTODO = vtodoHeader + vtodoParentTaskStub + vtodoFooter rec, err = newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, parentVTODO, nil, map[string]string{"project": "36", "task": "uid_parent_import"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 201, rec.Result().StatusCode) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.ProjectHandler, &testuser15, ``, nil, map[string]string{"project": "36"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 200, rec.Result().StatusCode) assert.Contains(t, rec.Body.String(), "UID:uid_parent_import") @@ -213,15 +215,15 @@ END:VTODO` e, _ := setupTestEnv() rec, err := newCaldavTestRequestWithUser(t, e, http.MethodDelete, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-child-task"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 204, rec.Result().StatusCode) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodDelete, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-child-task-2"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 204, rec.Result().StatusCode) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-parent-task"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 200, rec.Result().StatusCode) assert.NotContains(t, rec.Body.String(), "RELATED-TO;RELTYPE=CHILD:uid-caldav-test-child-task") @@ -232,11 +234,11 @@ END:VTODO` e, _ := setupTestEnv() rec, err := newCaldavTestRequestWithUser(t, e, http.MethodDelete, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-parent-task"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 204, rec.Result().StatusCode) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-child-task"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 200, rec.Result().StatusCode) assert.NotContains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task") @@ -280,22 +282,22 @@ END:VCALENDAR` e, _ := setupTestEnv() rec, err := newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, vtodoParentTask, nil, map[string]string{"project": "36", "task": "uid_parent_import"}) - assert.NoError(t, err) - assert.Equal(t, rec.Result().StatusCode, 201) + require.NoError(t, err) + assert.Equal(t, 201, rec.Result().StatusCode) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, vtodoChildTask, nil, map[string]string{"project": "38", "task": "uid_child_import"}) - assert.NoError(t, err) - assert.Equal(t, rec.Result().StatusCode, 201) + require.NoError(t, err) + assert.Equal(t, 201, rec.Result().StatusCode) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid_parent_import"}) - assert.NoError(t, err) - assert.Equal(t, rec.Result().StatusCode, 200) + require.NoError(t, err) + assert.Equal(t, 200, rec.Result().StatusCode) assert.Contains(t, rec.Body.String(), "UID:uid_parent_import") assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=CHILD:uid_child_import") rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "38", "task": "uid_child_import"}) - assert.NoError(t, err) - assert.Equal(t, rec.Result().StatusCode, 200) + require.NoError(t, err) + assert.Equal(t, 200, rec.Result().StatusCode) assert.Contains(t, rec.Body.String(), "UID:uid_child_import") assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid_parent_import") }) @@ -304,14 +306,14 @@ END:VCALENDAR` e, _ := setupTestEnv() rec, err := newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-parent-task-another-list"}) - assert.NoError(t, err) - assert.Equal(t, rec.Result().StatusCode, 200) + require.NoError(t, err) + assert.Equal(t, 200, rec.Result().StatusCode) assert.Contains(t, rec.Body.String(), "UID:uid-caldav-test-parent-task-another-list") assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=CHILD:uid-caldav-test-child-task-another-list") rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "38", "task": "uid-caldav-test-child-task-another-list"}) - assert.NoError(t, err) - assert.Equal(t, rec.Result().StatusCode, 200) + require.NoError(t, err) + assert.Equal(t, 200, rec.Result().StatusCode) assert.Contains(t, rec.Body.String(), "UID:uid-caldav-test-child-task-another-list") assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task-another-list") }) diff --git a/pkg/integrations/healthcheck_test.go b/pkg/integrations/healthcheck_test.go index ded69c42d23..0dd933b818e 100644 --- a/pkg/integrations/healthcheck_test.go +++ b/pkg/integrations/healthcheck_test.go @@ -21,13 +21,15 @@ import ( "testing" "code.vikunja.io/api/pkg/routes" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestHealthcheck(t *testing.T) { t.Run("healthcheck", func(t *testing.T) { rec, err := newTestRequest(t, http.MethodGet, routes.HealthcheckHandler, ``, nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), "OK") }) } diff --git a/pkg/integrations/integrations.go b/pkg/integrations/integrations.go index 205184bd0b5..9f760b45c16 100644 --- a/pkg/integrations/integrations.go +++ b/pkg/integrations/integrations.go @@ -37,9 +37,11 @@ import ( "code.vikunja.io/api/pkg/user" "code.vikunja.io/web" "code.vikunja.io/web/handler" + "github.com/golang-jwt/jwt/v5" "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // These are the test users, the same way they are in the test database @@ -100,7 +102,7 @@ func createRequest(e *echo.Echo, method string, payload string, queryParam url.V func bootstrapTestRequest(t *testing.T, method string, payload string, queryParam url.Values, urlParams map[string]string) (c echo.Context, rec *httptest.ResponseRecorder) { // Setup e, err := setupTestEnv() - assert.NoError(t, err) + require.NoError(t, err) c, rec = createRequest(e, method, payload, queryParam, urlParams) return @@ -116,24 +118,24 @@ func newTestRequest(t *testing.T, method string, handler func(ctx echo.Context) func addUserTokenToContext(t *testing.T, user *user.User, c echo.Context) { // Get the token as a string token, err := auth.NewUserJWTAuthtoken(user, false) - assert.NoError(t, err) + require.NoError(t, err) // We send the string token through the parsing function to get a valid jwt.Token tken, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) { return []byte(config.ServiceJWTSecret.GetString()), nil }) - assert.NoError(t, err) + require.NoError(t, err) c.Set("user", tken) } func addLinkShareTokenToContext(t *testing.T, share *models.LinkSharing, c echo.Context) { // Get the token as a string token, err := auth.NewLinkShareJWTAuthtoken(share) - assert.NoError(t, err) + require.NoError(t, err) // We send the string token through the parsing function to get a valid jwt.Token tken, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) { return []byte(config.ServiceJWTSecret.GetString()), nil }) - assert.NoError(t, err) + require.NoError(t, err) c.Set("user", tken) } diff --git a/pkg/integrations/kanban_test.go b/pkg/integrations/kanban_test.go index 91e714393ec..e874be3160d 100644 --- a/pkg/integrations/kanban_test.go +++ b/pkg/integrations/kanban_test.go @@ -20,11 +20,12 @@ import ( "testing" "code.vikunja.io/api/pkg/db" - "code.vikunja.io/api/pkg/models" "code.vikunja.io/web/handler" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestBucket(t *testing.T) { @@ -52,7 +53,7 @@ func TestBucket(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `testbucket1`) assert.Contains(t, rec.Body.String(), `testbucket2`) assert.Contains(t, rec.Body.String(), `testbucket3`) @@ -63,87 +64,87 @@ func TestBucket(t *testing.T) { t.Run("Normal", func(t *testing.T) { // Check the project was loaded successfully afterwards, see testReadOneWithUser rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "1"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Nonexisting Bucket", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "9999"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist) }) t.Run("Empty title", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "1"}, `{"title":""}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message.(models.ValidationHTTPError).InvalidFields, "title: non zero value required") }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "5"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "6"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "7"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "8"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "9"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "10"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "11"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "12"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "13"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "14"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "15"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "16"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "17"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) }) @@ -151,82 +152,82 @@ func TestBucket(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "1", "bucket": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"bucket": "999"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "20", "bucket": "5"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "6", "bucket": "6"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "7", "bucket": "7"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "8", "bucket": "8"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "9", "bucket": "9"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "10", "bucket": "10"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "11", "bucket": "11"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "12", "bucket": "12"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "13", "bucket": "13"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "14", "bucket": "14"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "15", "bucket": "15"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "16", "bucket": "16"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "17", "bucket": "17"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) }) @@ -234,88 +235,88 @@ func TestBucket(t *testing.T) { t.Run("Create", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9999"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "6"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "7"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "8"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "12"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "13"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "14"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "15"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "16"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "17"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) }) t.Run("Link Share", func(t *testing.T) { rec, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) db.AssertExists(t, "buckets", map[string]interface{}{ "project_id": 2, diff --git a/pkg/integrations/link_sharing_auth_test.go b/pkg/integrations/link_sharing_auth_test.go index 796ef37d151..bc6e5adea4e 100644 --- a/pkg/integrations/link_sharing_auth_test.go +++ b/pkg/integrations/link_sharing_auth_test.go @@ -22,39 +22,41 @@ import ( "code.vikunja.io/api/pkg/models" apiv1 "code.vikunja.io/api/pkg/routes/api/v1" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestLinkSharingAuth(t *testing.T) { t.Run("Without Password", func(t *testing.T) { rec, err := newTestRequest(t, http.MethodPost, apiv1.AuthenticateLinkShare, ``, nil, map[string]string{"share": "test"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.Contains(t, rec.Body.String(), `"token":"`) assert.Contains(t, rec.Body.String(), `"project_id":1`) }) t.Run("Without Password, Password Provided", func(t *testing.T) { rec, err := newTestRequest(t, http.MethodPost, apiv1.AuthenticateLinkShare, `{"password":"somethingsomething"}`, nil, map[string]string{"share": "test"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.Contains(t, rec.Body.String(), `"token":"`) assert.Contains(t, rec.Body.String(), `"project_id":1`) }) t.Run("With Password, No Password Provided", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.AuthenticateLinkShare, ``, nil, map[string]string{"share": "testWithPassword"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeLinkSharePasswordRequired) }) t.Run("With Password, Password Provided", func(t *testing.T) { rec, err := newTestRequest(t, http.MethodPost, apiv1.AuthenticateLinkShare, `{"password":"1234"}`, nil, map[string]string{"share": "testWithPassword"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.Contains(t, rec.Body.String(), `"token":"`) assert.Contains(t, rec.Body.String(), `"project_id":1`) }) t.Run("With Wrong Password", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.AuthenticateLinkShare, `{"password":"someWrongPassword"}`, nil, map[string]string{"share": "testWithPassword"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeLinkSharePasswordInvalid) }) } diff --git a/pkg/integrations/link_sharing_test.go b/pkg/integrations/link_sharing_test.go index c28d76ba50f..e144817b35d 100644 --- a/pkg/integrations/link_sharing_test.go +++ b/pkg/integrations/link_sharing_test.go @@ -22,8 +22,10 @@ import ( "code.vikunja.io/api/pkg/models" "code.vikunja.io/web/handler" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestLinkSharing(t *testing.T) { @@ -66,68 +68,68 @@ func TestLinkSharing(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { t.Run("read only", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"right":0}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("write", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"right":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("admin", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"right":2}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) t.Run("Read only access", func(t *testing.T) { t.Run("read only", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"right":0}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("write", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"right":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("admin", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"right":2}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) t.Run("Write access", func(t *testing.T) { t.Run("read only", func(t *testing.T) { req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"right":0}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, req.Body.String(), `"hash":`) }) t.Run("write", func(t *testing.T) { req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"right":1}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, req.Body.String(), `"hash":`) }) t.Run("admin", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"right":2}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) t.Run("Admin access", func(t *testing.T) { t.Run("read only", func(t *testing.T) { req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"right":0}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, req.Body.String(), `"hash":`) }) t.Run("write", func(t *testing.T) { req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"right":1}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, req.Body.String(), `"hash":`) }) t.Run("admin", func(t *testing.T) { req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"right":2}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, req.Body.String(), `"hash":`) }) }) @@ -159,7 +161,7 @@ func TestLinkSharing(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandlerProjectReadOnly.testReadAllWithLinkShare(nil, nil) - assert.NoError(t, err) + require.NoError(t, err) // Should only return the shared project, nothing else assert.Contains(t, rec.Body.String(), `Test1`) assert.NotContains(t, rec.Body.String(), `Test2`) @@ -169,7 +171,7 @@ func TestLinkSharing(t *testing.T) { }) t.Run("Search", func(t *testing.T) { rec, err := testHandlerProjectReadOnly.testReadAllWithLinkShare(url.Values{"s": []string{"est1"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) // Should only return the shared project, nothing else assert.Contains(t, rec.Body.String(), `Test1`) assert.NotContains(t, rec.Body.String(), `Test2`) @@ -181,35 +183,35 @@ func TestLinkSharing(t *testing.T) { t.Run("ReadOne", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test1"`) assert.NotContains(t, rec.Body.String(), `"title":"Test2"`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "9999999"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Project 2, not shared with this token _, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "2"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `You don't have the right to see this`) }) t.Run("Shared readonly", func(t *testing.T) { rec, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test1"`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerProjectWrite.testReadOneWithLinkShare(nil, map[string]string{"project": "2"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test2"`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerProjectAdmin.testReadOneWithLinkShare(nil, map[string]string{"project": "3"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test3"`) }) }) @@ -217,28 +219,28 @@ func TestLinkSharing(t *testing.T) { t.Run("Update", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "9999999"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "1"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerProjectWrite.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"TestLoremIpsum","namespace_id":1}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerProjectAdmin.testUpdateWithLinkShare(nil, map[string]string{"project": "3"}, `{"title":"TestLoremIpsum","namespace_id":2}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) }) @@ -246,28 +248,28 @@ func TestLinkSharing(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "9999999"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectWrite.testDeleteWithLinkShare(nil, map[string]string{"project": "2"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerProjectAdmin.testDeleteWithLinkShare(nil, map[string]string{"project": "3"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) }) @@ -277,23 +279,23 @@ func TestLinkSharing(t *testing.T) { t.Run("Create", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testCreateWithLinkShare(nil, nil, `{"title":"Lorem"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Rights check", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectReadOnly.testCreateWithLinkShare(nil, map[string]string{"namespace": "1"}, `{"title":"Lorem","description":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectWrite.testCreateWithLinkShare(nil, map[string]string{"namespace": "2"}, `{"title":"Lorem","description":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerProjectAdmin.testCreateWithLinkShare(nil, map[string]string{"namespace": "3"}, `{"title":"Lorem","description":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) @@ -325,51 +327,51 @@ func TestLinkSharing(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { rec, err := testHandlerProjectUserReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[]`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerProjectUserWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[]`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerProjectUserAdmin.testReadAllWithLinkShare(nil, map[string]string{"project": "3"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"username":"user1"`) }) }) t.Run("Create", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectUserReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{"user_id":"user1"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectUserWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"user_id":"user1"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerProjectUserAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{"user_id":"user1"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) t.Run("Update", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectUserReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "1"}, `{"user_id":"user1"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectUserWrite.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"user_id":"user1"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerProjectUserAdmin.testUpdateWithLinkShare(nil, map[string]string{"project": "3"}, `{"user_id":"user1"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) @@ -377,17 +379,17 @@ func TestLinkSharing(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectUserReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectUserWrite.testDeleteWithLinkShare(nil, map[string]string{"project": "2"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerProjectUserAdmin.testDeleteWithLinkShare(nil, map[string]string{"project": "3"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) @@ -417,51 +419,51 @@ func TestLinkSharing(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { rec, err := testHandlerProjectTeamReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[]`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerProjectTeamWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[]`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerProjectTeamAdmin.testReadAllWithLinkShare(nil, map[string]string{"project": "3"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"name":"testteam1"`) }) }) t.Run("Create", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectTeamReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{"team_id":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectTeamWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"team_id":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerProjectTeamAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{"team_id":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) t.Run("Update", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectTeamReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "1"}, `{"team_id":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectTeamWrite.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"team_id":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerProjectTeamAdmin.testUpdateWithLinkShare(nil, map[string]string{"project": "3"}, `{"team_id":1}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) @@ -469,17 +471,17 @@ func TestLinkSharing(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerProjectTeamReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerProjectTeamWrite.testDeleteWithLinkShare(nil, map[string]string{"project": "2"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerProjectTeamAdmin.testDeleteWithLinkShare(nil, map[string]string{"project": "3"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) @@ -533,7 +535,7 @@ func TestLinkSharing(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { rec, err := testHandlerTaskReadOnlyCollection.testReadAllWithLinkShare(nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `task #1`) assert.Contains(t, rec.Body.String(), `task #2`) assert.Contains(t, rec.Body.String(), `task #3`) @@ -551,7 +553,7 @@ func TestLinkSharing(t *testing.T) { }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerTaskWriteCollection.testReadAllWithLinkShare(nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #2`) assert.NotContains(t, rec.Body.String(), `task #3"`) assert.NotContains(t, rec.Body.String(), `task #4`) @@ -568,7 +570,7 @@ func TestLinkSharing(t *testing.T) { }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerTaskAdminCollection.testReadAllWithLinkShare(nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #2`) assert.NotContains(t, rec.Body.String(), `task #4`) assert.NotContains(t, rec.Body.String(), `task #5`) @@ -587,34 +589,34 @@ func TestLinkSharing(t *testing.T) { t.Run("Create", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerTaskReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerTaskWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerTaskAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) }) t.Run("Update", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerTaskReadOnly.testUpdateWithLinkShare(nil, map[string]string{"projecttask": "1"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerTaskWrite.testUpdateWithLinkShare(nil, map[string]string{"projecttask": "13"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerTaskAdmin.testUpdateWithLinkShare(nil, map[string]string{"projecttask": "32"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) @@ -622,17 +624,17 @@ func TestLinkSharing(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerTaskReadOnly.testDeleteWithLinkShare(nil, map[string]string{"projecttask": "1"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerTaskWrite.testDeleteWithLinkShare(nil, map[string]string{"projecttask": "13"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerTaskAdmin.testDeleteWithLinkShare(nil, map[string]string{"projecttask": "32"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) }) @@ -663,34 +665,34 @@ func TestLinkSharing(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerTeamReadOnly.testReadAllWithLinkShare(nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerTeamWrite.testReadAllWithLinkShare(nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerTeamAdmin.testReadAllWithLinkShare(nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) }) }) t.Run("Update", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerTeamReadOnly.testUpdateWithLinkShare(nil, map[string]string{"team": "1"}, `{"name":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerTeamWrite.testUpdateWithLinkShare(nil, map[string]string{"team": "2"}, `{"name":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerTeamAdmin.testUpdateWithLinkShare(nil, map[string]string{"team": "3"}, `{"name":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) @@ -698,17 +700,17 @@ func TestLinkSharing(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerTeamReadOnly.testDeleteWithLinkShare(nil, map[string]string{"team": "1"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerTeamWrite.testDeleteWithLinkShare(nil, map[string]string{"team": "2"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerTeamAdmin.testDeleteWithLinkShare(nil, map[string]string{"team": "3"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) @@ -739,51 +741,51 @@ func TestLinkSharing(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { rec, err := testHandlerLinkShareReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"hash":"test"`) }) t.Run("Shared write", func(t *testing.T) { rec, err := testHandlerLinkShareWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"hash":"test2"`) }) t.Run("Shared admin", func(t *testing.T) { rec, err := testHandlerLinkShareAdmin.testReadAllWithLinkShare(nil, map[string]string{"project": "3"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"hash":"test3"`) }) }) t.Run("Create", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerLinkShareReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerLinkShareAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) t.Run("Update", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerLinkShareReadOnly.testUpdateWithLinkShare(nil, map[string]string{"share": "1"}, `{}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerLinkShareWrite.testUpdateWithLinkShare(nil, map[string]string{"share": "2"}, `{}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerLinkShareAdmin.testUpdateWithLinkShare(nil, map[string]string{"share": "3"}, `{}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) @@ -791,17 +793,17 @@ func TestLinkSharing(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) { _, err := testHandlerLinkShareReadOnly.testDeleteWithLinkShare(nil, map[string]string{"share": "1"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared write", func(t *testing.T) { _, err := testHandlerLinkShareWrite.testDeleteWithLinkShare(nil, map[string]string{"share": "2"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared admin", func(t *testing.T) { _, err := testHandlerLinkShareAdmin.testDeleteWithLinkShare(nil, map[string]string{"share": "3"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) diff --git a/pkg/integrations/login_test.go b/pkg/integrations/login_test.go index 6a9fa383464..f8e9be9f18c 100644 --- a/pkg/integrations/login_test.go +++ b/pkg/integrations/login_test.go @@ -22,7 +22,9 @@ import ( apiv1 "code.vikunja.io/api/pkg/routes/api/v1" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestLogin(t *testing.T) { @@ -31,12 +33,12 @@ func TestLogin(t *testing.T) { "username": "user1", "password": "1234" }`, nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), "token") }) t.Run("Empty payload", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.Login, `{}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) }) t.Run("Not existing user", func(t *testing.T) { @@ -44,7 +46,7 @@ func TestLogin(t *testing.T) { "username": "userWichDoesNotExist", "password": "1234" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword) }) t.Run("Wrong password", func(t *testing.T) { @@ -52,7 +54,7 @@ func TestLogin(t *testing.T) { "username": "user1", "password": "wrong" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword) }) t.Run("user with unconfirmed email", func(t *testing.T) { @@ -60,7 +62,7 @@ func TestLogin(t *testing.T) { "username": "user5", "password": "1234" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeEmailNotConfirmed) }) } diff --git a/pkg/integrations/project_test.go b/pkg/integrations/project_test.go index b0352009338..cb17df4f070 100644 --- a/pkg/integrations/project_test.go +++ b/pkg/integrations/project_test.go @@ -22,8 +22,10 @@ import ( "code.vikunja.io/api/pkg/models" "code.vikunja.io/web/handler" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestProject(t *testing.T) { @@ -37,7 +39,7 @@ func TestProject(t *testing.T) { t.Run("ReadAll", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Test1`) assert.NotContains(t, rec.Body.String(), `Test2"`) assert.Contains(t, rec.Body.String(), `Test3`) // Shared directly via users_project @@ -47,7 +49,7 @@ func TestProject(t *testing.T) { }) t.Run("Search", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"Test1"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Test1`) assert.NotContains(t, rec.Body.String(), `Test2`) assert.NotContains(t, rec.Body.String(), `Test3`) @@ -56,7 +58,7 @@ func TestProject(t *testing.T) { }) t.Run("Normal with archived projects", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"is_archived": []string{"true"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Test1`) assert.NotContains(t, rec.Body.String(), `Test2"`) assert.Contains(t, rec.Body.String(), `Test3`) // Shared directly via users_project @@ -69,7 +71,7 @@ func TestProject(t *testing.T) { t.Run("ReadOne", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test1"`) assert.NotContains(t, rec.Body.String(), `"title":"Test2"`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1,"name":"","username":"user1",`) @@ -79,89 +81,89 @@ func TestProject(t *testing.T) { }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "9999"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "20"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `You don't have the right to see this`) assert.Empty(t, rec.Result().Header.Get("x-max-rights")) }) t.Run("Shared Via Team readonly", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "6"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test6"`) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "7"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test7"`) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "8"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test8"`) assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via User readonly", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "9"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test9"`) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "10"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test10"`) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "11"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test11"`) assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "12"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test12"`) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "13"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test13"`) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "14"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test14"`) assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "15"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test15"`) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "16"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test16"`) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "17"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Test17"`) assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) }) @@ -171,100 +173,100 @@ func TestProject(t *testing.T) { t.Run("Normal", func(t *testing.T) { // Check the project was loaded successfully afterwards, see testReadOneWithUser rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "1"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) // The description should not be updated but returned correctly assert.Contains(t, rec.Body.String(), `description":"Lorem Ipsum`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "9999"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Normal with updating the description", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "1"}, `{"title":"TestLoremIpsum","description":"Lorem Ipsum dolor sit amet"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) assert.Contains(t, rec.Body.String(), `"description":"Lorem Ipsum dolor sit amet`) }) t.Run("Empty title", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "1"}, `{"title":""}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message.(models.ValidationHTTPError).InvalidFields, "title: non zero value required") }) t.Run("Title too long", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea taki"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message.(models.ValidationHTTPError).InvalidFields[0], "does not validate as runelength(1|250)") }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "20"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "6"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "7"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "8"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "9"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "10"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "11"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "12"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "13"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "14"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "15"}, `{"title":"TestLoremIpsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "16"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "17"}, `{"title":"TestLoremIpsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`) }) }) @@ -272,82 +274,82 @@ func TestProject(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "999"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "20"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "6"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "7"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "8"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "9"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "10"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "11"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "12"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "13"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "14"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "15"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "16"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "17"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`) }) }) @@ -356,7 +358,7 @@ func TestProject(t *testing.T) { t.Run("Normal", func(t *testing.T) { // Check the project was loaded successfully after update, see testReadOneWithUser rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem"`) assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) @@ -364,7 +366,7 @@ func TestProject(t *testing.T) { }) t.Run("Normal with description", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","description":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem"`) assert.Contains(t, rec.Body.String(), `"description":"Lorem Ipsum"`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) @@ -372,34 +374,34 @@ func TestProject(t *testing.T) { }) t.Run("Nonexisting parent project", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":99999}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Empty title", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, nil, `{"title":""}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message.(models.ValidationHTTPError).InvalidFields, "title: non zero value required") }) t.Run("Title too long", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea taki"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message.(models.ValidationHTTPError).InvalidFields[0], "does not validate as runelength(1|250)") }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":20}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":32}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":33}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem"`) assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) @@ -407,7 +409,7 @@ func TestProject(t *testing.T) { }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":34}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem"`) assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) @@ -416,12 +418,12 @@ func TestProject(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":9}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":10}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem"`) assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) @@ -429,7 +431,7 @@ func TestProject(t *testing.T) { }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"namespace": "12"}, `{"title":"Lorem","parent_project_id":11}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem"`) assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) diff --git a/pkg/integrations/register_test.go b/pkg/integrations/register_test.go index 41001dab906..1eb303c4be5 100644 --- a/pkg/integrations/register_test.go +++ b/pkg/integrations/register_test.go @@ -22,7 +22,9 @@ import ( apiv1 "code.vikunja.io/api/pkg/routes/api/v1" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestRegister(t *testing.T) { @@ -32,12 +34,12 @@ func TestRegister(t *testing.T) { "password": "12345678", "email": "email@example.com" }`, nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"username":"newUser"`) }) t.Run("Empty payload", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.RegisterUser, `{}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) }) t.Run("Empty username", func(t *testing.T) { @@ -46,7 +48,7 @@ func TestRegister(t *testing.T) { "password": "12345678", "email": "email@example.com" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) }) t.Run("Empty password", func(t *testing.T) { @@ -55,7 +57,7 @@ func TestRegister(t *testing.T) { "password": "", "email": "email@example.com" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) }) t.Run("Empty email", func(t *testing.T) { @@ -64,7 +66,7 @@ func TestRegister(t *testing.T) { "password": "12345678", "email": "" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) }) t.Run("Already existing username", func(t *testing.T) { @@ -73,7 +75,7 @@ func TestRegister(t *testing.T) { "password": "12345678", "email": "email@example.com" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrorCodeUsernameExists) }) t.Run("Already existing email", func(t *testing.T) { @@ -82,7 +84,7 @@ func TestRegister(t *testing.T) { "password": "12345678", "email": "user1@example.com" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrorCodeUserEmailExists) }) } diff --git a/pkg/integrations/task_collection_test.go b/pkg/integrations/task_collection_test.go index 1c1933bb00e..3e507cedf70 100644 --- a/pkg/integrations/task_collection_test.go +++ b/pkg/integrations/task_collection_test.go @@ -22,7 +22,9 @@ import ( "code.vikunja.io/api/pkg/models" "code.vikunja.io/web/handler" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTaskCollection(t *testing.T) { @@ -39,7 +41,7 @@ func TestTaskCollection(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(nil, urlParams) - assert.NoError(t, err) + require.NoError(t, err) // Not using assert.Equal to avoid having the tests break every time we add new fixtures assert.Contains(t, rec.Body.String(), `task #1`) assert.Contains(t, rec.Body.String(), `task #2 `) @@ -73,7 +75,7 @@ func TestTaskCollection(t *testing.T) { }) t.Run("Search", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"task #6"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -91,7 +93,7 @@ func TestTaskCollection(t *testing.T) { }) t.Run("Search case insensitive", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"tASk #6"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -112,65 +114,65 @@ func TestTaskCollection(t *testing.T) { // should equal priority asc t.Run("by priority", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `{"id":33,"title":"task #33 with percent done","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0.5,"identifier":"test1-17","index":17,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}]`) }) t.Run("by priority desc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"desc"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":3,"title":"task #3 high prio","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":100,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-3","index":3,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":2,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":4,"title":"task #4 low prio","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":1`) }) t.Run("by priority asc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"asc"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `{"id":33,"title":"task #33 with percent done","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0.5,"identifier":"test1-17","index":17,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}]`) }) // should equal duedate asc t.Run("by due_date", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":6,"title":"task #6 lower due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-11-30T22:25:24Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-6","index":6,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":3,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}`) }) t.Run("by duedate desc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}, "order_by": []string{"desc"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":5,"title":"task #5 higher due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-12-01T03:58:44Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-5","index":5,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":2,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":6,"title":"task #6 lower due date`) }) // Due date without unix suffix t.Run("by duedate asc without suffix", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}, "order_by": []string{"asc"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":6,"title":"task #6 lower due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-11-30T22:25:24Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-6","index":6,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":3,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}`) }) t.Run("by due_date without suffix", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":6,"title":"task #6 lower due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-11-30T22:25:24Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-6","index":6,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":3,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}`) }) t.Run("by duedate desc without suffix", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}, "order_by": []string{"desc"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":5,"title":"task #5 higher due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-12-01T03:58:44Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-5","index":5,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":2,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":6,"title":"task #6 lower due date`) }) t.Run("by duedate asc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}, "order_by": []string{"asc"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":6,"title":"task #6 lower due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-11-30T22:25:24Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-6","index":6,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":3,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}`) }) t.Run("invalid sort parameter", func(t *testing.T) { _, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"loremipsum"}}, urlParams) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskField) }) t.Run("invalid sort order", func(t *testing.T) { _, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"id"}, "order_by": []string{"loremipsum"}}, urlParams) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeInvalidSortOrder) }) t.Run("invalid parameter", func(t *testing.T) { // Invalid parameter should not sort at all rec, err := testHandler.testReadAllWithUser(url.Values{"sort": []string{"loremipsum"}}, urlParams) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `[{"id":3,"title":"task #3 high prio","description":"","done":false,"due_date":0,"reminders":null,"repeat_after":0,"repeat_mode":0,"priority":100,"start_date":0,"end_date":0,"assignees":null,"labels":null,"hex_color":"","created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}},{"id":4,"title":"task #4 low prio","description":"","done":false,"due_date":0,"repeat_after":0,"repeat_mode":0,"priority":1`) assert.NotContains(t, rec.Body.String(), `{"id":4,"title":"task #4 low prio","description":"","done":false,"due_date":0,"reminders":null,"repeat_after":0,"repeat_mode":0,"priority":1,"start_date":0,"end_date":0,"assignees":null,"labels":null,"hex_color":"","created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}},{"id":3,"title":"task #3 high prio","description":"","done":false,"due_date":0,"repeat_after":0,"repeat_mode":0,"priority":100,"start_date":0,"end_date":0,"assignees":null,"labels":null,"created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}}]`) assert.NotContains(t, rec.Body.String(), `[{"id":5,"title":"task #5 higher due date","description":"","done":false,"due_date":1543636724,"reminders":null,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":0,"end_date":0,"assignees":null,"labels":null,"hex_color":"","created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}},{"id":6,"title":"task #6 lower due date"`) @@ -188,7 +190,7 @@ func TestTaskCollection(t *testing.T) { }, urlParams, ) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -213,7 +215,7 @@ func TestTaskCollection(t *testing.T) { }, urlParams, ) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -238,7 +240,7 @@ func TestTaskCollection(t *testing.T) { }, urlParams, ) - assert.NoError(t, err) + require.NoError(t, err) // If no start date but an end date is specified, this should be null // since we don't have any tasks in the fixtures with an end date > // the current date. @@ -253,7 +255,7 @@ func TestTaskCollection(t *testing.T) { }, urlParams, ) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -279,7 +281,7 @@ func TestTaskCollection(t *testing.T) { }, nil, ) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskFilterValue) }) }) @@ -289,7 +291,7 @@ func TestTaskCollection(t *testing.T) { nil, map[string]string{"project": "-2"}, // Actually a saved filter - contains the same filter arguments as the start and end date filter from above ) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -311,7 +313,7 @@ func TestTaskCollection(t *testing.T) { t.Run("ReadAll for all tasks", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(nil, nil) - assert.NoError(t, err) + require.NoError(t, err) // Not using assert.Equal to avoid having the tests break every time we add new fixtures assert.Contains(t, rec.Body.String(), `task #1`) assert.Contains(t, rec.Body.String(), `task #2 `) @@ -345,7 +347,7 @@ func TestTaskCollection(t *testing.T) { }) t.Run("Search", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"task #6"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -365,39 +367,39 @@ func TestTaskCollection(t *testing.T) { // should equal priority asc t.Run("by priority", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `{"id":33,"title":"task #33 with percent done","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0.5,"identifier":"test1-17","index":17,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":35,"title":"task #35","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":21,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":[{"id":2,"name":"","username":"user2","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}],"labels":[{"id":4,"title":"Label #4 - visible via other task","description":"","hex_color":"","created_by":{"id":2,"name":"","username":"user2","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"},"created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}],"hex_color":"","percent_done":0,"identifier":"test21-1","index":1,"related_tasks":{"related":[{"id":1,"title":"task #1","description":"Lorem Ipsum","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"","index":1,"related_tasks":null,"attachments":null,"cover_image_attachment_id":0,"is_favorite":true,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":2,"kanban_position":0,"created_by":null},{"id":1,"title":"task #1","description":"Lorem Ipsum","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"","index":1,"related_tasks":null,"attachments":null,"cover_image_attachment_id":0,"is_favorite":true,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":2,"kanban_position":0,"created_by":null}]},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":19,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}]`) }) t.Run("by priority desc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"desc"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":3,"title":"task #3 high prio","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":100,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-3","index":3,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":2,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":4,"title":"task #4 low prio","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":1`) }) t.Run("by priority asc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"asc"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `{"id":33,"title":"task #33 with percent done","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0.5,"identifier":"test1-17","index":17,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":35,"title":"task #35","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":21,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":[{"id":2,"name":"","username":"user2","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}],"labels":[{"id":4,"title":"Label #4 - visible via other task","description":"","hex_color":"","created_by":{"id":2,"name":"","username":"user2","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"},"created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}],"hex_color":"","percent_done":0,"identifier":"test21-1","index":1,"related_tasks":{"related":[{"id":1,"title":"task #1","description":"Lorem Ipsum","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"","index":1,"related_tasks":null,"attachments":null,"cover_image_attachment_id":0,"is_favorite":true,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":2,"kanban_position":0,"created_by":null},{"id":1,"title":"task #1","description":"Lorem Ipsum","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"0001-01-01T00:00:00Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"","index":1,"related_tasks":null,"attachments":null,"cover_image_attachment_id":0,"is_favorite":true,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":1,"position":2,"kanban_position":0,"created_by":null}]},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":19,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}]`) }) // should equal duedate asc t.Run("by due_date", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":6,"title":"task #6 lower due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-11-30T22:25:24Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-6","index":6,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":3,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":5,"title":"task #5 higher due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-12-01T03:58:44Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-5","index":5,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":2,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}`) }) t.Run("by duedate desc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}, "order_by": []string{"desc"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":5,"title":"task #5 higher due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-12-01T03:58:44Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-5","index":5,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":2,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":6,"title":"task #6 lower due date`) }) t.Run("by duedate asc", func(t *testing.T) { rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}, "order_by": []string{"asc"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `[{"id":6,"title":"task #6 lower due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-11-30T22:25:24Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-6","index":6,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":3,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}},{"id":5,"title":"task #5 higher due date","description":"","done":false,"done_at":"0001-01-01T00:00:00Z","due_date":"2018-12-01T03:58:44Z","reminders":null,"project_id":1,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":"0001-01-01T00:00:00Z","end_date":"0001-01-01T00:00:00Z","assignees":null,"labels":null,"hex_color":"","percent_done":0,"identifier":"test1-5","index":5,"related_tasks":{},"attachments":null,"cover_image_attachment_id":0,"is_favorite":false,"created":"2018-12-01T01:12:04Z","updated":"2018-12-01T01:12:04Z","bucket_id":2,"position":0,"kanban_position":0,"created_by":{"id":1,"name":"","username":"user1","created":"2018-12-01T15:13:12Z","updated":"2018-12-02T15:13:12Z"}}`) }) t.Run("invalid parameter", func(t *testing.T) { // Invalid parameter should not sort at all rec, err := testHandler.testReadAllWithUser(url.Values{"sort": []string{"loremipsum"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `[{"id":3,"title":"task #3 high prio","description":"","done":false,"due_date":0,"reminders":null,"repeat_after":0,"repeat_mode":0,"priority":100,"start_date":0,"end_date":0,"assignees":null,"labels":null,"hex_color":"","created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}},{"id":4,"title":"task #4 low prio","description":"","done":false,"due_date":0,"repeat_after":0,"repeat_mode":0,"priority":1`) assert.NotContains(t, rec.Body.String(), `{"id":4,"title":"task #4 low prio","description":"","done":false,"due_date":0,"reminders":null,"repeat_after":0,"repeat_mode":0,"priority":1,"start_date":0,"end_date":0,"assignees":null,"labels":null,"hex_color":"","created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}},{"id":3,"title":"task #3 high prio","description":"","done":false,"due_date":0,"repeat_after":0,"repeat_mode":0,"priority":100,"start_date":0,"end_date":0,"assignees":null,"labels":null,"created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}}]`) assert.NotContains(t, rec.Body.String(), `[{"id":5,"title":"task #5 higher due date","description":"","done":false,"due_date":1543636724,"reminders":null,"repeat_after":0,"repeat_mode":0,"priority":0,"start_date":0,"end_date":0,"assignees":null,"labels":null,"hex_color":"","created":1543626724,"updated":1543626724,"created_by":{"id":0,"name":"","username":"","email":"","created":0,"updated":0}},{"id":6,"title":"task #6 lower due date"`) @@ -415,7 +417,7 @@ func TestTaskCollection(t *testing.T) { }, nil, ) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -440,7 +442,7 @@ func TestTaskCollection(t *testing.T) { }, nil, ) - assert.NoError(t, err) + require.NoError(t, err) assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #3 `) @@ -465,7 +467,7 @@ func TestTaskCollection(t *testing.T) { }, nil, ) - assert.NoError(t, err) + require.NoError(t, err) // If no start date but an end date is specified, this should be null // since we don't have any tasks in the fixtures with an end date > // the current date. @@ -481,7 +483,7 @@ func TestTaskCollection(t *testing.T) { }, nil, ) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskFilterValue) }) }) diff --git a/pkg/integrations/task_comment_test.go b/pkg/integrations/task_comment_test.go index be2e28455cd..c09f4b08525 100644 --- a/pkg/integrations/task_comment_test.go +++ b/pkg/integrations/task_comment_test.go @@ -20,11 +20,12 @@ import ( "testing" "code.vikunja.io/api/pkg/db" - "code.vikunja.io/api/pkg/models" "code.vikunja.io/web/handler" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTaskComments(t *testing.T) { @@ -54,82 +55,82 @@ func TestTaskComments(t *testing.T) { t.Run("Update", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "1", "commentid": "1"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "99999", "commentid": "9999"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { // Only the own comments can be updated t.Run("Forbidden", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "14", "commentid": "2"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "15", "commentid": "3"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "16", "commentid": "4"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team admin", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "17", "commentid": "5"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "18", "commentid": "6"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "19", "commentid": "7"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User admin", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "20", "commentid": "8"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "21", "commentid": "9"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "22", "commentid": "10"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "23", "commentid": "11"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "24", "commentid": "12"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "25", "commentid": "13"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "26", "commentid": "14"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) @@ -137,82 +138,82 @@ func TestTaskComments(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "1", "commentid": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "99999", "commentid": "9999"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { // Only the own comments can be deleted t.Run("Forbidden", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "14", "commentid": "2"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "15", "commentid": "3"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "16", "commentid": "4"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team admin", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "17", "commentid": "5"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "18", "commentid": "6"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "19", "commentid": "7"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User admin", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "20", "commentid": "8"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "21", "commentid": "9"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "22", "commentid": "10"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "23", "commentid": "11"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "24", "commentid": "12"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "25", "commentid": "13"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "26", "commentid": "14"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) }) @@ -220,88 +221,88 @@ func TestTaskComments(t *testing.T) { t.Run("Create", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "1"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "9999"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "34"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "15"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "16"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "17"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "18"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "19"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "20"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "21"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "22"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "23"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "24"}, `{"comment":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "25"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "26"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) }) }) t.Run("Link Share", func(t *testing.T) { rec, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"task": "13"}, `{"comment":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`) db.AssertExists(t, "task_comments", map[string]interface{}{ "task_id": 13, diff --git a/pkg/integrations/task_test.go b/pkg/integrations/task_test.go index 55c5f034a79..761941d3c11 100644 --- a/pkg/integrations/task_test.go +++ b/pkg/integrations/task_test.go @@ -20,11 +20,12 @@ import ( "testing" "code.vikunja.io/api/pkg/db" - "code.vikunja.io/api/pkg/models" "code.vikunja.io/web/handler" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTask(t *testing.T) { @@ -55,49 +56,49 @@ func TestTask(t *testing.T) { t.Run("Update task items", func(t *testing.T) { t.Run("Title", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) assert.NotContains(t, rec.Body.String(), `"title":"task #1"`) }) t.Run("Description", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"description":"Dolor sit amet"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"description":"Dolor sit amet"`) assert.NotContains(t, rec.Body.String(), `"description":"Lorem Ipsum"`) }) t.Run("Description to empty", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"description":""}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"description":""`) assert.NotContains(t, rec.Body.String(), `"description":"Lorem Ipsum"`) }) t.Run("Done", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"done":true}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"done":true`) assert.NotContains(t, rec.Body.String(), `"done":false`) }) t.Run("Undone", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "2"}, `{"done":false}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"done":false`) assert.NotContains(t, rec.Body.String(), `"done":true`) }) t.Run("Due date", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"due_date": "2020-02-10T10:00:00Z"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"due_date":"2020-02-10T10:00:00Z"`) assert.NotContains(t, rec.Body.String(), `"due_date":0`) }) t.Run("Due date unset", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "5"}, `{"due_date": null}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"due_date":"0001-01-01T00:00:00Z"`) assert.NotContains(t, rec.Body.String(), `"due_date":"2020-02-10T10:00:00Z"`) }) t.Run("Reminders", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"reminders": [{"reminder": "2020-02-10T10:00:00Z"},{"reminder": "2020-02-11T10:00:00Z"}]}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"reminders":[`) assert.Contains(t, rec.Body.String(), `{"reminder":"2020-02-10T10:00:00Z"`) assert.Contains(t, rec.Body.String(), `{"reminder":"2020-02-11T10:00:00Z"`) @@ -105,109 +106,109 @@ func TestTask(t *testing.T) { }) t.Run("Reminders unset to empty array", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "27"}, `{"reminders": []}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"reminders":null`) assert.NotContains(t, rec.Body.String(), `{"Reminder":"2020-02-10T10:00:00Z"`) }) t.Run("Reminders unset to null", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "27"}, `{"reminders": null}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"reminders":null`) assert.NotContains(t, rec.Body.String(), `{"Reminder":"2020-02-10T10:00:00Z"`) }) t.Run("Repeat after", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"repeat_after":3600}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"repeat_after":3600`) assert.NotContains(t, rec.Body.String(), `"repeat_after":0`) }) t.Run("Repeat after unset", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "28"}, `{"repeat_after":0}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"repeat_after":0`) assert.NotContains(t, rec.Body.String(), `"repeat_after":3600`) }) t.Run("Repeat after update done", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "28"}, `{"done":true}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"done":false`) assert.NotContains(t, rec.Body.String(), `"done":true`) }) t.Run("Assignees", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"assignees":[{"id":1}]}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"assignees":[{"id":1`) assert.NotContains(t, rec.Body.String(), `"assignees":[]`) }) t.Run("Removing Assignees empty array", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "30"}, `{"assignees":[]}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"assignees":null`) assert.NotContains(t, rec.Body.String(), `"assignees":[{"id":1`) }) t.Run("Removing Assignees null", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "30"}, `{"assignees":null}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"assignees":null`) assert.NotContains(t, rec.Body.String(), `"assignees":[{"id":1`) }) t.Run("Priority", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"priority":100}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"priority":100`) assert.NotContains(t, rec.Body.String(), `"priority":0`) }) t.Run("Priority to 0", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "3"}, `{"priority":0}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"priority":0`) assert.NotContains(t, rec.Body.String(), `"priority":100`) }) t.Run("Start date", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"start_date":"2020-02-10T10:00:00Z"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"start_date":"2020-02-10T10:00:00Z"`) assert.NotContains(t, rec.Body.String(), `"start_date":0`) }) t.Run("Start date unset", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "7"}, `{"start_date":"0001-01-01T00:00:00Z"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"start_date":"0001-01-01T00:00:00Z"`) assert.NotContains(t, rec.Body.String(), `"start_date":"2020-02-10T10:00:00Z"`) }) t.Run("End date", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"end_date":"2020-02-10T12:00:00Z"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"end_date":"2020-02-10T12:00:00Z"`) assert.NotContains(t, rec.Body.String(), `"end_date":""`) }) t.Run("End date unset", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "8"}, `{"end_date":"0001-01-01T00:00:00Z"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"end_date":"0001-01-01T00:00:00Z"`) assert.NotContains(t, rec.Body.String(), `"end_date":"2020-02-10T10:00:00Z"`) }) t.Run("Color", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"hex_color":"f0f0f0"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"hex_color":"f0f0f0"`) assert.NotContains(t, rec.Body.String(), `"hex_color":""`) }) t.Run("Color unset", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "31"}, `{"hex_color":""}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"hex_color":""`) assert.NotContains(t, rec.Body.String(), `"hex_color":"f0f0f0"`) }) t.Run("Percent Done", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"percent_done":0.1}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"percent_done":0.1`) assert.NotContains(t, rec.Body.String(), `"percent_done":0,`) }) t.Run("Percent Done unset", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "33"}, `{"percent_done":0}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"percent_done":0,`) assert.NotContains(t, rec.Body.String(), `"percent_done":0.1`) }) @@ -215,112 +216,112 @@ func TestTask(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "99999"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "14"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "15"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "16"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "17"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "18"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "19"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "20"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "21"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "22"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "23"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "24"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "25"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "26"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) }) t.Run("Move to other project", func(t *testing.T) { t.Run("normal", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"project_id":7}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"project_id":7`) assert.NotContains(t, rec.Body.String(), `"project_id":1`) }) t.Run("Forbidden", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"project_id":20}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) }) t.Run("Read Only", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"project_id":6}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) }) }) t.Run("Bucket", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"bucket_id":3}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"bucket_id":3`) assert.NotContains(t, rec.Body.String(), `"bucket_id":1`) }) t.Run("Different Project", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"bucket_id":4}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotBelongToProject) }) t.Run("Nonexisting Bucket", func(t *testing.T) { _, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"bucket_id":9999}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist) }) }) @@ -328,81 +329,81 @@ func TestTask(t *testing.T) { t.Run("Delete", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "1"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "99999"}) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "14"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "15"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "16"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "17"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "18"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "19"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "20"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "21"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "22"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "23"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "24"}) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "25"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "26"}) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Successfully deleted.`) }) }) @@ -410,106 +411,106 @@ func TestTask(t *testing.T) { t.Run("Create", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Nonexisting", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9999"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) }) t.Run("Rights check", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) { // Owned by user13 _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "6"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Team write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "7"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Team admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "8"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via User readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via User write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via User admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "12"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project Team write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "13"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "14"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "15"}, `{"title":"Lorem Ipsum"}`) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) }) t.Run("Shared Via Parent Project User write", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "16"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) t.Run("Shared Via Parent Project User admin", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "17"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) }) }) t.Run("Bucket", func(t *testing.T) { t.Run("Normal", func(t *testing.T) { rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum","bucket_id":3}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"bucket_id":3`) assert.NotContains(t, rec.Body.String(), `"bucket_id":1`) }) t.Run("Different Project", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum","bucket_id":4}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotBelongToProject) }) t.Run("Nonexisting Bucket", func(t *testing.T) { _, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum","bucket_id":9999}`) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist) }) }) t.Run("Link Share", func(t *testing.T) { rec, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"Lorem Ipsum"}`) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`) db.AssertExists(t, "tasks", map[string]interface{}{ "project_id": 2, diff --git a/pkg/integrations/token_test.go b/pkg/integrations/token_test.go index 52dae7e6682..0b30aa7c248 100644 --- a/pkg/integrations/token_test.go +++ b/pkg/integrations/token_test.go @@ -22,12 +22,13 @@ import ( apiv1 "code.vikunja.io/api/pkg/routes/api/v1" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestCheckToken(t *testing.T) { t.Run("Normal test", func(t *testing.T) { rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.CheckToken, &testuser1, "", nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `🍵`) }) } diff --git a/pkg/integrations/user_change_password_test.go b/pkg/integrations/user_change_password_test.go index e73cc8716b3..2e585e5437e 100644 --- a/pkg/integrations/user_change_password_test.go +++ b/pkg/integrations/user_change_password_test.go @@ -22,7 +22,9 @@ import ( apiv1 "code.vikunja.io/api/pkg/routes/api/v1" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestUserChangePassword(t *testing.T) { @@ -31,7 +33,7 @@ func TestUserChangePassword(t *testing.T) { "new_password": "12345", "old_password": "1234" }`, nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `The password was updated successfully.`) }) t.Run("Wrong old password", func(t *testing.T) { @@ -39,7 +41,7 @@ func TestUserChangePassword(t *testing.T) { "new_password": "12345", "old_password": "invalid" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword) }) t.Run("Empty old password", func(t *testing.T) { @@ -47,7 +49,7 @@ func TestUserChangePassword(t *testing.T) { "new_password": "12345", "old_password": "" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeEmptyOldPassword) }) t.Run("Empty new password", func(t *testing.T) { @@ -55,7 +57,7 @@ func TestUserChangePassword(t *testing.T) { "new_password": "", "old_password": "1234" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeEmptyNewPassword) }) } diff --git a/pkg/integrations/user_confirm_email_test.go b/pkg/integrations/user_confirm_email_test.go index a47e1ae4a4a..0370dd73e84 100644 --- a/pkg/integrations/user_confirm_email_test.go +++ b/pkg/integrations/user_confirm_email_test.go @@ -22,30 +22,32 @@ import ( apiv1 "code.vikunja.io/api/pkg/routes/api/v1" "code.vikunja.io/api/pkg/user" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestUserConfirmEmail(t *testing.T) { t.Run("Normal test", func(t *testing.T) { rec, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": "tiepiQueed8ahc7zeeFe1eveiy4Ein8osooxegiephauph2Ael"}`, nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `The email was confirmed successfully.`) }) t.Run("Empty payload", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assert.Equal(t, http.StatusPreconditionFailed, err.(*echo.HTTPError).Code) assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken) }) t.Run("Empty token", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": ""}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken) }) t.Run("Invalid token", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": "invalidToken"}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken) }) } diff --git a/pkg/integrations/user_password_request_token_test.go b/pkg/integrations/user_password_request_token_test.go index 5987d797448..5e94c4ffe0f 100644 --- a/pkg/integrations/user_password_request_token_test.go +++ b/pkg/integrations/user_password_request_token_test.go @@ -24,27 +24,28 @@ import ( "code.vikunja.io/api/pkg/user" "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestUserRequestResetPasswordToken(t *testing.T) { t.Run("Normal requesting a password reset token", func(t *testing.T) { rec, err := newTestRequest(t, http.MethodPost, apiv1.UserRequestResetPasswordToken, `{"email": "user1@example.com"}`, nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `Token was sent.`) }) t.Run("Empty payload", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.UserRequestResetPasswordToken, `{}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) }) t.Run("Invalid email address", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.UserRequestResetPasswordToken, `{"email": "user1example.com"}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assert.Equal(t, http.StatusBadRequest, err.(*echo.HTTPError).Code) }) t.Run("No user with that email address", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.UserRequestResetPasswordToken, `{"email": "user1000@example.com"}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeUserDoesNotExist) }) } diff --git a/pkg/integrations/user_password_reset_test.go b/pkg/integrations/user_password_reset_test.go index 163e1adadd9..5dbdafd4fcb 100644 --- a/pkg/integrations/user_password_reset_test.go +++ b/pkg/integrations/user_password_reset_test.go @@ -22,8 +22,10 @@ import ( apiv1 "code.vikunja.io/api/pkg/routes/api/v1" "code.vikunja.io/api/pkg/user" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestUserPasswordReset(t *testing.T) { @@ -32,12 +34,12 @@ func TestUserPasswordReset(t *testing.T) { "new_password": "1234", "token": "passwordresettesttoken" }`, nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `The password was updated successfully.`) }) t.Run("Empty payload", func(t *testing.T) { _, err := newTestRequest(t, http.MethodPost, apiv1.UserResetPassword, `{}`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assert.Equal(t, http.StatusBadRequest, err.(*echo.HTTPError).Code) }) t.Run("No new password", func(t *testing.T) { @@ -45,7 +47,7 @@ func TestUserPasswordReset(t *testing.T) { "new_password": "", "token": "passwordresettesttoken" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) }) t.Run("Invalid password reset token", func(t *testing.T) { @@ -53,7 +55,7 @@ func TestUserPasswordReset(t *testing.T) { "new_password": "1234", "token": "invalidtoken" }`, nil, nil) - assert.Error(t, err) + require.Error(t, err) assertHandlerErrorCode(t, err, user.ErrCodeInvalidPasswordResetToken) }) } diff --git a/pkg/integrations/user_project_test.go b/pkg/integrations/user_project_test.go index c82c126138b..c62212a1e44 100644 --- a/pkg/integrations/user_project_test.go +++ b/pkg/integrations/user_project_test.go @@ -21,18 +21,20 @@ import ( "testing" apiv1 "code.vikunja.io/api/pkg/routes/api/v1" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestUserProject(t *testing.T) { t.Run("Normal test", func(t *testing.T) { rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.UserList, &testuser1, "", nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "null\n", rec.Body.String()) }) t.Run("Search for user3", func(t *testing.T) { rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.UserList, &testuser1, "", map[string][]string{"s": {"user3"}}, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `user3`) assert.NotContains(t, rec.Body.String(), `user1`) assert.NotContains(t, rec.Body.String(), `user2`) diff --git a/pkg/integrations/user_show_test.go b/pkg/integrations/user_show_test.go index bd9b5e374c9..b38a97c3f59 100644 --- a/pkg/integrations/user_show_test.go +++ b/pkg/integrations/user_show_test.go @@ -21,13 +21,15 @@ import ( "testing" apiv1 "code.vikunja.io/api/pkg/routes/api/v1" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestUserShow(t *testing.T) { t.Run("Normal test", func(t *testing.T) { rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.UserShow, &testuser1, "", nil, nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, rec.Body.String(), `"id":1`) assert.Contains(t, rec.Body.String(), `"username":"user1"`) assert.NotContains(t, rec.Body.String(), `"email":""`) diff --git a/pkg/models/api_tokens_test.go b/pkg/models/api_tokens_test.go index ad5ee119f74..9ddd3709dec 100644 --- a/pkg/models/api_tokens_test.go +++ b/pkg/models/api_tokens_test.go @@ -23,6 +23,7 @@ import ( "code.vikunja.io/api/pkg/user" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestAPIToken_ReadAll(t *testing.T) { @@ -35,11 +36,11 @@ func TestAPIToken_ReadAll(t *testing.T) { // Checking if the user only sees their own tokens result, count, total, err := token.ReadAll(s, u, "", 1, 50) - assert.NoError(t, err) + require.NoError(t, err) tokens, is := result.([]*APIToken) assert.Truef(t, is, "tokens are not of type []*APIToken") assert.Len(t, tokens, 2) - assert.Equal(t, count, len(tokens)) + assert.Len(t, tokens, count) assert.Equal(t, int64(2), total) assert.Equal(t, int64(1), tokens[0].ID) assert.Equal(t, int64(2), tokens[1].ID) @@ -54,7 +55,7 @@ func TestAPIToken_CanDelete(t *testing.T) { db.LoadAndAssertFixtures(t) can, err := token.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("noneixsting token", func(t *testing.T) { @@ -65,7 +66,7 @@ func TestAPIToken_CanDelete(t *testing.T) { db.LoadAndAssertFixtures(t) can, err := token.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("token of another user", func(t *testing.T) { @@ -76,7 +77,7 @@ func TestAPIToken_CanDelete(t *testing.T) { db.LoadAndAssertFixtures(t) can, err := token.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) } @@ -90,7 +91,7 @@ func TestAPIToken_Create(t *testing.T) { db.LoadAndAssertFixtures(t) err := token.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) }) } @@ -102,7 +103,7 @@ func TestAPIToken_GetTokenFromTokenString(t *testing.T) { token, err := GetTokenFromTokenString(s, "tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e") // Token 1 - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, int64(1), token.ID) }) t.Run("invalid token", func(t *testing.T) { @@ -112,7 +113,7 @@ func TestAPIToken_GetTokenFromTokenString(t *testing.T) { _, err := GetTokenFromTokenString(s, "tk_loremipsum") - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrAPITokenInvalid(err)) }) } diff --git a/pkg/models/kanban_test.go b/pkg/models/kanban_test.go index 181d67ca1f3..8ff69a9df5c 100644 --- a/pkg/models/kanban_test.go +++ b/pkg/models/kanban_test.go @@ -23,7 +23,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestBucket_ReadAll(t *testing.T) { @@ -35,7 +37,7 @@ func TestBucket_ReadAll(t *testing.T) { testuser := &user.User{ID: 1} b := &Bucket{ProjectID: 1} bucketsInterface, _, _, err := b.ReadAll(s, testuser, "", 0, 0) - assert.NoError(t, err) + require.NoError(t, err) buckets, is := bucketsInterface.([]*Bucket) assert.True(t, is) @@ -85,7 +87,7 @@ func TestBucket_ReadAll(t *testing.T) { }, } bucketsInterface, _, _, err := b.ReadAll(s, testuser, "", -1, 0) - assert.NoError(t, err) + require.NoError(t, err) buckets := bucketsInterface.([]*Bucket) assert.Len(t, buckets, 3) @@ -104,7 +106,7 @@ func TestBucket_ReadAll(t *testing.T) { } b := &Bucket{ProjectID: 1} result, _, _, err := b.ReadAll(s, linkShare, "", 0, 0) - assert.NoError(t, err) + require.NoError(t, err) buckets, _ := result.([]*Bucket) assert.Len(t, buckets, 3) assert.NotNil(t, buckets[0].CreatedBy) @@ -118,7 +120,7 @@ func TestBucket_ReadAll(t *testing.T) { testuser := &user.User{ID: 12} b := &Bucket{ProjectID: 23} result, _, _, err := b.ReadAll(s, testuser, "", 0, 0) - assert.NoError(t, err) + require.NoError(t, err) buckets, _ := result.([]*Bucket) assert.Len(t, buckets, 1) assert.NotNil(t, buckets[0].CreatedBy) @@ -139,14 +141,14 @@ func TestBucket_Delete(t *testing.T) { ProjectID: 1, } err := b.Delete(s, user) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) // Assert all tasks have been moved to bucket 1 as that one is the first tasks := []*Task{} err = s.Where("bucket_id = ?", 1).Find(&tasks) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, tasks, 15) db.AssertMissing(t, "buckets", map[string]interface{}{ "id": 2, @@ -163,10 +165,10 @@ func TestBucket_Delete(t *testing.T) { ProjectID: 18, } err := b.Delete(s, user) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrCannotRemoveLastBucket(err)) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "buckets", map[string]interface{}{ "id": 34, @@ -179,10 +181,10 @@ func TestBucket_Update(t *testing.T) { testAndAssertBucketUpdate := func(t *testing.T, b *Bucket, s *xorm.Session) { err := b.Update(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "buckets", map[string]interface{}{ "id": 1, diff --git a/pkg/models/link_sharing_test.go b/pkg/models/link_sharing_test.go index 3b42e79b21f..07353bc5ca9 100644 --- a/pkg/models/link_sharing_test.go +++ b/pkg/models/link_sharing_test.go @@ -21,7 +21,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestLinkSharing_Create(t *testing.T) { @@ -38,7 +40,7 @@ func TestLinkSharing_Create(t *testing.T) { } err := share.Create(s, doer) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, share.Hash) assert.NotEmpty(t, share.ID) assert.Equal(t, SharingTypeWithoutPassword, share.SharingType) @@ -57,7 +59,7 @@ func TestLinkSharing_Create(t *testing.T) { } err := share.Create(s, doer) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrInvalidRight(err)) }) t.Run("password should be hashed", func(t *testing.T) { @@ -72,7 +74,7 @@ func TestLinkSharing_Create(t *testing.T) { } err := share.Create(s, doer) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, share.Hash) assert.NotEmpty(t, share.ID) assert.Empty(t, share.Password) @@ -97,7 +99,7 @@ func TestLinkSharing_ReadAll(t *testing.T) { all, _, _, err := share.ReadAll(s, doer, "", 1, -1) shares := all.([]*LinkSharing) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, shares, 2) for _, sharing := range shares { assert.Empty(t, sharing.Password) @@ -114,7 +116,7 @@ func TestLinkSharing_ReadAll(t *testing.T) { all, _, _, err := share.ReadAll(s, doer, "wITHPASS", 1, -1) shares := all.([]*LinkSharing) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, shares, 1) assert.Equal(t, int64(4), shares[0].ID) }) @@ -133,7 +135,7 @@ func TestLinkSharing_ReadOne(t *testing.T) { } err := share.ReadOne(s, doer) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, share.Hash) assert.Equal(t, SharingTypeWithoutPassword, share.SharingType) }) @@ -147,7 +149,7 @@ func TestLinkSharing_ReadOne(t *testing.T) { } err := share.ReadOne(s, doer) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, share.Hash) assert.Equal(t, SharingTypeWithPassword, share.SharingType) assert.Empty(t, share.Password) diff --git a/pkg/models/mentions_test.go b/pkg/models/mentions_test.go index 43545b988d6..0f4ee23c6c1 100644 --- a/pkg/models/mentions_test.go +++ b/pkg/models/mentions_test.go @@ -19,11 +19,12 @@ package models import ( "testing" - "github.com/stretchr/testify/assert" - "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/notifications" "code.vikunja.io/api/pkg/user" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestFindMentionedUsersInText(t *testing.T) { @@ -100,13 +101,13 @@ func TestSendingMentionNotification(t *testing.T) { defer s.Close() task, err := GetTaskByIDSimple(s, 32) - assert.NoError(t, err) + require.NoError(t, err) tc := &TaskComment{ Comment: "Lorem Ipsum @user1 @user2 @user3 @user4 @user5 @user6", TaskID: 32, // user2 has access to the project that task belongs to } err = tc.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) n := &TaskCommentNotification{ Doer: u, Task: &task, @@ -114,7 +115,7 @@ func TestSendingMentionNotification(t *testing.T) { } _, err = notifyMentionedUsers(s, &task, tc.Comment, n) - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "notifications", map[string]interface{}{ "subject_id": tc.ID, @@ -153,13 +154,13 @@ func TestSendingMentionNotification(t *testing.T) { defer s.Close() task, err := GetTaskByIDSimple(s, 32) - assert.NoError(t, err) + require.NoError(t, err) tc := &TaskComment{ Comment: "Lorem Ipsum @user2", TaskID: 32, // user2 has access to the project that task belongs to } err = tc.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) n := &TaskCommentNotification{ Doer: u, Task: &task, @@ -167,14 +168,14 @@ func TestSendingMentionNotification(t *testing.T) { } _, err = notifyMentionedUsers(s, &task, tc.Comment, n) - assert.NoError(t, err) + require.NoError(t, err) _, err = notifyMentionedUsers(s, &task, "Lorem Ipsum @user2 @user3", n) - assert.NoError(t, err) + require.NoError(t, err) // The second time mentioning the user in the same task should not create another notification dbNotifications, err := notifications.GetNotificationsForNameAndUser(s, 2, n.Name(), tc.ID) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, dbNotifications, 1) }) } diff --git a/pkg/models/project_duplicate_test.go b/pkg/models/project_duplicate_test.go index 26ef67c213a..0f3957791ff 100644 --- a/pkg/models/project_duplicate_test.go +++ b/pkg/models/project_duplicate_test.go @@ -22,7 +22,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestProjectDuplicate(t *testing.T) { @@ -40,16 +42,16 @@ func TestProjectDuplicate(t *testing.T) { ProjectID: 1, } can, err := l.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) err = l.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) // assert the new project has the same number of buckets as the old one numberOfOriginalBuckets, err := s.Where("project_id = ?", l.ProjectID).Count(&Bucket{}) - assert.NoError(t, err) + require.NoError(t, err) numberOfDuplicatedBuckets, err := s.Where("project_id = ?", l.Project.ID).Count(&Bucket{}) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, numberOfOriginalBuckets, numberOfDuplicatedBuckets, "duplicated project does not have the same amount of buckets as the original one") // To make this test 100% useful, it would need to assert a lot more stuff, but it is good enough for now. diff --git a/pkg/models/project_team_test.go b/pkg/models/project_team_test.go index ef13b1bd442..f53fd3ba31b 100644 --- a/pkg/models/project_team_test.go +++ b/pkg/models/project_team_test.go @@ -25,7 +25,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" "code.vikunja.io/web" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTeamProject_ReadAll(t *testing.T) { @@ -39,10 +41,10 @@ func TestTeamProject_ReadAll(t *testing.T) { db.LoadAndAssertFixtures(t) s := db.NewSession() teams, _, _, err := tl.ReadAll(s, u, "", 1, 50) - assert.NoError(t, err) - assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) + require.NoError(t, err) + assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind()) ts := reflect.ValueOf(teams) - assert.Equal(t, ts.Len(), 1) + assert.Equal(t, 1, ts.Len()) _ = s.Close() }) t.Run("nonexistant project", func(t *testing.T) { @@ -52,7 +54,7 @@ func TestTeamProject_ReadAll(t *testing.T) { db.LoadAndAssertFixtures(t) s := db.NewSession() _, _, _, err := tl.ReadAll(s, u, "", 1, 50) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectDoesNotExist(err)) _ = s.Close() }) @@ -65,7 +67,7 @@ func TestTeamProject_ReadAll(t *testing.T) { db.LoadAndAssertFixtures(t) s := db.NewSession() _, _, _, err := tl.ReadAll(s, u, "", 1, 50) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNeedToHaveProjectReadAccess(err)) _ = s.Close() }) @@ -76,8 +78,8 @@ func TestTeamProject_ReadAll(t *testing.T) { db.LoadAndAssertFixtures(t) s := db.NewSession() teams, _, _, err := tl.ReadAll(s, u, "TEAM9", 1, 50) - assert.NoError(t, err) - assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) + require.NoError(t, err) + assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind()) ts := teams.([]*TeamWithRight) assert.Len(t, ts, 1) assert.Equal(t, int64(9), ts[0].ID) @@ -98,9 +100,9 @@ func TestTeamProject_Create(t *testing.T) { allowed, _ := tl.CanCreate(s, u) assert.True(t, allowed) err := tl.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "team_projects", map[string]interface{}{ "team_id": 1, "project_id": 1, @@ -116,7 +118,7 @@ func TestTeamProject_Create(t *testing.T) { Right: RightAdmin, } err := tl.Create(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamAlreadyHasAccess(err)) _ = s.Close() }) @@ -129,7 +131,7 @@ func TestTeamProject_Create(t *testing.T) { Right: RightUnknown, } err := tl.Create(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrInvalidRight(err)) _ = s.Close() }) @@ -141,7 +143,7 @@ func TestTeamProject_Create(t *testing.T) { ProjectID: 1, } err := tl.Create(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamDoesNotExist(err)) _ = s.Close() }) @@ -153,7 +155,7 @@ func TestTeamProject_Create(t *testing.T) { ProjectID: 9999, } err := tl.Create(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectDoesNotExist(err)) _ = s.Close() }) @@ -170,9 +172,9 @@ func TestTeamProject_Delete(t *testing.T) { ProjectID: 3, } err := tl.Delete(s, user) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "team_projects", map[string]interface{}{ "team_id": 1, "project_id": 3, @@ -186,7 +188,7 @@ func TestTeamProject_Delete(t *testing.T) { ProjectID: 1, } err := tl.Delete(s, user) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamDoesNotExist(err)) _ = s.Close() }) @@ -198,7 +200,7 @@ func TestTeamProject_Delete(t *testing.T) { ProjectID: 9999, } err := tl.Delete(s, user) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamDoesNotHaveAccessToProject(err)) _ = s.Close() }) @@ -279,7 +281,7 @@ func TestTeamProject_Update(t *testing.T) { t.Errorf("TeamProject.Update() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name()) } err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) if !tt.wantErr { db.AssertExists(t, "team_projects", map[string]interface{}{ "project_id": tt.fields.ProjectID, diff --git a/pkg/models/project_test.go b/pkg/models/project_test.go index 0db70907801..04d44d6fa53 100644 --- a/pkg/models/project_test.go +++ b/pkg/models/project_test.go @@ -23,7 +23,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestProject_CreateOrUpdate(t *testing.T) { @@ -42,9 +44,9 @@ func TestProject_CreateOrUpdate(t *testing.T) { Description: "Lorem Ipsum", } err := project.Create(s, usr) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "projects", map[string]interface{}{ "id": project.ID, "title": project.Title, @@ -64,7 +66,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { ParentProjectID: 999999, } err := project.Create(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectDoesNotExist(err)) _ = s.Close() }) @@ -77,7 +79,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { Description: "Lorem Ipsum", } err := project.Create(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, user.IsErrUserDoesNotExist(err)) _ = s.Close() }) @@ -90,7 +92,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { Identifier: "test1", } err := project.Create(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectIdentifierIsNotUnique(err)) _ = s.Close() }) @@ -102,9 +104,9 @@ func TestProject_CreateOrUpdate(t *testing.T) { Description: "Lorem Ipsum", } err := project.Create(s, usr) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "projects", map[string]interface{}{ "id": project.ID, "title": project.Title, @@ -124,9 +126,9 @@ func TestProject_CreateOrUpdate(t *testing.T) { } project.Description = "Lorem Ipsum dolor sit amet." err := project.Update(s, usr) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "projects", map[string]interface{}{ "id": project.ID, "title": project.Title, @@ -141,7 +143,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { Title: "test", } err := project.Update(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectDoesNotExist(err)) _ = s.Close() @@ -155,7 +157,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { Identifier: "test1", } err := project.Create(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectIdentifierIsNotUnique(err)) _ = s.Close() }) @@ -176,12 +178,12 @@ func TestProject_CreateOrUpdate(t *testing.T) { ParentProjectID: 7, // from 6 } can, err := project.CanUpdate(s, usr) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) err = project.Update(s, usr) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "projects", map[string]interface{}{ "id": project.ID, "title": project.Title, @@ -218,7 +220,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { ParentProjectID: -1, } err := project.Update(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectCannotBelongToAPseudoParentProject(err)) }) }) @@ -230,7 +232,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { IsArchived: true, } err := project.Update(s, &user.User{ID: 3}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrCannotArchiveDefaultProject(err)) }) t.Run("archive default project of another user", func(t *testing.T) { @@ -241,7 +243,7 @@ func TestProject_CreateOrUpdate(t *testing.T) { IsArchived: true, } err := project.Update(s, &user.User{ID: 2}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrCannotArchiveDefaultProject(err)) }) }) @@ -255,9 +257,9 @@ func TestProject_Delete(t *testing.T) { ID: 1, } err := project.Delete(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "projects", map[string]interface{}{ "id": 1, }) @@ -273,9 +275,9 @@ func TestProject_Delete(t *testing.T) { ID: 35, } err := project.Delete(s, &user.User{ID: 6}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "projects", map[string]interface{}{ "id": 35, }) @@ -290,7 +292,7 @@ func TestProject_Delete(t *testing.T) { ID: 4, } err := project.Delete(s, &user.User{ID: 3}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrCannotDeleteDefaultProject(err)) }) t.Run("default project of a different user", func(t *testing.T) { @@ -300,7 +302,7 @@ func TestProject_Delete(t *testing.T) { ID: 4, } err := project.Delete(s, &user.User{ID: 2}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrCannotDeleteDefaultProject(err)) }) } @@ -316,9 +318,9 @@ func TestProject_DeleteBackgroundFileIfExists(t *testing.T) { BackgroundFileID: file.ID, } err := SetProjectBackground(s, project.ID, file, "") - assert.NoError(t, err) + require.NoError(t, err) err = project.DeleteBackgroundFileIfExists() - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("project with invalid background", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -330,16 +332,16 @@ func TestProject_DeleteBackgroundFileIfExists(t *testing.T) { BackgroundFileID: file.ID, } err := SetProjectBackground(s, project.ID, file, "") - assert.NoError(t, err) + require.NoError(t, err) err = project.DeleteBackgroundFileIfExists() - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("project without background", func(t *testing.T) { db.LoadAndAssertFixtures(t) files.InitTestFileFixtures(t) project := Project{ID: 1} err := project.DeleteBackgroundFileIfExists() - assert.NoError(t, err) + require.NoError(t, err) }) } @@ -350,8 +352,8 @@ func TestProject_ReadAll(t *testing.T) { projects := []*Project{} archivedProjects := make(map[int64]bool) _, _, err := getAllProjectsForUser(s, 1, nil, &projectOptions{}, &projects, 0, archivedProjects) - assert.NoError(t, err) - assert.Equal(t, 24, len(projects)) + require.NoError(t, err) + assert.Len(t, projects, 24) _ = s.Close() }) t.Run("only child projects for one project", func(t *testing.T) { @@ -364,10 +366,10 @@ func TestProject_ReadAll(t *testing.T) { project := Project{} projects3, _, _, err := project.ReadAll(s, u, "", 1, 50) - assert.NoError(t, err) - assert.Equal(t, reflect.TypeOf(projects3).Kind(), reflect.Slice) + require.NoError(t, err) + assert.Equal(t, reflect.Slice, reflect.TypeOf(projects3).Kind()) ls := projects3.([]*Project) - assert.Equal(t, 26, len(ls)) + assert.Len(t, ls, 26) assert.Equal(t, int64(3), ls[0].ID) // Project 3 has a position of 1 and should be sorted first assert.Equal(t, int64(1), ls[1].ID) assert.Equal(t, int64(6), ls[2].ID) @@ -381,7 +383,7 @@ func TestProject_ReadAll(t *testing.T) { usr := &user.User{ID: 999999} project := Project{} _, _, _, err := project.ReadAll(s, usr, "", 1, 50) - assert.Error(t, err) + require.Error(t, err) assert.True(t, user.IsErrUserDoesNotExist(err)) _ = s.Close() }) @@ -392,9 +394,9 @@ func TestProject_ReadAll(t *testing.T) { project := Project{} projects3, _, _, err := project.ReadAll(s, u, "TEST10", 1, 50) - assert.NoError(t, err) + require.NoError(t, err) ls := projects3.([]*Project) - assert.Equal(t, 3, len(ls)) + assert.Len(t, ls, 3) assert.Equal(t, int64(10), ls[0].ID) assert.Equal(t, int64(-1), ls[1].ID) assert.Equal(t, int64(-2), ls[2].ID) @@ -411,10 +413,10 @@ func TestProject_ReadOne(t *testing.T) { u := &user.User{ID: 1} l := &Project{ID: 1} can, _, err := l.CanRead(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) err = l.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "Test1", l.Title) }) t.Run("with subscription", func(t *testing.T) { @@ -425,10 +427,10 @@ func TestProject_ReadOne(t *testing.T) { u := &user.User{ID: 6} l := &Project{ID: 12} can, _, err := l.CanRead(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) err = l.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, l.Subscription) }) } diff --git a/pkg/models/project_users_test.go b/pkg/models/project_users_test.go index 96357b01a99..e9ad3a87f11 100644 --- a/pkg/models/project_users_test.go +++ b/pkg/models/project_users_test.go @@ -25,7 +25,8 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" "code.vikunja.io/web" - "github.com/stretchr/testify/assert" + + "github.com/stretchr/testify/require" "gopkg.in/d4l3k/messagediff.v1" ) @@ -130,7 +131,7 @@ func TestProjectUser_Create(t *testing.T) { } err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) if !tt.wantErr { db.AssertExists(t, "users_projects", map[string]interface{}{ @@ -340,7 +341,7 @@ func TestProjectUser_Update(t *testing.T) { } err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) if !tt.wantErr { db.AssertExists(t, "users_projects", map[string]interface{}{ @@ -422,7 +423,7 @@ func TestProjectUser_Delete(t *testing.T) { } err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) if !tt.wantErr { db.AssertMissing(t, "users_projects", map[string]interface{}{ diff --git a/pkg/models/saved_filters_test.go b/pkg/models/saved_filters_test.go index 7c4940c0191..3943d086468 100644 --- a/pkg/models/saved_filters_test.go +++ b/pkg/models/saved_filters_test.go @@ -21,7 +21,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "xorm.io/xorm/schemas" ) @@ -56,10 +58,10 @@ func TestSavedFilter_Create(t *testing.T) { u := &user.User{ID: 1} err := sf.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, u.ID, sf.OwnerID) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) vals := map[string]interface{}{ "title": "'test'", "description": "'Lorem Ipsum dolor sit amet'", @@ -85,9 +87,9 @@ func TestSavedFilter_ReadOne(t *testing.T) { } // canRead pre-populates the struct _, _, err := sf.CanRead(s, user1) - assert.NoError(t, err) + require.NoError(t, err) err = sf.ReadOne(s, user1) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sf.Owner) } @@ -104,9 +106,9 @@ func TestSavedFilter_Update(t *testing.T) { Filters: &TaskCollection{}, } err := sf.Update(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "saved_filters", map[string]interface{}{ "id": 1, "title": "NewTitle", @@ -124,9 +126,9 @@ func TestSavedFilter_Update(t *testing.T) { Filters: &TaskCollection{}, } err := sf.Update(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "saved_filters", map[string]interface{}{ "id": 1, "is_favorite": true, @@ -143,9 +145,9 @@ func TestSavedFilter_Delete(t *testing.T) { ID: 1, } err := sf.Delete(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "saved_filters", map[string]interface{}{ "id": 1, }) @@ -163,7 +165,7 @@ func TestSavedFilter_Rights(t *testing.T) { defer s.Close() can, err := (&SavedFilter{}).CanCreate(s, user1) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("read", func(t *testing.T) { @@ -177,7 +179,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, max, err := sf.CanRead(s, user1) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, int(RightAdmin), max) assert.True(t, can) }) @@ -191,7 +193,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, _, err := sf.CanRead(s, user2) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("nonexisting", func(t *testing.T) { @@ -204,7 +206,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, _, err := sf.CanRead(s, user1) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrSavedFilterDoesNotExist(err)) assert.False(t, can) }) @@ -218,7 +220,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, _, err := sf.CanRead(s, ls) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err)) assert.False(t, can) }) @@ -234,7 +236,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, err := sf.CanUpdate(s, user1) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("not owner", func(t *testing.T) { @@ -247,7 +249,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, err := sf.CanUpdate(s, user2) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("nonexisting", func(t *testing.T) { @@ -260,7 +262,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, err := sf.CanUpdate(s, user1) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrSavedFilterDoesNotExist(err)) assert.False(t, can) }) @@ -274,7 +276,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, err := sf.CanUpdate(s, ls) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err)) assert.False(t, can) }) @@ -289,7 +291,7 @@ func TestSavedFilter_Rights(t *testing.T) { ID: 1, } can, err := sf.CanDelete(s, user1) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("not owner", func(t *testing.T) { @@ -301,7 +303,7 @@ func TestSavedFilter_Rights(t *testing.T) { ID: 1, } can, err := sf.CanDelete(s, user2) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("nonexisting", func(t *testing.T) { @@ -314,7 +316,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, err := sf.CanDelete(s, user1) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrSavedFilterDoesNotExist(err)) assert.False(t, can) }) @@ -328,7 +330,7 @@ func TestSavedFilter_Rights(t *testing.T) { Title: "Lorem", } can, err := sf.CanDelete(s, ls) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err)) assert.False(t, can) }) diff --git a/pkg/models/subscription_test.go b/pkg/models/subscription_test.go index 33df50276e4..5bf7dfd8d8c 100644 --- a/pkg/models/subscription_test.go +++ b/pkg/models/subscription_test.go @@ -21,7 +21,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestSubscriptionGetTypeFromString(t *testing.T) { @@ -54,11 +56,11 @@ func TestSubscription_Create(t *testing.T) { } can, err := sb.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) err = sb.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sb.User) db.AssertExists(t, "subscriptions", map[string]interface{}{ @@ -81,7 +83,7 @@ func TestSubscription_Create(t *testing.T) { } can, err := sb.CanCreate(s, linkShare) - assert.Error(t, err) + require.Error(t, err) assert.False(t, can) }) t.Run("noneixsting project", func(t *testing.T) { @@ -96,7 +98,7 @@ func TestSubscription_Create(t *testing.T) { } can, err := sb.CanCreate(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectDoesNotExist(err)) assert.False(t, can) }) @@ -112,7 +114,7 @@ func TestSubscription_Create(t *testing.T) { } can, err := sb.CanCreate(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskDoesNotExist(err)) assert.False(t, can) }) @@ -128,7 +130,7 @@ func TestSubscription_Create(t *testing.T) { } can, err := sb.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("no rights to see task", func(t *testing.T) { @@ -143,7 +145,7 @@ func TestSubscription_Create(t *testing.T) { } can, err := sb.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("existing subscription for (entity_id, entity_type, user_id) ", func(t *testing.T) { @@ -158,11 +160,11 @@ func TestSubscription_Create(t *testing.T) { } can, err := sb.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) err = sb.Create(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrSubscriptionAlreadyExists(err)) }) @@ -183,11 +185,11 @@ func TestSubscription_Delete(t *testing.T) { } can, err := sb.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) err = sb.Delete(s, u) - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "subscriptions", map[string]interface{}{ "entity_type": 3, "entity_id": 2, @@ -208,7 +210,7 @@ func TestSubscription_Delete(t *testing.T) { } can, err := sb.CanDelete(s, linkShare) - assert.Error(t, err) + require.Error(t, err) assert.False(t, can) }) t.Run("not owner of the subscription", func(t *testing.T) { @@ -224,7 +226,7 @@ func TestSubscription_Delete(t *testing.T) { } can, err := sb.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) } @@ -239,7 +241,7 @@ func TestSubscriptionGet(t *testing.T) { defer s.Close() sub, err := GetSubscription(s, SubscriptionEntityProject, 12, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sub) assert.Equal(t, int64(3), sub.ID) }) @@ -249,7 +251,7 @@ func TestSubscriptionGet(t *testing.T) { defer s.Close() sub, err := GetSubscription(s, SubscriptionEntityTask, 22, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sub) assert.Equal(t, int64(4), sub.ID) }) @@ -262,7 +264,7 @@ func TestSubscriptionGet(t *testing.T) { // Project 25 belongs to project 12 where user 6 has subscribed to sub, err := GetSubscription(s, SubscriptionEntityProject, 25, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sub) assert.Equal(t, int64(12), sub.EntityID) assert.Equal(t, int64(3), sub.ID) @@ -274,7 +276,7 @@ func TestSubscriptionGet(t *testing.T) { // Project 26 belongs to project 25 which belongs to project 12 where user 6 has subscribed to sub, err := GetSubscription(s, SubscriptionEntityProject, 26, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sub) assert.Equal(t, int64(12), sub.EntityID) assert.Equal(t, int64(3), sub.ID) @@ -286,7 +288,7 @@ func TestSubscriptionGet(t *testing.T) { // Task 39 belongs to project 25 which belongs to project 12 where the user has subscribed sub, err := GetSubscription(s, SubscriptionEntityTask, 39, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sub) // assert.Equal(t, int64(2), sub.ID) TODO }) @@ -297,7 +299,7 @@ func TestSubscriptionGet(t *testing.T) { // Task 21 belongs to project 32 which the user has subscribed to sub, err := GetSubscription(s, SubscriptionEntityTask, 21, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, sub) assert.Equal(t, int64(8), sub.ID) }) @@ -308,7 +310,7 @@ func TestSubscriptionGet(t *testing.T) { defer s.Close() _, err := GetSubscription(s, 2342, 21, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUnknownSubscriptionEntityType(err)) }) } diff --git a/pkg/models/task_attachment_test.go b/pkg/models/task_attachment_test.go index f05e4c82b15..d9770a00048 100644 --- a/pkg/models/task_attachment_test.go +++ b/pkg/models/task_attachment_test.go @@ -26,7 +26,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTaskAttachment_ReadOne(t *testing.T) { @@ -42,17 +44,17 @@ func TestTaskAttachment_ReadOne(t *testing.T) { ID: 1, } err := ta.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, ta.File) assert.True(t, ta.File.ID == ta.FileID && ta.FileID != 0) // Load the actual attachment file and check its content err = ta.File.LoadFileByID() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, config.FilesBasePath.GetString()+"/1", ta.File.File.Name()) content := make([]byte, 9) read, err := ta.File.File.Read(content) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 9, read) assert.Equal(t, []byte("testfile1"), content) }) @@ -66,7 +68,7 @@ func TestTaskAttachment_ReadOne(t *testing.T) { ID: 9999, } err := ta.ReadOne(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskAttachmentDoesNotExist(err)) }) t.Run("Existing Attachment, Nonexisting File", func(t *testing.T) { @@ -79,8 +81,8 @@ func TestTaskAttachment_ReadOne(t *testing.T) { ID: 2, } err := ta.ReadOne(s, u) - assert.Error(t, err) - assert.EqualError(t, err, "file 9999 does not exist") + require.Error(t, err) + require.EqualError(t, err, "file 9999 does not exist") }) } @@ -118,17 +120,17 @@ func TestTaskAttachment_NewAttachment(t *testing.T) { testuser := &user.User{ID: 1} err := ta.NewAttachment(s, tf, "testfile", 100, testuser) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEqual(t, 0, ta.FileID) _, err = files.FileStat("files/" + strconv.FormatInt(ta.FileID, 10)) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, os.IsNotExist(err)) assert.Equal(t, testuser.ID, ta.CreatedByID) // Check the file was inserted correctly ta.File = &files.File{ID: ta.FileID} err = ta.File.LoadFileMetaByID() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, testuser.ID, ta.File.CreatedByID) assert.Equal(t, "testfile", ta.File.Name) assert.Equal(t, uint64(100), ta.File.Size) @@ -145,7 +147,7 @@ func TestTaskAttachment_ReadAll(t *testing.T) { ta := &TaskAttachment{TaskID: 1} as, _, _, err := ta.ReadAll(s, &user.User{ID: 1}, "", 0, 50) attachments, _ := as.([]*TaskAttachment) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, attachments, 3) assert.Equal(t, "test", attachments[0].File.Name) for _, a := range attachments { @@ -166,7 +168,7 @@ func TestTaskAttachment_Delete(t *testing.T) { t.Run("Normal", func(t *testing.T) { ta := &TaskAttachment{ID: 1} err := ta.Delete(s, u) - assert.NoError(t, err) + require.NoError(t, err) // Check if the file itself was deleted _, err = files.FileStat("/1") // The new file has the id 2 since it's the second attachment assert.True(t, os.IsNotExist(err)) @@ -175,14 +177,14 @@ func TestTaskAttachment_Delete(t *testing.T) { files.InitTestFileFixtures(t) ta := &TaskAttachment{ID: 9999} err := ta.Delete(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskAttachmentDoesNotExist(err)) }) t.Run("Existing attachment, nonexisting file", func(t *testing.T) { files.InitTestFileFixtures(t) ta := &TaskAttachment{ID: 2} err := ta.Delete(s, u) - assert.NoError(t, err) + require.NoError(t, err) }) } @@ -196,7 +198,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 1} can, _, err := ta.CanRead(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("Forbidden", func(t *testing.T) { @@ -206,7 +208,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 14} can, _, err := ta.CanRead(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) }) @@ -218,7 +220,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 1} can, err := ta.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("Forbidden, no access", func(t *testing.T) { @@ -228,7 +230,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 14} can, err := ta.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("Forbidden, shared read only", func(t *testing.T) { @@ -238,7 +240,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 15} can, err := ta.CanDelete(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) }) @@ -250,7 +252,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 1} can, err := ta.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("Forbidden, no access", func(t *testing.T) { @@ -260,7 +262,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 14} can, err := ta.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("Forbidden, shared read only", func(t *testing.T) { @@ -270,7 +272,7 @@ func TestTaskAttachment_Rights(t *testing.T) { ta := &TaskAttachment{TaskID: 15} can, err := ta.CanCreate(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) }) diff --git a/pkg/models/task_collection_sort_test.go b/pkg/models/task_collection_sort_test.go index 0f00755f8ef..d8385cbd3cd 100644 --- a/pkg/models/task_collection_sort_test.go +++ b/pkg/models/task_collection_sort_test.go @@ -20,6 +20,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestSortParamValidation(t *testing.T) { @@ -30,7 +31,7 @@ func TestSortParamValidation(t *testing.T) { sortBy: "id", } err := s.validate() - assert.NoError(t, err) + require.NoError(t, err) }) t.Run(orderDescending.String(), func(t *testing.T) { s := &sortParam{ @@ -38,7 +39,7 @@ func TestSortParamValidation(t *testing.T) { sortBy: "id", } err := s.validate() - assert.NoError(t, err) + require.NoError(t, err) }) }) t.Run("Test valid sort by", func(t *testing.T) { @@ -68,7 +69,7 @@ func TestSortParamValidation(t *testing.T) { sortBy: test, } err := s.validate() - assert.NoError(t, err) + require.NoError(t, err) }) } }) @@ -78,7 +79,7 @@ func TestSortParamValidation(t *testing.T) { sortBy: "id", } err := s.validate() - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrInvalidSortOrder(err)) }) t.Run("Test invalid sort by", func(t *testing.T) { @@ -87,7 +88,7 @@ func TestSortParamValidation(t *testing.T) { sortBy: "somethingInvalid", } err := s.validate() - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrInvalidTaskField(err)) }) } diff --git a/pkg/models/task_comments_test.go b/pkg/models/task_comments_test.go index d25f71c80b6..08264db913e 100644 --- a/pkg/models/task_comments_test.go +++ b/pkg/models/task_comments_test.go @@ -19,11 +19,12 @@ package models import ( "testing" - "code.vikunja.io/api/pkg/events" - "code.vikunja.io/api/pkg/db" + "code.vikunja.io/api/pkg/events" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTaskComment_Create(t *testing.T) { @@ -38,11 +39,11 @@ func TestTaskComment_Create(t *testing.T) { TaskID: 1, } err := tc.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "test", tc.Comment) assert.Equal(t, int64(1), tc.Author.ID) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) events.AssertDispatched(t, &TaskCommentCreatedEvent{}) db.AssertExists(t, "task_comments", map[string]interface{}{ @@ -62,7 +63,7 @@ func TestTaskComment_Create(t *testing.T) { TaskID: 99999, } err := tc.Create(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskDoesNotExist(err)) }) t.Run("should send notifications for comment mentions", func(t *testing.T) { @@ -71,13 +72,13 @@ func TestTaskComment_Create(t *testing.T) { defer s.Close() task, err := GetTaskByIDSimple(s, 32) - assert.NoError(t, err) + require.NoError(t, err) tc := &TaskComment{ Comment: "Lorem Ipsum @user2", TaskID: 32, // user2 has access to the project that task belongs to } err = tc.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) ev := &TaskCommentCreatedEvent{ Task: &task, Doer: u, @@ -103,9 +104,9 @@ func TestTaskComment_Delete(t *testing.T) { tc := &TaskComment{ID: 1} err := tc.Delete(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "task_comments", map[string]interface{}{ "id": 1, @@ -118,7 +119,7 @@ func TestTaskComment_Delete(t *testing.T) { tc := &TaskComment{ID: 9999} err := tc.Delete(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskCommentDoesNotExist(err)) }) t.Run("not the own comment", func(t *testing.T) { @@ -128,7 +129,7 @@ func TestTaskComment_Delete(t *testing.T) { tc := &TaskComment{ID: 1, TaskID: 1} can, err := tc.CanDelete(s, &user.User{ID: 2}) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) } @@ -146,9 +147,9 @@ func TestTaskComment_Update(t *testing.T) { Comment: "testing", } err := tc.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "task_comments", map[string]interface{}{ "id": 1, @@ -164,7 +165,7 @@ func TestTaskComment_Update(t *testing.T) { ID: 9999, } err := tc.Update(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskCommentDoesNotExist(err)) }) t.Run("not the own comment", func(t *testing.T) { @@ -174,7 +175,7 @@ func TestTaskComment_Update(t *testing.T) { tc := &TaskComment{ID: 1, TaskID: 1} can, err := tc.CanUpdate(s, &user.User{ID: 2}) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) } @@ -189,7 +190,7 @@ func TestTaskComment_ReadOne(t *testing.T) { tc := &TaskComment{ID: 1, TaskID: 1} err := tc.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "Lorem Ipsum Dolor Sit Amet", tc.Comment) assert.NotEmpty(t, tc.Author.ID) }) @@ -200,7 +201,7 @@ func TestTaskComment_ReadOne(t *testing.T) { tc := &TaskComment{ID: 9999} err := tc.ReadOne(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskCommentDoesNotExist(err)) }) } @@ -214,7 +215,7 @@ func TestTaskComment_ReadAll(t *testing.T) { tc := &TaskComment{TaskID: 1} u := &user.User{ID: 1} result, resultCount, total, err := tc.ReadAll(s, u, "", 0, -1) - assert.NoError(t, err) + require.NoError(t, err) resultComment := result.([]*TaskComment) assert.Equal(t, 1, resultCount) assert.Equal(t, int64(1), total) @@ -230,7 +231,7 @@ func TestTaskComment_ReadAll(t *testing.T) { tc := &TaskComment{TaskID: 14} u := &user.User{ID: 1} _, _, _, err := tc.ReadAll(s, u, "", 0, -1) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrGenericForbidden(err)) }) t.Run("comment from link share", func(t *testing.T) { @@ -241,7 +242,7 @@ func TestTaskComment_ReadAll(t *testing.T) { tc := &TaskComment{TaskID: 35} u := &user.User{ID: 1} result, _, _, err := tc.ReadAll(s, u, "", 0, -1) - assert.NoError(t, err) + require.NoError(t, err) comments := result.([]*TaskComment) assert.Len(t, comments, 2) var foundComment bool @@ -261,7 +262,7 @@ func TestTaskComment_ReadAll(t *testing.T) { tc := &TaskComment{TaskID: 35} u := &user.User{ID: 1} result, _, _, err := tc.ReadAll(s, u, "COMMENT 15", 0, -1) - assert.NoError(t, err) + require.NoError(t, err) resultComment := result.([]*TaskComment) assert.Equal(t, int64(15), resultComment[0].ID) }) diff --git a/pkg/models/task_overdue_reminder_test.go b/pkg/models/task_overdue_reminder_test.go index 8a01e088dca..84a9897e3da 100644 --- a/pkg/models/task_overdue_reminder_test.go +++ b/pkg/models/task_overdue_reminder_test.go @@ -22,6 +22,7 @@ import ( "code.vikunja.io/api/pkg/db" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestGetUndoneOverDueTasks(t *testing.T) { @@ -31,10 +32,10 @@ func TestGetUndoneOverDueTasks(t *testing.T) { defer s.Close() now, err := time.Parse(time.RFC3339Nano, "2018-01-01T01:13:00Z") - assert.NoError(t, err) + require.NoError(t, err) tasks, err := getUndoneOverdueTasks(s, now) - assert.NoError(t, err) - assert.Len(t, tasks, 0) + require.NoError(t, err) + assert.Empty(t, tasks) }) t.Run("undone overdue", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -42,9 +43,9 @@ func TestGetUndoneOverDueTasks(t *testing.T) { defer s.Close() now, err := time.Parse(time.RFC3339Nano, "2018-12-01T09:00:00Z") - assert.NoError(t, err) + require.NoError(t, err) uts, err := getUndoneOverdueTasks(s, now) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, uts, 1) assert.Len(t, uts[1].tasks, 2) // The tasks don't always have the same order, so we only check their presence, not their position. @@ -67,9 +68,9 @@ func TestGetUndoneOverDueTasks(t *testing.T) { defer s.Close() now, err := time.Parse(time.RFC3339Nano, "2018-11-01T01:13:00Z") - assert.NoError(t, err) + require.NoError(t, err) tasks, err := getUndoneOverdueTasks(s, now) - assert.NoError(t, err) - assert.Len(t, tasks, 0) + require.NoError(t, err) + assert.Empty(t, tasks) }) } diff --git a/pkg/models/task_relation_test.go b/pkg/models/task_relation_test.go index da79ae368e4..fe02ce60a5e 100644 --- a/pkg/models/task_relation_test.go +++ b/pkg/models/task_relation_test.go @@ -21,7 +21,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTaskRelation_Create(t *testing.T) { @@ -36,9 +38,9 @@ func TestTaskRelation_Create(t *testing.T) { RelationKind: RelationKindSubtask, } err := rel.Create(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "task_relations", map[string]interface{}{ "task_id": 1, "other_task_id": 2, @@ -57,9 +59,9 @@ func TestTaskRelation_Create(t *testing.T) { RelationKind: RelationKindSubtask, } err := rel.Create(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "task_relations", map[string]interface{}{ "task_id": 1, "other_task_id": 13, @@ -78,7 +80,7 @@ func TestTaskRelation_Create(t *testing.T) { RelationKind: RelationKindSubtask, } err := rel.Create(s, &user.User{ID: 1}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrRelationAlreadyExists(err)) }) t.Run("Same Task", func(t *testing.T) { @@ -91,7 +93,7 @@ func TestTaskRelation_Create(t *testing.T) { OtherTaskID: 1, } err := rel.Create(s, &user.User{ID: 1}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrRelationTasksCannotBeTheSame(err)) }) } @@ -110,9 +112,9 @@ func TestTaskRelation_Delete(t *testing.T) { RelationKind: RelationKindSubtask, } err := rel.Delete(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "task_relations", map[string]interface{}{ "task_id": 1, "other_task_id": 29, @@ -135,7 +137,7 @@ func TestTaskRelation_Delete(t *testing.T) { RelationKind: RelationKindSubtask, } err := rel.Delete(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrRelationDoesNotExist(err)) }) } @@ -152,7 +154,7 @@ func TestTaskRelation_CanCreate(t *testing.T) { RelationKind: RelationKindSubtask, } can, err := rel.CanCreate(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("Two tasks on different projects", func(t *testing.T) { @@ -166,7 +168,7 @@ func TestTaskRelation_CanCreate(t *testing.T) { RelationKind: RelationKindSubtask, } can, err := rel.CanCreate(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, can) }) t.Run("No update rights on base task", func(t *testing.T) { @@ -180,7 +182,7 @@ func TestTaskRelation_CanCreate(t *testing.T) { RelationKind: RelationKindSubtask, } can, err := rel.CanCreate(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("No update rights on base task, but read rights", func(t *testing.T) { @@ -194,7 +196,7 @@ func TestTaskRelation_CanCreate(t *testing.T) { RelationKind: RelationKindSubtask, } can, err := rel.CanCreate(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("No read rights on other task", func(t *testing.T) { @@ -208,7 +210,7 @@ func TestTaskRelation_CanCreate(t *testing.T) { RelationKind: RelationKindSubtask, } can, err := rel.CanCreate(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, can) }) t.Run("Nonexisting base task", func(t *testing.T) { @@ -222,7 +224,7 @@ func TestTaskRelation_CanCreate(t *testing.T) { RelationKind: RelationKindSubtask, } can, err := rel.CanCreate(s, &user.User{ID: 1}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskDoesNotExist(err)) assert.False(t, can) }) @@ -237,7 +239,7 @@ func TestTaskRelation_CanCreate(t *testing.T) { RelationKind: RelationKindSubtask, } can, err := rel.CanCreate(s, &user.User{ID: 1}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskDoesNotExist(err)) assert.False(t, can) }) diff --git a/pkg/models/task_reminder_test.go b/pkg/models/task_reminder_test.go index ced09167f96..66b1c9bea7c 100644 --- a/pkg/models/task_reminder_test.go +++ b/pkg/models/task_reminder_test.go @@ -21,7 +21,9 @@ import ( "time" "code.vikunja.io/api/pkg/db" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestReminderGetTasksInTheNextMinute(t *testing.T) { @@ -31,9 +33,9 @@ func TestReminderGetTasksInTheNextMinute(t *testing.T) { defer s.Close() now, err := time.Parse(time.RFC3339Nano, "2018-12-01T01:12:00Z") - assert.NoError(t, err) + require.NoError(t, err) notifications, err := getTasksWithRemindersDueAndTheirUsers(s, now) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, notifications, 1) assert.Equal(t, int64(27), notifications[0].Task.ID) }) @@ -43,9 +45,9 @@ func TestReminderGetTasksInTheNextMinute(t *testing.T) { defer s.Close() now, err := time.Parse(time.RFC3339Nano, "2018-12-02T01:13:00Z") - assert.NoError(t, err) + require.NoError(t, err) taskIDs, err := getTasksWithRemindersDueAndTheirUsers(s, now) - assert.NoError(t, err) - assert.Len(t, taskIDs, 0) + require.NoError(t, err) + assert.Empty(t, taskIDs) }) } diff --git a/pkg/models/tasks_test.go b/pkg/models/tasks_test.go index a50d506419d..6e730f56584 100644 --- a/pkg/models/tasks_test.go +++ b/pkg/models/tasks_test.go @@ -25,6 +25,7 @@ import ( "code.vikunja.io/api/pkg/user" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "xorm.io/builder" ) @@ -48,7 +49,7 @@ func TestTask_Create(t *testing.T) { ProjectID: 1, } err := task.Create(s, usr) - assert.NoError(t, err) + require.NoError(t, err) // Assert getting a uid assert.NotEmpty(t, task.UID) // Assert getting a new index @@ -57,7 +58,7 @@ func TestTask_Create(t *testing.T) { // Assert moving it into the default bucket assert.Equal(t, int64(1), task.BucketID) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "tasks", map[string]interface{}{ "id": task.ID, @@ -100,7 +101,7 @@ func TestTask_Create(t *testing.T) { }, }} err := task.Create(s, usr) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, time.Date(2023, time.March, 7, 22, 5, 1, 0, time.Local), task.Reminders[0].Reminder) assert.Equal(t, int64(1), task.Reminders[0].RelativePeriod) assert.Equal(t, ReminderRelationDueDate, task.Reminders[0].RelativeTo) @@ -110,7 +111,7 @@ func TestTask_Create(t *testing.T) { assert.Equal(t, ReminderRelationEndDate, task.Reminders[2].RelativeTo) assert.Equal(t, time.Date(2023, time.March, 7, 23, 0, 0, 0, time.Local), task.Reminders[3].Reminder) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("empty title", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -123,7 +124,7 @@ func TestTask_Create(t *testing.T) { ProjectID: 1, } err := task.Create(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskCannotBeEmpty(err)) }) t.Run("nonexistant project", func(t *testing.T) { @@ -137,7 +138,7 @@ func TestTask_Create(t *testing.T) { ProjectID: 9999999, } err := task.Create(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrProjectDoesNotExist(err)) }) t.Run("nonexistant user", func(t *testing.T) { @@ -152,7 +153,7 @@ func TestTask_Create(t *testing.T) { ProjectID: 1, } err := task.Create(s, nUser) - assert.Error(t, err) + require.Error(t, err) assert.True(t, user.IsErrUserDoesNotExist(err)) }) t.Run("full bucket", func(t *testing.T) { @@ -167,7 +168,7 @@ func TestTask_Create(t *testing.T) { BucketID: 2, // Bucket 2 already has 3 tasks and a limit of 3 } err := task.Create(s, usr) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrBucketLimitExceeded(err)) }) t.Run("default bucket different", func(t *testing.T) { @@ -181,7 +182,7 @@ func TestTask_Create(t *testing.T) { ProjectID: 6, } err := task.Create(s, usr) - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "tasks", map[string]interface{}{ "id": task.ID, "bucket_id": 22, // default bucket of project 6 but with a position of 2 @@ -204,9 +205,9 @@ func TestTask_Update(t *testing.T) { ProjectID: 1, } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "tasks", map[string]interface{}{ "id": 1, @@ -227,7 +228,7 @@ func TestTask_Update(t *testing.T) { ProjectID: 1, } err := task.Update(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskDoesNotExist(err)) }) t.Run("full bucket", func(t *testing.T) { @@ -243,7 +244,7 @@ func TestTask_Update(t *testing.T) { BucketID: 2, // Bucket 2 already has 3 tasks and a limit of 3 } err := task.Update(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrBucketLimitExceeded(err)) }) t.Run("full bucket but not changing the bucket", func(t *testing.T) { @@ -260,7 +261,7 @@ func TestTask_Update(t *testing.T) { BucketID: 2, // Bucket 2 already has 3 tasks and a limit of 3 } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("bucket on other project", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -275,7 +276,7 @@ func TestTask_Update(t *testing.T) { BucketID: 4, // Bucket 4 belongs to project 2 } err := task.Update(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrBucketDoesNotBelongToProject(err)) }) t.Run("moving a task to the done bucket", func(t *testing.T) { @@ -290,9 +291,9 @@ func TestTask_Update(t *testing.T) { BucketID: 3, // Bucket 3 is the done bucket } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, task.Done) db.AssertExists(t, "tasks", map[string]interface{}{ @@ -316,9 +317,9 @@ func TestTask_Update(t *testing.T) { RepeatAfter: 3600, } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, task.Done) assert.Equal(t, int64(1), task.BucketID) // Bucket should not be updated @@ -340,9 +341,9 @@ func TestTask_Update(t *testing.T) { ProjectID: 2, } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, int64(4), task.BucketID) // bucket 4 is the default bucket on project 2 assert.True(t, task.Done) // bucket 4 is the done bucket, so the task should be marked as done as well @@ -357,9 +358,9 @@ func TestTask_Update(t *testing.T) { Done: true, } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, task.Done) assert.Equal(t, int64(3), task.BucketID) @@ -379,9 +380,9 @@ func TestTask_Update(t *testing.T) { ProjectID: 2, } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "tasks", map[string]interface{}{ "id": 1, @@ -400,9 +401,9 @@ func TestTask_Update(t *testing.T) { RepeatAfter: 3600, } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, task.Done) assert.Equal(t, int64(1), task.BucketID) @@ -422,9 +423,9 @@ func TestTask_Update(t *testing.T) { ProjectID: 2, // From project 1 } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, int64(3), task.Index) }) @@ -458,7 +459,7 @@ func TestTask_Update(t *testing.T) { }, }} err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, time.Date(2023, time.March, 7, 22, 5, 1, 0, time.Local), task.Reminders[0].Reminder) assert.Equal(t, int64(1), task.Reminders[0].RelativePeriod) assert.Equal(t, ReminderRelationDueDate, task.Reminders[0].RelativeTo) @@ -468,7 +469,7 @@ func TestTask_Update(t *testing.T) { assert.Equal(t, ReminderRelationEndDate, task.Reminders[2].RelativeTo) assert.Equal(t, time.Date(2023, time.March, 7, 23, 0, 0, 0, time.Local), task.Reminders[3].Reminder) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertCount(t, "task_reminders", builder.Eq{"task_id": 1}, 4) }) t.Run("the same reminder multiple times should be saved once", func(t *testing.T) { @@ -490,9 +491,9 @@ func TestTask_Update(t *testing.T) { ProjectID: 1, } err := task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertCount(t, "task_reminders", builder.Eq{"task_id": 1}, 1) }) t.Run("update relative reminder when start_date changes", func(t *testing.T) { @@ -512,21 +513,21 @@ func TestTask_Update(t *testing.T) { }, }} err := taskBefore.Create(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, time.Date(2022, time.March, 8, 8, 4, 20, 0, time.Local), taskBefore.Reminders[0].Reminder) // when start_date is modified task := taskBefore task.StartDate = time.Date(2023, time.March, 8, 8, 5, 0, 0, time.Local) err = task.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) // then reminder time is updated assert.Equal(t, time.Date(2023, time.March, 8, 8, 4, 0, 0, time.Local), task.Reminders[0].Reminder) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) }) } @@ -540,9 +541,9 @@ func TestTask_Delete(t *testing.T) { ID: 1, } err := task.Delete(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "tasks", map[string]interface{}{ "id": 1, @@ -920,7 +921,7 @@ func TestTask_ReadOne(t *testing.T) { task := &Task{ID: 1} err := task.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "task #1", task.Title) }) t.Run("nonexisting", func(t *testing.T) { @@ -930,7 +931,7 @@ func TestTask_ReadOne(t *testing.T) { task := &Task{ID: 99999} err := task.ReadOne(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTaskDoesNotExist(err)) }) t.Run("with subscription", func(t *testing.T) { @@ -940,7 +941,7 @@ func TestTask_ReadOne(t *testing.T) { task := &Task{ID: 22} err := task.ReadOne(s, &user.User{ID: 6}) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, task.Subscription) }) t.Run("created by link share", func(t *testing.T) { @@ -950,7 +951,7 @@ func TestTask_ReadOne(t *testing.T) { task := &Task{ID: 37} err := task.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "task #37", task.Title) assert.Equal(t, int64(-2), task.CreatedByID) assert.NotNil(t, task.CreatedBy) @@ -963,7 +964,7 @@ func TestTask_ReadOne(t *testing.T) { task := &Task{ID: 1} err := task.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, task.IsFavorite) }) t.Run("favorite for a different user", func(t *testing.T) { @@ -973,7 +974,7 @@ func TestTask_ReadOne(t *testing.T) { task := &Task{ID: 1} err := task.ReadOne(s, &user.User{ID: 2}) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, task.IsFavorite) }) } diff --git a/pkg/models/team_members_test.go b/pkg/models/team_members_test.go index 0be00f6ecbc..3d0f21d54ae 100644 --- a/pkg/models/team_members_test.go +++ b/pkg/models/team_members_test.go @@ -21,7 +21,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTeamMember_Create(t *testing.T) { @@ -40,9 +42,9 @@ func TestTeamMember_Create(t *testing.T) { Username: "user3", } err := tm.Create(s, doer) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "team_members", map[string]interface{}{ "id": tm.ID, @@ -60,7 +62,7 @@ func TestTeamMember_Create(t *testing.T) { Username: "user1", } err := tm.Create(s, doer) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUserIsMemberOfTeam(err)) }) t.Run("nonexisting user", func(t *testing.T) { @@ -73,7 +75,7 @@ func TestTeamMember_Create(t *testing.T) { Username: "nonexistinguser", } err := tm.Create(s, doer) - assert.Error(t, err) + require.Error(t, err) assert.True(t, user.IsErrUserDoesNotExist(err)) }) t.Run("nonexisting team", func(t *testing.T) { @@ -86,7 +88,7 @@ func TestTeamMember_Create(t *testing.T) { Username: "user1", } err := tm.Create(s, doer) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamDoesNotExist(err)) }) } @@ -102,9 +104,9 @@ func TestTeamMember_Delete(t *testing.T) { Username: "user1", } err := tm.Delete(s, &user.User{ID: 1}) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "team_members", map[string]interface{}{ "team_id": 1, @@ -127,10 +129,10 @@ func TestTeamMember_Update(t *testing.T) { Admin: true, } err := tm.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, tm.Admin) // Since this endpoint toggles the right, we should get a false for admin back. err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "team_members", map[string]interface{}{ "team_id": 1, @@ -151,10 +153,10 @@ func TestTeamMember_Update(t *testing.T) { Admin: true, } err := tm.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, tm.Admin) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "team_members", map[string]interface{}{ "team_id": 1, diff --git a/pkg/models/teams_test.go b/pkg/models/teams_test.go index 0cf74ed2651..627cbc24940 100644 --- a/pkg/models/teams_test.go +++ b/pkg/models/teams_test.go @@ -22,7 +22,9 @@ import ( "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTeam_Create(t *testing.T) { @@ -40,9 +42,9 @@ func TestTeam_Create(t *testing.T) { Description: "Lorem Ispum", } err := team.Create(s, doer) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "teams", map[string]interface{}{ "id": team.ID, "name": "Testteam293", @@ -56,7 +58,7 @@ func TestTeam_Create(t *testing.T) { team := &Team{} err := team.Create(s, doer) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamNameCannotBeEmpty(err)) }) } @@ -71,7 +73,7 @@ func TestTeam_ReadOne(t *testing.T) { team := &Team{ID: 1} err := team.ReadOne(s, u) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "testteam1", team.Name) assert.Equal(t, "Lorem Ipsum", team.Description) assert.Equal(t, int64(1), team.CreatedBy.ID) @@ -84,7 +86,7 @@ func TestTeam_ReadOne(t *testing.T) { team := &Team{ID: -1} err := team.ReadOne(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamDoesNotExist(err)) }) t.Run("nonexisting", func(t *testing.T) { @@ -94,7 +96,7 @@ func TestTeam_ReadOne(t *testing.T) { team := &Team{ID: 99999} err := team.ReadOne(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamDoesNotExist(err)) }) } @@ -107,8 +109,8 @@ func TestTeam_ReadAll(t *testing.T) { team := &Team{} teams, _, _, err := team.ReadAll(s, doer, "", 1, 50) - assert.NoError(t, err) - assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) + require.NoError(t, err) + assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind()) ts := reflect.ValueOf(teams) assert.Equal(t, 5, ts.Len()) }) @@ -118,8 +120,8 @@ func TestTeam_ReadAll(t *testing.T) { team := &Team{} teams, _, _, err := team.ReadAll(s, doer, "READ_only_on_project6", 1, 50) - assert.NoError(t, err) - assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) + require.NoError(t, err) + assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind()) ts := teams.([]*Team) assert.Len(t, ts, 1) assert.Equal(t, int64(2), ts[0].ID) @@ -139,9 +141,9 @@ func TestTeam_Update(t *testing.T) { Name: "SomethingNew", } err := team.Update(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "teams", map[string]interface{}{ "id": team.ID, "name": "SomethingNew", @@ -157,7 +159,7 @@ func TestTeam_Update(t *testing.T) { Name: "", } err := team.Update(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamNameCannotBeEmpty(err)) }) t.Run("nonexisting", func(t *testing.T) { @@ -170,7 +172,7 @@ func TestTeam_Update(t *testing.T) { Name: "SomethingNew", } err := team.Update(s, u) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrTeamDoesNotExist(err)) }) } @@ -187,9 +189,9 @@ func TestTeam_Delete(t *testing.T) { ID: 1, } err := team.Delete(s, u) - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "teams", map[string]interface{}{ "id": 1, }) @@ -197,13 +199,13 @@ func TestTeam_Delete(t *testing.T) { } func TestIsErrInvalidRight(t *testing.T) { - assert.NoError(t, RightAdmin.isValid()) - assert.NoError(t, RightRead.isValid()) - assert.NoError(t, RightWrite.isValid()) + require.NoError(t, RightAdmin.isValid()) + require.NoError(t, RightRead.isValid()) + require.NoError(t, RightWrite.isValid()) // Check invalid var tr Right = 938 err := tr.isValid() - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrInvalidRight(err)) } diff --git a/pkg/models/user_delete_test.go b/pkg/models/user_delete_test.go index 9955b7362a5..220bb6e0ce5 100644 --- a/pkg/models/user_delete_test.go +++ b/pkg/models/user_delete_test.go @@ -23,7 +23,7 @@ import ( "code.vikunja.io/api/pkg/notifications" "code.vikunja.io/api/pkg/user" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestDeleteUser(t *testing.T) { @@ -36,7 +36,7 @@ func TestDeleteUser(t *testing.T) { u := &user.User{ID: 6} err := DeleteUser(s, u) - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "users", map[string]interface{}{"id": u.ID}) db.AssertMissing(t, "projects", map[string]interface{}{"id": 24}) // only user6 had access to this project db.AssertExists(t, "projects", map[string]interface{}{"id": 6}, false) @@ -55,7 +55,7 @@ func TestDeleteUser(t *testing.T) { u := &user.User{ID: 4} err := DeleteUser(s, u) - assert.NoError(t, err) + require.NoError(t, err) // No assertions for deleted projects since that user doesn't have any }) t.Run("user with a default project", func(t *testing.T) { @@ -67,7 +67,7 @@ func TestDeleteUser(t *testing.T) { u := &user.User{ID: 16} err := DeleteUser(s, u) - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "users", map[string]interface{}{"id": u.ID}) db.AssertMissing(t, "projects", map[string]interface{}{"id": 37}) // only user16 had access to this project, and it was their default }) diff --git a/pkg/modules/auth/openid/openid_test.go b/pkg/modules/auth/openid/openid_test.go index 47d0846b757..18da67eb7e5 100644 --- a/pkg/modules/auth/openid/openid_test.go +++ b/pkg/modules/auth/openid/openid_test.go @@ -20,7 +20,9 @@ import ( "testing" "code.vikunja.io/api/pkg/db" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestGetOrCreateUser(t *testing.T) { @@ -34,9 +36,9 @@ func TestGetOrCreateUser(t *testing.T) { PreferredUsername: "someUserWhoDoesNotExistYet", } u, err := getOrCreateUser(s, cl, "https://some.issuer", "12345") - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "users", map[string]interface{}{ "id": u.ID, @@ -54,10 +56,10 @@ func TestGetOrCreateUser(t *testing.T) { PreferredUsername: "", } u, err := getOrCreateUser(s, cl, "https://some.issuer", "12345") - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, u.Username) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "users", map[string]interface{}{ "id": u.ID, @@ -73,7 +75,7 @@ func TestGetOrCreateUser(t *testing.T) { Email: "", } _, err := getOrCreateUser(s, cl, "https://some.issuer", "12345") - assert.Error(t, err) + require.Error(t, err) }) t.Run("existing user, different email address", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -84,9 +86,9 @@ func TestGetOrCreateUser(t *testing.T) { Email: "other-email-address@some.service.com", } u, err := getOrCreateUser(s, cl, "https://some.service.com", "12345") - assert.NoError(t, err) + require.NoError(t, err) err = s.Commit() - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "users", map[string]interface{}{ "id": u.ID, diff --git a/pkg/modules/migration/create_from_structure_test.go b/pkg/modules/migration/create_from_structure_test.go index 69fc1261678..41395436ad7 100644 --- a/pkg/modules/migration/create_from_structure_test.go +++ b/pkg/modules/migration/create_from_structure_test.go @@ -23,7 +23,9 @@ import ( "code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/user" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestInsertFromStructure(t *testing.T) { @@ -135,7 +137,7 @@ func TestInsertFromStructure(t *testing.T) { }, } err := InsertFromStructure(testStructure, u) - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "projects", map[string]interface{}{ "title": testStructure[1].Title, "description": testStructure[1].Description, diff --git a/pkg/modules/migration/microsoft-todo/microsoft_todo_test.go b/pkg/modules/migration/microsoft-todo/microsoft_todo_test.go index 69d55d481eb..eee93af445f 100644 --- a/pkg/modules/migration/microsoft-todo/microsoft_todo_test.go +++ b/pkg/modules/migration/microsoft-todo/microsoft_todo_test.go @@ -21,8 +21,10 @@ import ( "time" "code.vikunja.io/api/pkg/models" + "github.com/d4l3k/messagediff" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestConverting(t *testing.T) { @@ -33,7 +35,7 @@ func TestConverting(t *testing.T) { } testtimeTime, err := time.Parse(time.RFC3339Nano, "2020-12-18T03:00:00.4770000Z") - assert.NoError(t, err) + require.NoError(t, err) microsoftTodoData := []*project{ { @@ -188,7 +190,7 @@ func TestConverting(t *testing.T) { } hierachie, err := convertMicrosoftTodoData(microsoftTodoData) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, hierachie) if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal { t.Errorf("converted microsoft todo data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff) diff --git a/pkg/modules/migration/ticktick/ticktick_test.go b/pkg/modules/migration/ticktick/ticktick_test.go index 5e9792418f2..f77fc549e9a 100644 --- a/pkg/modules/migration/ticktick/ticktick_test.go +++ b/pkg/modules/migration/ticktick/ticktick_test.go @@ -99,41 +99,41 @@ func TestConvertTicktickTasksToVikunja(t *testing.T) { assert.Equal(t, vikunjaTasks[1].Tasks[0].StartDate, tickTickTasks[0].StartDate.Time) assert.Equal(t, vikunjaTasks[1].Tasks[0].EndDate, tickTickTasks[0].DueDate.Time) assert.Equal(t, vikunjaTasks[1].Tasks[0].DueDate, tickTickTasks[0].DueDate.Time) - assert.Equal(t, vikunjaTasks[1].Tasks[0].Labels, []*models.Label{ + assert.Equal(t, []*models.Label{ {Title: "label1"}, {Title: "label2"}, - }) + }, vikunjaTasks[1].Tasks[0].Labels) assert.Equal(t, vikunjaTasks[1].Tasks[0].Reminders[0].RelativeTo, models.ReminderRelation("due_date")) assert.Equal(t, vikunjaTasks[1].Tasks[0].Reminders[0].RelativePeriod, int64(-24*3600)) assert.Equal(t, vikunjaTasks[1].Tasks[0].Position, tickTickTasks[0].Order) - assert.Equal(t, vikunjaTasks[1].Tasks[0].Done, false) + assert.False(t, vikunjaTasks[1].Tasks[0].Done) assert.Equal(t, vikunjaTasks[1].Tasks[1].Title, tickTickTasks[1].Title) assert.Equal(t, vikunjaTasks[1].Tasks[1].Position, tickTickTasks[1].Order) - assert.Equal(t, vikunjaTasks[1].Tasks[1].Done, true) + assert.True(t, vikunjaTasks[1].Tasks[1].Done) assert.Equal(t, vikunjaTasks[1].Tasks[1].DoneAt, tickTickTasks[1].CompletedTime.Time) - assert.Equal(t, vikunjaTasks[1].Tasks[1].RelatedTasks, models.RelatedTaskMap{ + assert.Equal(t, models.RelatedTaskMap{ models.RelationKindParenttask: []*models.Task{ { ID: tickTickTasks[1].ParentID, }, }, - }) + }, vikunjaTasks[1].Tasks[1].RelatedTasks) assert.Equal(t, vikunjaTasks[1].Tasks[2].Title, tickTickTasks[2].Title) assert.Equal(t, vikunjaTasks[1].Tasks[2].Description, tickTickTasks[2].Content) assert.Equal(t, vikunjaTasks[1].Tasks[2].StartDate, tickTickTasks[2].StartDate.Time) assert.Equal(t, vikunjaTasks[1].Tasks[2].EndDate, tickTickTasks[2].DueDate.Time) assert.Equal(t, vikunjaTasks[1].Tasks[2].DueDate, tickTickTasks[2].DueDate.Time) - assert.Equal(t, vikunjaTasks[1].Tasks[2].Labels, []*models.Label{ + assert.Equal(t, []*models.Label{ {Title: "label1"}, {Title: "label2"}, {Title: "other label"}, - }) + }, vikunjaTasks[1].Tasks[2].Labels) assert.Equal(t, vikunjaTasks[1].Tasks[2].Reminders[0].RelativeTo, models.ReminderRelation("due_date")) assert.Equal(t, vikunjaTasks[1].Tasks[2].Reminders[0].RelativePeriod, int64(-24*3600)) assert.Equal(t, vikunjaTasks[1].Tasks[2].Position, tickTickTasks[2].Order) - assert.Equal(t, vikunjaTasks[1].Tasks[2].Done, false) + assert.False(t, vikunjaTasks[1].Tasks[2].Done) assert.Len(t, vikunjaTasks[2].Tasks, 1) assert.Equal(t, vikunjaTasks[2].Title, tickTickTasks[3].ProjectName) diff --git a/pkg/modules/migration/todoist/todoist_test.go b/pkg/modules/migration/todoist/todoist_test.go index 1fa145dcea2..d94cfac309b 100644 --- a/pkg/modules/migration/todoist/todoist_test.go +++ b/pkg/modules/migration/todoist/todoist_test.go @@ -24,7 +24,9 @@ import ( "code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/models" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gopkg.in/d4l3k/messagediff.v1" ) @@ -33,21 +35,21 @@ func TestConvertTodoistToVikunja(t *testing.T) { config.InitConfig() time1, err := time.Parse(time.RFC3339Nano, "2014-09-26T08:25:05Z") - assert.NoError(t, err) + require.NoError(t, err) time1 = time1.In(config.GetTimeZone()) time3, err := time.Parse(time.RFC3339Nano, "2014-10-21T08:25:05Z") - assert.NoError(t, err) + require.NoError(t, err) time3 = time3.In(config.GetTimeZone()) dueTime, err := time.Parse(time.RFC3339Nano, "2020-05-31T23:59:00Z") - assert.NoError(t, err) + require.NoError(t, err) dueTime = dueTime.In(config.GetTimeZone()) dueTimeWithTime, err := time.Parse(time.RFC3339Nano, "2021-01-31T19:00:00Z") - assert.NoError(t, err) + require.NoError(t, err) dueTimeWithTime = dueTimeWithTime.In(config.GetTimeZone()) nilTime, err := time.Parse(time.RFC3339Nano, "0001-01-01T00:00:00Z") - assert.NoError(t, err) + require.NoError(t, err) exampleFile, err := os.ReadFile(config.ServiceRootpath.GetString() + "/pkg/modules/migration/testimage.jpg") - assert.NoError(t, err) + require.NoError(t, err) makeTestItem := func(id, projectId string, hasDueDate, hasLabels, done bool) *item { item := &item{ @@ -629,7 +631,7 @@ func TestConvertTodoistToVikunja(t *testing.T) { doneItems := make(map[string]*doneItem) hierachie, err := convertTodoistToVikunja(testSync, doneItems) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, hierachie) if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal { t.Errorf("converted todoist data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff) diff --git a/pkg/modules/migration/trello/trello_test.go b/pkg/modules/migration/trello/trello_test.go index 32201b095d1..febc38c2b0f 100644 --- a/pkg/modules/migration/trello/trello_test.go +++ b/pkg/modules/migration/trello/trello_test.go @@ -25,9 +25,11 @@ import ( "code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/models" + "github.com/adlio/trello" "github.com/d4l3k/messagediff" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestConvertTrelloToVikunja(t *testing.T) { @@ -35,9 +37,9 @@ func TestConvertTrelloToVikunja(t *testing.T) { config.InitConfig() time1, err := time.Parse(time.RFC3339Nano, "2014-09-26T08:25:05Z") - assert.NoError(t, err) + require.NoError(t, err) exampleFile, err := os.ReadFile(config.ServiceRootpath.GetString() + "/pkg/modules/migration/testimage.jpg") - assert.NoError(t, err) + require.NoError(t, err) trelloData := []*trello.Board{ { @@ -365,7 +367,7 @@ func TestConvertTrelloToVikunja(t *testing.T) { } hierachie, err := convertTrelloDataToVikunja(trelloData, "") - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, hierachie) if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal { t.Errorf("converted trello data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff) diff --git a/pkg/modules/migration/vikunja-file/vikunja_test.go b/pkg/modules/migration/vikunja-file/vikunja_test.go index b619a660942..7d8b4d04eb6 100644 --- a/pkg/modules/migration/vikunja-file/vikunja_test.go +++ b/pkg/modules/migration/vikunja-file/vikunja_test.go @@ -23,7 +23,8 @@ import ( "code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/user" - "github.com/stretchr/testify/assert" + + "github.com/stretchr/testify/require" ) func TestVikunjaFileMigrator_Migrate(t *testing.T) { @@ -44,7 +45,7 @@ func TestVikunjaFileMigrator_Migrate(t *testing.T) { } err = m.Migrate(u, f, s.Size()) - assert.NoError(t, err) + require.NoError(t, err) db.AssertExists(t, "projects", map[string]interface{}{ "title": "test project", "owner_id": u.ID, @@ -91,7 +92,7 @@ func TestVikunjaFileMigrator_Migrate(t *testing.T) { } err = m.Migrate(u, f, s.Size()) - assert.Error(t, err) - assert.ErrorContainsf(t, err, "export was created with an older version", "Invalid error message") + require.Error(t, err) + require.ErrorContainsf(t, err, "export was created with an older version", "Invalid error message") }) } diff --git a/pkg/notifications/mail_test.go b/pkg/notifications/mail_test.go index c2de40e0ef5..4a8d3034f32 100644 --- a/pkg/notifications/mail_test.go +++ b/pkg/notifications/mail_test.go @@ -20,6 +20,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNewMail(t *testing.T) { @@ -97,7 +98,7 @@ func TestRenderMail(t *testing.T) { Line("And one more, because why not?") mailopts, err := RenderMail(mail) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, mail.from, mailopts.From) assert.Equal(t, mail.to, mailopts.To) diff --git a/pkg/notifications/notification_test.go b/pkg/notifications/notification_test.go index 826fb970c60..509d01c331d 100644 --- a/pkg/notifications/notification_test.go +++ b/pkg/notifications/notification_test.go @@ -20,7 +20,8 @@ import ( "testing" "code.vikunja.io/api/pkg/db" - "github.com/stretchr/testify/assert" + + "github.com/stretchr/testify/require" "xorm.io/xorm/schemas" ) @@ -73,7 +74,7 @@ func TestNotify(t *testing.T) { s := db.NewSession() defer s.Close() _, err := s.Exec("delete from notifications") - assert.NoError(t, err) + require.NoError(t, err) tn := &testNotification{ Test: "somethingsomething", @@ -84,7 +85,7 @@ func TestNotify(t *testing.T) { } err = Notify(tnf, tn) - assert.NoError(t, err) + require.NoError(t, err) vals := map[string]interface{}{ "notifiable_id": 42, "notification": "'{\"other_value\":42,\"test\":\"somethingsomething\"}'", @@ -107,7 +108,7 @@ func TestNotify(t *testing.T) { s := db.NewSession() defer s.Close() _, err := s.Exec("delete from notifications") - assert.NoError(t, err) + require.NoError(t, err) tn := &testNotification{ Test: "somethingsomething", @@ -118,7 +119,7 @@ func TestNotify(t *testing.T) { } err = Notify(tnf, tn) - assert.NoError(t, err) + require.NoError(t, err) db.AssertMissing(t, "notifications", map[string]interface{}{ "notifiable_id": 42, }) diff --git a/pkg/routes/caldav/listStorageProvider_test.go b/pkg/routes/caldav/listStorageProvider_test.go index 06cfba5ce00..9e46aa0140f 100644 --- a/pkg/routes/caldav/listStorageProvider_test.go +++ b/pkg/routes/caldav/listStorageProvider_test.go @@ -29,6 +29,7 @@ import ( "github.com/samedi/caldav-go/data" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // Check logic related to creating sub-tasks @@ -78,7 +79,7 @@ END:VCALENDAR` // Create the subtask: taskResource, err := storage.CreateResource(taskUID, taskContent) - assert.NoError(t, err) + require.NoError(t, err) // Check that the result CALDAV contains the relation: content, _ := taskResource.GetContentData() @@ -87,7 +88,7 @@ END:VCALENDAR` // Get the task from the DB: tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task := tasks[0] // Check that the parent-child relationship is present: @@ -129,7 +130,7 @@ END:VCALENDAR` // Create the subtask: _, err := storage.CreateResource(taskUIDChild, taskContentChild) - assert.NoError(t, err) + require.NoError(t, err) const taskUID = "uid_grand_child1" const taskContent = `BEGIN:VCALENDAR @@ -157,7 +158,7 @@ END:VCALENDAR` // Create the task: var taskResource *data.Resource taskResource, err = storage.CreateResource(taskUID, taskContent) - assert.NoError(t, err) + require.NoError(t, err) // Check that the result CALDAV contains the relation: content, _ := taskResource.GetContentData() @@ -166,7 +167,7 @@ END:VCALENDAR` // Get the task from the DB: tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task := tasks[0] // Check that the parent-child relationship of the grandchildren is present: @@ -176,7 +177,7 @@ END:VCALENDAR` // Get the child task and check that it now has a parent and a child: tasks, err = models.GetTasksByUIDs(s, []string{"uid_child1"}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] assert.Len(t, task.RelatedTasks[models.RelationKindParenttask], 1) parentTask = task.RelatedTasks[models.RelationKindParenttask][0] @@ -220,7 +221,7 @@ END:VCALENDAR` // Create the task: taskResource, err := storage.CreateResource(taskUID, taskContent) - assert.NoError(t, err) + require.NoError(t, err) // Check that the result CALDAV contains the relation: content, _ := taskResource.GetContentData() @@ -229,7 +230,7 @@ END:VCALENDAR` // Get the task from the DB: tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task := tasks[0] // Check that the parent-child relationship is present: @@ -239,7 +240,7 @@ END:VCALENDAR` // Check that the non-existent parent task was created in the process: tasks, err = models.GetTasksByUIDs(s, []string{"uid-caldav-test-parent-doesnt-exist-yet"}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] assert.Equal(t, "uid-caldav-test-parent-doesnt-exist-yet", task.UID) }) @@ -279,7 +280,7 @@ RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task END:VTODO END:VCALENDAR` tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task := tasks[0] storage := &VikunjaCaldavProjectStorage{ project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, @@ -289,7 +290,7 @@ END:VCALENDAR` // Edit the task: taskResource, err := storage.UpdateResource(taskUID, taskContent) - assert.NoError(t, err) + require.NoError(t, err) // Check that the result CALDAV still contains the relation: content, _ := taskResource.GetContentData() @@ -298,7 +299,7 @@ END:VCALENDAR` // Get the task from the DB: tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] // Check that the parent-child relationship is still present: @@ -334,7 +335,7 @@ RELATED-TO;RELTYPE=CHILD:uid-caldav-test-child-task-2 END:VTODO END:VCALENDAR` tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task := tasks[0] storage := &VikunjaCaldavProjectStorage{ project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, @@ -344,11 +345,11 @@ END:VCALENDAR` // Edit the task: _, err = storage.UpdateResource(taskUID, taskContent) - assert.NoError(t, err) + require.NoError(t, err) // Get the task from the DB: tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] // Check that the subtasks are still linked: @@ -385,7 +386,7 @@ RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task-2 END:VTODO END:VCALENDAR` tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task := tasks[0] storage := &VikunjaCaldavProjectStorage{ project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, @@ -395,7 +396,7 @@ END:VCALENDAR` // Edit the task: taskResource, err := storage.UpdateResource(taskUID, taskContent) - assert.NoError(t, err) + require.NoError(t, err) // Check that the result CALDAV contains the new relation: content, _ := taskResource.GetContentData() @@ -404,7 +405,7 @@ END:VCALENDAR` // Get the task from the DB: tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] // Check that the parent-child relationship has changed to the new parent: @@ -414,7 +415,7 @@ END:VCALENDAR` // Get the previous parent from the DB and check that its previous child is gone: tasks, err = models.GetTasksByUIDs(s, []string{"uid-caldav-test-parent-task"}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] assert.Len(t, task.RelatedTasks[models.RelationKindSubtask], 1) // We're gone, but our former sibling is still there: @@ -447,7 +448,7 @@ LAST-MODIFIED:20230301T073337Z END:VTODO END:VCALENDAR` tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task := tasks[0] storage := &VikunjaCaldavProjectStorage{ project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, @@ -457,7 +458,7 @@ END:VCALENDAR` // Edit the task: taskResource, err := storage.UpdateResource(taskUID, taskContent) - assert.NoError(t, err) + require.NoError(t, err) // Check that the result CALDAV contains the new relation: content, _ := taskResource.GetContentData() @@ -466,15 +467,15 @@ END:VCALENDAR` // Get the task from the DB: tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] // Check that the parent-child relationship is gone: - assert.Len(t, task.RelatedTasks[models.RelationKindParenttask], 0) + assert.Empty(t, task.RelatedTasks[models.RelationKindParenttask]) // Get the previous parent from the DB and check that its child is gone: tasks, err = models.GetTasksByUIDs(s, []string{"uid-caldav-test-parent-task"}, u) - assert.NoError(t, err) + require.NoError(t, err) task = tasks[0] // We're gone, but our former sibling is still there: assert.Len(t, task.RelatedTasks[models.RelationKindSubtask], 1) diff --git a/pkg/user/user_test.go b/pkg/user/user_test.go index a0460d28a36..f7ef9b13974 100644 --- a/pkg/user/user_test.go +++ b/pkg/user/user_test.go @@ -22,6 +22,7 @@ import ( "code.vikunja.io/api/pkg/db" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "xorm.io/builder" ) @@ -39,7 +40,7 @@ func TestCreateUser(t *testing.T) { defer s.Close() createdUser, err := CreateUser(s, dummyuser) - assert.NoError(t, err) + require.NoError(t, err) assert.NotZero(t, createdUser.Created) }) t.Run("already existing", func(t *testing.T) { @@ -52,7 +53,7 @@ func TestCreateUser(t *testing.T) { Password: "12345", Email: "email@example.com", }) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUsernameExists(err)) }) t.Run("same email", func(t *testing.T) { @@ -65,7 +66,7 @@ func TestCreateUser(t *testing.T) { Password: "12345", Email: "user1@example.com", }) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUserEmailExists(err)) }) t.Run("no username", func(t *testing.T) { @@ -78,7 +79,7 @@ func TestCreateUser(t *testing.T) { Password: "12345", Email: "user1@example.com", }) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNoUsernamePassword(err)) }) t.Run("no password", func(t *testing.T) { @@ -91,7 +92,7 @@ func TestCreateUser(t *testing.T) { Password: "", Email: "user1@example.com", }) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNoUsernamePassword(err)) }) t.Run("no email", func(t *testing.T) { @@ -104,7 +105,7 @@ func TestCreateUser(t *testing.T) { Password: "12345", Email: "", }) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNoUsernamePassword(err)) }) t.Run("same email but different issuer", func(t *testing.T) { @@ -118,7 +119,7 @@ func TestCreateUser(t *testing.T) { Issuer: "https://some.site", Subject: "12345", }) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("same subject but different issuer", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -131,7 +132,7 @@ func TestCreateUser(t *testing.T) { Issuer: "https://some.site", Subject: "12345", }) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("space in username", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -143,7 +144,7 @@ func TestCreateUser(t *testing.T) { Password: "12345", Email: "user1@example.com", }) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUsernameMustNotContainSpaces(err)) }) } @@ -161,8 +162,8 @@ func TestGetUser(t *testing.T) { }, false, ) - assert.NoError(t, err) - assert.Equal(t, theuser.ID, int64(1)) + require.NoError(t, err) + assert.Equal(t, int64(1), theuser.ID) assert.Empty(t, theuser.Email) }) t.Run("by email", func(t *testing.T) { @@ -176,8 +177,8 @@ func TestGetUser(t *testing.T) { Email: "user1@example.com", }, false) - assert.NoError(t, err) - assert.Equal(t, theuser.ID, int64(1)) + require.NoError(t, err) + assert.Equal(t, int64(1), theuser.ID) assert.Empty(t, theuser.Email) }) t.Run("by id", func(t *testing.T) { @@ -186,9 +187,9 @@ func TestGetUser(t *testing.T) { defer s.Close() theuser, err := GetUserByID(s, 1) - assert.NoError(t, err) - assert.Equal(t, theuser.ID, int64(1)) - assert.Equal(t, theuser.Username, "user1") + require.NoError(t, err) + assert.Equal(t, int64(1), theuser.ID) + assert.Equal(t, "user1", theuser.Username) assert.Empty(t, theuser.Email) }) t.Run("invalid id", func(t *testing.T) { @@ -197,7 +198,7 @@ func TestGetUser(t *testing.T) { defer s.Close() _, err := GetUserByID(s, 99999) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUserDoesNotExist(err)) }) t.Run("nonexistant", func(t *testing.T) { @@ -206,7 +207,7 @@ func TestGetUser(t *testing.T) { defer s.Close() _, err := GetUserByID(s, 0) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUserDoesNotExist(err)) }) t.Run("empty name", func(t *testing.T) { @@ -215,7 +216,7 @@ func TestGetUser(t *testing.T) { defer s.Close() _, err := GetUserByUsername(s, "") - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUserDoesNotExist(err)) }) t.Run("with email", func(t *testing.T) { @@ -224,9 +225,9 @@ func TestGetUser(t *testing.T) { defer s.Close() theuser, err := GetUserWithEmail(s, &User{ID: 1}) - assert.NoError(t, err) - assert.Equal(t, theuser.ID, int64(1)) - assert.Equal(t, theuser.Username, "user1") + require.NoError(t, err) + assert.Equal(t, int64(1), theuser.ID) + assert.Equal(t, "user1", theuser.Username) assert.NotEmpty(t, theuser.Email) }) } @@ -238,7 +239,7 @@ func TestCheckUserCredentials(t *testing.T) { defer s.Close() _, err := CheckUserCredentials(s, &Login{Username: "user1", Password: "1234"}) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("unverified email", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -246,7 +247,7 @@ func TestCheckUserCredentials(t *testing.T) { defer s.Close() _, err := CheckUserCredentials(s, &Login{Username: "user5", Password: "1234"}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrEmailNotConfirmed(err)) }) t.Run("wrong password", func(t *testing.T) { @@ -255,7 +256,7 @@ func TestCheckUserCredentials(t *testing.T) { defer s.Close() _, err := CheckUserCredentials(s, &Login{Username: "user1", Password: "12345"}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrWrongUsernameOrPassword(err)) }) t.Run("nonexistant user", func(t *testing.T) { @@ -264,7 +265,7 @@ func TestCheckUserCredentials(t *testing.T) { defer s.Close() _, err := CheckUserCredentials(s, &Login{Username: "dfstestuu", Password: "1234"}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrWrongUsernameOrPassword(err)) }) t.Run("empty password", func(t *testing.T) { @@ -273,7 +274,7 @@ func TestCheckUserCredentials(t *testing.T) { defer s.Close() _, err := CheckUserCredentials(s, &Login{Username: "user1"}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNoUsernamePassword(err)) }) t.Run("empty username", func(t *testing.T) { @@ -282,7 +283,7 @@ func TestCheckUserCredentials(t *testing.T) { defer s.Close() _, err := CheckUserCredentials(s, &Login{Password: "1234"}) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNoUsernamePassword(err)) }) t.Run("email", func(t *testing.T) { @@ -291,7 +292,7 @@ func TestCheckUserCredentials(t *testing.T) { defer s.Close() _, err := CheckUserCredentials(s, &Login{Username: "user1@example.com", Password: "1234"}) - assert.NoError(t, err) + require.NoError(t, err) }) } @@ -306,7 +307,7 @@ func TestUpdateUser(t *testing.T) { Password: "LoremIpsum", Email: "testing@example.com", }, false) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "$2a$14$dcadBoMBL9jQoOcZK8Fju.cy0Ptx2oZECkKLnaa8ekRoTFe1w7To.", uuser.Password) // Password should not change assert.Equal(t, "user1", uuser.Username) // Username should not change either }) @@ -319,7 +320,7 @@ func TestUpdateUser(t *testing.T) { ID: 1, Username: "changedname", }, false) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "$2a$14$dcadBoMBL9jQoOcZK8Fju.cy0Ptx2oZECkKLnaa8ekRoTFe1w7To.", uuser.Password) // Password should not change assert.Equal(t, "changedname", uuser.Username) }) @@ -331,7 +332,7 @@ func TestUpdateUser(t *testing.T) { _, err := UpdateUser(s, &User{ ID: 99999, }, false) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUserDoesNotExist(err)) }) } @@ -345,7 +346,7 @@ func TestUpdateUserPassword(t *testing.T) { err := UpdateUserPassword(s, &User{ ID: 1, }, "12345") - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("nonexistant user", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -355,7 +356,7 @@ func TestUpdateUserPassword(t *testing.T) { err := UpdateUserPassword(s, &User{ ID: 9999, }, "12345") - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrUserDoesNotExist(err)) }) t.Run("empty password", func(t *testing.T) { @@ -366,7 +367,7 @@ func TestUpdateUserPassword(t *testing.T) { err := UpdateUserPassword(s, &User{ ID: 1, }, "") - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrEmptyNewPassword(err)) }) } @@ -378,9 +379,9 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "user1", nil) - assert.NoError(t, err) - assert.True(t, len(all) > 0) - assert.Equal(t, all[0].Username, "user1") + require.NoError(t, err) + assert.NotEmpty(t, all) + assert.Equal(t, "user1", all[0].Username) }) t.Run("case insensitive", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -388,9 +389,9 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "uSEr1", nil) - assert.NoError(t, err) - assert.True(t, len(all) > 0) - assert.Equal(t, all[0].Username, "user1") + require.NoError(t, err) + assert.NotEmpty(t, len(all)) + assert.Equal(t, "user1", all[0].Username) }) t.Run("all users", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -398,7 +399,7 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListAllUsers(s) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, all, 16) }) t.Run("no search term", func(t *testing.T) { @@ -407,8 +408,8 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "", nil) - assert.NoError(t, err) - assert.Len(t, all, 0) + require.NoError(t, err) + assert.Empty(t, all) }) t.Run("not discoverable by email", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -416,8 +417,8 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "user1@example.com", nil) - assert.NoError(t, err) - assert.Len(t, all, 0) + require.NoError(t, err) + assert.Empty(t, all) db.AssertExists(t, "users", map[string]interface{}{ "email": "user1@example.com", "discoverable_by_email": false, @@ -429,8 +430,8 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "one else", nil) - assert.NoError(t, err) - assert.Len(t, all, 0) + require.NoError(t, err) + assert.Empty(t, all) db.AssertExists(t, "users", map[string]interface{}{ "name": "Some one else", "discoverable_by_name": false, @@ -442,7 +443,7 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "user7@example.com", nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, all, 1) assert.Equal(t, int64(7), all[0].ID) db.AssertExists(t, "users", map[string]interface{}{ @@ -456,7 +457,7 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "with space", nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, all, 1) assert.Equal(t, int64(12), all[0].ID) db.AssertExists(t, "users", map[string]interface{}{ @@ -470,7 +471,7 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "user7@example.com", &ProjectUserOpts{AdditionalCond: builder.In("id", 7)}) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, all, 1) assert.Equal(t, int64(7), all[0].ID) db.AssertExists(t, "users", map[string]interface{}{ @@ -484,7 +485,7 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "user7", nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, all, 1) assert.Equal(t, int64(7), all[0].ID) db.AssertExists(t, "users", map[string]interface{}{ @@ -497,8 +498,8 @@ func TestListUsers(t *testing.T) { defer s.Close() all, err := ListUsers(s, "user", nil) - assert.NoError(t, err) - assert.Len(t, all, 0) + require.NoError(t, err) + assert.Empty(t, all) db.AssertExists(t, "users", map[string]interface{}{ "username": "user7", }, false) @@ -511,7 +512,7 @@ func TestListUsers(t *testing.T) { all, err := ListUsers(s, "user", &ProjectUserOpts{ MatchFuzzily: true, }) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, all, 16) }) } @@ -527,7 +528,7 @@ func TestUserPasswordReset(t *testing.T) { NewPassword: "12345", } err := ResetPassword(s, reset) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("without password", func(t *testing.T) { db.LoadAndAssertFixtures(t) @@ -538,7 +539,7 @@ func TestUserPasswordReset(t *testing.T) { Token: "passwordresettesttoken", } err := ResetPassword(s, reset) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNoUsernamePassword(err)) }) t.Run("empty token", func(t *testing.T) { @@ -551,7 +552,7 @@ func TestUserPasswordReset(t *testing.T) { NewPassword: "12345", } err := ResetPassword(s, reset) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrNoPasswordResetToken(err)) }) t.Run("wrong token", func(t *testing.T) { @@ -564,7 +565,7 @@ func TestUserPasswordReset(t *testing.T) { NewPassword: "12345", } err := ResetPassword(s, reset) - assert.Error(t, err) + require.Error(t, err) assert.True(t, IsErrInvalidPasswordResetToken(err)) }) } diff --git a/pkg/utils/random_test.go b/pkg/utils/random_test.go index f877c4d8542..461ac557c92 100644 --- a/pkg/utils/random_test.go +++ b/pkg/utils/random_test.go @@ -24,6 +24,6 @@ import ( func TestMakeRandomString(t *testing.T) { rand := MakeRandomString(32) - assert.NotEqual(t, rand, "loremipsuim") - assert.Equal(t, len(rand), 32) + assert.NotEqual(t, "loremipsuim", rand) + assert.Len(t, rand, 32) }