diff --git a/.golangci.yml b/.golangci.yml index 24c9e5b035..69e9782115 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 c7b9bf2060..f60700f4af 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 a375d42187..4ca27c86e5 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 8b6c1c408d..3b9100b131 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 d9f84c0524..cd33959e46 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 d98e030379..91f0d55e6a 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 40ea347eaf..22af6fe437 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 4ccde721f5..7fde9e0014 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 c9e3b35580..86559259db 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 a1cc8e68ec..671de1c06c 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 ded69c42d2..0dd933b818 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 205184bd0b..9f760b45c1 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 91e714393e..e874be3160 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 796ef37d15..bc6e5adea4 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 c28d76ba50..e144817b35 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 6a9fa38346..f8e9be9f18 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 b035200933..cb17df4f07 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 41001dab90..1eb303c4be 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 1c1933bb00..3e507cedf7 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 be2e28455c..c09f4b0852 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 55c5f034a7..761941d3c1 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 52dae7e668..0b30aa7c24 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 e73cc8716b..2e585e5437 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 a47e1ae4a4..0370dd73e8 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 5987d79744..5e94c4ffe0 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 163e1adadd..5dbdafd4fc 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 c82c126138..c62212a1e4 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 bd9b5e374c..b38a97c3f5 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 ad5ee119f7..9ddd3709de 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 181d67ca1f..8ff69a9df5 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 3b42e79b21..07353bc5ca 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 43545b988d..0f4ee23c6c 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 26ef67c213..0f3957791f 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 ef13b1bd44..f53fd3ba31 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 0db7090780..04d44d6fa5 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 96357b01a9..e9ad3a87f1 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 7c4940c019..3943d08646 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 33df50276e..5bf7dfd8d8 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 f05e4c82b1..d9770a0004 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 0f00755f8e..d8385cbd3c 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 d25f71c80b..08264db913 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 8a01e088dc..84a9897e3d 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 da79ae368e..fe02ce60a5 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 ced09167f9..66b1c9bea7 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 a50d506419..6e730f5658 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 0be00f6ecb..3d0f21d54a 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 0cf74ed265..627cbc2494 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 9955b7362a..220bb6e0ce 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 47d0846b75..18da67eb7e 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 69fc126167..41395436ad 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 69d55d481e..eee93af445 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 5e9792418f..f77fc549e9 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 1fa145dcea..d94cfac309 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 32201b095d..febc38c2b0 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 b619a66094..7d8b4d04eb 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 c2de40e0ef..4a8d3034f3 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 826fb970c6..509d01c331 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 06cfba5ce0..9e46aa0140 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 a0460d28a3..f7ef9b1397 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 f877c4d854..461ac557c9 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) }