mvaldes14
/
vikunja-api
forked from vikunja/vikunja
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(deps): update golangci-lint rules

This commit is contained in:
kolaente 2023-12-19 13:34:31 +01:00
parent 48a173a563
commit c05f51b923
Signed by untrusted user: konrad
GPG Key ID: F40E70337AB24C9B
60 changed files with 999 additions and 921 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.golangci.yml
View File

@ -6,7 +6,6 @@ linters:
enable: enable:
- megacheck - megacheck
- govet - govet
- goconst
- gocritic - gocritic
- gocyclo - gocyclo
- goerr113 - goerr113
@ -18,6 +17,7 @@ linters:
disable: disable:
- scopelint # Obsolete, using exportloopref instead - scopelint # Obsolete, using exportloopref instead
- durationcheck - durationcheck
- goconst
presets: presets:
- bugs - bugs
- unused - unused
@ -54,7 +54,6 @@ issues:
- path: pkg/migration/* - path: pkg/migration/*
linters: linters:
- exhaustive - exhaustive
- goconst
- goerr113 - goerr113
- path: pkg/models/task_collection_filter\.go - path: pkg/models/task_collection_filter\.go
linters: linters:
@ -97,12 +96,6 @@ issues:
- musttag - musttag
- path: pkg/models/task_collection.go - path: pkg/models/task_collection.go
text: 'append result not assigned to the same slice' 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: linters:
- goconst - testifylint
- text: 'string `labels` has 3 occurrences, make it a constant'
linters:
- goconst
- text: 'string `off` has 6 occurrences, make it a constant'
linters:
- goconst

2
magefile.go
View File

@ -412,7 +412,7 @@ func checkGolangCiLintInstalled() {
mg.Deps(initVars) mg.Deps(initVars)
if err := exec.Command("golangci-lint").Run(); err != nil && strings.Contains(err.Error(), "executable file not found") { 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("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) os.Exit(1)
} }
} }

11
pkg/db/test.go
View File

@ -26,6 +26,7 @@ import (
"code.vikunja.io/api/pkg/log" "code.vikunja.io/api/pkg/log"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"xorm.io/builder" "xorm.io/builder"
"xorm.io/xorm" "xorm.io/xorm"
"xorm.io/xorm/names" "xorm.io/xorm/names"
@ -93,14 +94,14 @@ func AssertExists(t *testing.T, table string, values map[string]interface{}, cus
} else { } else {
exists, err = x.Table(table).Where(values).Get(&v) 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 { if !exists {
all := []map[string]interface{}{} all := []map[string]interface{}{}
err = x.Table(table).Find(&all) 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, "", " ") 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))) 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{}) { func AssertMissing(t *testing.T, table string, values map[string]interface{}) {
v := make(map[string]interface{}) v := make(map[string]interface{})
exists, err := x.Table(table).Where(values).Exist(&v) 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)) 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 // AssertCount checks if a number of entries exists in the database
func AssertCount(t *testing.T, table string, where builder.Cond, count int64) { func AssertCount(t *testing.T, table string, where builder.Cond, count int64) {
dbCount, err := x.Table(table).Where(where).Count() 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)) assert.Equal(t, count, dbCount, fmt.Sprintf("Found %d entries instead of expected %d in table %s", dbCount, count, table))
} }

5
pkg/db/test_fixtures.go
View File

@ -22,8 +22,9 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/config"
"github.com/go-testfixtures/testfixtures/v3" "github.com/go-testfixtures/testfixtures/v3"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
"xorm.io/xorm/schemas" "xorm.io/xorm/schemas"
) )
@ -108,5 +109,5 @@ func LoadFixtures() error {
// LoadAndAssertFixtures loads all fixtures defined before and asserts they are correctly loaded // LoadAndAssertFixtures loads all fixtures defined before and asserts they are correctly loaded
func LoadAndAssertFixtures(t *testing.T) { func LoadAndAssertFixtures(t *testing.T) {
err := LoadFixtures() err := LoadFixtures()
assert.NoError(t, err) require.NoError(t, err)
} }

6
pkg/events/testing.go
View File

@ -22,8 +22,8 @@ import (
"github.com/ThreeDotsLabs/watermill" "github.com/ThreeDotsLabs/watermill"
"github.com/ThreeDotsLabs/watermill/message" "github.com/ThreeDotsLabs/watermill/message"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
var ( 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. // TestListener takes an event and a listener and calls the listener's Handle method.
func TestListener(t *testing.T, event Event, listener Listener) { func TestListener(t *testing.T, event Event, listener Listener) {
content, err := json.Marshal(event) content, err := json.Marshal(event)
assert.NoError(t, err) require.NoError(t, err)
msg := message.NewMessage(watermill.NewUUID(), content) msg := message.NewMessage(watermill.NewUUID(), content)
err = listener.Handle(msg) err = listener.Handle(msg)
assert.NoError(t, err) require.NoError(t, err)
} }

4
pkg/files/filehandling.go
View File

@ -26,7 +26,7 @@ import (
"code.vikunja.io/api/pkg/modules/keyvalue" "code.vikunja.io/api/pkg/modules/keyvalue"
"github.com/spf13/afero" "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 // This file handles storing and retrieving a file for different backends
@ -57,7 +57,7 @@ func InitTestFileFixtures(t *testing.T) {
// Init fixture files // Init fixture files
filename := config.FilesBasePath.GetString() + "/1" filename := config.FilesBasePath.GetString() + "/1"
err := afero.WriteFile(afs, filename, []byte("testfile1"), 0644) 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 // InitTests handles the actual bootstrapping of the test env

19
pkg/files/files_test.go
View File

@ -22,6 +22,7 @@ import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
type testfile struct { type testfile struct {
@ -58,12 +59,12 @@ func TestCreate(t *testing.T) {
} }
ta := &testauth{id: 1} ta := &testauth{id: 1}
createdFile, err := Create(tf, "testfile", 100, ta) createdFile, err := Create(tf, "testfile", 100, ta)
assert.NoError(t, err) require.NoError(t, err)
// Check the file was created correctly // Check the file was created correctly
file := &File{ID: createdFile.ID} file := &File{ID: createdFile.ID}
err = file.LoadFileMetaByID() err = file.LoadFileMetaByID()
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, int64(1), file.CreatedByID) assert.Equal(t, int64(1), file.CreatedByID)
assert.Equal(t, "testfile", file.Name) assert.Equal(t, "testfile", file.Name)
assert.Equal(t, uint64(100), file.Size) assert.Equal(t, uint64(100), file.Size)
@ -76,7 +77,7 @@ func TestCreate(t *testing.T) {
} }
ta := &testauth{id: 1} ta := &testauth{id: 1}
_, err := Create(tf, "testfile", 99999999999, ta) _, err := Create(tf, "testfile", 99999999999, ta)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrFileIsTooLarge(err)) assert.True(t, IsErrFileIsTooLarge(err))
}) })
} }
@ -86,13 +87,13 @@ func TestFile_Delete(t *testing.T) {
initFixtures(t) initFixtures(t)
f := &File{ID: 1} f := &File{ID: 1}
err := f.Delete() err := f.Delete()
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
initFixtures(t) initFixtures(t)
f := &File{ID: 9999} f := &File{ID: 9999}
err := f.Delete() err := f.Delete()
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrFileDoesNotExist(err)) assert.True(t, IsErrFileDoesNotExist(err))
}) })
} }
@ -102,13 +103,13 @@ func TestFile_LoadFileByID(t *testing.T) {
initFixtures(t) initFixtures(t)
f := &File{ID: 1} f := &File{ID: 1}
err := f.LoadFileByID() err := f.LoadFileByID()
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
initFixtures(t) initFixtures(t)
f := &File{ID: 9999} f := &File{ID: 9999}
err := f.LoadFileByID() err := f.LoadFileByID()
assert.Error(t, err) require.Error(t, err)
assert.True(t, os.IsNotExist(err)) assert.True(t, os.IsNotExist(err))
}) })
} }
@ -118,14 +119,14 @@ func TestFile_LoadFileMetaByID(t *testing.T) {
initFixtures(t) initFixtures(t)
f := &File{ID: 1} f := &File{ID: 1}
err := f.LoadFileMetaByID() err := f.LoadFileMetaByID()
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, "test", f.Name) assert.Equal(t, "test", f.Name)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
initFixtures(t) initFixtures(t)
f := &File{ID: 9999} f := &File{ID: 9999}
err := f.LoadFileMetaByID() err := f.LoadFileMetaByID()
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrFileDoesNotExist(err)) assert.True(t, IsErrFileDoesNotExist(err))
}) })
} }

25
pkg/integrations/api_tokens_test.go
View File

@ -28,12 +28,13 @@ import (
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestAPIToken(t *testing.T) { func TestAPIToken(t *testing.T) {
t.Run("valid token", func(t *testing.T) { t.Run("valid token", func(t *testing.T) {
e, err := setupTestEnv() e, err := setupTestEnv()
assert.NoError(t, err) require.NoError(t, err)
req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil)
res := httptest.NewRecorder() res := httptest.NewRecorder()
c := e.NewContext(req, res) c := e.NewContext(req, res)
@ -47,13 +48,13 @@ func TestAPIToken(t *testing.T) {
}) })
req.Header.Set(echo.HeaderAuthorization, "Bearer tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e") // Token 1 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 // check if the request handlers "see" the request as if it came directly from that user
assert.Contains(t, res.Body.String(), `"username":"user1"`) assert.Contains(t, res.Body.String(), `"username":"user1"`)
}) })
t.Run("invalid token", func(t *testing.T) { t.Run("invalid token", func(t *testing.T) {
e, err := setupTestEnv() e, err := setupTestEnv()
assert.NoError(t, err) require.NoError(t, err)
req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil)
res := httptest.NewRecorder() res := httptest.NewRecorder()
c := e.NewContext(req, res) c := e.NewContext(req, res)
@ -62,11 +63,11 @@ func TestAPIToken(t *testing.T) {
}) })
req.Header.Set(echo.HeaderAuthorization, "Bearer tk_loremipsumdolorsitamet") 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) { t.Run("expired token", func(t *testing.T) {
e, err := setupTestEnv() e, err := setupTestEnv()
assert.NoError(t, err) require.NoError(t, err)
req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil)
res := httptest.NewRecorder() res := httptest.NewRecorder()
c := e.NewContext(req, res) c := e.NewContext(req, res)
@ -75,11 +76,11 @@ func TestAPIToken(t *testing.T) {
}) })
req.Header.Set(echo.HeaderAuthorization, "Bearer tk_a5e6f92ddbad68f49ee2c63e52174db0235008c8") // Token 2 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) { t.Run("valid token, invalid scope", func(t *testing.T) {
e, err := setupTestEnv() e, err := setupTestEnv()
assert.NoError(t, err) require.NoError(t, err)
req := httptest.NewRequest(http.MethodGet, "/api/v1/projects", nil) req := httptest.NewRequest(http.MethodGet, "/api/v1/projects", nil)
res := httptest.NewRecorder() res := httptest.NewRecorder()
c := e.NewContext(req, res) c := e.NewContext(req, res)
@ -88,11 +89,11 @@ func TestAPIToken(t *testing.T) {
}) })
req.Header.Set(echo.HeaderAuthorization, "Bearer tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e") 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) { t.Run("jwt", func(t *testing.T) {
e, err := setupTestEnv() e, err := setupTestEnv()
assert.NoError(t, err) require.NoError(t, err)
req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil) req := httptest.NewRequest(http.MethodGet, "/api/v1/tasks/all", nil)
res := httptest.NewRecorder() res := httptest.NewRecorder()
c := e.NewContext(req, res) c := e.NewContext(req, res)
@ -103,11 +104,11 @@ func TestAPIToken(t *testing.T) {
s := db.NewSession() s := db.NewSession()
defer s.Close() defer s.Close()
u, err := user.GetUserByID(s, 1) u, err := user.GetUserByID(s, 1)
assert.NoError(t, err) require.NoError(t, err)
jwt, err := auth.NewUserJWTAuthtoken(u, false) jwt, err := auth.NewUserJWTAuthtoken(u, false)
assert.NoError(t, err) require.NoError(t, err)
req.Header.Set(echo.HeaderAuthorization, "Bearer "+jwt) req.Header.Set(echo.HeaderAuthorization, "Bearer "+jwt)
assert.NoError(t, h(c)) require.NoError(t, h(c))
}) })
} }

34
pkg/integrations/archived_test.go
View File

@ -21,7 +21,9 @@ import (
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
// This tests the following behaviour: // This tests the following behaviour:
@ -96,47 +98,47 @@ func TestArchived(t *testing.T) {
t.Run("task", func(t *testing.T) { t.Run("task", func(t *testing.T) {
t.Run("edit task", func(t *testing.T) { t.Run("edit task", func(t *testing.T) {
_, err := testTaskHandler.testUpdateWithUser(nil, map[string]string{"projecttask": taskID}, `{"title":"TestIpsum"}`) _, err := testTaskHandler.testUpdateWithUser(nil, map[string]string{"projecttask": taskID}, `{"title":"TestIpsum"}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("delete", func(t *testing.T) { t.Run("delete", func(t *testing.T) {
_, err := testTaskHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID}) _, err := testTaskHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("add new labels", func(t *testing.T) { t.Run("add new labels", func(t *testing.T) {
_, err := testLabelHandler.testCreateWithUser(nil, map[string]string{"projecttask": taskID}, `{"label_id":1}`) _, err := testLabelHandler.testCreateWithUser(nil, map[string]string{"projecttask": taskID}, `{"label_id":1}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("remove lables", func(t *testing.T) { t.Run("remove lables", func(t *testing.T) {
_, err := testLabelHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID, "label": "4"}) _, err := testLabelHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID, "label": "4"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("add assignees", func(t *testing.T) { t.Run("add assignees", func(t *testing.T) {
_, err := testAssigneeHandler.testCreateWithUser(nil, map[string]string{"projecttask": taskID}, `{"user_id":3}`) _, err := testAssigneeHandler.testCreateWithUser(nil, map[string]string{"projecttask": taskID}, `{"user_id":3}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("remove assignees", func(t *testing.T) { t.Run("remove assignees", func(t *testing.T) {
_, err := testAssigneeHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID, "user": "2"}) _, err := testAssigneeHandler.testDeleteWithUser(nil, map[string]string{"projecttask": taskID, "user": "2"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("add relation", func(t *testing.T) { t.Run("add relation", func(t *testing.T) {
_, err := testRelationHandler.testCreateWithUser(nil, map[string]string{"task": taskID}, `{"other_task_id":1,"relation_kind":"related"}`) _, 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) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("remove relation", func(t *testing.T) { t.Run("remove relation", func(t *testing.T) {
_, err := testRelationHandler.testDeleteWithUser(nil, map[string]string{"task": taskID}, `{"other_task_id":2,"relation_kind":"related"}`) _, 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) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("add comment", func(t *testing.T) { t.Run("add comment", func(t *testing.T) {
_, err := testCommentHandler.testCreateWithUser(nil, map[string]string{"task": taskID}, `{"comment":"Lorem"}`) _, err := testCommentHandler.testCreateWithUser(nil, map[string]string{"task": taskID}, `{"comment":"Lorem"}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
t.Run("remove comment", func(t *testing.T) { t.Run("remove comment", func(t *testing.T) {
@ -145,7 +147,7 @@ func TestArchived(t *testing.T) {
commentID = "16" commentID = "16"
} }
_, err := testCommentHandler.testDeleteWithUser(nil, map[string]string{"task": taskID, "commentid": commentID}) _, err := testCommentHandler.testDeleteWithUser(nil, map[string]string{"task": taskID, "commentid": commentID})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, errCode) assertHandlerErrorCode(t, err, errCode)
}) })
}) })
@ -155,17 +157,17 @@ func TestArchived(t *testing.T) {
t.Run("archived parent project", func(t *testing.T) { t.Run("archived parent project", func(t *testing.T) {
t.Run("not editable", 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}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived)
}) })
t.Run("no new tasks", func(t *testing.T) { t.Run("no new tasks", func(t *testing.T) {
_, err := testTaskHandler.testCreateWithUser(nil, map[string]string{"project": "21"}, `{"title":"Lorem"}`) _, err := testTaskHandler.testCreateWithUser(nil, map[string]string{"project": "21"}, `{"title":"Lorem"}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived)
}) })
t.Run("not unarchivable", func(t *testing.T) { t.Run("not unarchivable", func(t *testing.T) {
_, err := testProjectHandler.testUpdateWithUser(nil, map[string]string{"project": "21"}, `{"title":"LoremIpsum","is_archived":false}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived)
}) })
@ -175,17 +177,17 @@ func TestArchived(t *testing.T) {
t.Run("archived individually", func(t *testing.T) { t.Run("archived individually", func(t *testing.T) {
t.Run("not editable", 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}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived)
}) })
t.Run("no new tasks", func(t *testing.T) { t.Run("no new tasks", func(t *testing.T) {
_, err := testTaskHandler.testCreateWithUser(nil, map[string]string{"project": "22"}, `{"title":"Lorem"}`) _, err := testTaskHandler.testCreateWithUser(nil, map[string]string{"project": "22"}, `{"title":"Lorem"}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived) assertHandlerErrorCode(t, err, models.ErrCodeProjectIsArchived)
}) })
t.Run("unarchivable", func(t *testing.T) { t.Run("unarchivable", func(t *testing.T) {
rec, err := testProjectHandler.testUpdateWithUser(nil, map[string]string{"project": "22"}, `{"title":"LoremIpsum","is_archived":false}`) 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`) assert.Contains(t, rec.Body.String(), `"is_archived":false`)
}) })

58
pkg/integrations/caldav_test.go
View File

@ -21,14 +21,16 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/routes/caldav" "code.vikunja.io/api/pkg/routes/caldav"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestCaldav(t *testing.T) { func TestCaldav(t *testing.T) {
t.Run("Delivers VTODO for project", func(t *testing.T) { t.Run("Delivers VTODO for project", func(t *testing.T) {
e, _ := setupTestEnv() e, _ := setupTestEnv()
rec, err := newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.ProjectHandler, &testuser15, ``, nil, map[string]string{"project": "36"}) 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(), "BEGIN:VCALENDAR")
assert.Contains(t, rec.Body.String(), "PRODID:-//Vikunja Todo App//EN") 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") assert.Contains(t, rec.Body.String(), "X-WR-CALNAME:Project 36 for Caldav tests")
@ -59,13 +61,13 @@ END:VCALENDAR`
e, _ := setupTestEnv() e, _ := setupTestEnv()
rec, err := newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, vtodo, nil, map[string]string{"project": "36", "task": "uid"}) 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) assert.Equal(t, 201, rec.Result().StatusCode)
}) })
t.Run("Export VTODO", func(t *testing.T) { t.Run("Export VTODO", func(t *testing.T) {
e, _ := setupTestEnv() e, _ := setupTestEnv()
rec, err := newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test"}) 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(), "BEGIN:VCALENDAR")
assert.Contains(t, rec.Body.String(), "SUMMARY:Title Caldav Test") assert.Contains(t, rec.Body.String(), "SUMMARY:Title Caldav Test")
assert.Contains(t, rec.Body.String(), "DESCRIPTION:Description Caldav Test") assert.Contains(t, rec.Body.String(), "DESCRIPTION:Description Caldav Test")
@ -123,21 +125,21 @@ END:VTODO`
const parentVTODO = vtodoHeader + vtodoParentTaskStub + vtodoFooter 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"}) 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) assert.Equal(t, 201, rec.Result().StatusCode)
const childVTODO = vtodoHeader + vtodoChildTaskStub + vtodoFooter 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"}) 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) assert.Equal(t, 201, rec.Result().StatusCode)
const grandChildVTODO = vtodoHeader + vtodoGrandChildTaskStub + vtodoFooter 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"}) 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) assert.Equal(t, 201, rec.Result().StatusCode)
rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.ProjectHandler, &testuser15, ``, nil, map[string]string{"project": "36"}) 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.Equal(t, 200, rec.Result().StatusCode)
assert.Contains(t, rec.Body.String(), "UID:uid_parent_import") assert.Contains(t, rec.Body.String(), "UID:uid_parent_import")
@ -164,7 +166,7 @@ END:VTODO`
const grandChildVTODO = vtodoHeader + vtodoGrandChildTaskStub + vtodoFooter 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"}) 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) assert.Equal(t, 201, rec.Result().StatusCode)
const vtodoChildTaskStub = `BEGIN:VTODO const vtodoChildTaskStub = `BEGIN:VTODO
@ -179,7 +181,7 @@ END:VTODO`
const childVTODO = vtodoHeader + vtodoChildTaskStub + vtodoFooter 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"}) 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) assert.Equal(t, 201, rec.Result().StatusCode)
const vtodoParentTaskStub = `BEGIN:VTODO const vtodoParentTaskStub = `BEGIN:VTODO
@ -193,11 +195,11 @@ END:VTODO`
const parentVTODO = vtodoHeader + vtodoParentTaskStub + vtodoFooter 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"}) 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) assert.Equal(t, 201, rec.Result().StatusCode)
rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.ProjectHandler, &testuser15, ``, nil, map[string]string{"project": "36"}) 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.Equal(t, 200, rec.Result().StatusCode)
assert.Contains(t, rec.Body.String(), "UID:uid_parent_import") assert.Contains(t, rec.Body.String(), "UID:uid_parent_import")
@ -213,15 +215,15 @@ END:VTODO`
e, _ := setupTestEnv() e, _ := setupTestEnv()
rec, err := newCaldavTestRequestWithUser(t, e, http.MethodDelete, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-child-task"}) 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) 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"}) 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) 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"}) 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.Equal(t, 200, rec.Result().StatusCode)
assert.NotContains(t, rec.Body.String(), "RELATED-TO;RELTYPE=CHILD:uid-caldav-test-child-task") assert.NotContains(t, rec.Body.String(), "RELATED-TO;RELTYPE=CHILD:uid-caldav-test-child-task")
@ -232,11 +234,11 @@ END:VTODO`
e, _ := setupTestEnv() e, _ := setupTestEnv()
rec, err := newCaldavTestRequestWithUser(t, e, http.MethodDelete, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid-caldav-test-parent-task"}) 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) 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"}) 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.Equal(t, 200, rec.Result().StatusCode)
assert.NotContains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task") assert.NotContains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task")
@ -280,22 +282,22 @@ END:VCALENDAR`
e, _ := setupTestEnv() e, _ := setupTestEnv()
rec, err := newCaldavTestRequestWithUser(t, e, http.MethodPut, caldav.TaskHandler, &testuser15, vtodoParentTask, nil, map[string]string{"project": "36", "task": "uid_parent_import"}) 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) require.NoError(t, err)
assert.Equal(t, rec.Result().StatusCode, 201) 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"}) 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) require.NoError(t, err)
assert.Equal(t, rec.Result().StatusCode, 201) 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"}) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "36", "task": "uid_parent_import"})
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, rec.Result().StatusCode, 200) assert.Equal(t, 200, rec.Result().StatusCode)
assert.Contains(t, rec.Body.String(), "UID:uid_parent_import") assert.Contains(t, rec.Body.String(), "UID:uid_parent_import")
assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=CHILD:uid_child_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"}) rec, err = newCaldavTestRequestWithUser(t, e, http.MethodGet, caldav.TaskHandler, &testuser15, ``, nil, map[string]string{"project": "38", "task": "uid_child_import"})
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, rec.Result().StatusCode, 200) assert.Equal(t, 200, rec.Result().StatusCode)
assert.Contains(t, rec.Body.String(), "UID:uid_child_import") assert.Contains(t, rec.Body.String(), "UID:uid_child_import")
assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid_parent_import") assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid_parent_import")
}) })
@ -304,14 +306,14 @@ END:VCALENDAR`
e, _ := setupTestEnv() 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"}) 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) require.NoError(t, err)
assert.Equal(t, rec.Result().StatusCode, 200) 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(), "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") 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"}) 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) require.NoError(t, err)
assert.Equal(t, rec.Result().StatusCode, 200) 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(), "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") assert.Contains(t, rec.Body.String(), "RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task-another-list")
}) })

4
pkg/integrations/healthcheck_test.go
View File

@ -21,13 +21,15 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/routes" "code.vikunja.io/api/pkg/routes"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestHealthcheck(t *testing.T) { func TestHealthcheck(t *testing.T) {
t.Run("healthcheck", func(t *testing.T) { t.Run("healthcheck", func(t *testing.T) {
rec, err := newTestRequest(t, http.MethodGet, routes.HealthcheckHandler, ``, nil, nil) 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") assert.Contains(t, rec.Body.String(), "OK")
}) })
} }

12
pkg/integrations/integrations.go
View File

@ -37,9 +37,11 @@ import (
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"code.vikunja.io/web" "code.vikunja.io/web"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/golang-jwt/jwt/v5" "github.com/golang-jwt/jwt/v5"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
// These are the test users, the same way they are in the test database // 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) { func bootstrapTestRequest(t *testing.T, method string, payload string, queryParam url.Values, urlParams map[string]string) (c echo.Context, rec *httptest.ResponseRecorder) {
// Setup // Setup
e, err := setupTestEnv() e, err := setupTestEnv()
assert.NoError(t, err) require.NoError(t, err)
c, rec = createRequest(e, method, payload, queryParam, urlParams) c, rec = createRequest(e, method, payload, queryParam, urlParams)
return 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) { func addUserTokenToContext(t *testing.T, user *user.User, c echo.Context) {
// Get the token as a string // Get the token as a string
token, err := auth.NewUserJWTAuthtoken(user, false) 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 // 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) { tken, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
return []byte(config.ServiceJWTSecret.GetString()), nil return []byte(config.ServiceJWTSecret.GetString()), nil
}) })
assert.NoError(t, err) require.NoError(t, err)
c.Set("user", tken) c.Set("user", tken)
} }
func addLinkShareTokenToContext(t *testing.T, share *models.LinkSharing, c echo.Context) { func addLinkShareTokenToContext(t *testing.T, share *models.LinkSharing, c echo.Context) {
// Get the token as a string // Get the token as a string
token, err := auth.NewLinkShareJWTAuthtoken(share) 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 // 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) { tken, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
return []byte(config.ServiceJWTSecret.GetString()), nil return []byte(config.ServiceJWTSecret.GetString()), nil
}) })
assert.NoError(t, err) require.NoError(t, err)
c.Set("user", tken) c.Set("user", tken)
} }

99
pkg/integrations/kanban_test.go
View File

@ -20,11 +20,12 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestBucket(t *testing.T) { func TestBucket(t *testing.T) {
@ -52,7 +53,7 @@ func TestBucket(t *testing.T) {
t.Run("ReadAll", func(t *testing.T) { t.Run("ReadAll", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(nil, map[string]string{"project": "1"}) 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(), `testbucket1`)
assert.Contains(t, rec.Body.String(), `testbucket2`) assert.Contains(t, rec.Body.String(), `testbucket2`)
assert.Contains(t, rec.Body.String(), `testbucket3`) assert.Contains(t, rec.Body.String(), `testbucket3`)
@ -63,87 +64,87 @@ func TestBucket(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
// Check the project was loaded successfully afterwards, see testReadOneWithUser // Check the project was loaded successfully afterwards, see testReadOneWithUser
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "1"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Nonexisting Bucket", func(t *testing.T) { t.Run("Nonexisting Bucket", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "9999"}, `{"title":"TestLoremIpsum"}`) _, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "9999"}, `{"title":"TestLoremIpsum"}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist)
}) })
t.Run("Empty title", func(t *testing.T) { t.Run("Empty title", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "1"}, `{"title":""}`) _, 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") 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("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "5"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "6"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "7"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "8"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "9"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "10"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "11"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "12"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "13"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { t.Run("Shared Via Parent Project User admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "14"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "15"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "16"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"bucket": "17"}, `{"title":"TestLoremIpsum"}`) 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"`) 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("Delete", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "1", "bucket": "1"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"bucket": "999"}) _, err := testHandler.testDeleteWithUser(nil, map[string]string{"bucket": "999"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "20", "bucket": "5"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "6", "bucket": "6"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "7", "bucket": "7"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "8", "bucket": "8"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "9", "bucket": "9"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "10", "bucket": "10"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "11", "bucket": "11"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "12", "bucket": "12"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "13", "bucket": "13"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "14", "bucket": "14"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "15", "bucket": "15"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "16", "bucket": "16"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { t.Run("Shared Via Parent Project User admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "17", "bucket": "17"}) 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."`) 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("Create", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9999"}, `{"title":"Lorem Ipsum"}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "6"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "7"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "8"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "12"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "15"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
}) })
t.Run("Link Share", func(t *testing.T) { t.Run("Link Share", func(t *testing.T) {
rec, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
db.AssertExists(t, "buckets", map[string]interface{}{ db.AssertExists(t, "buckets", map[string]interface{}{
"project_id": 2, "project_id": 2,

12
pkg/integrations/link_sharing_auth_test.go
View File

@ -22,39 +22,41 @@ import (
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestLinkSharingAuth(t *testing.T) { func TestLinkSharingAuth(t *testing.T) {
t.Run("Without Password", func(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"}) 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.Equal(t, http.StatusOK, rec.Code)
assert.Contains(t, rec.Body.String(), `"token":"`) assert.Contains(t, rec.Body.String(), `"token":"`)
assert.Contains(t, rec.Body.String(), `"project_id":1`) assert.Contains(t, rec.Body.String(), `"project_id":1`)
}) })
t.Run("Without Password, Password Provided", func(t *testing.T) { 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"}) 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.Equal(t, http.StatusOK, rec.Code)
assert.Contains(t, rec.Body.String(), `"token":"`) assert.Contains(t, rec.Body.String(), `"token":"`)
assert.Contains(t, rec.Body.String(), `"project_id":1`) assert.Contains(t, rec.Body.String(), `"project_id":1`)
}) })
t.Run("With Password, No Password Provided", func(t *testing.T) { t.Run("With Password, No Password Provided", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.AuthenticateLinkShare, ``, nil, map[string]string{"share": "testWithPassword"}) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeLinkSharePasswordRequired)
}) })
t.Run("With Password, Password Provided", func(t *testing.T) { 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"}) 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.Equal(t, http.StatusOK, rec.Code)
assert.Contains(t, rec.Body.String(), `"token":"`) assert.Contains(t, rec.Body.String(), `"token":"`)
assert.Contains(t, rec.Body.String(), `"project_id":1`) assert.Contains(t, rec.Body.String(), `"project_id":1`)
}) })
t.Run("With Wrong Password", func(t *testing.T) { t.Run("With Wrong Password", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.AuthenticateLinkShare, `{"password":"someWrongPassword"}`, nil, map[string]string{"share": "testWithPassword"}) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeLinkSharePasswordInvalid)
}) })
} }

184
pkg/integrations/link_sharing_test.go
View File

@ -22,8 +22,10 @@ import (
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestLinkSharing(t *testing.T) { func TestLinkSharing(t *testing.T) {
@ -66,68 +68,68 @@ func TestLinkSharing(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
t.Run("read only", func(t *testing.T) { t.Run("read only", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"right":0}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("write", func(t *testing.T) { t.Run("write", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"right":1}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("admin", func(t *testing.T) { t.Run("admin", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"right":2}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
}) })
t.Run("Read only access", func(t *testing.T) { t.Run("Read only access", func(t *testing.T) {
t.Run("read only", func(t *testing.T) { t.Run("read only", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"right":0}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("write", func(t *testing.T) { t.Run("write", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"right":1}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("admin", func(t *testing.T) { t.Run("admin", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"right":2}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
}) })
t.Run("Write access", func(t *testing.T) { t.Run("Write access", func(t *testing.T) {
t.Run("read only", func(t *testing.T) { t.Run("read only", func(t *testing.T) {
req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"right":0}`) 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":`) assert.Contains(t, req.Body.String(), `"hash":`)
}) })
t.Run("write", func(t *testing.T) { t.Run("write", func(t *testing.T) {
req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"right":1}`) 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":`) assert.Contains(t, req.Body.String(), `"hash":`)
}) })
t.Run("admin", func(t *testing.T) { t.Run("admin", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"right":2}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
}) })
t.Run("Admin access", func(t *testing.T) { t.Run("Admin access", func(t *testing.T) {
t.Run("read only", func(t *testing.T) { t.Run("read only", func(t *testing.T) {
req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"right":0}`) 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":`) assert.Contains(t, req.Body.String(), `"hash":`)
}) })
t.Run("write", func(t *testing.T) { t.Run("write", func(t *testing.T) {
req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"right":1}`) 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":`) assert.Contains(t, req.Body.String(), `"hash":`)
}) })
t.Run("admin", func(t *testing.T) { t.Run("admin", func(t *testing.T) {
req, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"right":2}`) 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":`) 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("ReadAll", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandlerProjectReadOnly.testReadAllWithLinkShare(nil, nil) rec, err := testHandlerProjectReadOnly.testReadAllWithLinkShare(nil, nil)
assert.NoError(t, err) require.NoError(t, err)
// Should only return the shared project, nothing else // Should only return the shared project, nothing else
assert.Contains(t, rec.Body.String(), `Test1`) assert.Contains(t, rec.Body.String(), `Test1`)
assert.NotContains(t, rec.Body.String(), `Test2`) assert.NotContains(t, rec.Body.String(), `Test2`)
@ -169,7 +171,7 @@ func TestLinkSharing(t *testing.T) {
}) })
t.Run("Search", func(t *testing.T) { t.Run("Search", func(t *testing.T) {
rec, err := testHandlerProjectReadOnly.testReadAllWithLinkShare(url.Values{"s": []string{"est1"}}, nil) 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 // Should only return the shared project, nothing else
assert.Contains(t, rec.Body.String(), `Test1`) assert.Contains(t, rec.Body.String(), `Test1`)
assert.NotContains(t, rec.Body.String(), `Test2`) 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("ReadOne", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "1"}) 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.Contains(t, rec.Body.String(), `"title":"Test1"`)
assert.NotContains(t, rec.Body.String(), `"title":"Test2"`) assert.NotContains(t, rec.Body.String(), `"title":"Test2"`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "9999999"}) _, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "9999999"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Project 2, not shared with this token // Project 2, not shared with this token
_, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "2"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `You don't have the right to see this`)
}) })
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
rec, err := testHandlerProjectReadOnly.testReadOneWithLinkShare(nil, map[string]string{"project": "1"}) 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.Contains(t, rec.Body.String(), `"title":"Test1"`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerProjectWrite.testReadOneWithLinkShare(nil, map[string]string{"project": "2"}) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Test2"`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerProjectAdmin.testReadOneWithLinkShare(nil, map[string]string{"project": "3"}) 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"`) 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("Update", func(t *testing.T) {
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "9999999"}, `{"title":"TestLoremIpsum"}`) _, err := testHandlerProjectReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "9999999"}, `{"title":"TestLoremIpsum"}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "1"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerProjectWrite.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"TestLoremIpsum","namespace_id":1}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerProjectAdmin.testUpdateWithLinkShare(nil, map[string]string{"project": "3"}, `{"title":"TestLoremIpsum","namespace_id":2}`) 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"`) 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("Delete", func(t *testing.T) {
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "9999999"}) _, err := testHandlerProjectReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "9999999"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectWrite.testDeleteWithLinkShare(nil, map[string]string{"project": "2"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerProjectAdmin.testDeleteWithLinkShare(nil, map[string]string{"project": "3"}) 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."`) 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("Create", func(t *testing.T) {
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandlerProjectReadOnly.testCreateWithLinkShare(nil, nil, `{"title":"Lorem"}`) _, err := testHandlerProjectReadOnly.testCreateWithLinkShare(nil, nil, `{"title":"Lorem"}`)
assert.Error(t, err) require.Error(t, err)
assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Shared readonly", 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"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectWrite.testCreateWithLinkShare(nil, map[string]string{"namespace": "2"}, `{"title":"Lorem","description":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerProjectAdmin.testCreateWithLinkShare(nil, map[string]string{"namespace": "3"}, `{"title":"Lorem","description":"Lorem Ipsum"}`) _, 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`) 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("ReadAll", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
rec, err := testHandlerProjectUserReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"}) rec, err := testHandlerProjectUserReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"})
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `[]`) assert.Contains(t, rec.Body.String(), `[]`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerProjectUserWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"}) rec, err := testHandlerProjectUserWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"})
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `[]`) assert.Contains(t, rec.Body.String(), `[]`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerProjectUserAdmin.testReadAllWithLinkShare(nil, map[string]string{"project": "3"}) 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"`) assert.Contains(t, rec.Body.String(), `"username":"user1"`)
}) })
}) })
t.Run("Create", func(t *testing.T) { t.Run("Create", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectUserReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{"user_id":"user1"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectUserWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"user_id":"user1"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerProjectUserAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{"user_id":"user1"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
}) })
t.Run("Update", func(t *testing.T) { t.Run("Update", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectUserReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "1"}, `{"user_id":"user1"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectUserWrite.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"user_id":"user1"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerProjectUserAdmin.testUpdateWithLinkShare(nil, map[string]string{"project": "3"}, `{"user_id":"user1"}`) _, 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`) 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("Delete", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectUserReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectUserWrite.testDeleteWithLinkShare(nil, map[string]string{"project": "2"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerProjectUserAdmin.testDeleteWithLinkShare(nil, map[string]string{"project": "3"}) _, 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`) 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("ReadAll", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
rec, err := testHandlerProjectTeamReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"}) rec, err := testHandlerProjectTeamReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"})
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `[]`) assert.Contains(t, rec.Body.String(), `[]`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerProjectTeamWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"}) rec, err := testHandlerProjectTeamWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"})
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `[]`) assert.Contains(t, rec.Body.String(), `[]`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerProjectTeamAdmin.testReadAllWithLinkShare(nil, map[string]string{"project": "3"}) 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"`) assert.Contains(t, rec.Body.String(), `"name":"testteam1"`)
}) })
}) })
t.Run("Create", func(t *testing.T) { t.Run("Create", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectTeamReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{"team_id":1}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectTeamWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"team_id":1}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerProjectTeamAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{"team_id":1}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
}) })
t.Run("Update", func(t *testing.T) { t.Run("Update", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectTeamReadOnly.testUpdateWithLinkShare(nil, map[string]string{"project": "1"}, `{"team_id":1}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectTeamWrite.testUpdateWithLinkShare(nil, map[string]string{"project": "2"}, `{"team_id":1}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerProjectTeamAdmin.testUpdateWithLinkShare(nil, map[string]string{"project": "3"}, `{"team_id":1}`) _, 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`) 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("Delete", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerProjectTeamReadOnly.testDeleteWithLinkShare(nil, map[string]string{"project": "1"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerProjectTeamWrite.testDeleteWithLinkShare(nil, map[string]string{"project": "2"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerProjectTeamAdmin.testDeleteWithLinkShare(nil, map[string]string{"project": "3"}) _, 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`) 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("ReadAll", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
rec, err := testHandlerTaskReadOnlyCollection.testReadAllWithLinkShare(nil, nil) 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 #1`)
assert.Contains(t, rec.Body.String(), `task #2`) assert.Contains(t, rec.Body.String(), `task #2`)
assert.Contains(t, rec.Body.String(), `task #3`) 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) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerTaskWriteCollection.testReadAllWithLinkShare(nil, nil) 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 #2`)
assert.NotContains(t, rec.Body.String(), `task #3"`) assert.NotContains(t, rec.Body.String(), `task #3"`)
assert.NotContains(t, rec.Body.String(), `task #4`) 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) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerTaskAdminCollection.testReadAllWithLinkShare(nil, nil) 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 #2`)
assert.NotContains(t, rec.Body.String(), `task #4`) assert.NotContains(t, rec.Body.String(), `task #4`)
assert.NotContains(t, rec.Body.String(), `task #5`) 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("Create", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerTaskReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerTaskWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerTaskAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
}) })
t.Run("Update", func(t *testing.T) { t.Run("Update", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerTaskReadOnly.testUpdateWithLinkShare(nil, map[string]string{"projecttask": "1"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerTaskWrite.testUpdateWithLinkShare(nil, map[string]string{"projecttask": "13"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerTaskAdmin.testUpdateWithLinkShare(nil, map[string]string{"projecttask": "32"}, `{"title":"Lorem Ipsum"}`) 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"`) 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("Delete", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerTaskReadOnly.testDeleteWithLinkShare(nil, map[string]string{"projecttask": "1"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerTaskWrite.testDeleteWithLinkShare(nil, map[string]string{"projecttask": "13"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerTaskAdmin.testDeleteWithLinkShare(nil, map[string]string{"projecttask": "32"}) 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.`) 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("ReadAll", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerTeamReadOnly.testReadAllWithLinkShare(nil, nil) _, err := testHandlerTeamReadOnly.testReadAllWithLinkShare(nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerTeamWrite.testReadAllWithLinkShare(nil, nil) _, err := testHandlerTeamWrite.testReadAllWithLinkShare(nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerTeamAdmin.testReadAllWithLinkShare(nil, nil) _, err := testHandlerTeamAdmin.testReadAllWithLinkShare(nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden)
}) })
}) })
t.Run("Update", func(t *testing.T) { t.Run("Update", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerTeamReadOnly.testUpdateWithLinkShare(nil, map[string]string{"team": "1"}, `{"name":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerTeamWrite.testUpdateWithLinkShare(nil, map[string]string{"team": "2"}, `{"name":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerTeamAdmin.testUpdateWithLinkShare(nil, map[string]string{"team": "3"}, `{"name":"Lorem Ipsum"}`) _, 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`) 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("Delete", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerTeamReadOnly.testDeleteWithLinkShare(nil, map[string]string{"team": "1"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerTeamWrite.testDeleteWithLinkShare(nil, map[string]string{"team": "2"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerTeamAdmin.testDeleteWithLinkShare(nil, map[string]string{"team": "3"}) _, 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`) 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("ReadAll", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
rec, err := testHandlerLinkShareReadOnly.testReadAllWithLinkShare(nil, map[string]string{"project": "1"}) 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"`) assert.Contains(t, rec.Body.String(), `"hash":"test"`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
rec, err := testHandlerLinkShareWrite.testReadAllWithLinkShare(nil, map[string]string{"project": "2"}) 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"`) assert.Contains(t, rec.Body.String(), `"hash":"test2"`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
rec, err := testHandlerLinkShareAdmin.testReadAllWithLinkShare(nil, map[string]string{"project": "3"}) 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"`) assert.Contains(t, rec.Body.String(), `"hash":"test3"`)
}) })
}) })
t.Run("Create", func(t *testing.T) { t.Run("Create", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerLinkShareReadOnly.testCreateWithLinkShare(nil, map[string]string{"project": "1"}, `{}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerLinkShareAdmin.testCreateWithLinkShare(nil, map[string]string{"project": "3"}, `{}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
}) })
t.Run("Update", func(t *testing.T) { t.Run("Update", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerLinkShareReadOnly.testUpdateWithLinkShare(nil, map[string]string{"share": "1"}, `{}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerLinkShareWrite.testUpdateWithLinkShare(nil, map[string]string{"share": "2"}, `{}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerLinkShareAdmin.testUpdateWithLinkShare(nil, map[string]string{"share": "3"}, `{}`) _, 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`) 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("Delete", func(t *testing.T) {
t.Run("Shared readonly", func(t *testing.T) { t.Run("Shared readonly", func(t *testing.T) {
_, err := testHandlerLinkShareReadOnly.testDeleteWithLinkShare(nil, map[string]string{"share": "1"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared write", func(t *testing.T) { t.Run("Shared write", func(t *testing.T) {
_, err := testHandlerLinkShareWrite.testDeleteWithLinkShare(nil, map[string]string{"share": "2"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared admin", func(t *testing.T) { t.Run("Shared admin", func(t *testing.T) {
_, err := testHandlerLinkShareAdmin.testDeleteWithLinkShare(nil, map[string]string{"share": "3"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
}) })

12
pkg/integrations/login_test.go
View File

@ -22,7 +22,9 @@ import (
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestLogin(t *testing.T) { func TestLogin(t *testing.T) {
@ -31,12 +33,12 @@ func TestLogin(t *testing.T) {
"username": "user1", "username": "user1",
"password": "1234" "password": "1234"
}`, nil, nil) }`, nil, nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), "token") assert.Contains(t, rec.Body.String(), "token")
}) })
t.Run("Empty payload", func(t *testing.T) { t.Run("Empty payload", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.Login, `{}`, nil, nil) _, err := newTestRequest(t, http.MethodPost, apiv1.Login, `{}`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword)
}) })
t.Run("Not existing user", func(t *testing.T) { t.Run("Not existing user", func(t *testing.T) {
@ -44,7 +46,7 @@ func TestLogin(t *testing.T) {
"username": "userWichDoesNotExist", "username": "userWichDoesNotExist",
"password": "1234" "password": "1234"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword) assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword)
}) })
t.Run("Wrong password", func(t *testing.T) { t.Run("Wrong password", func(t *testing.T) {
@ -52,7 +54,7 @@ func TestLogin(t *testing.T) {
"username": "user1", "username": "user1",
"password": "wrong" "password": "wrong"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword) assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword)
}) })
t.Run("user with unconfirmed email", func(t *testing.T) { t.Run("user with unconfirmed email", func(t *testing.T) {
@ -60,7 +62,7 @@ func TestLogin(t *testing.T) {
"username": "user5", "username": "user5",
"password": "1234" "password": "1234"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeEmailNotConfirmed) assertHandlerErrorCode(t, err, user.ErrCodeEmailNotConfirmed)
}) })
} }

128
pkg/integrations/project_test.go
View File

@ -22,8 +22,10 @@ import (
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestProject(t *testing.T) { func TestProject(t *testing.T) {
@ -37,7 +39,7 @@ func TestProject(t *testing.T) {
t.Run("ReadAll", func(t *testing.T) { t.Run("ReadAll", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(nil, nil) rec, err := testHandler.testReadAllWithUser(nil, nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `Test1`) assert.Contains(t, rec.Body.String(), `Test1`)
assert.NotContains(t, rec.Body.String(), `Test2"`) assert.NotContains(t, rec.Body.String(), `Test2"`)
assert.Contains(t, rec.Body.String(), `Test3`) // Shared directly via users_project 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) { t.Run("Search", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"Test1"}}, nil) 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.Contains(t, rec.Body.String(), `Test1`)
assert.NotContains(t, rec.Body.String(), `Test2`) assert.NotContains(t, rec.Body.String(), `Test2`)
assert.NotContains(t, rec.Body.String(), `Test3`) 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) { t.Run("Normal with archived projects", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"is_archived": []string{"true"}}, nil) 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.Contains(t, rec.Body.String(), `Test1`)
assert.NotContains(t, rec.Body.String(), `Test2"`) assert.NotContains(t, rec.Body.String(), `Test2"`)
assert.Contains(t, rec.Body.String(), `Test3`) // Shared directly via users_project 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("ReadOne", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "1"}) 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.Contains(t, rec.Body.String(), `"title":"Test1"`)
assert.NotContains(t, rec.Body.String(), `"title":"Test2"`) assert.NotContains(t, rec.Body.String(), `"title":"Test2"`)
assert.Contains(t, rec.Body.String(), `"owner":{"id":1,"name":"","username":"user1",`) 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) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "9999"}) _, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "9999"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "20"}) 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.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")) assert.Empty(t, rec.Result().Header.Get("x-max-rights"))
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "6"}) 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.Contains(t, rec.Body.String(), `"title":"Test6"`)
assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "7"}) 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.Contains(t, rec.Body.String(), `"title":"Test7"`)
assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "8"}) 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.Contains(t, rec.Body.String(), `"title":"Test8"`)
assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "2", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "9"}) 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.Contains(t, rec.Body.String(), `"title":"Test9"`)
assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "10"}) 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.Contains(t, rec.Body.String(), `"title":"Test10"`)
assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "11"}) 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.Contains(t, rec.Body.String(), `"title":"Test11"`)
assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "2", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "12"}) 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.Contains(t, rec.Body.String(), `"title":"Test12"`)
assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "13"}) 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.Contains(t, rec.Body.String(), `"title":"Test13"`)
assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "14"}) 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.Contains(t, rec.Body.String(), `"title":"Test14"`)
assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "2", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "15"}) 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.Contains(t, rec.Body.String(), `"title":"Test15"`)
assert.Equal(t, "0", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "0", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "16"}) 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.Contains(t, rec.Body.String(), `"title":"Test16"`)
assert.Equal(t, "1", rec.Result().Header.Get("x-max-right")) assert.Equal(t, "1", rec.Result().Header.Get("x-max-right"))
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { t.Run("Shared Via Parent Project User admin", func(t *testing.T) {
rec, err := testHandler.testReadOneWithUser(nil, map[string]string{"project": "17"}) 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.Contains(t, rec.Body.String(), `"title":"Test17"`)
assert.Equal(t, "2", rec.Result().Header.Get("x-max-right")) 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) { t.Run("Normal", func(t *testing.T) {
// Check the project was loaded successfully afterwards, see testReadOneWithUser // Check the project was loaded successfully afterwards, see testReadOneWithUser
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "1"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
// The description should not be updated but returned correctly // The description should not be updated but returned correctly
assert.Contains(t, rec.Body.String(), `description":"Lorem Ipsum`) assert.Contains(t, rec.Body.String(), `description":"Lorem Ipsum`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "9999"}, `{"title":"TestLoremIpsum"}`) _, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "9999"}, `{"title":"TestLoremIpsum"}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Normal with updating the description", func(t *testing.T) { 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"}`) 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(), `"title":"TestLoremIpsum"`)
assert.Contains(t, rec.Body.String(), `"description":"Lorem Ipsum dolor sit amet`) assert.Contains(t, rec.Body.String(), `"description":"Lorem Ipsum dolor sit amet`)
}) })
t.Run("Empty title", func(t *testing.T) { t.Run("Empty title", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "1"}, `{"title":""}`) _, 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") assert.Contains(t, err.(*echo.HTTPError).Message.(models.ValidationHTTPError).InvalidFields, "title: non zero value required")
}) })
t.Run("Title too long", func(t *testing.T) { 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"}`) _, 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)") 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("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "20"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "6"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "7"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "8"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "9"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "10"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "11"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "12"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "13"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "14"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "15"}, `{"title":"TestLoremIpsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "16"}, `{"title":"TestLoremIpsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { t.Run("Shared Via Parent Project User admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"project": "17"}, `{"title":"TestLoremIpsum"}`) 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"`) 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("Delete", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "1"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "999"}) _, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "999"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "20"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "6"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "7"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "8"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "9"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "10"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "11"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "12"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "13"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "14"}) 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."`) assert.Contains(t, rec.Body.String(), `"message":"Successfully deleted."`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "15"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "16"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { t.Run("Shared Via Parent Project User admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"project": "17"}) 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."`) 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) { t.Run("Normal", func(t *testing.T) {
// Check the project was loaded successfully after update, see testReadOneWithUser // Check the project was loaded successfully after update, see testReadOneWithUser
rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem"}`) 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(), `"title":"Lorem"`)
assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"description":""`)
assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) 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) { t.Run("Normal with description", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","description":"Lorem Ipsum"}`) 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(), `"title":"Lorem"`)
assert.Contains(t, rec.Body.String(), `"description":"Lorem Ipsum"`) assert.Contains(t, rec.Body.String(), `"description":"Lorem Ipsum"`)
assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) 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) { t.Run("Nonexisting parent project", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":99999}`) _, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":99999}`)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Empty title", func(t *testing.T) { t.Run("Empty title", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, nil, `{"title":""}`) _, 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") assert.Contains(t, err.(*echo.HTTPError).Message.(models.ValidationHTTPError).InvalidFields, "title: non zero value required")
}) })
t.Run("Title too long", func(t *testing.T) { 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"}`) _, 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)") 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("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":20}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":32}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":33}`) 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(), `"title":"Lorem"`)
assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"description":""`)
assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) 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) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":34}`) 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(), `"title":"Lorem"`)
assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"description":""`)
assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) 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) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":9}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, nil, `{"title":"Lorem","parent_project_id":10}`) 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(), `"title":"Lorem"`)
assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"description":""`)
assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) 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) { 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}`) 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(), `"title":"Lorem"`)
assert.Contains(t, rec.Body.String(), `"description":""`) assert.Contains(t, rec.Body.String(), `"description":""`)
assert.Contains(t, rec.Body.String(), `"owner":{"id":1`) assert.Contains(t, rec.Body.String(), `"owner":{"id":1`)

16
pkg/integrations/register_test.go
View File

@ -22,7 +22,9 @@ import (
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestRegister(t *testing.T) { func TestRegister(t *testing.T) {
@ -32,12 +34,12 @@ func TestRegister(t *testing.T) {
"password": "12345678", "password": "12345678",
"email": "email@example.com" "email": "email@example.com"
}`, nil, nil) }`, nil, nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `"username":"newUser"`) assert.Contains(t, rec.Body.String(), `"username":"newUser"`)
}) })
t.Run("Empty payload", func(t *testing.T) { t.Run("Empty payload", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.RegisterUser, `{}`, nil, nil) _, err := newTestRequest(t, http.MethodPost, apiv1.RegisterUser, `{}`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword)
}) })
t.Run("Empty username", func(t *testing.T) { t.Run("Empty username", func(t *testing.T) {
@ -46,7 +48,7 @@ func TestRegister(t *testing.T) {
"password": "12345678", "password": "12345678",
"email": "email@example.com" "email": "email@example.com"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword)
}) })
t.Run("Empty password", func(t *testing.T) { t.Run("Empty password", func(t *testing.T) {
@ -55,7 +57,7 @@ func TestRegister(t *testing.T) {
"password": "", "password": "",
"email": "email@example.com" "email": "email@example.com"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword)
}) })
t.Run("Empty email", func(t *testing.T) { t.Run("Empty email", func(t *testing.T) {
@ -64,7 +66,7 @@ func TestRegister(t *testing.T) {
"password": "12345678", "password": "12345678",
"email": "" "email": ""
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword)
}) })
t.Run("Already existing username", func(t *testing.T) { t.Run("Already existing username", func(t *testing.T) {
@ -73,7 +75,7 @@ func TestRegister(t *testing.T) {
"password": "12345678", "password": "12345678",
"email": "email@example.com" "email": "email@example.com"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrorCodeUsernameExists) assertHandlerErrorCode(t, err, user.ErrorCodeUsernameExists)
}) })
t.Run("Already existing email", func(t *testing.T) { t.Run("Already existing email", func(t *testing.T) {
@ -82,7 +84,7 @@ func TestRegister(t *testing.T) {
"password": "12345678", "password": "12345678",
"email": "user1@example.com" "email": "user1@example.com"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrorCodeUserEmailExists) assertHandlerErrorCode(t, err, user.ErrorCodeUserEmailExists)
}) })
} }

70
pkg/integrations/task_collection_test.go
View File

@ -22,7 +22,9 @@ import (
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTaskCollection(t *testing.T) { func TestTaskCollection(t *testing.T) {
@ -39,7 +41,7 @@ func TestTaskCollection(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(nil, urlParams) 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 // 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 #1`)
assert.Contains(t, rec.Body.String(), `task #2 `) assert.Contains(t, rec.Body.String(), `task #2 `)
@ -73,7 +75,7 @@ func TestTaskCollection(t *testing.T) {
}) })
t.Run("Search", func(t *testing.T) { t.Run("Search", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"task #6"}}, urlParams) 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 #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) 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) { t.Run("Search case insensitive", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"tASk #6"}}, urlParams) 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 #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) assert.NotContains(t, rec.Body.String(), `task #3 `)
@ -112,65 +114,65 @@ func TestTaskCollection(t *testing.T) {
// should equal priority asc // should equal priority asc
t.Run("by priority", func(t *testing.T) { t.Run("by priority", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}}, urlParams) 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"}}]`) 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) { t.Run("by priority desc", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"desc"}}, urlParams) 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`) 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) { t.Run("by priority asc", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"asc"}}, urlParams) 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"}}]`) 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 // should equal duedate asc
t.Run("by due_date", func(t *testing.T) { t.Run("by due_date", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}}, urlParams) 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"}}`) 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) { 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) 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`) 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 // Due date without unix suffix
t.Run("by duedate asc without suffix", func(t *testing.T) { 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) 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"}}`) 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) { t.Run("by due_date without suffix", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}}, urlParams) 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"}}`) 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) { 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) 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`) 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) { 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) 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"}}`) 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) { t.Run("invalid sort parameter", func(t *testing.T) {
_, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"loremipsum"}}, urlParams) _, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"loremipsum"}}, urlParams)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskField) assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskField)
}) })
t.Run("invalid sort order", func(t *testing.T) { t.Run("invalid sort order", func(t *testing.T) {
_, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"id"}, "order_by": []string{"loremipsum"}}, urlParams) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeInvalidSortOrder)
}) })
t.Run("invalid parameter", func(t *testing.T) { t.Run("invalid parameter", func(t *testing.T) {
// Invalid parameter should not sort at all // Invalid parameter should not sort at all
rec, err := testHandler.testReadAllWithUser(url.Values{"sort": []string{"loremipsum"}}, urlParams) 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":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":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"`) 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, urlParams,
) )
assert.NoError(t, err) require.NoError(t, err)
assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) assert.NotContains(t, rec.Body.String(), `task #3 `)
@ -213,7 +215,7 @@ func TestTaskCollection(t *testing.T) {
}, },
urlParams, urlParams,
) )
assert.NoError(t, err) require.NoError(t, err)
assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) assert.NotContains(t, rec.Body.String(), `task #3 `)
@ -238,7 +240,7 @@ func TestTaskCollection(t *testing.T) {
}, },
urlParams, urlParams,
) )
assert.NoError(t, err) require.NoError(t, err)
// If no start date but an end date is specified, this should be null // 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 > // since we don't have any tasks in the fixtures with an end date >
// the current date. // the current date.
@ -253,7 +255,7 @@ func TestTaskCollection(t *testing.T) {
}, },
urlParams, urlParams,
) )
assert.NoError(t, err) require.NoError(t, err)
assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) assert.NotContains(t, rec.Body.String(), `task #3 `)
@ -279,7 +281,7 @@ func TestTaskCollection(t *testing.T) {
}, },
nil, nil,
) )
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskFilterValue) assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskFilterValue)
}) })
}) })
@ -289,7 +291,7 @@ func TestTaskCollection(t *testing.T) {
nil, nil,
map[string]string{"project": "-2"}, // Actually a saved filter - contains the same filter arguments as the start and end date filter from above 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 #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) 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("ReadAll for all tasks", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(nil, nil) 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 // 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 #1`)
assert.Contains(t, rec.Body.String(), `task #2 `) assert.Contains(t, rec.Body.String(), `task #2 `)
@ -345,7 +347,7 @@ func TestTaskCollection(t *testing.T) {
}) })
t.Run("Search", func(t *testing.T) { t.Run("Search", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"s": []string{"task #6"}}, nil) 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 #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) assert.NotContains(t, rec.Body.String(), `task #3 `)
@ -365,39 +367,39 @@ func TestTaskCollection(t *testing.T) {
// should equal priority asc // should equal priority asc
t.Run("by priority", func(t *testing.T) { t.Run("by priority", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}}, nil) 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"}}]`) 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) { t.Run("by priority desc", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"desc"}}, nil) 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`) 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) { t.Run("by priority asc", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"priority"}, "order_by": []string{"asc"}}, nil) 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"}}]`) 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 // should equal duedate asc
t.Run("by due_date", func(t *testing.T) { t.Run("by due_date", func(t *testing.T) {
rec, err := testHandler.testReadAllWithUser(url.Values{"sort_by": []string{"due_date"}}, nil) 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"}}`) 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) { 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) 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`) 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) { 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) 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"}}`) 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) { t.Run("invalid parameter", func(t *testing.T) {
// Invalid parameter should not sort at all // Invalid parameter should not sort at all
rec, err := testHandler.testReadAllWithUser(url.Values{"sort": []string{"loremipsum"}}, nil) 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":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":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"`) 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, nil,
) )
assert.NoError(t, err) require.NoError(t, err)
assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) assert.NotContains(t, rec.Body.String(), `task #3 `)
@ -440,7 +442,7 @@ func TestTaskCollection(t *testing.T) {
}, },
nil, nil,
) )
assert.NoError(t, err) require.NoError(t, err)
assert.NotContains(t, rec.Body.String(), `task #1`) assert.NotContains(t, rec.Body.String(), `task #1`)
assert.NotContains(t, rec.Body.String(), `task #2 `) assert.NotContains(t, rec.Body.String(), `task #2 `)
assert.NotContains(t, rec.Body.String(), `task #3 `) assert.NotContains(t, rec.Body.String(), `task #3 `)
@ -465,7 +467,7 @@ func TestTaskCollection(t *testing.T) {
}, },
nil, nil,
) )
assert.NoError(t, err) require.NoError(t, err)
// If no start date but an end date is specified, this should be null // 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 > // since we don't have any tasks in the fixtures with an end date >
// the current date. // the current date.
@ -481,7 +483,7 @@ func TestTaskCollection(t *testing.T) {
}, },
nil, nil,
) )
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskFilterValue) assertHandlerErrorCode(t, err, models.ErrCodeInvalidTaskFilterValue)
}) })
}) })

95
pkg/integrations/task_comment_test.go
View File

@ -20,11 +20,12 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTaskComments(t *testing.T) { func TestTaskComments(t *testing.T) {
@ -54,82 +55,82 @@ func TestTaskComments(t *testing.T) {
t.Run("Update", func(t *testing.T) { t.Run("Update", func(t *testing.T) {
t.Run("Normal", 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "99999", "commentid": "9999"}, `{"comment":"Lorem Ipsum"}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
// Only the own comments can be updated // Only the own comments can be updated
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "14", "commentid": "2"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "15", "commentid": "3"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "16", "commentid": "4"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "17", "commentid": "5"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "18", "commentid": "6"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "19", "commentid": "7"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"task": "20", "commentid": "8"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { 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"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { 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"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { 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"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { 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"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { 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"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { 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"}`) _, 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`) 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("Delete", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "1", "commentid": "1"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "99999", "commentid": "9999"}) _, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "99999", "commentid": "9999"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
// Only the own comments can be deleted // Only the own comments can be deleted
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "14", "commentid": "2"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "15", "commentid": "3"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "16", "commentid": "4"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "17", "commentid": "5"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "18", "commentid": "6"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "19", "commentid": "7"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "20", "commentid": "8"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "21", "commentid": "9"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "22", "commentid": "10"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "23", "commentid": "11"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "24", "commentid": "12"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "25", "commentid": "13"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { t.Run("Shared Via Parent Project User admin", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"task": "26", "commentid": "14"}) _, 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`) 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("Create", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "1"}, `{"comment":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "9999"}, `{"comment":"Lorem Ipsum"}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "34"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "15"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "16"}, `{"comment":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "17"}, `{"comment":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "18"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "19"}, `{"comment":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "20"}, `{"comment":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "21"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"task": "24"}, `{"comment":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
}) })
}) })
t.Run("Link Share", func(t *testing.T) { t.Run("Link Share", func(t *testing.T) {
rec, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"task": "13"}, `{"comment":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"comment":"Lorem Ipsum"`)
db.AssertExists(t, "task_comments", map[string]interface{}{ db.AssertExists(t, "task_comments", map[string]interface{}{
"task_id": 13, "task_id": 13,

163
pkg/integrations/task_test.go
View File

@ -20,11 +20,12 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/web/handler" "code.vikunja.io/web/handler"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTask(t *testing.T) { 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("Update task items", func(t *testing.T) {
t.Run("Title", func(t *testing.T) { t.Run("Title", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"title":"Lorem Ipsum"}`) 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.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
assert.NotContains(t, rec.Body.String(), `"title":"task #1"`) assert.NotContains(t, rec.Body.String(), `"title":"task #1"`)
}) })
t.Run("Description", func(t *testing.T) { t.Run("Description", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"description":"Dolor sit amet"}`) 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.Contains(t, rec.Body.String(), `"description":"Dolor sit amet"`)
assert.NotContains(t, rec.Body.String(), `"description":"Lorem Ipsum"`) assert.NotContains(t, rec.Body.String(), `"description":"Lorem Ipsum"`)
}) })
t.Run("Description to empty", func(t *testing.T) { t.Run("Description to empty", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"description":""}`) 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.Contains(t, rec.Body.String(), `"description":""`)
assert.NotContains(t, rec.Body.String(), `"description":"Lorem Ipsum"`) assert.NotContains(t, rec.Body.String(), `"description":"Lorem Ipsum"`)
}) })
t.Run("Done", func(t *testing.T) { t.Run("Done", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"done":true}`) 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.Contains(t, rec.Body.String(), `"done":true`)
assert.NotContains(t, rec.Body.String(), `"done":false`) assert.NotContains(t, rec.Body.String(), `"done":false`)
}) })
t.Run("Undone", func(t *testing.T) { t.Run("Undone", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "2"}, `{"done":false}`) 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.Contains(t, rec.Body.String(), `"done":false`)
assert.NotContains(t, rec.Body.String(), `"done":true`) assert.NotContains(t, rec.Body.String(), `"done":true`)
}) })
t.Run("Due date", func(t *testing.T) { 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"}`) 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.Contains(t, rec.Body.String(), `"due_date":"2020-02-10T10:00:00Z"`)
assert.NotContains(t, rec.Body.String(), `"due_date":0`) assert.NotContains(t, rec.Body.String(), `"due_date":0`)
}) })
t.Run("Due date unset", func(t *testing.T) { t.Run("Due date unset", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "5"}, `{"due_date": null}`) 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.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"`) assert.NotContains(t, rec.Body.String(), `"due_date":"2020-02-10T10:00:00Z"`)
}) })
t.Run("Reminders", func(t *testing.T) { 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"}]}`) 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(), `"reminders":[`)
assert.Contains(t, rec.Body.String(), `{"reminder":"2020-02-10T10:00:00Z"`) assert.Contains(t, rec.Body.String(), `{"reminder":"2020-02-10T10:00:00Z"`)
assert.Contains(t, rec.Body.String(), `{"reminder":"2020-02-11T10: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) { t.Run("Reminders unset to empty array", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "27"}, `{"reminders": []}`) 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.Contains(t, rec.Body.String(), `"reminders":null`)
assert.NotContains(t, rec.Body.String(), `{"Reminder":"2020-02-10T10:00:00Z"`) assert.NotContains(t, rec.Body.String(), `{"Reminder":"2020-02-10T10:00:00Z"`)
}) })
t.Run("Reminders unset to null", func(t *testing.T) { t.Run("Reminders unset to null", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "27"}, `{"reminders": null}`) 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.Contains(t, rec.Body.String(), `"reminders":null`)
assert.NotContains(t, rec.Body.String(), `{"Reminder":"2020-02-10T10:00:00Z"`) assert.NotContains(t, rec.Body.String(), `{"Reminder":"2020-02-10T10:00:00Z"`)
}) })
t.Run("Repeat after", func(t *testing.T) { t.Run("Repeat after", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"repeat_after":3600}`) 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.Contains(t, rec.Body.String(), `"repeat_after":3600`)
assert.NotContains(t, rec.Body.String(), `"repeat_after":0`) assert.NotContains(t, rec.Body.String(), `"repeat_after":0`)
}) })
t.Run("Repeat after unset", func(t *testing.T) { t.Run("Repeat after unset", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "28"}, `{"repeat_after":0}`) 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.Contains(t, rec.Body.String(), `"repeat_after":0`)
assert.NotContains(t, rec.Body.String(), `"repeat_after":3600`) assert.NotContains(t, rec.Body.String(), `"repeat_after":3600`)
}) })
t.Run("Repeat after update done", func(t *testing.T) { t.Run("Repeat after update done", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "28"}, `{"done":true}`) 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.Contains(t, rec.Body.String(), `"done":false`)
assert.NotContains(t, rec.Body.String(), `"done":true`) assert.NotContains(t, rec.Body.String(), `"done":true`)
}) })
t.Run("Assignees", func(t *testing.T) { t.Run("Assignees", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"assignees":[{"id":1}]}`) 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.Contains(t, rec.Body.String(), `"assignees":[{"id":1`)
assert.NotContains(t, rec.Body.String(), `"assignees":[]`) assert.NotContains(t, rec.Body.String(), `"assignees":[]`)
}) })
t.Run("Removing Assignees empty array", func(t *testing.T) { t.Run("Removing Assignees empty array", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "30"}, `{"assignees":[]}`) 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.Contains(t, rec.Body.String(), `"assignees":null`)
assert.NotContains(t, rec.Body.String(), `"assignees":[{"id":1`) assert.NotContains(t, rec.Body.String(), `"assignees":[{"id":1`)
}) })
t.Run("Removing Assignees null", func(t *testing.T) { t.Run("Removing Assignees null", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "30"}, `{"assignees":null}`) 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.Contains(t, rec.Body.String(), `"assignees":null`)
assert.NotContains(t, rec.Body.String(), `"assignees":[{"id":1`) assert.NotContains(t, rec.Body.String(), `"assignees":[{"id":1`)
}) })
t.Run("Priority", func(t *testing.T) { t.Run("Priority", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"priority":100}`) 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.Contains(t, rec.Body.String(), `"priority":100`)
assert.NotContains(t, rec.Body.String(), `"priority":0`) assert.NotContains(t, rec.Body.String(), `"priority":0`)
}) })
t.Run("Priority to 0", func(t *testing.T) { t.Run("Priority to 0", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "3"}, `{"priority":0}`) 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.Contains(t, rec.Body.String(), `"priority":0`)
assert.NotContains(t, rec.Body.String(), `"priority":100`) assert.NotContains(t, rec.Body.String(), `"priority":100`)
}) })
t.Run("Start date", func(t *testing.T) { 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"}`) 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.Contains(t, rec.Body.String(), `"start_date":"2020-02-10T10:00:00Z"`)
assert.NotContains(t, rec.Body.String(), `"start_date":0`) assert.NotContains(t, rec.Body.String(), `"start_date":0`)
}) })
t.Run("Start date unset", func(t *testing.T) { 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"}`) 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.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"`) assert.NotContains(t, rec.Body.String(), `"start_date":"2020-02-10T10:00:00Z"`)
}) })
t.Run("End date", func(t *testing.T) { 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"}`) 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.Contains(t, rec.Body.String(), `"end_date":"2020-02-10T12:00:00Z"`)
assert.NotContains(t, rec.Body.String(), `"end_date":""`) assert.NotContains(t, rec.Body.String(), `"end_date":""`)
}) })
t.Run("End date unset", func(t *testing.T) { 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"}`) 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.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"`) assert.NotContains(t, rec.Body.String(), `"end_date":"2020-02-10T10:00:00Z"`)
}) })
t.Run("Color", func(t *testing.T) { t.Run("Color", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"hex_color":"f0f0f0"}`) 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.Contains(t, rec.Body.String(), `"hex_color":"f0f0f0"`)
assert.NotContains(t, rec.Body.String(), `"hex_color":""`) assert.NotContains(t, rec.Body.String(), `"hex_color":""`)
}) })
t.Run("Color unset", func(t *testing.T) { t.Run("Color unset", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "31"}, `{"hex_color":""}`) 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.Contains(t, rec.Body.String(), `"hex_color":""`)
assert.NotContains(t, rec.Body.String(), `"hex_color":"f0f0f0"`) assert.NotContains(t, rec.Body.String(), `"hex_color":"f0f0f0"`)
}) })
t.Run("Percent Done", func(t *testing.T) { t.Run("Percent Done", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"percent_done":0.1}`) 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.Contains(t, rec.Body.String(), `"percent_done":0.1`)
assert.NotContains(t, rec.Body.String(), `"percent_done":0,`) assert.NotContains(t, rec.Body.String(), `"percent_done":0,`)
}) })
t.Run("Percent Done unset", func(t *testing.T) { t.Run("Percent Done unset", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "33"}, `{"percent_done":0}`) 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.Contains(t, rec.Body.String(), `"percent_done":0,`)
assert.NotContains(t, rec.Body.String(), `"percent_done":0.1`) 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) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "99999"}, `{"title":"Lorem Ipsum"}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "14"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "15"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "16"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "17"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "18"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "19"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "20"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "21"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "24"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
}) })
t.Run("Move to other project", func(t *testing.T) { t.Run("Move to other project", func(t *testing.T) {
t.Run("normal", func(t *testing.T) { t.Run("normal", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"project_id":7}`) 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.Contains(t, rec.Body.String(), `"project_id":7`)
assert.NotContains(t, rec.Body.String(), `"project_id":1`) assert.NotContains(t, rec.Body.String(), `"project_id":1`)
}) })
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"project_id":20}`) _, 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) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden)
}) })
t.Run("Read Only", func(t *testing.T) { t.Run("Read Only", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"project_id":6}`) _, 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) assertHandlerErrorCode(t, err, models.ErrorCodeGenericForbidden)
}) })
}) })
t.Run("Bucket", func(t *testing.T) { t.Run("Bucket", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"bucket_id":3}`) 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.Contains(t, rec.Body.String(), `"bucket_id":3`)
assert.NotContains(t, rec.Body.String(), `"bucket_id":1`) assert.NotContains(t, rec.Body.String(), `"bucket_id":1`)
}) })
t.Run("Different Project", func(t *testing.T) { t.Run("Different Project", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"bucket_id":4}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotBelongToProject)
}) })
t.Run("Nonexisting Bucket", func(t *testing.T) { t.Run("Nonexisting Bucket", func(t *testing.T) {
_, err := testHandler.testUpdateWithUser(nil, map[string]string{"projecttask": "1"}, `{"bucket_id":9999}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist)
}) })
}) })
@ -328,81 +329,81 @@ func TestTask(t *testing.T) {
t.Run("Delete", func(t *testing.T) { t.Run("Delete", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "1"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "99999"}) _, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "99999"})
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist) assertHandlerErrorCode(t, err, models.ErrCodeTaskDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "14"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "15"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "16"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "17"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "18"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "19"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "20"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "21"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { t.Run("Shared Via Parent Project Team write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "22"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { t.Run("Shared Via Parent Project Team admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "23"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "24"}) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { t.Run("Shared Via Parent Project User write", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "25"}) 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.`) assert.Contains(t, rec.Body.String(), `Successfully deleted.`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { t.Run("Shared Via Parent Project User admin", func(t *testing.T) {
rec, err := testHandler.testDeleteWithUser(nil, map[string]string{"projecttask": "26"}) 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.`) 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("Create", func(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Nonexisting", func(t *testing.T) { t.Run("Nonexisting", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9999"}, `{"title":"Lorem Ipsum"}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeProjectDoesNotExist)
}) })
t.Run("Rights check", func(t *testing.T) { t.Run("Rights check", func(t *testing.T) {
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
// Owned by user13 // Owned by user13
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "20"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team readonly", func(t *testing.T) { t.Run("Shared Via Team readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "6"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Team write", func(t *testing.T) { t.Run("Shared Via Team write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "7"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Team admin", func(t *testing.T) { t.Run("Shared Via Team admin", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "8"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User readonly", func(t *testing.T) { t.Run("Shared Via User readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "9"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via User write", func(t *testing.T) { t.Run("Shared Via User write", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "10"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via User admin", func(t *testing.T) { t.Run("Shared Via User admin", func(t *testing.T) {
rec, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "11"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) { t.Run("Shared Via Parent Project Team readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "12"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project Team write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project Team admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User readonly", func(t *testing.T) { t.Run("Shared Via Parent Project User readonly", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "15"}, `{"title":"Lorem Ipsum"}`) _, 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`) assert.Contains(t, err.(*echo.HTTPError).Message, `Forbidden`)
}) })
t.Run("Shared Via Parent Project User write", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
t.Run("Shared Via Parent Project User admin", func(t *testing.T) { 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"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
}) })
}) })
t.Run("Bucket", func(t *testing.T) { t.Run("Bucket", func(t *testing.T) {
t.Run("Normal", 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}`) 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.Contains(t, rec.Body.String(), `"bucket_id":3`)
assert.NotContains(t, rec.Body.String(), `"bucket_id":1`) assert.NotContains(t, rec.Body.String(), `"bucket_id":1`)
}) })
t.Run("Different Project", func(t *testing.T) { t.Run("Different Project", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum","bucket_id":4}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotBelongToProject)
}) })
t.Run("Nonexisting Bucket", func(t *testing.T) { t.Run("Nonexisting Bucket", func(t *testing.T) {
_, err := testHandler.testCreateWithUser(nil, map[string]string{"project": "1"}, `{"title":"Lorem Ipsum","bucket_id":9999}`) _, 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) assertHandlerErrorCode(t, err, models.ErrCodeBucketDoesNotExist)
}) })
}) })
t.Run("Link Share", func(t *testing.T) { t.Run("Link Share", func(t *testing.T) {
rec, err := testHandlerLinkShareWrite.testCreateWithLinkShare(nil, map[string]string{"project": "2"}, `{"title":"Lorem Ipsum"}`) 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"`) assert.Contains(t, rec.Body.String(), `"title":"Lorem Ipsum"`)
db.AssertExists(t, "tasks", map[string]interface{}{ db.AssertExists(t, "tasks", map[string]interface{}{
"project_id": 2, "project_id": 2,

3
pkg/integrations/token_test.go
View File

@ -22,12 +22,13 @@ import (
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestCheckToken(t *testing.T) { func TestCheckToken(t *testing.T) {
t.Run("Normal test", func(t *testing.T) { t.Run("Normal test", func(t *testing.T) {
rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.CheckToken, &testuser1, "", nil, nil) 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(), `🍵`) assert.Contains(t, rec.Body.String(), `🍵`)
}) })
} }

10
pkg/integrations/user_change_password_test.go
View File

@ -22,7 +22,9 @@ import (
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestUserChangePassword(t *testing.T) { func TestUserChangePassword(t *testing.T) {
@ -31,7 +33,7 @@ func TestUserChangePassword(t *testing.T) {
"new_password": "12345", "new_password": "12345",
"old_password": "1234" "old_password": "1234"
}`, nil, nil) }`, nil, nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `The password was updated successfully.`) assert.Contains(t, rec.Body.String(), `The password was updated successfully.`)
}) })
t.Run("Wrong old password", func(t *testing.T) { t.Run("Wrong old password", func(t *testing.T) {
@ -39,7 +41,7 @@ func TestUserChangePassword(t *testing.T) {
"new_password": "12345", "new_password": "12345",
"old_password": "invalid" "old_password": "invalid"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword) assertHandlerErrorCode(t, err, user.ErrCodeWrongUsernameOrPassword)
}) })
t.Run("Empty old password", func(t *testing.T) { t.Run("Empty old password", func(t *testing.T) {
@ -47,7 +49,7 @@ func TestUserChangePassword(t *testing.T) {
"new_password": "12345", "new_password": "12345",
"old_password": "" "old_password": ""
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeEmptyOldPassword) assertHandlerErrorCode(t, err, user.ErrCodeEmptyOldPassword)
}) })
t.Run("Empty new password", func(t *testing.T) { t.Run("Empty new password", func(t *testing.T) {
@ -55,7 +57,7 @@ func TestUserChangePassword(t *testing.T) {
"new_password": "", "new_password": "",
"old_password": "1234" "old_password": "1234"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeEmptyNewPassword) assertHandlerErrorCode(t, err, user.ErrCodeEmptyNewPassword)
}) })
} }

10
pkg/integrations/user_confirm_email_test.go
View File

@ -22,30 +22,32 @@ import (
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestUserConfirmEmail(t *testing.T) { func TestUserConfirmEmail(t *testing.T) {
t.Run("Normal test", func(t *testing.T) { t.Run("Normal test", func(t *testing.T) {
rec, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": "tiepiQueed8ahc7zeeFe1eveiy4Ein8osooxegiephauph2Ael"}`, nil, nil) 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.`) assert.Contains(t, rec.Body.String(), `The email was confirmed successfully.`)
}) })
t.Run("Empty payload", func(t *testing.T) { t.Run("Empty payload", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{}`, nil, nil) _, 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) assert.Equal(t, http.StatusPreconditionFailed, err.(*echo.HTTPError).Code)
assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken) assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken)
}) })
t.Run("Empty token", func(t *testing.T) { t.Run("Empty token", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": ""}`, nil, nil) _, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": ""}`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken) assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken)
}) })
t.Run("Invalid token", func(t *testing.T) { t.Run("Invalid token", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": "invalidToken"}`, nil, nil) _, err := newTestRequest(t, http.MethodPost, apiv1.UserConfirmEmail, `{"token": "invalidToken"}`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken) assertHandlerErrorCode(t, err, user.ErrCodeInvalidEmailConfirmToken)
}) })
} }

9
pkg/integrations/user_password_request_token_test.go
View File

@ -24,27 +24,28 @@ import (
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestUserRequestResetPasswordToken(t *testing.T) { func TestUserRequestResetPasswordToken(t *testing.T) {
t.Run("Normal requesting a password reset token", func(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) 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.`) assert.Contains(t, rec.Body.String(), `Token was sent.`)
}) })
t.Run("Empty payload", func(t *testing.T) { t.Run("Empty payload", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.UserRequestResetPasswordToken, `{}`, nil, nil) _, err := newTestRequest(t, http.MethodPost, apiv1.UserRequestResetPasswordToken, `{}`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword)
}) })
t.Run("Invalid email address", func(t *testing.T) { t.Run("Invalid email address", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.UserRequestResetPasswordToken, `{"email": "user1example.com"}`, nil, nil) _, 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) assert.Equal(t, http.StatusBadRequest, err.(*echo.HTTPError).Code)
}) })
t.Run("No user with that email address", func(t *testing.T) { 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) _, 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) assertHandlerErrorCode(t, err, user.ErrCodeUserDoesNotExist)
}) })
} }

10
pkg/integrations/user_password_reset_test.go
View File

@ -22,8 +22,10 @@ import (
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/labstack/echo/v4" "github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestUserPasswordReset(t *testing.T) { func TestUserPasswordReset(t *testing.T) {
@ -32,12 +34,12 @@ func TestUserPasswordReset(t *testing.T) {
"new_password": "1234", "new_password": "1234",
"token": "passwordresettesttoken" "token": "passwordresettesttoken"
}`, nil, nil) }`, nil, nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Contains(t, rec.Body.String(), `The password was updated successfully.`) assert.Contains(t, rec.Body.String(), `The password was updated successfully.`)
}) })
t.Run("Empty payload", func(t *testing.T) { t.Run("Empty payload", func(t *testing.T) {
_, err := newTestRequest(t, http.MethodPost, apiv1.UserResetPassword, `{}`, nil, nil) _, 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) assert.Equal(t, http.StatusBadRequest, err.(*echo.HTTPError).Code)
}) })
t.Run("No new password", func(t *testing.T) { t.Run("No new password", func(t *testing.T) {
@ -45,7 +47,7 @@ func TestUserPasswordReset(t *testing.T) {
"new_password": "", "new_password": "",
"token": "passwordresettesttoken" "token": "passwordresettesttoken"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword) assertHandlerErrorCode(t, err, user.ErrCodeNoUsernamePassword)
}) })
t.Run("Invalid password reset token", func(t *testing.T) { t.Run("Invalid password reset token", func(t *testing.T) {
@ -53,7 +55,7 @@ func TestUserPasswordReset(t *testing.T) {
"new_password": "1234", "new_password": "1234",
"token": "invalidtoken" "token": "invalidtoken"
}`, nil, nil) }`, nil, nil)
assert.Error(t, err) require.Error(t, err)
assertHandlerErrorCode(t, err, user.ErrCodeInvalidPasswordResetToken) assertHandlerErrorCode(t, err, user.ErrCodeInvalidPasswordResetToken)
}) })
} }

6
pkg/integrations/user_project_test.go
View File

@ -21,18 +21,20 @@ import (
"testing" "testing"
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestUserProject(t *testing.T) { func TestUserProject(t *testing.T) {
t.Run("Normal test", func(t *testing.T) { t.Run("Normal test", func(t *testing.T) {
rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.UserList, &testuser1, "", nil, nil) 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()) assert.Equal(t, "null\n", rec.Body.String())
}) })
t.Run("Search for user3", func(t *testing.T) { t.Run("Search for user3", func(t *testing.T) {
rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.UserList, &testuser1, "", map[string][]string{"s": {"user3"}}, nil) 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.Contains(t, rec.Body.String(), `user3`)
assert.NotContains(t, rec.Body.String(), `user1`) assert.NotContains(t, rec.Body.String(), `user1`)
assert.NotContains(t, rec.Body.String(), `user2`) assert.NotContains(t, rec.Body.String(), `user2`)

4
pkg/integrations/user_show_test.go
View File

@ -21,13 +21,15 @@ import (
"testing" "testing"
apiv1 "code.vikunja.io/api/pkg/routes/api/v1" apiv1 "code.vikunja.io/api/pkg/routes/api/v1"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestUserShow(t *testing.T) { func TestUserShow(t *testing.T) {
t.Run("Normal test", func(t *testing.T) { t.Run("Normal test", func(t *testing.T) {
rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.UserShow, &testuser1, "", nil, nil) 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(), `"id":1`)
assert.Contains(t, rec.Body.String(), `"username":"user1"`) assert.Contains(t, rec.Body.String(), `"username":"user1"`)
assert.NotContains(t, rec.Body.String(), `"email":""`) assert.NotContains(t, rec.Body.String(), `"email":""`)

17
pkg/models/api_tokens_test.go
View File

@ -23,6 +23,7 @@ import (
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestAPIToken_ReadAll(t *testing.T) { 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 // Checking if the user only sees their own tokens
result, count, total, err := token.ReadAll(s, u, "", 1, 50) result, count, total, err := token.ReadAll(s, u, "", 1, 50)
assert.NoError(t, err) require.NoError(t, err)
tokens, is := result.([]*APIToken) tokens, is := result.([]*APIToken)
assert.Truef(t, is, "tokens are not of type []*APIToken") assert.Truef(t, is, "tokens are not of type []*APIToken")
assert.Len(t, tokens, 2) 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(2), total)
assert.Equal(t, int64(1), tokens[0].ID) assert.Equal(t, int64(1), tokens[0].ID)
assert.Equal(t, int64(2), tokens[1].ID) assert.Equal(t, int64(2), tokens[1].ID)
@ -54,7 +55,7 @@ func TestAPIToken_CanDelete(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
can, err := token.CanDelete(s, u) can, err := token.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("noneixsting token", func(t *testing.T) { t.Run("noneixsting token", func(t *testing.T) {
@ -65,7 +66,7 @@ func TestAPIToken_CanDelete(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
can, err := token.CanDelete(s, u) can, err := token.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("token of another user", func(t *testing.T) { t.Run("token of another user", func(t *testing.T) {
@ -76,7 +77,7 @@ func TestAPIToken_CanDelete(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
can, err := token.CanDelete(s, u) can, err := token.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
} }
@ -90,7 +91,7 @@ func TestAPIToken_Create(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
err := token.Create(s, u) 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 token, err := GetTokenFromTokenString(s, "tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e") // Token 1
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, int64(1), token.ID) assert.Equal(t, int64(1), token.ID)
}) })
t.Run("invalid token", func(t *testing.T) { t.Run("invalid token", func(t *testing.T) {
@ -112,7 +113,7 @@ func TestAPIToken_GetTokenFromTokenString(t *testing.T) {
_, err := GetTokenFromTokenString(s, "tk_loremipsum") _, err := GetTokenFromTokenString(s, "tk_loremipsum")
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrAPITokenInvalid(err)) assert.True(t, IsErrAPITokenInvalid(err))
}) })
} }

24
pkg/models/kanban_test.go
View File

@ -23,7 +23,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestBucket_ReadAll(t *testing.T) { func TestBucket_ReadAll(t *testing.T) {
@ -35,7 +37,7 @@ func TestBucket_ReadAll(t *testing.T) {
testuser := &user.User{ID: 1} testuser := &user.User{ID: 1}
b := &Bucket{ProjectID: 1} b := &Bucket{ProjectID: 1}
bucketsInterface, _, _, err := b.ReadAll(s, testuser, "", 0, 0) bucketsInterface, _, _, err := b.ReadAll(s, testuser, "", 0, 0)
assert.NoError(t, err) require.NoError(t, err)
buckets, is := bucketsInterface.([]*Bucket) buckets, is := bucketsInterface.([]*Bucket)
assert.True(t, is) assert.True(t, is)
@ -85,7 +87,7 @@ func TestBucket_ReadAll(t *testing.T) {
}, },
} }
bucketsInterface, _, _, err := b.ReadAll(s, testuser, "", -1, 0) bucketsInterface, _, _, err := b.ReadAll(s, testuser, "", -1, 0)
assert.NoError(t, err) require.NoError(t, err)
buckets := bucketsInterface.([]*Bucket) buckets := bucketsInterface.([]*Bucket)
assert.Len(t, buckets, 3) assert.Len(t, buckets, 3)
@ -104,7 +106,7 @@ func TestBucket_ReadAll(t *testing.T) {
} }
b := &Bucket{ProjectID: 1} b := &Bucket{ProjectID: 1}
result, _, _, err := b.ReadAll(s, linkShare, "", 0, 0) result, _, _, err := b.ReadAll(s, linkShare, "", 0, 0)
assert.NoError(t, err) require.NoError(t, err)
buckets, _ := result.([]*Bucket) buckets, _ := result.([]*Bucket)
assert.Len(t, buckets, 3) assert.Len(t, buckets, 3)
assert.NotNil(t, buckets[0].CreatedBy) assert.NotNil(t, buckets[0].CreatedBy)
@ -118,7 +120,7 @@ func TestBucket_ReadAll(t *testing.T) {
testuser := &user.User{ID: 12} testuser := &user.User{ID: 12}
b := &Bucket{ProjectID: 23} b := &Bucket{ProjectID: 23}
result, _, _, err := b.ReadAll(s, testuser, "", 0, 0) result, _, _, err := b.ReadAll(s, testuser, "", 0, 0)
assert.NoError(t, err) require.NoError(t, err)
buckets, _ := result.([]*Bucket) buckets, _ := result.([]*Bucket)
assert.Len(t, buckets, 1) assert.Len(t, buckets, 1)
assert.NotNil(t, buckets[0].CreatedBy) assert.NotNil(t, buckets[0].CreatedBy)
@ -139,14 +141,14 @@ func TestBucket_Delete(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
err := b.Delete(s, user) err := b.Delete(s, user)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() 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 // Assert all tasks have been moved to bucket 1 as that one is the first
tasks := []*Task{} tasks := []*Task{}
err = s.Where("bucket_id = ?", 1).Find(&tasks) err = s.Where("bucket_id = ?", 1).Find(&tasks)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, tasks, 15) assert.Len(t, tasks, 15)
db.AssertMissing(t, "buckets", map[string]interface{}{ db.AssertMissing(t, "buckets", map[string]interface{}{
"id": 2, "id": 2,
@ -163,10 +165,10 @@ func TestBucket_Delete(t *testing.T) {
ProjectID: 18, ProjectID: 18,
} }
err := b.Delete(s, user) err := b.Delete(s, user)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrCannotRemoveLastBucket(err)) assert.True(t, IsErrCannotRemoveLastBucket(err))
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "buckets", map[string]interface{}{ db.AssertExists(t, "buckets", map[string]interface{}{
"id": 34, "id": 34,
@ -179,10 +181,10 @@ func TestBucket_Update(t *testing.T) {
testAndAssertBucketUpdate := func(t *testing.T, b *Bucket, s *xorm.Session) { testAndAssertBucketUpdate := func(t *testing.T, b *Bucket, s *xorm.Session) {
err := b.Update(s, &user.User{ID: 1}) err := b.Update(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "buckets", map[string]interface{}{ db.AssertExists(t, "buckets", map[string]interface{}{
"id": 1, "id": 1,

16
pkg/models/link_sharing_test.go
View File

@ -21,7 +21,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestLinkSharing_Create(t *testing.T) { func TestLinkSharing_Create(t *testing.T) {
@ -38,7 +40,7 @@ func TestLinkSharing_Create(t *testing.T) {
} }
err := share.Create(s, doer) err := share.Create(s, doer)
assert.NoError(t, err) require.NoError(t, err)
assert.NotEmpty(t, share.Hash) assert.NotEmpty(t, share.Hash)
assert.NotEmpty(t, share.ID) assert.NotEmpty(t, share.ID)
assert.Equal(t, SharingTypeWithoutPassword, share.SharingType) assert.Equal(t, SharingTypeWithoutPassword, share.SharingType)
@ -57,7 +59,7 @@ func TestLinkSharing_Create(t *testing.T) {
} }
err := share.Create(s, doer) err := share.Create(s, doer)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrInvalidRight(err)) assert.True(t, IsErrInvalidRight(err))
}) })
t.Run("password should be hashed", func(t *testing.T) { 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) err := share.Create(s, doer)
assert.NoError(t, err) require.NoError(t, err)
assert.NotEmpty(t, share.Hash) assert.NotEmpty(t, share.Hash)
assert.NotEmpty(t, share.ID) assert.NotEmpty(t, share.ID)
assert.Empty(t, share.Password) assert.Empty(t, share.Password)
@ -97,7 +99,7 @@ func TestLinkSharing_ReadAll(t *testing.T) {
all, _, _, err := share.ReadAll(s, doer, "", 1, -1) all, _, _, err := share.ReadAll(s, doer, "", 1, -1)
shares := all.([]*LinkSharing) shares := all.([]*LinkSharing)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, shares, 2) assert.Len(t, shares, 2)
for _, sharing := range shares { for _, sharing := range shares {
assert.Empty(t, sharing.Password) assert.Empty(t, sharing.Password)
@ -114,7 +116,7 @@ func TestLinkSharing_ReadAll(t *testing.T) {
all, _, _, err := share.ReadAll(s, doer, "wITHPASS", 1, -1) all, _, _, err := share.ReadAll(s, doer, "wITHPASS", 1, -1)
shares := all.([]*LinkSharing) shares := all.([]*LinkSharing)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, shares, 1) assert.Len(t, shares, 1)
assert.Equal(t, int64(4), shares[0].ID) assert.Equal(t, int64(4), shares[0].ID)
}) })
@ -133,7 +135,7 @@ func TestLinkSharing_ReadOne(t *testing.T) {
} }
err := share.ReadOne(s, doer) err := share.ReadOne(s, doer)
assert.NoError(t, err) require.NoError(t, err)
assert.NotEmpty(t, share.Hash) assert.NotEmpty(t, share.Hash)
assert.Equal(t, SharingTypeWithoutPassword, share.SharingType) assert.Equal(t, SharingTypeWithoutPassword, share.SharingType)
}) })
@ -147,7 +149,7 @@ func TestLinkSharing_ReadOne(t *testing.T) {
} }
err := share.ReadOne(s, doer) err := share.ReadOne(s, doer)
assert.NoError(t, err) require.NoError(t, err)
assert.NotEmpty(t, share.Hash) assert.NotEmpty(t, share.Hash)
assert.Equal(t, SharingTypeWithPassword, share.SharingType) assert.Equal(t, SharingTypeWithPassword, share.SharingType)
assert.Empty(t, share.Password) assert.Empty(t, share.Password)

21
pkg/models/mentions_test.go
View File

@ -19,11 +19,12 @@ package models
import ( import (
"testing" "testing"
"github.com/stretchr/testify/assert"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/notifications" "code.vikunja.io/api/pkg/notifications"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestFindMentionedUsersInText(t *testing.T) { func TestFindMentionedUsersInText(t *testing.T) {
@ -100,13 +101,13 @@ func TestSendingMentionNotification(t *testing.T) {
defer s.Close() defer s.Close()
task, err := GetTaskByIDSimple(s, 32) task, err := GetTaskByIDSimple(s, 32)
assert.NoError(t, err) require.NoError(t, err)
tc := &TaskComment{ tc := &TaskComment{
Comment: "Lorem Ipsum @user1 @user2 @user3 @user4 @user5 @user6", Comment: "Lorem Ipsum @user1 @user2 @user3 @user4 @user5 @user6",
TaskID: 32, // user2 has access to the project that task belongs to TaskID: 32, // user2 has access to the project that task belongs to
} }
err = tc.Create(s, u) err = tc.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
n := &TaskCommentNotification{ n := &TaskCommentNotification{
Doer: u, Doer: u,
Task: &task, Task: &task,
@ -114,7 +115,7 @@ func TestSendingMentionNotification(t *testing.T) {
} }
_, err = notifyMentionedUsers(s, &task, tc.Comment, n) _, err = notifyMentionedUsers(s, &task, tc.Comment, n)
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "notifications", map[string]interface{}{ db.AssertExists(t, "notifications", map[string]interface{}{
"subject_id": tc.ID, "subject_id": tc.ID,
@ -153,13 +154,13 @@ func TestSendingMentionNotification(t *testing.T) {
defer s.Close() defer s.Close()
task, err := GetTaskByIDSimple(s, 32) task, err := GetTaskByIDSimple(s, 32)
assert.NoError(t, err) require.NoError(t, err)
tc := &TaskComment{ tc := &TaskComment{
Comment: "Lorem Ipsum @user2", Comment: "Lorem Ipsum @user2",
TaskID: 32, // user2 has access to the project that task belongs to TaskID: 32, // user2 has access to the project that task belongs to
} }
err = tc.Create(s, u) err = tc.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
n := &TaskCommentNotification{ n := &TaskCommentNotification{
Doer: u, Doer: u,
Task: &task, Task: &task,
@ -167,14 +168,14 @@ func TestSendingMentionNotification(t *testing.T) {
} }
_, err = notifyMentionedUsers(s, &task, tc.Comment, n) _, err = notifyMentionedUsers(s, &task, tc.Comment, n)
assert.NoError(t, err) require.NoError(t, err)
_, err = notifyMentionedUsers(s, &task, "Lorem Ipsum @user2 @user3", n) _, 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 // 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) dbNotifications, err := notifications.GetNotificationsForNameAndUser(s, 2, n.Name(), tc.ID)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, dbNotifications, 1) assert.Len(t, dbNotifications, 1)
}) })
} }

10
pkg/models/project_duplicate_test.go
View File

@ -22,7 +22,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/files"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestProjectDuplicate(t *testing.T) { func TestProjectDuplicate(t *testing.T) {
@ -40,16 +42,16 @@ func TestProjectDuplicate(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
can, err := l.CanCreate(s, u) can, err := l.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
err = l.Create(s, u) 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 // assert the new project has the same number of buckets as the old one
numberOfOriginalBuckets, err := s.Where("project_id = ?", l.ProjectID).Count(&Bucket{}) 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{}) 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") 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. // To make this test 100% useful, it would need to assert a lot more stuff, but it is good enough for now.

38
pkg/models/project_team_test.go
View File

@ -25,7 +25,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"code.vikunja.io/web" "code.vikunja.io/web"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTeamProject_ReadAll(t *testing.T) { func TestTeamProject_ReadAll(t *testing.T) {
@ -39,10 +41,10 @@ func TestTeamProject_ReadAll(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
s := db.NewSession() s := db.NewSession()
teams, _, _, err := tl.ReadAll(s, u, "", 1, 50) teams, _, _, err := tl.ReadAll(s, u, "", 1, 50)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind())
ts := reflect.ValueOf(teams) ts := reflect.ValueOf(teams)
assert.Equal(t, ts.Len(), 1) assert.Equal(t, 1, ts.Len())
_ = s.Close() _ = s.Close()
}) })
t.Run("nonexistant project", func(t *testing.T) { t.Run("nonexistant project", func(t *testing.T) {
@ -52,7 +54,7 @@ func TestTeamProject_ReadAll(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
s := db.NewSession() s := db.NewSession()
_, _, _, err := tl.ReadAll(s, u, "", 1, 50) _, _, _, err := tl.ReadAll(s, u, "", 1, 50)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectDoesNotExist(err)) assert.True(t, IsErrProjectDoesNotExist(err))
_ = s.Close() _ = s.Close()
}) })
@ -65,7 +67,7 @@ func TestTeamProject_ReadAll(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
s := db.NewSession() s := db.NewSession()
_, _, _, err := tl.ReadAll(s, u, "", 1, 50) _, _, _, err := tl.ReadAll(s, u, "", 1, 50)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNeedToHaveProjectReadAccess(err)) assert.True(t, IsErrNeedToHaveProjectReadAccess(err))
_ = s.Close() _ = s.Close()
}) })
@ -76,8 +78,8 @@ func TestTeamProject_ReadAll(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
s := db.NewSession() s := db.NewSession()
teams, _, _, err := tl.ReadAll(s, u, "TEAM9", 1, 50) teams, _, _, err := tl.ReadAll(s, u, "TEAM9", 1, 50)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind())
ts := teams.([]*TeamWithRight) ts := teams.([]*TeamWithRight)
assert.Len(t, ts, 1) assert.Len(t, ts, 1)
assert.Equal(t, int64(9), ts[0].ID) assert.Equal(t, int64(9), ts[0].ID)
@ -98,9 +100,9 @@ func TestTeamProject_Create(t *testing.T) {
allowed, _ := tl.CanCreate(s, u) allowed, _ := tl.CanCreate(s, u)
assert.True(t, allowed) assert.True(t, allowed)
err := tl.Create(s, u) err := tl.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "team_projects", map[string]interface{}{ db.AssertExists(t, "team_projects", map[string]interface{}{
"team_id": 1, "team_id": 1,
"project_id": 1, "project_id": 1,
@ -116,7 +118,7 @@ func TestTeamProject_Create(t *testing.T) {
Right: RightAdmin, Right: RightAdmin,
} }
err := tl.Create(s, u) err := tl.Create(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamAlreadyHasAccess(err)) assert.True(t, IsErrTeamAlreadyHasAccess(err))
_ = s.Close() _ = s.Close()
}) })
@ -129,7 +131,7 @@ func TestTeamProject_Create(t *testing.T) {
Right: RightUnknown, Right: RightUnknown,
} }
err := tl.Create(s, u) err := tl.Create(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrInvalidRight(err)) assert.True(t, IsErrInvalidRight(err))
_ = s.Close() _ = s.Close()
}) })
@ -141,7 +143,7 @@ func TestTeamProject_Create(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
err := tl.Create(s, u) err := tl.Create(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamDoesNotExist(err)) assert.True(t, IsErrTeamDoesNotExist(err))
_ = s.Close() _ = s.Close()
}) })
@ -153,7 +155,7 @@ func TestTeamProject_Create(t *testing.T) {
ProjectID: 9999, ProjectID: 9999,
} }
err := tl.Create(s, u) err := tl.Create(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectDoesNotExist(err)) assert.True(t, IsErrProjectDoesNotExist(err))
_ = s.Close() _ = s.Close()
}) })
@ -170,9 +172,9 @@ func TestTeamProject_Delete(t *testing.T) {
ProjectID: 3, ProjectID: 3,
} }
err := tl.Delete(s, user) err := tl.Delete(s, user)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "team_projects", map[string]interface{}{ db.AssertMissing(t, "team_projects", map[string]interface{}{
"team_id": 1, "team_id": 1,
"project_id": 3, "project_id": 3,
@ -186,7 +188,7 @@ func TestTeamProject_Delete(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
err := tl.Delete(s, user) err := tl.Delete(s, user)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamDoesNotExist(err)) assert.True(t, IsErrTeamDoesNotExist(err))
_ = s.Close() _ = s.Close()
}) })
@ -198,7 +200,7 @@ func TestTeamProject_Delete(t *testing.T) {
ProjectID: 9999, ProjectID: 9999,
} }
err := tl.Delete(s, user) err := tl.Delete(s, user)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamDoesNotHaveAccessToProject(err)) assert.True(t, IsErrTeamDoesNotHaveAccessToProject(err))
_ = s.Close() _ = 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()) t.Errorf("TeamProject.Update() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
} }
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
if !tt.wantErr { if !tt.wantErr {
db.AssertExists(t, "team_projects", map[string]interface{}{ db.AssertExists(t, "team_projects", map[string]interface{}{
"project_id": tt.fields.ProjectID, "project_id": tt.fields.ProjectID,

82
pkg/models/project_test.go
View File

@ -23,7 +23,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/files"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestProject_CreateOrUpdate(t *testing.T) { func TestProject_CreateOrUpdate(t *testing.T) {
@ -42,9 +44,9 @@ func TestProject_CreateOrUpdate(t *testing.T) {
Description: "Lorem Ipsum", Description: "Lorem Ipsum",
} }
err := project.Create(s, usr) err := project.Create(s, usr)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "projects", map[string]interface{}{ db.AssertExists(t, "projects", map[string]interface{}{
"id": project.ID, "id": project.ID,
"title": project.Title, "title": project.Title,
@ -64,7 +66,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
ParentProjectID: 999999, ParentProjectID: 999999,
} }
err := project.Create(s, usr) err := project.Create(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectDoesNotExist(err)) assert.True(t, IsErrProjectDoesNotExist(err))
_ = s.Close() _ = s.Close()
}) })
@ -77,7 +79,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
Description: "Lorem Ipsum", Description: "Lorem Ipsum",
} }
err := project.Create(s, usr) err := project.Create(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, user.IsErrUserDoesNotExist(err)) assert.True(t, user.IsErrUserDoesNotExist(err))
_ = s.Close() _ = s.Close()
}) })
@ -90,7 +92,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
Identifier: "test1", Identifier: "test1",
} }
err := project.Create(s, usr) err := project.Create(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectIdentifierIsNotUnique(err)) assert.True(t, IsErrProjectIdentifierIsNotUnique(err))
_ = s.Close() _ = s.Close()
}) })
@ -102,9 +104,9 @@ func TestProject_CreateOrUpdate(t *testing.T) {
Description: "Lorem Ipsum", Description: "Lorem Ipsum",
} }
err := project.Create(s, usr) err := project.Create(s, usr)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "projects", map[string]interface{}{ db.AssertExists(t, "projects", map[string]interface{}{
"id": project.ID, "id": project.ID,
"title": project.Title, "title": project.Title,
@ -124,9 +126,9 @@ func TestProject_CreateOrUpdate(t *testing.T) {
} }
project.Description = "Lorem Ipsum dolor sit amet." project.Description = "Lorem Ipsum dolor sit amet."
err := project.Update(s, usr) err := project.Update(s, usr)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "projects", map[string]interface{}{ db.AssertExists(t, "projects", map[string]interface{}{
"id": project.ID, "id": project.ID,
"title": project.Title, "title": project.Title,
@ -141,7 +143,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
Title: "test", Title: "test",
} }
err := project.Update(s, usr) err := project.Update(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectDoesNotExist(err)) assert.True(t, IsErrProjectDoesNotExist(err))
_ = s.Close() _ = s.Close()
@ -155,7 +157,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
Identifier: "test1", Identifier: "test1",
} }
err := project.Create(s, usr) err := project.Create(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectIdentifierIsNotUnique(err)) assert.True(t, IsErrProjectIdentifierIsNotUnique(err))
_ = s.Close() _ = s.Close()
}) })
@ -176,12 +178,12 @@ func TestProject_CreateOrUpdate(t *testing.T) {
ParentProjectID: 7, // from 6 ParentProjectID: 7, // from 6
} }
can, err := project.CanUpdate(s, usr) can, err := project.CanUpdate(s, usr)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
err = project.Update(s, usr) err = project.Update(s, usr)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "projects", map[string]interface{}{ db.AssertExists(t, "projects", map[string]interface{}{
"id": project.ID, "id": project.ID,
"title": project.Title, "title": project.Title,
@ -218,7 +220,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
ParentProjectID: -1, ParentProjectID: -1,
} }
err := project.Update(s, usr) err := project.Update(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectCannotBelongToAPseudoParentProject(err)) assert.True(t, IsErrProjectCannotBelongToAPseudoParentProject(err))
}) })
}) })
@ -230,7 +232,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
IsArchived: true, IsArchived: true,
} }
err := project.Update(s, &user.User{ID: 3}) err := project.Update(s, &user.User{ID: 3})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrCannotArchiveDefaultProject(err)) assert.True(t, IsErrCannotArchiveDefaultProject(err))
}) })
t.Run("archive default project of another user", func(t *testing.T) { t.Run("archive default project of another user", func(t *testing.T) {
@ -241,7 +243,7 @@ func TestProject_CreateOrUpdate(t *testing.T) {
IsArchived: true, IsArchived: true,
} }
err := project.Update(s, &user.User{ID: 2}) err := project.Update(s, &user.User{ID: 2})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrCannotArchiveDefaultProject(err)) assert.True(t, IsErrCannotArchiveDefaultProject(err))
}) })
}) })
@ -255,9 +257,9 @@ func TestProject_Delete(t *testing.T) {
ID: 1, ID: 1,
} }
err := project.Delete(s, &user.User{ID: 1}) err := project.Delete(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "projects", map[string]interface{}{ db.AssertMissing(t, "projects", map[string]interface{}{
"id": 1, "id": 1,
}) })
@ -273,9 +275,9 @@ func TestProject_Delete(t *testing.T) {
ID: 35, ID: 35,
} }
err := project.Delete(s, &user.User{ID: 6}) err := project.Delete(s, &user.User{ID: 6})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "projects", map[string]interface{}{ db.AssertMissing(t, "projects", map[string]interface{}{
"id": 35, "id": 35,
}) })
@ -290,7 +292,7 @@ func TestProject_Delete(t *testing.T) {
ID: 4, ID: 4,
} }
err := project.Delete(s, &user.User{ID: 3}) err := project.Delete(s, &user.User{ID: 3})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrCannotDeleteDefaultProject(err)) assert.True(t, IsErrCannotDeleteDefaultProject(err))
}) })
t.Run("default project of a different user", func(t *testing.T) { t.Run("default project of a different user", func(t *testing.T) {
@ -300,7 +302,7 @@ func TestProject_Delete(t *testing.T) {
ID: 4, ID: 4,
} }
err := project.Delete(s, &user.User{ID: 2}) err := project.Delete(s, &user.User{ID: 2})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrCannotDeleteDefaultProject(err)) assert.True(t, IsErrCannotDeleteDefaultProject(err))
}) })
} }
@ -316,9 +318,9 @@ func TestProject_DeleteBackgroundFileIfExists(t *testing.T) {
BackgroundFileID: file.ID, BackgroundFileID: file.ID,
} }
err := SetProjectBackground(s, project.ID, file, "") err := SetProjectBackground(s, project.ID, file, "")
assert.NoError(t, err) require.NoError(t, err)
err = project.DeleteBackgroundFileIfExists() err = project.DeleteBackgroundFileIfExists()
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("project with invalid background", func(t *testing.T) { t.Run("project with invalid background", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -330,16 +332,16 @@ func TestProject_DeleteBackgroundFileIfExists(t *testing.T) {
BackgroundFileID: file.ID, BackgroundFileID: file.ID,
} }
err := SetProjectBackground(s, project.ID, file, "") err := SetProjectBackground(s, project.ID, file, "")
assert.NoError(t, err) require.NoError(t, err)
err = project.DeleteBackgroundFileIfExists() err = project.DeleteBackgroundFileIfExists()
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("project without background", func(t *testing.T) { t.Run("project without background", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
files.InitTestFileFixtures(t) files.InitTestFileFixtures(t)
project := Project{ID: 1} project := Project{ID: 1}
err := project.DeleteBackgroundFileIfExists() err := project.DeleteBackgroundFileIfExists()
assert.NoError(t, err) require.NoError(t, err)
}) })
} }
@ -350,8 +352,8 @@ func TestProject_ReadAll(t *testing.T) {
projects := []*Project{} projects := []*Project{}
archivedProjects := make(map[int64]bool) archivedProjects := make(map[int64]bool)
_, _, err := getAllProjectsForUser(s, 1, nil, &projectOptions{}, &projects, 0, archivedProjects) _, _, err := getAllProjectsForUser(s, 1, nil, &projectOptions{}, &projects, 0, archivedProjects)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, 24, len(projects)) assert.Len(t, projects, 24)
_ = s.Close() _ = s.Close()
}) })
t.Run("only child projects for one project", func(t *testing.T) { t.Run("only child projects for one project", func(t *testing.T) {
@ -364,10 +366,10 @@ func TestProject_ReadAll(t *testing.T) {
project := Project{} project := Project{}
projects3, _, _, err := project.ReadAll(s, u, "", 1, 50) projects3, _, _, err := project.ReadAll(s, u, "", 1, 50)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, reflect.TypeOf(projects3).Kind(), reflect.Slice) assert.Equal(t, reflect.Slice, reflect.TypeOf(projects3).Kind())
ls := projects3.([]*Project) 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(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(1), ls[1].ID)
assert.Equal(t, int64(6), ls[2].ID) assert.Equal(t, int64(6), ls[2].ID)
@ -381,7 +383,7 @@ func TestProject_ReadAll(t *testing.T) {
usr := &user.User{ID: 999999} usr := &user.User{ID: 999999}
project := Project{} project := Project{}
_, _, _, err := project.ReadAll(s, usr, "", 1, 50) _, _, _, err := project.ReadAll(s, usr, "", 1, 50)
assert.Error(t, err) require.Error(t, err)
assert.True(t, user.IsErrUserDoesNotExist(err)) assert.True(t, user.IsErrUserDoesNotExist(err))
_ = s.Close() _ = s.Close()
}) })
@ -392,9 +394,9 @@ func TestProject_ReadAll(t *testing.T) {
project := Project{} project := Project{}
projects3, _, _, err := project.ReadAll(s, u, "TEST10", 1, 50) projects3, _, _, err := project.ReadAll(s, u, "TEST10", 1, 50)
assert.NoError(t, err) require.NoError(t, err)
ls := projects3.([]*Project) 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(10), ls[0].ID)
assert.Equal(t, int64(-1), ls[1].ID) assert.Equal(t, int64(-1), ls[1].ID)
assert.Equal(t, int64(-2), ls[2].ID) assert.Equal(t, int64(-2), ls[2].ID)
@ -411,10 +413,10 @@ func TestProject_ReadOne(t *testing.T) {
u := &user.User{ID: 1} u := &user.User{ID: 1}
l := &Project{ID: 1} l := &Project{ID: 1}
can, _, err := l.CanRead(s, u) can, _, err := l.CanRead(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
err = l.ReadOne(s, u) err = l.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, "Test1", l.Title) assert.Equal(t, "Test1", l.Title)
}) })
t.Run("with subscription", func(t *testing.T) { t.Run("with subscription", func(t *testing.T) {
@ -425,10 +427,10 @@ func TestProject_ReadOne(t *testing.T) {
u := &user.User{ID: 6} u := &user.User{ID: 6}
l := &Project{ID: 12} l := &Project{ID: 12}
can, _, err := l.CanRead(s, u) can, _, err := l.CanRead(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
err = l.ReadOne(s, u) err = l.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, l.Subscription) assert.NotNil(t, l.Subscription)
}) })
} }

9
pkg/models/project_users_test.go
View File

@ -25,7 +25,8 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"code.vikunja.io/web" "code.vikunja.io/web"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gopkg.in/d4l3k/messagediff.v1" "gopkg.in/d4l3k/messagediff.v1"
) )
@ -130,7 +131,7 @@ func TestProjectUser_Create(t *testing.T) {
} }
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
if !tt.wantErr { if !tt.wantErr {
db.AssertExists(t, "users_projects", map[string]interface{}{ db.AssertExists(t, "users_projects", map[string]interface{}{
@ -340,7 +341,7 @@ func TestProjectUser_Update(t *testing.T) {
} }
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
if !tt.wantErr { if !tt.wantErr {
db.AssertExists(t, "users_projects", map[string]interface{}{ db.AssertExists(t, "users_projects", map[string]interface{}{
@ -422,7 +423,7 @@ func TestProjectUser_Delete(t *testing.T) {
} }
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
if !tt.wantErr { if !tt.wantErr {
db.AssertMissing(t, "users_projects", map[string]interface{}{ db.AssertMissing(t, "users_projects", map[string]interface{}{

48
pkg/models/saved_filters_test.go
View File

@ -21,7 +21,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"xorm.io/xorm/schemas" "xorm.io/xorm/schemas"
) )
@ -56,10 +58,10 @@ func TestSavedFilter_Create(t *testing.T) {
u := &user.User{ID: 1} u := &user.User{ID: 1}
err := sf.Create(s, u) err := sf.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, u.ID, sf.OwnerID) assert.Equal(t, u.ID, sf.OwnerID)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
vals := map[string]interface{}{ vals := map[string]interface{}{
"title": "'test'", "title": "'test'",
"description": "'Lorem Ipsum dolor sit amet'", "description": "'Lorem Ipsum dolor sit amet'",
@ -85,9 +87,9 @@ func TestSavedFilter_ReadOne(t *testing.T) {
} }
// canRead pre-populates the struct // canRead pre-populates the struct
_, _, err := sf.CanRead(s, user1) _, _, err := sf.CanRead(s, user1)
assert.NoError(t, err) require.NoError(t, err)
err = sf.ReadOne(s, user1) err = sf.ReadOne(s, user1)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sf.Owner) assert.NotNil(t, sf.Owner)
} }
@ -104,9 +106,9 @@ func TestSavedFilter_Update(t *testing.T) {
Filters: &TaskCollection{}, Filters: &TaskCollection{},
} }
err := sf.Update(s, &user.User{ID: 1}) err := sf.Update(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "saved_filters", map[string]interface{}{ db.AssertExists(t, "saved_filters", map[string]interface{}{
"id": 1, "id": 1,
"title": "NewTitle", "title": "NewTitle",
@ -124,9 +126,9 @@ func TestSavedFilter_Update(t *testing.T) {
Filters: &TaskCollection{}, Filters: &TaskCollection{},
} }
err := sf.Update(s, &user.User{ID: 1}) err := sf.Update(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "saved_filters", map[string]interface{}{ db.AssertExists(t, "saved_filters", map[string]interface{}{
"id": 1, "id": 1,
"is_favorite": true, "is_favorite": true,
@ -143,9 +145,9 @@ func TestSavedFilter_Delete(t *testing.T) {
ID: 1, ID: 1,
} }
err := sf.Delete(s, &user.User{ID: 1}) err := sf.Delete(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "saved_filters", map[string]interface{}{ db.AssertMissing(t, "saved_filters", map[string]interface{}{
"id": 1, "id": 1,
}) })
@ -163,7 +165,7 @@ func TestSavedFilter_Rights(t *testing.T) {
defer s.Close() defer s.Close()
can, err := (&SavedFilter{}).CanCreate(s, user1) can, err := (&SavedFilter{}).CanCreate(s, user1)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("read", func(t *testing.T) { t.Run("read", func(t *testing.T) {
@ -177,7 +179,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, max, err := sf.CanRead(s, user1) can, max, err := sf.CanRead(s, user1)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, int(RightAdmin), max) assert.Equal(t, int(RightAdmin), max)
assert.True(t, can) assert.True(t, can)
}) })
@ -191,7 +193,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, _, err := sf.CanRead(s, user2) can, _, err := sf.CanRead(s, user2)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("nonexisting", func(t *testing.T) { t.Run("nonexisting", func(t *testing.T) {
@ -204,7 +206,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, _, err := sf.CanRead(s, user1) can, _, err := sf.CanRead(s, user1)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrSavedFilterDoesNotExist(err)) assert.True(t, IsErrSavedFilterDoesNotExist(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -218,7 +220,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, _, err := sf.CanRead(s, ls) can, _, err := sf.CanRead(s, ls)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err)) assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -234,7 +236,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, err := sf.CanUpdate(s, user1) can, err := sf.CanUpdate(s, user1)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("not owner", func(t *testing.T) { t.Run("not owner", func(t *testing.T) {
@ -247,7 +249,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, err := sf.CanUpdate(s, user2) can, err := sf.CanUpdate(s, user2)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("nonexisting", func(t *testing.T) { t.Run("nonexisting", func(t *testing.T) {
@ -260,7 +262,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, err := sf.CanUpdate(s, user1) can, err := sf.CanUpdate(s, user1)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrSavedFilterDoesNotExist(err)) assert.True(t, IsErrSavedFilterDoesNotExist(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -274,7 +276,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, err := sf.CanUpdate(s, ls) can, err := sf.CanUpdate(s, ls)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err)) assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -289,7 +291,7 @@ func TestSavedFilter_Rights(t *testing.T) {
ID: 1, ID: 1,
} }
can, err := sf.CanDelete(s, user1) can, err := sf.CanDelete(s, user1)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("not owner", func(t *testing.T) { t.Run("not owner", func(t *testing.T) {
@ -301,7 +303,7 @@ func TestSavedFilter_Rights(t *testing.T) {
ID: 1, ID: 1,
} }
can, err := sf.CanDelete(s, user2) can, err := sf.CanDelete(s, user2)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("nonexisting", func(t *testing.T) { t.Run("nonexisting", func(t *testing.T) {
@ -314,7 +316,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, err := sf.CanDelete(s, user1) can, err := sf.CanDelete(s, user1)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrSavedFilterDoesNotExist(err)) assert.True(t, IsErrSavedFilterDoesNotExist(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -328,7 +330,7 @@ func TestSavedFilter_Rights(t *testing.T) {
Title: "Lorem", Title: "Lorem",
} }
can, err := sf.CanDelete(s, ls) can, err := sf.CanDelete(s, ls)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err)) assert.True(t, IsErrSavedFilterNotAvailableForLinkShare(err))
assert.False(t, can) assert.False(t, can)
}) })

42
pkg/models/subscription_test.go
View File

@ -21,7 +21,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestSubscriptionGetTypeFromString(t *testing.T) { func TestSubscriptionGetTypeFromString(t *testing.T) {
@ -54,11 +56,11 @@ func TestSubscription_Create(t *testing.T) {
} }
can, err := sb.CanCreate(s, u) can, err := sb.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
err = sb.Create(s, u) err = sb.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sb.User) assert.NotNil(t, sb.User)
db.AssertExists(t, "subscriptions", map[string]interface{}{ db.AssertExists(t, "subscriptions", map[string]interface{}{
@ -81,7 +83,7 @@ func TestSubscription_Create(t *testing.T) {
} }
can, err := sb.CanCreate(s, linkShare) can, err := sb.CanCreate(s, linkShare)
assert.Error(t, err) require.Error(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("noneixsting project", func(t *testing.T) { t.Run("noneixsting project", func(t *testing.T) {
@ -96,7 +98,7 @@ func TestSubscription_Create(t *testing.T) {
} }
can, err := sb.CanCreate(s, u) can, err := sb.CanCreate(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectDoesNotExist(err)) assert.True(t, IsErrProjectDoesNotExist(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -112,7 +114,7 @@ func TestSubscription_Create(t *testing.T) {
} }
can, err := sb.CanCreate(s, u) can, err := sb.CanCreate(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskDoesNotExist(err)) assert.True(t, IsErrTaskDoesNotExist(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -128,7 +130,7 @@ func TestSubscription_Create(t *testing.T) {
} }
can, err := sb.CanCreate(s, u) can, err := sb.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("no rights to see task", func(t *testing.T) { 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) can, err := sb.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("existing subscription for (entity_id, entity_type, user_id) ", func(t *testing.T) { 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) can, err := sb.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
err = sb.Create(s, u) err = sb.Create(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrSubscriptionAlreadyExists(err)) assert.True(t, IsErrSubscriptionAlreadyExists(err))
}) })
@ -183,11 +185,11 @@ func TestSubscription_Delete(t *testing.T) {
} }
can, err := sb.CanDelete(s, u) can, err := sb.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
err = sb.Delete(s, u) err = sb.Delete(s, u)
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "subscriptions", map[string]interface{}{ db.AssertMissing(t, "subscriptions", map[string]interface{}{
"entity_type": 3, "entity_type": 3,
"entity_id": 2, "entity_id": 2,
@ -208,7 +210,7 @@ func TestSubscription_Delete(t *testing.T) {
} }
can, err := sb.CanDelete(s, linkShare) can, err := sb.CanDelete(s, linkShare)
assert.Error(t, err) require.Error(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("not owner of the subscription", func(t *testing.T) { 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) can, err := sb.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
} }
@ -239,7 +241,7 @@ func TestSubscriptionGet(t *testing.T) {
defer s.Close() defer s.Close()
sub, err := GetSubscription(s, SubscriptionEntityProject, 12, u) sub, err := GetSubscription(s, SubscriptionEntityProject, 12, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sub) assert.NotNil(t, sub)
assert.Equal(t, int64(3), sub.ID) assert.Equal(t, int64(3), sub.ID)
}) })
@ -249,7 +251,7 @@ func TestSubscriptionGet(t *testing.T) {
defer s.Close() defer s.Close()
sub, err := GetSubscription(s, SubscriptionEntityTask, 22, u) sub, err := GetSubscription(s, SubscriptionEntityTask, 22, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sub) assert.NotNil(t, sub)
assert.Equal(t, int64(4), sub.ID) 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 // Project 25 belongs to project 12 where user 6 has subscribed to
sub, err := GetSubscription(s, SubscriptionEntityProject, 25, u) sub, err := GetSubscription(s, SubscriptionEntityProject, 25, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sub) assert.NotNil(t, sub)
assert.Equal(t, int64(12), sub.EntityID) assert.Equal(t, int64(12), sub.EntityID)
assert.Equal(t, int64(3), sub.ID) 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 // Project 26 belongs to project 25 which belongs to project 12 where user 6 has subscribed to
sub, err := GetSubscription(s, SubscriptionEntityProject, 26, u) sub, err := GetSubscription(s, SubscriptionEntityProject, 26, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sub) assert.NotNil(t, sub)
assert.Equal(t, int64(12), sub.EntityID) assert.Equal(t, int64(12), sub.EntityID)
assert.Equal(t, int64(3), sub.ID) 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 // Task 39 belongs to project 25 which belongs to project 12 where the user has subscribed
sub, err := GetSubscription(s, SubscriptionEntityTask, 39, u) sub, err := GetSubscription(s, SubscriptionEntityTask, 39, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sub) assert.NotNil(t, sub)
// assert.Equal(t, int64(2), sub.ID) TODO // 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 // Task 21 belongs to project 32 which the user has subscribed to
sub, err := GetSubscription(s, SubscriptionEntityTask, 21, u) sub, err := GetSubscription(s, SubscriptionEntityTask, 21, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, sub) assert.NotNil(t, sub)
assert.Equal(t, int64(8), sub.ID) assert.Equal(t, int64(8), sub.ID)
}) })
@ -308,7 +310,7 @@ func TestSubscriptionGet(t *testing.T) {
defer s.Close() defer s.Close()
_, err := GetSubscription(s, 2342, 21, u) _, err := GetSubscription(s, 2342, 21, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUnknownSubscriptionEntityType(err)) assert.True(t, IsErrUnknownSubscriptionEntityType(err))
}) })
} }

44
pkg/models/task_attachment_test.go
View File

@ -26,7 +26,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/files"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTaskAttachment_ReadOne(t *testing.T) { func TestTaskAttachment_ReadOne(t *testing.T) {
@ -42,17 +44,17 @@ func TestTaskAttachment_ReadOne(t *testing.T) {
ID: 1, ID: 1,
} }
err := ta.ReadOne(s, u) err := ta.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, ta.File) assert.NotNil(t, ta.File)
assert.True(t, ta.File.ID == ta.FileID && ta.FileID != 0) assert.True(t, ta.File.ID == ta.FileID && ta.FileID != 0)
// Load the actual attachment file and check its content // Load the actual attachment file and check its content
err = ta.File.LoadFileByID() err = ta.File.LoadFileByID()
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, config.FilesBasePath.GetString()+"/1", ta.File.File.Name()) assert.Equal(t, config.FilesBasePath.GetString()+"/1", ta.File.File.Name())
content := make([]byte, 9) content := make([]byte, 9)
read, err := ta.File.File.Read(content) read, err := ta.File.File.Read(content)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, 9, read) assert.Equal(t, 9, read)
assert.Equal(t, []byte("testfile1"), content) assert.Equal(t, []byte("testfile1"), content)
}) })
@ -66,7 +68,7 @@ func TestTaskAttachment_ReadOne(t *testing.T) {
ID: 9999, ID: 9999,
} }
err := ta.ReadOne(s, u) err := ta.ReadOne(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskAttachmentDoesNotExist(err)) assert.True(t, IsErrTaskAttachmentDoesNotExist(err))
}) })
t.Run("Existing Attachment, Nonexisting File", func(t *testing.T) { t.Run("Existing Attachment, Nonexisting File", func(t *testing.T) {
@ -79,8 +81,8 @@ func TestTaskAttachment_ReadOne(t *testing.T) {
ID: 2, ID: 2,
} }
err := ta.ReadOne(s, u) err := ta.ReadOne(s, u)
assert.Error(t, err) require.Error(t, err)
assert.EqualError(t, err, "file 9999 does not exist") require.EqualError(t, err, "file 9999 does not exist")
}) })
} }
@ -118,17 +120,17 @@ func TestTaskAttachment_NewAttachment(t *testing.T) {
testuser := &user.User{ID: 1} testuser := &user.User{ID: 1}
err := ta.NewAttachment(s, tf, "testfile", 100, testuser) err := ta.NewAttachment(s, tf, "testfile", 100, testuser)
assert.NoError(t, err) require.NoError(t, err)
assert.NotEqual(t, 0, ta.FileID) assert.NotEqual(t, 0, ta.FileID)
_, err = files.FileStat("files/" + strconv.FormatInt(ta.FileID, 10)) _, err = files.FileStat("files/" + strconv.FormatInt(ta.FileID, 10))
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, os.IsNotExist(err)) assert.False(t, os.IsNotExist(err))
assert.Equal(t, testuser.ID, ta.CreatedByID) assert.Equal(t, testuser.ID, ta.CreatedByID)
// Check the file was inserted correctly // Check the file was inserted correctly
ta.File = &files.File{ID: ta.FileID} ta.File = &files.File{ID: ta.FileID}
err = ta.File.LoadFileMetaByID() err = ta.File.LoadFileMetaByID()
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, testuser.ID, ta.File.CreatedByID) assert.Equal(t, testuser.ID, ta.File.CreatedByID)
assert.Equal(t, "testfile", ta.File.Name) assert.Equal(t, "testfile", ta.File.Name)
assert.Equal(t, uint64(100), ta.File.Size) assert.Equal(t, uint64(100), ta.File.Size)
@ -145,7 +147,7 @@ func TestTaskAttachment_ReadAll(t *testing.T) {
ta := &TaskAttachment{TaskID: 1} ta := &TaskAttachment{TaskID: 1}
as, _, _, err := ta.ReadAll(s, &user.User{ID: 1}, "", 0, 50) as, _, _, err := ta.ReadAll(s, &user.User{ID: 1}, "", 0, 50)
attachments, _ := as.([]*TaskAttachment) attachments, _ := as.([]*TaskAttachment)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, attachments, 3) assert.Len(t, attachments, 3)
assert.Equal(t, "test", attachments[0].File.Name) assert.Equal(t, "test", attachments[0].File.Name)
for _, a := range attachments { for _, a := range attachments {
@ -166,7 +168,7 @@ func TestTaskAttachment_Delete(t *testing.T) {
t.Run("Normal", func(t *testing.T) { t.Run("Normal", func(t *testing.T) {
ta := &TaskAttachment{ID: 1} ta := &TaskAttachment{ID: 1}
err := ta.Delete(s, u) err := ta.Delete(s, u)
assert.NoError(t, err) require.NoError(t, err)
// Check if the file itself was deleted // Check if the file itself was deleted
_, err = files.FileStat("/1") // The new file has the id 2 since it's the second attachment _, err = files.FileStat("/1") // The new file has the id 2 since it's the second attachment
assert.True(t, os.IsNotExist(err)) assert.True(t, os.IsNotExist(err))
@ -175,14 +177,14 @@ func TestTaskAttachment_Delete(t *testing.T) {
files.InitTestFileFixtures(t) files.InitTestFileFixtures(t)
ta := &TaskAttachment{ID: 9999} ta := &TaskAttachment{ID: 9999}
err := ta.Delete(s, u) err := ta.Delete(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskAttachmentDoesNotExist(err)) assert.True(t, IsErrTaskAttachmentDoesNotExist(err))
}) })
t.Run("Existing attachment, nonexisting file", func(t *testing.T) { t.Run("Existing attachment, nonexisting file", func(t *testing.T) {
files.InitTestFileFixtures(t) files.InitTestFileFixtures(t)
ta := &TaskAttachment{ID: 2} ta := &TaskAttachment{ID: 2}
err := ta.Delete(s, u) 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} ta := &TaskAttachment{TaskID: 1}
can, _, err := ta.CanRead(s, u) can, _, err := ta.CanRead(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("Forbidden", func(t *testing.T) { t.Run("Forbidden", func(t *testing.T) {
@ -206,7 +208,7 @@ func TestTaskAttachment_Rights(t *testing.T) {
ta := &TaskAttachment{TaskID: 14} ta := &TaskAttachment{TaskID: 14}
can, _, err := ta.CanRead(s, u) can, _, err := ta.CanRead(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
}) })
@ -218,7 +220,7 @@ func TestTaskAttachment_Rights(t *testing.T) {
ta := &TaskAttachment{TaskID: 1} ta := &TaskAttachment{TaskID: 1}
can, err := ta.CanDelete(s, u) can, err := ta.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("Forbidden, no access", func(t *testing.T) { t.Run("Forbidden, no access", func(t *testing.T) {
@ -228,7 +230,7 @@ func TestTaskAttachment_Rights(t *testing.T) {
ta := &TaskAttachment{TaskID: 14} ta := &TaskAttachment{TaskID: 14}
can, err := ta.CanDelete(s, u) can, err := ta.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("Forbidden, shared read only", func(t *testing.T) { t.Run("Forbidden, shared read only", func(t *testing.T) {
@ -238,7 +240,7 @@ func TestTaskAttachment_Rights(t *testing.T) {
ta := &TaskAttachment{TaskID: 15} ta := &TaskAttachment{TaskID: 15}
can, err := ta.CanDelete(s, u) can, err := ta.CanDelete(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
}) })
@ -250,7 +252,7 @@ func TestTaskAttachment_Rights(t *testing.T) {
ta := &TaskAttachment{TaskID: 1} ta := &TaskAttachment{TaskID: 1}
can, err := ta.CanCreate(s, u) can, err := ta.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("Forbidden, no access", func(t *testing.T) { t.Run("Forbidden, no access", func(t *testing.T) {
@ -260,7 +262,7 @@ func TestTaskAttachment_Rights(t *testing.T) {
ta := &TaskAttachment{TaskID: 14} ta := &TaskAttachment{TaskID: 14}
can, err := ta.CanCreate(s, u) can, err := ta.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("Forbidden, shared read only", func(t *testing.T) { t.Run("Forbidden, shared read only", func(t *testing.T) {
@ -270,7 +272,7 @@ func TestTaskAttachment_Rights(t *testing.T) {
ta := &TaskAttachment{TaskID: 15} ta := &TaskAttachment{TaskID: 15}
can, err := ta.CanCreate(s, u) can, err := ta.CanCreate(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
}) })

11
pkg/models/task_collection_sort_test.go
View File

@ -20,6 +20,7 @@ import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestSortParamValidation(t *testing.T) { func TestSortParamValidation(t *testing.T) {
@ -30,7 +31,7 @@ func TestSortParamValidation(t *testing.T) {
sortBy: "id", sortBy: "id",
} }
err := s.validate() err := s.validate()
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run(orderDescending.String(), func(t *testing.T) { t.Run(orderDescending.String(), func(t *testing.T) {
s := &sortParam{ s := &sortParam{
@ -38,7 +39,7 @@ func TestSortParamValidation(t *testing.T) {
sortBy: "id", sortBy: "id",
} }
err := s.validate() err := s.validate()
assert.NoError(t, err) require.NoError(t, err)
}) })
}) })
t.Run("Test valid sort by", func(t *testing.T) { t.Run("Test valid sort by", func(t *testing.T) {
@ -68,7 +69,7 @@ func TestSortParamValidation(t *testing.T) {
sortBy: test, sortBy: test,
} }
err := s.validate() err := s.validate()
assert.NoError(t, err) require.NoError(t, err)
}) })
} }
}) })
@ -78,7 +79,7 @@ func TestSortParamValidation(t *testing.T) {
sortBy: "id", sortBy: "id",
} }
err := s.validate() err := s.validate()
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrInvalidSortOrder(err)) assert.True(t, IsErrInvalidSortOrder(err))
}) })
t.Run("Test invalid sort by", func(t *testing.T) { t.Run("Test invalid sort by", func(t *testing.T) {
@ -87,7 +88,7 @@ func TestSortParamValidation(t *testing.T) {
sortBy: "somethingInvalid", sortBy: "somethingInvalid",
} }
err := s.validate() err := s.validate()
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrInvalidTaskField(err)) assert.True(t, IsErrInvalidTaskField(err))
}) })
} }

43
pkg/models/task_comments_test.go
View File

@ -19,11 +19,12 @@ package models
import ( import (
"testing" "testing"
"code.vikunja.io/api/pkg/events"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/events"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTaskComment_Create(t *testing.T) { func TestTaskComment_Create(t *testing.T) {
@ -38,11 +39,11 @@ func TestTaskComment_Create(t *testing.T) {
TaskID: 1, TaskID: 1,
} }
err := tc.Create(s, u) err := tc.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, "test", tc.Comment) assert.Equal(t, "test", tc.Comment)
assert.Equal(t, int64(1), tc.Author.ID) assert.Equal(t, int64(1), tc.Author.ID)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
events.AssertDispatched(t, &TaskCommentCreatedEvent{}) events.AssertDispatched(t, &TaskCommentCreatedEvent{})
db.AssertExists(t, "task_comments", map[string]interface{}{ db.AssertExists(t, "task_comments", map[string]interface{}{
@ -62,7 +63,7 @@ func TestTaskComment_Create(t *testing.T) {
TaskID: 99999, TaskID: 99999,
} }
err := tc.Create(s, u) err := tc.Create(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskDoesNotExist(err)) assert.True(t, IsErrTaskDoesNotExist(err))
}) })
t.Run("should send notifications for comment mentions", func(t *testing.T) { 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() defer s.Close()
task, err := GetTaskByIDSimple(s, 32) task, err := GetTaskByIDSimple(s, 32)
assert.NoError(t, err) require.NoError(t, err)
tc := &TaskComment{ tc := &TaskComment{
Comment: "Lorem Ipsum @user2", Comment: "Lorem Ipsum @user2",
TaskID: 32, // user2 has access to the project that task belongs to TaskID: 32, // user2 has access to the project that task belongs to
} }
err = tc.Create(s, u) err = tc.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
ev := &TaskCommentCreatedEvent{ ev := &TaskCommentCreatedEvent{
Task: &task, Task: &task,
Doer: u, Doer: u,
@ -103,9 +104,9 @@ func TestTaskComment_Delete(t *testing.T) {
tc := &TaskComment{ID: 1} tc := &TaskComment{ID: 1}
err := tc.Delete(s, u) err := tc.Delete(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "task_comments", map[string]interface{}{ db.AssertMissing(t, "task_comments", map[string]interface{}{
"id": 1, "id": 1,
@ -118,7 +119,7 @@ func TestTaskComment_Delete(t *testing.T) {
tc := &TaskComment{ID: 9999} tc := &TaskComment{ID: 9999}
err := tc.Delete(s, u) err := tc.Delete(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskCommentDoesNotExist(err)) assert.True(t, IsErrTaskCommentDoesNotExist(err))
}) })
t.Run("not the own comment", func(t *testing.T) { 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} tc := &TaskComment{ID: 1, TaskID: 1}
can, err := tc.CanDelete(s, &user.User{ID: 2}) can, err := tc.CanDelete(s, &user.User{ID: 2})
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
} }
@ -146,9 +147,9 @@ func TestTaskComment_Update(t *testing.T) {
Comment: "testing", Comment: "testing",
} }
err := tc.Update(s, u) err := tc.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "task_comments", map[string]interface{}{ db.AssertExists(t, "task_comments", map[string]interface{}{
"id": 1, "id": 1,
@ -164,7 +165,7 @@ func TestTaskComment_Update(t *testing.T) {
ID: 9999, ID: 9999,
} }
err := tc.Update(s, u) err := tc.Update(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskCommentDoesNotExist(err)) assert.True(t, IsErrTaskCommentDoesNotExist(err))
}) })
t.Run("not the own comment", func(t *testing.T) { 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} tc := &TaskComment{ID: 1, TaskID: 1}
can, err := tc.CanUpdate(s, &user.User{ID: 2}) can, err := tc.CanUpdate(s, &user.User{ID: 2})
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
} }
@ -189,7 +190,7 @@ func TestTaskComment_ReadOne(t *testing.T) {
tc := &TaskComment{ID: 1, TaskID: 1} tc := &TaskComment{ID: 1, TaskID: 1}
err := tc.ReadOne(s, u) err := tc.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, "Lorem Ipsum Dolor Sit Amet", tc.Comment) assert.Equal(t, "Lorem Ipsum Dolor Sit Amet", tc.Comment)
assert.NotEmpty(t, tc.Author.ID) assert.NotEmpty(t, tc.Author.ID)
}) })
@ -200,7 +201,7 @@ func TestTaskComment_ReadOne(t *testing.T) {
tc := &TaskComment{ID: 9999} tc := &TaskComment{ID: 9999}
err := tc.ReadOne(s, u) err := tc.ReadOne(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskCommentDoesNotExist(err)) assert.True(t, IsErrTaskCommentDoesNotExist(err))
}) })
} }
@ -214,7 +215,7 @@ func TestTaskComment_ReadAll(t *testing.T) {
tc := &TaskComment{TaskID: 1} tc := &TaskComment{TaskID: 1}
u := &user.User{ID: 1} u := &user.User{ID: 1}
result, resultCount, total, err := tc.ReadAll(s, u, "", 0, -1) result, resultCount, total, err := tc.ReadAll(s, u, "", 0, -1)
assert.NoError(t, err) require.NoError(t, err)
resultComment := result.([]*TaskComment) resultComment := result.([]*TaskComment)
assert.Equal(t, 1, resultCount) assert.Equal(t, 1, resultCount)
assert.Equal(t, int64(1), total) assert.Equal(t, int64(1), total)
@ -230,7 +231,7 @@ func TestTaskComment_ReadAll(t *testing.T) {
tc := &TaskComment{TaskID: 14} tc := &TaskComment{TaskID: 14}
u := &user.User{ID: 1} u := &user.User{ID: 1}
_, _, _, err := tc.ReadAll(s, u, "", 0, -1) _, _, _, err := tc.ReadAll(s, u, "", 0, -1)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrGenericForbidden(err)) assert.True(t, IsErrGenericForbidden(err))
}) })
t.Run("comment from link share", func(t *testing.T) { t.Run("comment from link share", func(t *testing.T) {
@ -241,7 +242,7 @@ func TestTaskComment_ReadAll(t *testing.T) {
tc := &TaskComment{TaskID: 35} tc := &TaskComment{TaskID: 35}
u := &user.User{ID: 1} u := &user.User{ID: 1}
result, _, _, err := tc.ReadAll(s, u, "", 0, -1) result, _, _, err := tc.ReadAll(s, u, "", 0, -1)
assert.NoError(t, err) require.NoError(t, err)
comments := result.([]*TaskComment) comments := result.([]*TaskComment)
assert.Len(t, comments, 2) assert.Len(t, comments, 2)
var foundComment bool var foundComment bool
@ -261,7 +262,7 @@ func TestTaskComment_ReadAll(t *testing.T) {
tc := &TaskComment{TaskID: 35} tc := &TaskComment{TaskID: 35}
u := &user.User{ID: 1} u := &user.User{ID: 1}
result, _, _, err := tc.ReadAll(s, u, "COMMENT 15", 0, -1) result, _, _, err := tc.ReadAll(s, u, "COMMENT 15", 0, -1)
assert.NoError(t, err) require.NoError(t, err)
resultComment := result.([]*TaskComment) resultComment := result.([]*TaskComment)
assert.Equal(t, int64(15), resultComment[0].ID) assert.Equal(t, int64(15), resultComment[0].ID)
}) })

17
pkg/models/task_overdue_reminder_test.go
View File

@ -22,6 +22,7 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestGetUndoneOverDueTasks(t *testing.T) { func TestGetUndoneOverDueTasks(t *testing.T) {
@ -31,10 +32,10 @@ func TestGetUndoneOverDueTasks(t *testing.T) {
defer s.Close() defer s.Close()
now, err := time.Parse(time.RFC3339Nano, "2018-01-01T01:13:00Z") now, err := time.Parse(time.RFC3339Nano, "2018-01-01T01:13:00Z")
assert.NoError(t, err) require.NoError(t, err)
tasks, err := getUndoneOverdueTasks(s, now) tasks, err := getUndoneOverdueTasks(s, now)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, tasks, 0) assert.Empty(t, tasks)
}) })
t.Run("undone overdue", func(t *testing.T) { t.Run("undone overdue", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -42,9 +43,9 @@ func TestGetUndoneOverDueTasks(t *testing.T) {
defer s.Close() defer s.Close()
now, err := time.Parse(time.RFC3339Nano, "2018-12-01T09:00:00Z") now, err := time.Parse(time.RFC3339Nano, "2018-12-01T09:00:00Z")
assert.NoError(t, err) require.NoError(t, err)
uts, err := getUndoneOverdueTasks(s, now) uts, err := getUndoneOverdueTasks(s, now)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, uts, 1) assert.Len(t, uts, 1)
assert.Len(t, uts[1].tasks, 2) 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. // 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() defer s.Close()
now, err := time.Parse(time.RFC3339Nano, "2018-11-01T01:13:00Z") now, err := time.Parse(time.RFC3339Nano, "2018-11-01T01:13:00Z")
assert.NoError(t, err) require.NoError(t, err)
tasks, err := getUndoneOverdueTasks(s, now) tasks, err := getUndoneOverdueTasks(s, now)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, tasks, 0) assert.Empty(t, tasks)
}) })
} }

34
pkg/models/task_relation_test.go
View File

@ -21,7 +21,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTaskRelation_Create(t *testing.T) { func TestTaskRelation_Create(t *testing.T) {
@ -36,9 +38,9 @@ func TestTaskRelation_Create(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
err := rel.Create(s, &user.User{ID: 1}) err := rel.Create(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "task_relations", map[string]interface{}{ db.AssertExists(t, "task_relations", map[string]interface{}{
"task_id": 1, "task_id": 1,
"other_task_id": 2, "other_task_id": 2,
@ -57,9 +59,9 @@ func TestTaskRelation_Create(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
err := rel.Create(s, &user.User{ID: 1}) err := rel.Create(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "task_relations", map[string]interface{}{ db.AssertExists(t, "task_relations", map[string]interface{}{
"task_id": 1, "task_id": 1,
"other_task_id": 13, "other_task_id": 13,
@ -78,7 +80,7 @@ func TestTaskRelation_Create(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
err := rel.Create(s, &user.User{ID: 1}) err := rel.Create(s, &user.User{ID: 1})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrRelationAlreadyExists(err)) assert.True(t, IsErrRelationAlreadyExists(err))
}) })
t.Run("Same Task", func(t *testing.T) { t.Run("Same Task", func(t *testing.T) {
@ -91,7 +93,7 @@ func TestTaskRelation_Create(t *testing.T) {
OtherTaskID: 1, OtherTaskID: 1,
} }
err := rel.Create(s, &user.User{ID: 1}) err := rel.Create(s, &user.User{ID: 1})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrRelationTasksCannotBeTheSame(err)) assert.True(t, IsErrRelationTasksCannotBeTheSame(err))
}) })
} }
@ -110,9 +112,9 @@ func TestTaskRelation_Delete(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
err := rel.Delete(s, u) err := rel.Delete(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "task_relations", map[string]interface{}{ db.AssertMissing(t, "task_relations", map[string]interface{}{
"task_id": 1, "task_id": 1,
"other_task_id": 29, "other_task_id": 29,
@ -135,7 +137,7 @@ func TestTaskRelation_Delete(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
err := rel.Delete(s, u) err := rel.Delete(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrRelationDoesNotExist(err)) assert.True(t, IsErrRelationDoesNotExist(err))
}) })
} }
@ -152,7 +154,7 @@ func TestTaskRelation_CanCreate(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
can, err := rel.CanCreate(s, &user.User{ID: 1}) can, err := rel.CanCreate(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("Two tasks on different projects", func(t *testing.T) { t.Run("Two tasks on different projects", func(t *testing.T) {
@ -166,7 +168,7 @@ func TestTaskRelation_CanCreate(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
can, err := rel.CanCreate(s, &user.User{ID: 1}) can, err := rel.CanCreate(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, can) assert.True(t, can)
}) })
t.Run("No update rights on base task", func(t *testing.T) { t.Run("No update rights on base task", func(t *testing.T) {
@ -180,7 +182,7 @@ func TestTaskRelation_CanCreate(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
can, err := rel.CanCreate(s, &user.User{ID: 1}) can, err := rel.CanCreate(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("No update rights on base task, but read rights", func(t *testing.T) { 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, RelationKind: RelationKindSubtask,
} }
can, err := rel.CanCreate(s, &user.User{ID: 1}) can, err := rel.CanCreate(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("No read rights on other task", func(t *testing.T) { t.Run("No read rights on other task", func(t *testing.T) {
@ -208,7 +210,7 @@ func TestTaskRelation_CanCreate(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
can, err := rel.CanCreate(s, &user.User{ID: 1}) can, err := rel.CanCreate(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, can) assert.False(t, can)
}) })
t.Run("Nonexisting base task", func(t *testing.T) { t.Run("Nonexisting base task", func(t *testing.T) {
@ -222,7 +224,7 @@ func TestTaskRelation_CanCreate(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
can, err := rel.CanCreate(s, &user.User{ID: 1}) can, err := rel.CanCreate(s, &user.User{ID: 1})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskDoesNotExist(err)) assert.True(t, IsErrTaskDoesNotExist(err))
assert.False(t, can) assert.False(t, can)
}) })
@ -237,7 +239,7 @@ func TestTaskRelation_CanCreate(t *testing.T) {
RelationKind: RelationKindSubtask, RelationKind: RelationKindSubtask,
} }
can, err := rel.CanCreate(s, &user.User{ID: 1}) can, err := rel.CanCreate(s, &user.User{ID: 1})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskDoesNotExist(err)) assert.True(t, IsErrTaskDoesNotExist(err))
assert.False(t, can) assert.False(t, can)
}) })

12
pkg/models/task_reminder_test.go
View File

@ -21,7 +21,9 @@ import (
"time" "time"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestReminderGetTasksInTheNextMinute(t *testing.T) { func TestReminderGetTasksInTheNextMinute(t *testing.T) {
@ -31,9 +33,9 @@ func TestReminderGetTasksInTheNextMinute(t *testing.T) {
defer s.Close() defer s.Close()
now, err := time.Parse(time.RFC3339Nano, "2018-12-01T01:12:00Z") now, err := time.Parse(time.RFC3339Nano, "2018-12-01T01:12:00Z")
assert.NoError(t, err) require.NoError(t, err)
notifications, err := getTasksWithRemindersDueAndTheirUsers(s, now) notifications, err := getTasksWithRemindersDueAndTheirUsers(s, now)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, notifications, 1) assert.Len(t, notifications, 1)
assert.Equal(t, int64(27), notifications[0].Task.ID) assert.Equal(t, int64(27), notifications[0].Task.ID)
}) })
@ -43,9 +45,9 @@ func TestReminderGetTasksInTheNextMinute(t *testing.T) {
defer s.Close() defer s.Close()
now, err := time.Parse(time.RFC3339Nano, "2018-12-02T01:13:00Z") now, err := time.Parse(time.RFC3339Nano, "2018-12-02T01:13:00Z")
assert.NoError(t, err) require.NoError(t, err)
taskIDs, err := getTasksWithRemindersDueAndTheirUsers(s, now) taskIDs, err := getTasksWithRemindersDueAndTheirUsers(s, now)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, taskIDs, 0) assert.Empty(t, taskIDs)
}) })
} }

91
pkg/models/tasks_test.go
View File

@ -25,6 +25,7 @@ import (
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"xorm.io/builder" "xorm.io/builder"
) )
@ -48,7 +49,7 @@ func TestTask_Create(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
err := task.Create(s, usr) err := task.Create(s, usr)
assert.NoError(t, err) require.NoError(t, err)
// Assert getting a uid // Assert getting a uid
assert.NotEmpty(t, task.UID) assert.NotEmpty(t, task.UID)
// Assert getting a new index // Assert getting a new index
@ -57,7 +58,7 @@ func TestTask_Create(t *testing.T) {
// Assert moving it into the default bucket // Assert moving it into the default bucket
assert.Equal(t, int64(1), task.BucketID) assert.Equal(t, int64(1), task.BucketID)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "tasks", map[string]interface{}{ db.AssertExists(t, "tasks", map[string]interface{}{
"id": task.ID, "id": task.ID,
@ -100,7 +101,7 @@ func TestTask_Create(t *testing.T) {
}, },
}} }}
err := task.Create(s, usr) 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, 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, int64(1), task.Reminders[0].RelativePeriod)
assert.Equal(t, ReminderRelationDueDate, task.Reminders[0].RelativeTo) 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, ReminderRelationEndDate, task.Reminders[2].RelativeTo)
assert.Equal(t, time.Date(2023, time.March, 7, 23, 0, 0, 0, time.Local), task.Reminders[3].Reminder) assert.Equal(t, time.Date(2023, time.March, 7, 23, 0, 0, 0, time.Local), task.Reminders[3].Reminder)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("empty title", func(t *testing.T) { t.Run("empty title", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -123,7 +124,7 @@ func TestTask_Create(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
err := task.Create(s, usr) err := task.Create(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskCannotBeEmpty(err)) assert.True(t, IsErrTaskCannotBeEmpty(err))
}) })
t.Run("nonexistant project", func(t *testing.T) { t.Run("nonexistant project", func(t *testing.T) {
@ -137,7 +138,7 @@ func TestTask_Create(t *testing.T) {
ProjectID: 9999999, ProjectID: 9999999,
} }
err := task.Create(s, usr) err := task.Create(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrProjectDoesNotExist(err)) assert.True(t, IsErrProjectDoesNotExist(err))
}) })
t.Run("nonexistant user", func(t *testing.T) { t.Run("nonexistant user", func(t *testing.T) {
@ -152,7 +153,7 @@ func TestTask_Create(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
err := task.Create(s, nUser) err := task.Create(s, nUser)
assert.Error(t, err) require.Error(t, err)
assert.True(t, user.IsErrUserDoesNotExist(err)) assert.True(t, user.IsErrUserDoesNotExist(err))
}) })
t.Run("full bucket", func(t *testing.T) { 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 BucketID: 2, // Bucket 2 already has 3 tasks and a limit of 3
} }
err := task.Create(s, usr) err := task.Create(s, usr)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrBucketLimitExceeded(err)) assert.True(t, IsErrBucketLimitExceeded(err))
}) })
t.Run("default bucket different", func(t *testing.T) { t.Run("default bucket different", func(t *testing.T) {
@ -181,7 +182,7 @@ func TestTask_Create(t *testing.T) {
ProjectID: 6, ProjectID: 6,
} }
err := task.Create(s, usr) err := task.Create(s, usr)
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "tasks", map[string]interface{}{ db.AssertExists(t, "tasks", map[string]interface{}{
"id": task.ID, "id": task.ID,
"bucket_id": 22, // default bucket of project 6 but with a position of 2 "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, ProjectID: 1,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "tasks", map[string]interface{}{ db.AssertExists(t, "tasks", map[string]interface{}{
"id": 1, "id": 1,
@ -227,7 +228,7 @@ func TestTask_Update(t *testing.T) {
ProjectID: 1, ProjectID: 1,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskDoesNotExist(err)) assert.True(t, IsErrTaskDoesNotExist(err))
}) })
t.Run("full bucket", func(t *testing.T) { 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 BucketID: 2, // Bucket 2 already has 3 tasks and a limit of 3
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrBucketLimitExceeded(err)) assert.True(t, IsErrBucketLimitExceeded(err))
}) })
t.Run("full bucket but not changing the bucket", func(t *testing.T) { 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 BucketID: 2, // Bucket 2 already has 3 tasks and a limit of 3
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("bucket on other project", func(t *testing.T) { t.Run("bucket on other project", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -275,7 +276,7 @@ func TestTask_Update(t *testing.T) {
BucketID: 4, // Bucket 4 belongs to project 2 BucketID: 4, // Bucket 4 belongs to project 2
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrBucketDoesNotBelongToProject(err)) assert.True(t, IsErrBucketDoesNotBelongToProject(err))
}) })
t.Run("moving a task to the done bucket", func(t *testing.T) { 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 BucketID: 3, // Bucket 3 is the done bucket
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, task.Done) assert.True(t, task.Done)
db.AssertExists(t, "tasks", map[string]interface{}{ db.AssertExists(t, "tasks", map[string]interface{}{
@ -316,9 +317,9 @@ func TestTask_Update(t *testing.T) {
RepeatAfter: 3600, RepeatAfter: 3600,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, task.Done) assert.False(t, task.Done)
assert.Equal(t, int64(1), task.BucketID) // Bucket should not be updated assert.Equal(t, int64(1), task.BucketID) // Bucket should not be updated
@ -340,9 +341,9 @@ func TestTask_Update(t *testing.T) {
ProjectID: 2, ProjectID: 2,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() 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.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 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, Done: true,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, task.Done) assert.True(t, task.Done)
assert.Equal(t, int64(3), task.BucketID) assert.Equal(t, int64(3), task.BucketID)
@ -379,9 +380,9 @@ func TestTask_Update(t *testing.T) {
ProjectID: 2, ProjectID: 2,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "tasks", map[string]interface{}{ db.AssertExists(t, "tasks", map[string]interface{}{
"id": 1, "id": 1,
@ -400,9 +401,9 @@ func TestTask_Update(t *testing.T) {
RepeatAfter: 3600, RepeatAfter: 3600,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, task.Done) assert.False(t, task.Done)
assert.Equal(t, int64(1), task.BucketID) assert.Equal(t, int64(1), task.BucketID)
@ -422,9 +423,9 @@ func TestTask_Update(t *testing.T) {
ProjectID: 2, // From project 1 ProjectID: 2, // From project 1
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, int64(3), task.Index) assert.Equal(t, int64(3), task.Index)
}) })
@ -458,7 +459,7 @@ func TestTask_Update(t *testing.T) {
}, },
}} }}
err := task.Update(s, u) 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, 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, int64(1), task.Reminders[0].RelativePeriod)
assert.Equal(t, ReminderRelationDueDate, task.Reminders[0].RelativeTo) 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, ReminderRelationEndDate, task.Reminders[2].RelativeTo)
assert.Equal(t, time.Date(2023, time.March, 7, 23, 0, 0, 0, time.Local), task.Reminders[3].Reminder) assert.Equal(t, time.Date(2023, time.March, 7, 23, 0, 0, 0, time.Local), task.Reminders[3].Reminder)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertCount(t, "task_reminders", builder.Eq{"task_id": 1}, 4) 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) { 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, ProjectID: 1,
} }
err := task.Update(s, u) err := task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertCount(t, "task_reminders", builder.Eq{"task_id": 1}, 1) db.AssertCount(t, "task_reminders", builder.Eq{"task_id": 1}, 1)
}) })
t.Run("update relative reminder when start_date changes", func(t *testing.T) { 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) err := taskBefore.Create(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() 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) assert.Equal(t, time.Date(2022, time.March, 8, 8, 4, 20, 0, time.Local), taskBefore.Reminders[0].Reminder)
// when start_date is modified // when start_date is modified
task := taskBefore task := taskBefore
task.StartDate = time.Date(2023, time.March, 8, 8, 5, 0, 0, time.Local) task.StartDate = time.Date(2023, time.March, 8, 8, 5, 0, 0, time.Local)
err = task.Update(s, u) err = task.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
// then reminder time is updated // then reminder time is updated
assert.Equal(t, time.Date(2023, time.March, 8, 8, 4, 0, 0, time.Local), task.Reminders[0].Reminder) assert.Equal(t, time.Date(2023, time.March, 8, 8, 4, 0, 0, time.Local), task.Reminders[0].Reminder)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
}) })
} }
@ -540,9 +541,9 @@ func TestTask_Delete(t *testing.T) {
ID: 1, ID: 1,
} }
err := task.Delete(s, &user.User{ID: 1}) err := task.Delete(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "tasks", map[string]interface{}{ db.AssertMissing(t, "tasks", map[string]interface{}{
"id": 1, "id": 1,
@ -920,7 +921,7 @@ func TestTask_ReadOne(t *testing.T) {
task := &Task{ID: 1} task := &Task{ID: 1}
err := task.ReadOne(s, u) err := task.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, "task #1", task.Title) assert.Equal(t, "task #1", task.Title)
}) })
t.Run("nonexisting", func(t *testing.T) { t.Run("nonexisting", func(t *testing.T) {
@ -930,7 +931,7 @@ func TestTask_ReadOne(t *testing.T) {
task := &Task{ID: 99999} task := &Task{ID: 99999}
err := task.ReadOne(s, u) err := task.ReadOne(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTaskDoesNotExist(err)) assert.True(t, IsErrTaskDoesNotExist(err))
}) })
t.Run("with subscription", func(t *testing.T) { t.Run("with subscription", func(t *testing.T) {
@ -940,7 +941,7 @@ func TestTask_ReadOne(t *testing.T) {
task := &Task{ID: 22} task := &Task{ID: 22}
err := task.ReadOne(s, &user.User{ID: 6}) err := task.ReadOne(s, &user.User{ID: 6})
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, task.Subscription) assert.NotNil(t, task.Subscription)
}) })
t.Run("created by link share", func(t *testing.T) { t.Run("created by link share", func(t *testing.T) {
@ -950,7 +951,7 @@ func TestTask_ReadOne(t *testing.T) {
task := &Task{ID: 37} task := &Task{ID: 37}
err := task.ReadOne(s, u) err := task.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, "task #37", task.Title) assert.Equal(t, "task #37", task.Title)
assert.Equal(t, int64(-2), task.CreatedByID) assert.Equal(t, int64(-2), task.CreatedByID)
assert.NotNil(t, task.CreatedBy) assert.NotNil(t, task.CreatedBy)
@ -963,7 +964,7 @@ func TestTask_ReadOne(t *testing.T) {
task := &Task{ID: 1} task := &Task{ID: 1}
err := task.ReadOne(s, u) err := task.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, task.IsFavorite) assert.True(t, task.IsFavorite)
}) })
t.Run("favorite for a different user", func(t *testing.T) { 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} task := &Task{ID: 1}
err := task.ReadOne(s, &user.User{ID: 2}) err := task.ReadOne(s, &user.User{ID: 2})
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, task.IsFavorite) assert.False(t, task.IsFavorite)
}) })
} }

24
pkg/models/team_members_test.go
View File

@ -21,7 +21,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTeamMember_Create(t *testing.T) { func TestTeamMember_Create(t *testing.T) {
@ -40,9 +42,9 @@ func TestTeamMember_Create(t *testing.T) {
Username: "user3", Username: "user3",
} }
err := tm.Create(s, doer) err := tm.Create(s, doer)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "team_members", map[string]interface{}{ db.AssertExists(t, "team_members", map[string]interface{}{
"id": tm.ID, "id": tm.ID,
@ -60,7 +62,7 @@ func TestTeamMember_Create(t *testing.T) {
Username: "user1", Username: "user1",
} }
err := tm.Create(s, doer) err := tm.Create(s, doer)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUserIsMemberOfTeam(err)) assert.True(t, IsErrUserIsMemberOfTeam(err))
}) })
t.Run("nonexisting user", func(t *testing.T) { t.Run("nonexisting user", func(t *testing.T) {
@ -73,7 +75,7 @@ func TestTeamMember_Create(t *testing.T) {
Username: "nonexistinguser", Username: "nonexistinguser",
} }
err := tm.Create(s, doer) err := tm.Create(s, doer)
assert.Error(t, err) require.Error(t, err)
assert.True(t, user.IsErrUserDoesNotExist(err)) assert.True(t, user.IsErrUserDoesNotExist(err))
}) })
t.Run("nonexisting team", func(t *testing.T) { t.Run("nonexisting team", func(t *testing.T) {
@ -86,7 +88,7 @@ func TestTeamMember_Create(t *testing.T) {
Username: "user1", Username: "user1",
} }
err := tm.Create(s, doer) err := tm.Create(s, doer)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamDoesNotExist(err)) assert.True(t, IsErrTeamDoesNotExist(err))
}) })
} }
@ -102,9 +104,9 @@ func TestTeamMember_Delete(t *testing.T) {
Username: "user1", Username: "user1",
} }
err := tm.Delete(s, &user.User{ID: 1}) err := tm.Delete(s, &user.User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "team_members", map[string]interface{}{ db.AssertMissing(t, "team_members", map[string]interface{}{
"team_id": 1, "team_id": 1,
@ -127,10 +129,10 @@ func TestTeamMember_Update(t *testing.T) {
Admin: true, Admin: true,
} }
err := tm.Update(s, u) 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. assert.False(t, tm.Admin) // Since this endpoint toggles the right, we should get a false for admin back.
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "team_members", map[string]interface{}{ db.AssertExists(t, "team_members", map[string]interface{}{
"team_id": 1, "team_id": 1,
@ -151,10 +153,10 @@ func TestTeamMember_Update(t *testing.T) {
Admin: true, Admin: true,
} }
err := tm.Update(s, u) err := tm.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.False(t, tm.Admin) assert.False(t, tm.Admin)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "team_members", map[string]interface{}{ db.AssertExists(t, "team_members", map[string]interface{}{
"team_id": 1, "team_id": 1,

42
pkg/models/teams_test.go
View File

@ -22,7 +22,9 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestTeam_Create(t *testing.T) { func TestTeam_Create(t *testing.T) {
@ -40,9 +42,9 @@ func TestTeam_Create(t *testing.T) {
Description: "Lorem Ispum", Description: "Lorem Ispum",
} }
err := team.Create(s, doer) err := team.Create(s, doer)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "teams", map[string]interface{}{ db.AssertExists(t, "teams", map[string]interface{}{
"id": team.ID, "id": team.ID,
"name": "Testteam293", "name": "Testteam293",
@ -56,7 +58,7 @@ func TestTeam_Create(t *testing.T) {
team := &Team{} team := &Team{}
err := team.Create(s, doer) err := team.Create(s, doer)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamNameCannotBeEmpty(err)) assert.True(t, IsErrTeamNameCannotBeEmpty(err))
}) })
} }
@ -71,7 +73,7 @@ func TestTeam_ReadOne(t *testing.T) {
team := &Team{ID: 1} team := &Team{ID: 1}
err := team.ReadOne(s, u) err := team.ReadOne(s, u)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, "testteam1", team.Name) assert.Equal(t, "testteam1", team.Name)
assert.Equal(t, "Lorem Ipsum", team.Description) assert.Equal(t, "Lorem Ipsum", team.Description)
assert.Equal(t, int64(1), team.CreatedBy.ID) assert.Equal(t, int64(1), team.CreatedBy.ID)
@ -84,7 +86,7 @@ func TestTeam_ReadOne(t *testing.T) {
team := &Team{ID: -1} team := &Team{ID: -1}
err := team.ReadOne(s, u) err := team.ReadOne(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamDoesNotExist(err)) assert.True(t, IsErrTeamDoesNotExist(err))
}) })
t.Run("nonexisting", func(t *testing.T) { t.Run("nonexisting", func(t *testing.T) {
@ -94,7 +96,7 @@ func TestTeam_ReadOne(t *testing.T) {
team := &Team{ID: 99999} team := &Team{ID: 99999}
err := team.ReadOne(s, u) err := team.ReadOne(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamDoesNotExist(err)) assert.True(t, IsErrTeamDoesNotExist(err))
}) })
} }
@ -107,8 +109,8 @@ func TestTeam_ReadAll(t *testing.T) {
team := &Team{} team := &Team{}
teams, _, _, err := team.ReadAll(s, doer, "", 1, 50) teams, _, _, err := team.ReadAll(s, doer, "", 1, 50)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind())
ts := reflect.ValueOf(teams) ts := reflect.ValueOf(teams)
assert.Equal(t, 5, ts.Len()) assert.Equal(t, 5, ts.Len())
}) })
@ -118,8 +120,8 @@ func TestTeam_ReadAll(t *testing.T) {
team := &Team{} team := &Team{}
teams, _, _, err := team.ReadAll(s, doer, "READ_only_on_project6", 1, 50) teams, _, _, err := team.ReadAll(s, doer, "READ_only_on_project6", 1, 50)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice) assert.Equal(t, reflect.Slice, reflect.TypeOf(teams).Kind())
ts := teams.([]*Team) ts := teams.([]*Team)
assert.Len(t, ts, 1) assert.Len(t, ts, 1)
assert.Equal(t, int64(2), ts[0].ID) assert.Equal(t, int64(2), ts[0].ID)
@ -139,9 +141,9 @@ func TestTeam_Update(t *testing.T) {
Name: "SomethingNew", Name: "SomethingNew",
} }
err := team.Update(s, u) err := team.Update(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "teams", map[string]interface{}{ db.AssertExists(t, "teams", map[string]interface{}{
"id": team.ID, "id": team.ID,
"name": "SomethingNew", "name": "SomethingNew",
@ -157,7 +159,7 @@ func TestTeam_Update(t *testing.T) {
Name: "", Name: "",
} }
err := team.Update(s, u) err := team.Update(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamNameCannotBeEmpty(err)) assert.True(t, IsErrTeamNameCannotBeEmpty(err))
}) })
t.Run("nonexisting", func(t *testing.T) { t.Run("nonexisting", func(t *testing.T) {
@ -170,7 +172,7 @@ func TestTeam_Update(t *testing.T) {
Name: "SomethingNew", Name: "SomethingNew",
} }
err := team.Update(s, u) err := team.Update(s, u)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrTeamDoesNotExist(err)) assert.True(t, IsErrTeamDoesNotExist(err))
}) })
} }
@ -187,9 +189,9 @@ func TestTeam_Delete(t *testing.T) {
ID: 1, ID: 1,
} }
err := team.Delete(s, u) err := team.Delete(s, u)
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "teams", map[string]interface{}{ db.AssertMissing(t, "teams", map[string]interface{}{
"id": 1, "id": 1,
}) })
@ -197,13 +199,13 @@ func TestTeam_Delete(t *testing.T) {
} }
func TestIsErrInvalidRight(t *testing.T) { func TestIsErrInvalidRight(t *testing.T) {
assert.NoError(t, RightAdmin.isValid()) require.NoError(t, RightAdmin.isValid())
assert.NoError(t, RightRead.isValid()) require.NoError(t, RightRead.isValid())
assert.NoError(t, RightWrite.isValid()) require.NoError(t, RightWrite.isValid())
// Check invalid // Check invalid
var tr Right = 938 var tr Right = 938
err := tr.isValid() err := tr.isValid()
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrInvalidRight(err)) assert.True(t, IsErrInvalidRight(err))
} }

8
pkg/models/user_delete_test.go
View File

@ -23,7 +23,7 @@ import (
"code.vikunja.io/api/pkg/notifications" "code.vikunja.io/api/pkg/notifications"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
func TestDeleteUser(t *testing.T) { func TestDeleteUser(t *testing.T) {
@ -36,7 +36,7 @@ func TestDeleteUser(t *testing.T) {
u := &user.User{ID: 6} u := &user.User{ID: 6}
err := DeleteUser(s, u) 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, "users", map[string]interface{}{"id": u.ID})
db.AssertMissing(t, "projects", map[string]interface{}{"id": 24}) // only user6 had access to this project 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) db.AssertExists(t, "projects", map[string]interface{}{"id": 6}, false)
@ -55,7 +55,7 @@ func TestDeleteUser(t *testing.T) {
u := &user.User{ID: 4} u := &user.User{ID: 4}
err := DeleteUser(s, u) err := DeleteUser(s, u)
assert.NoError(t, err) require.NoError(t, err)
// No assertions for deleted projects since that user doesn't have any // No assertions for deleted projects since that user doesn't have any
}) })
t.Run("user with a default project", func(t *testing.T) { 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} u := &user.User{ID: 16}
err := DeleteUser(s, u) 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, "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 db.AssertMissing(t, "projects", map[string]interface{}{"id": 37}) // only user16 had access to this project, and it was their default
}) })

16
pkg/modules/auth/openid/openid_test.go
View File

@ -20,7 +20,9 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestGetOrCreateUser(t *testing.T) { func TestGetOrCreateUser(t *testing.T) {
@ -34,9 +36,9 @@ func TestGetOrCreateUser(t *testing.T) {
PreferredUsername: "someUserWhoDoesNotExistYet", PreferredUsername: "someUserWhoDoesNotExistYet",
} }
u, err := getOrCreateUser(s, cl, "https://some.issuer", "12345") u, err := getOrCreateUser(s, cl, "https://some.issuer", "12345")
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
"id": u.ID, "id": u.ID,
@ -54,10 +56,10 @@ func TestGetOrCreateUser(t *testing.T) {
PreferredUsername: "", PreferredUsername: "",
} }
u, err := getOrCreateUser(s, cl, "https://some.issuer", "12345") u, err := getOrCreateUser(s, cl, "https://some.issuer", "12345")
assert.NoError(t, err) require.NoError(t, err)
assert.NotEmpty(t, u.Username) assert.NotEmpty(t, u.Username)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
"id": u.ID, "id": u.ID,
@ -73,7 +75,7 @@ func TestGetOrCreateUser(t *testing.T) {
Email: "", Email: "",
} }
_, err := getOrCreateUser(s, cl, "https://some.issuer", "12345") _, 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) { t.Run("existing user, different email address", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -84,9 +86,9 @@ func TestGetOrCreateUser(t *testing.T) {
Email: "other-email-address@some.service.com", Email: "other-email-address@some.service.com",
} }
u, err := getOrCreateUser(s, cl, "https://some.service.com", "12345") u, err := getOrCreateUser(s, cl, "https://some.service.com", "12345")
assert.NoError(t, err) require.NoError(t, err)
err = s.Commit() err = s.Commit()
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
"id": u.ID, "id": u.ID,

4
pkg/modules/migration/create_from_structure_test.go
View File

@ -23,7 +23,9 @@ import (
"code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/files"
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestInsertFromStructure(t *testing.T) { func TestInsertFromStructure(t *testing.T) {
@ -135,7 +137,7 @@ func TestInsertFromStructure(t *testing.T) {
}, },
} }
err := InsertFromStructure(testStructure, u) err := InsertFromStructure(testStructure, u)
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "projects", map[string]interface{}{ db.AssertExists(t, "projects", map[string]interface{}{
"title": testStructure[1].Title, "title": testStructure[1].Title,
"description": testStructure[1].Description, "description": testStructure[1].Description,

6
pkg/modules/migration/microsoft-todo/microsoft_todo_test.go
View File

@ -21,8 +21,10 @@ import (
"time" "time"
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"github.com/d4l3k/messagediff" "github.com/d4l3k/messagediff"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestConverting(t *testing.T) { 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") testtimeTime, err := time.Parse(time.RFC3339Nano, "2020-12-18T03:00:00.4770000Z")
assert.NoError(t, err) require.NoError(t, err)
microsoftTodoData := []*project{ microsoftTodoData := []*project{
{ {
@ -188,7 +190,7 @@ func TestConverting(t *testing.T) {
} }
hierachie, err := convertMicrosoftTodoData(microsoftTodoData) hierachie, err := convertMicrosoftTodoData(microsoftTodoData)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, hierachie) assert.NotNil(t, hierachie)
if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal { if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal {
t.Errorf("converted microsoft todo data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff) t.Errorf("converted microsoft todo data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff)

18
pkg/modules/migration/ticktick/ticktick_test.go
View File

@ -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].StartDate, tickTickTasks[0].StartDate.Time)
assert.Equal(t, vikunjaTasks[1].Tasks[0].EndDate, tickTickTasks[0].DueDate.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].DueDate, tickTickTasks[0].DueDate.Time)
assert.Equal(t, vikunjaTasks[1].Tasks[0].Labels, []*models.Label{ assert.Equal(t, []*models.Label{
{Title: "label1"}, {Title: "label1"},
{Title: "label2"}, {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].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].Reminders[0].RelativePeriod, int64(-24*3600))
assert.Equal(t, vikunjaTasks[1].Tasks[0].Position, tickTickTasks[0].Order) 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].Title, tickTickTasks[1].Title)
assert.Equal(t, vikunjaTasks[1].Tasks[1].Position, tickTickTasks[1].Order) 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].DoneAt, tickTickTasks[1].CompletedTime.Time)
assert.Equal(t, vikunjaTasks[1].Tasks[1].RelatedTasks, models.RelatedTaskMap{ assert.Equal(t, models.RelatedTaskMap{
models.RelationKindParenttask: []*models.Task{ models.RelationKindParenttask: []*models.Task{
{ {
ID: tickTickTasks[1].ParentID, 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].Title, tickTickTasks[2].Title)
assert.Equal(t, vikunjaTasks[1].Tasks[2].Description, tickTickTasks[2].Content) 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].StartDate, tickTickTasks[2].StartDate.Time)
assert.Equal(t, vikunjaTasks[1].Tasks[2].EndDate, tickTickTasks[2].DueDate.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].DueDate, tickTickTasks[2].DueDate.Time)
assert.Equal(t, vikunjaTasks[1].Tasks[2].Labels, []*models.Label{ assert.Equal(t, []*models.Label{
{Title: "label1"}, {Title: "label1"},
{Title: "label2"}, {Title: "label2"},
{Title: "other label"}, {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].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].Reminders[0].RelativePeriod, int64(-24*3600))
assert.Equal(t, vikunjaTasks[1].Tasks[2].Position, tickTickTasks[2].Order) 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.Len(t, vikunjaTasks[2].Tasks, 1)
assert.Equal(t, vikunjaTasks[2].Title, tickTickTasks[3].ProjectName) assert.Equal(t, vikunjaTasks[2].Title, tickTickTasks[3].ProjectName)

16
pkg/modules/migration/todoist/todoist_test.go
View File

@ -24,7 +24,9 @@ import (
"code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/config"
"code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/files"
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gopkg.in/d4l3k/messagediff.v1" "gopkg.in/d4l3k/messagediff.v1"
) )
@ -33,21 +35,21 @@ func TestConvertTodoistToVikunja(t *testing.T) {
config.InitConfig() config.InitConfig()
time1, err := time.Parse(time.RFC3339Nano, "2014-09-26T08:25:05Z") time1, err := time.Parse(time.RFC3339Nano, "2014-09-26T08:25:05Z")
assert.NoError(t, err) require.NoError(t, err)
time1 = time1.In(config.GetTimeZone()) time1 = time1.In(config.GetTimeZone())
time3, err := time.Parse(time.RFC3339Nano, "2014-10-21T08:25:05Z") time3, err := time.Parse(time.RFC3339Nano, "2014-10-21T08:25:05Z")
assert.NoError(t, err) require.NoError(t, err)
time3 = time3.In(config.GetTimeZone()) time3 = time3.In(config.GetTimeZone())
dueTime, err := time.Parse(time.RFC3339Nano, "2020-05-31T23:59:00Z") dueTime, err := time.Parse(time.RFC3339Nano, "2020-05-31T23:59:00Z")
assert.NoError(t, err) require.NoError(t, err)
dueTime = dueTime.In(config.GetTimeZone()) dueTime = dueTime.In(config.GetTimeZone())
dueTimeWithTime, err := time.Parse(time.RFC3339Nano, "2021-01-31T19:00:00Z") dueTimeWithTime, err := time.Parse(time.RFC3339Nano, "2021-01-31T19:00:00Z")
assert.NoError(t, err) require.NoError(t, err)
dueTimeWithTime = dueTimeWithTime.In(config.GetTimeZone()) dueTimeWithTime = dueTimeWithTime.In(config.GetTimeZone())
nilTime, err := time.Parse(time.RFC3339Nano, "0001-01-01T00:00:00Z") 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") 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 { makeTestItem := func(id, projectId string, hasDueDate, hasLabels, done bool) *item {
item := &item{ item := &item{
@ -629,7 +631,7 @@ func TestConvertTodoistToVikunja(t *testing.T) {
doneItems := make(map[string]*doneItem) doneItems := make(map[string]*doneItem)
hierachie, err := convertTodoistToVikunja(testSync, doneItems) hierachie, err := convertTodoistToVikunja(testSync, doneItems)
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, hierachie) assert.NotNil(t, hierachie)
if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal { if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal {
t.Errorf("converted todoist data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff) t.Errorf("converted todoist data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff)

8
pkg/modules/migration/trello/trello_test.go
View File

@ -25,9 +25,11 @@ import (
"code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/config"
"code.vikunja.io/api/pkg/files" "code.vikunja.io/api/pkg/files"
"code.vikunja.io/api/pkg/models" "code.vikunja.io/api/pkg/models"
"github.com/adlio/trello" "github.com/adlio/trello"
"github.com/d4l3k/messagediff" "github.com/d4l3k/messagediff"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestConvertTrelloToVikunja(t *testing.T) { func TestConvertTrelloToVikunja(t *testing.T) {
@ -35,9 +37,9 @@ func TestConvertTrelloToVikunja(t *testing.T) {
config.InitConfig() config.InitConfig()
time1, err := time.Parse(time.RFC3339Nano, "2014-09-26T08:25:05Z") 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") exampleFile, err := os.ReadFile(config.ServiceRootpath.GetString() + "/pkg/modules/migration/testimage.jpg")
assert.NoError(t, err) require.NoError(t, err)
trelloData := []*trello.Board{ trelloData := []*trello.Board{
{ {
@ -365,7 +367,7 @@ func TestConvertTrelloToVikunja(t *testing.T) {
} }
hierachie, err := convertTrelloDataToVikunja(trelloData, "") hierachie, err := convertTrelloDataToVikunja(trelloData, "")
assert.NoError(t, err) require.NoError(t, err)
assert.NotNil(t, hierachie) assert.NotNil(t, hierachie)
if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal { if diff, equal := messagediff.PrettyDiff(hierachie, expectedHierachie); !equal {
t.Errorf("converted trello data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff) t.Errorf("converted trello data = %v, want %v, diff: %v", hierachie, expectedHierachie, diff)

9
pkg/modules/migration/vikunja-file/vikunja_test.go
View File

@ -23,7 +23,8 @@ import (
"code.vikunja.io/api/pkg/config" "code.vikunja.io/api/pkg/config"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"code.vikunja.io/api/pkg/user" "code.vikunja.io/api/pkg/user"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestVikunjaFileMigrator_Migrate(t *testing.T) { func TestVikunjaFileMigrator_Migrate(t *testing.T) {
@ -44,7 +45,7 @@ func TestVikunjaFileMigrator_Migrate(t *testing.T) {
} }
err = m.Migrate(u, f, s.Size()) err = m.Migrate(u, f, s.Size())
assert.NoError(t, err) require.NoError(t, err)
db.AssertExists(t, "projects", map[string]interface{}{ db.AssertExists(t, "projects", map[string]interface{}{
"title": "test project", "title": "test project",
"owner_id": u.ID, "owner_id": u.ID,
@ -91,7 +92,7 @@ func TestVikunjaFileMigrator_Migrate(t *testing.T) {
} }
err = m.Migrate(u, f, s.Size()) err = m.Migrate(u, f, s.Size())
assert.Error(t, err) require.Error(t, err)
assert.ErrorContainsf(t, err, "export was created with an older version", "Invalid error message") require.ErrorContainsf(t, err, "export was created with an older version", "Invalid error message")
}) })
} }

3
pkg/notifications/mail_test.go
View File

@ -20,6 +20,7 @@ import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestNewMail(t *testing.T) { func TestNewMail(t *testing.T) {
@ -97,7 +98,7 @@ func TestRenderMail(t *testing.T) {
Line("And one more, because why not?") Line("And one more, because why not?")
mailopts, err := RenderMail(mail) mailopts, err := RenderMail(mail)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, mail.from, mailopts.From) assert.Equal(t, mail.from, mailopts.From)
assert.Equal(t, mail.to, mailopts.To) assert.Equal(t, mail.to, mailopts.To)

11
pkg/notifications/notification_test.go
View File

@ -20,7 +20,8 @@ import (
"testing" "testing"
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"xorm.io/xorm/schemas" "xorm.io/xorm/schemas"
) )
@ -73,7 +74,7 @@ func TestNotify(t *testing.T) {
s := db.NewSession() s := db.NewSession()
defer s.Close() defer s.Close()
_, err := s.Exec("delete from notifications") _, err := s.Exec("delete from notifications")
assert.NoError(t, err) require.NoError(t, err)
tn := &testNotification{ tn := &testNotification{
Test: "somethingsomething", Test: "somethingsomething",
@ -84,7 +85,7 @@ func TestNotify(t *testing.T) {
} }
err = Notify(tnf, tn) err = Notify(tnf, tn)
assert.NoError(t, err) require.NoError(t, err)
vals := map[string]interface{}{ vals := map[string]interface{}{
"notifiable_id": 42, "notifiable_id": 42,
"notification": "'{\"other_value\":42,\"test\":\"somethingsomething\"}'", "notification": "'{\"other_value\":42,\"test\":\"somethingsomething\"}'",
@ -107,7 +108,7 @@ func TestNotify(t *testing.T) {
s := db.NewSession() s := db.NewSession()
defer s.Close() defer s.Close()
_, err := s.Exec("delete from notifications") _, err := s.Exec("delete from notifications")
assert.NoError(t, err) require.NoError(t, err)
tn := &testNotification{ tn := &testNotification{
Test: "somethingsomething", Test: "somethingsomething",
@ -118,7 +119,7 @@ func TestNotify(t *testing.T) {
} }
err = Notify(tnf, tn) err = Notify(tnf, tn)
assert.NoError(t, err) require.NoError(t, err)
db.AssertMissing(t, "notifications", map[string]interface{}{ db.AssertMissing(t, "notifications", map[string]interface{}{
"notifiable_id": 42, "notifiable_id": 42,
}) })

49
pkg/routes/caldav/listStorageProvider_test.go
View File

@ -29,6 +29,7 @@ import (
"github.com/samedi/caldav-go/data" "github.com/samedi/caldav-go/data"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
// Check logic related to creating sub-tasks // Check logic related to creating sub-tasks
@ -78,7 +79,7 @@ END:VCALENDAR`
// Create the subtask: // Create the subtask:
taskResource, err := storage.CreateResource(taskUID, taskContent) taskResource, err := storage.CreateResource(taskUID, taskContent)
assert.NoError(t, err) require.NoError(t, err)
// Check that the result CALDAV contains the relation: // Check that the result CALDAV contains the relation:
content, _ := taskResource.GetContentData() content, _ := taskResource.GetContentData()
@ -87,7 +88,7 @@ END:VCALENDAR`
// Get the task from the DB: // Get the task from the DB:
tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task := tasks[0] task := tasks[0]
// Check that the parent-child relationship is present: // Check that the parent-child relationship is present:
@ -129,7 +130,7 @@ END:VCALENDAR`
// Create the subtask: // Create the subtask:
_, err := storage.CreateResource(taskUIDChild, taskContentChild) _, err := storage.CreateResource(taskUIDChild, taskContentChild)
assert.NoError(t, err) require.NoError(t, err)
const taskUID = "uid_grand_child1" const taskUID = "uid_grand_child1"
const taskContent = `BEGIN:VCALENDAR const taskContent = `BEGIN:VCALENDAR
@ -157,7 +158,7 @@ END:VCALENDAR`
// Create the task: // Create the task:
var taskResource *data.Resource var taskResource *data.Resource
taskResource, err = storage.CreateResource(taskUID, taskContent) taskResource, err = storage.CreateResource(taskUID, taskContent)
assert.NoError(t, err) require.NoError(t, err)
// Check that the result CALDAV contains the relation: // Check that the result CALDAV contains the relation:
content, _ := taskResource.GetContentData() content, _ := taskResource.GetContentData()
@ -166,7 +167,7 @@ END:VCALENDAR`
// Get the task from the DB: // Get the task from the DB:
tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task := tasks[0] task := tasks[0]
// Check that the parent-child relationship of the grandchildren is present: // 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: // Get the child task and check that it now has a parent and a child:
tasks, err = models.GetTasksByUIDs(s, []string{"uid_child1"}, u) tasks, err = models.GetTasksByUIDs(s, []string{"uid_child1"}, u)
assert.NoError(t, err) require.NoError(t, err)
task = tasks[0] task = tasks[0]
assert.Len(t, task.RelatedTasks[models.RelationKindParenttask], 1) assert.Len(t, task.RelatedTasks[models.RelationKindParenttask], 1)
parentTask = task.RelatedTasks[models.RelationKindParenttask][0] parentTask = task.RelatedTasks[models.RelationKindParenttask][0]
@ -220,7 +221,7 @@ END:VCALENDAR`
// Create the task: // Create the task:
taskResource, err := storage.CreateResource(taskUID, taskContent) taskResource, err := storage.CreateResource(taskUID, taskContent)
assert.NoError(t, err) require.NoError(t, err)
// Check that the result CALDAV contains the relation: // Check that the result CALDAV contains the relation:
content, _ := taskResource.GetContentData() content, _ := taskResource.GetContentData()
@ -229,7 +230,7 @@ END:VCALENDAR`
// Get the task from the DB: // Get the task from the DB:
tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task := tasks[0] task := tasks[0]
// Check that the parent-child relationship is present: // 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: // 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) 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] task = tasks[0]
assert.Equal(t, "uid-caldav-test-parent-doesnt-exist-yet", task.UID) 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:VTODO
END:VCALENDAR` END:VCALENDAR`
tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task := tasks[0] task := tasks[0]
storage := &VikunjaCaldavProjectStorage{ storage := &VikunjaCaldavProjectStorage{
project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}},
@ -289,7 +290,7 @@ END:VCALENDAR`
// Edit the task: // Edit the task:
taskResource, err := storage.UpdateResource(taskUID, taskContent) taskResource, err := storage.UpdateResource(taskUID, taskContent)
assert.NoError(t, err) require.NoError(t, err)
// Check that the result CALDAV still contains the relation: // Check that the result CALDAV still contains the relation:
content, _ := taskResource.GetContentData() content, _ := taskResource.GetContentData()
@ -298,7 +299,7 @@ END:VCALENDAR`
// Get the task from the DB: // Get the task from the DB:
tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task = tasks[0] task = tasks[0]
// Check that the parent-child relationship is still present: // 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:VTODO
END:VCALENDAR` END:VCALENDAR`
tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task := tasks[0] task := tasks[0]
storage := &VikunjaCaldavProjectStorage{ storage := &VikunjaCaldavProjectStorage{
project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}},
@ -344,11 +345,11 @@ END:VCALENDAR`
// Edit the task: // Edit the task:
_, err = storage.UpdateResource(taskUID, taskContent) _, err = storage.UpdateResource(taskUID, taskContent)
assert.NoError(t, err) require.NoError(t, err)
// Get the task from the DB: // Get the task from the DB:
tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task = tasks[0] task = tasks[0]
// Check that the subtasks are still linked: // Check that the subtasks are still linked:
@ -385,7 +386,7 @@ RELATED-TO;RELTYPE=PARENT:uid-caldav-test-parent-task-2
END:VTODO END:VTODO
END:VCALENDAR` END:VCALENDAR`
tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task := tasks[0] task := tasks[0]
storage := &VikunjaCaldavProjectStorage{ storage := &VikunjaCaldavProjectStorage{
project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}},
@ -395,7 +396,7 @@ END:VCALENDAR`
// Edit the task: // Edit the task:
taskResource, err := storage.UpdateResource(taskUID, taskContent) taskResource, err := storage.UpdateResource(taskUID, taskContent)
assert.NoError(t, err) require.NoError(t, err)
// Check that the result CALDAV contains the new relation: // Check that the result CALDAV contains the new relation:
content, _ := taskResource.GetContentData() content, _ := taskResource.GetContentData()
@ -404,7 +405,7 @@ END:VCALENDAR`
// Get the task from the DB: // Get the task from the DB:
tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task = tasks[0] task = tasks[0]
// Check that the parent-child relationship has changed to the new parent: // 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: // 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) tasks, err = models.GetTasksByUIDs(s, []string{"uid-caldav-test-parent-task"}, u)
assert.NoError(t, err) require.NoError(t, err)
task = tasks[0] task = tasks[0]
assert.Len(t, task.RelatedTasks[models.RelationKindSubtask], 1) assert.Len(t, task.RelatedTasks[models.RelationKindSubtask], 1)
// We're gone, but our former sibling is still there: // We're gone, but our former sibling is still there:
@ -447,7 +448,7 @@ LAST-MODIFIED:20230301T073337Z
END:VTODO END:VTODO
END:VCALENDAR` END:VCALENDAR`
tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err := models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task := tasks[0] task := tasks[0]
storage := &VikunjaCaldavProjectStorage{ storage := &VikunjaCaldavProjectStorage{
project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}}, project: &models.ProjectWithTasksAndBuckets{Project: models.Project{ID: 36}},
@ -457,7 +458,7 @@ END:VCALENDAR`
// Edit the task: // Edit the task:
taskResource, err := storage.UpdateResource(taskUID, taskContent) taskResource, err := storage.UpdateResource(taskUID, taskContent)
assert.NoError(t, err) require.NoError(t, err)
// Check that the result CALDAV contains the new relation: // Check that the result CALDAV contains the new relation:
content, _ := taskResource.GetContentData() content, _ := taskResource.GetContentData()
@ -466,15 +467,15 @@ END:VCALENDAR`
// Get the task from the DB: // Get the task from the DB:
tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u) tasks, err = models.GetTasksByUIDs(s, []string{taskUID}, u)
assert.NoError(t, err) require.NoError(t, err)
task = tasks[0] task = tasks[0]
// Check that the parent-child relationship is gone: // 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: // 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) tasks, err = models.GetTasksByUIDs(s, []string{"uid-caldav-test-parent-task"}, u)
assert.NoError(t, err) require.NoError(t, err)
task = tasks[0] task = tasks[0]
// We're gone, but our former sibling is still there: // We're gone, but our former sibling is still there:
assert.Len(t, task.RelatedTasks[models.RelationKindSubtask], 1) assert.Len(t, task.RelatedTasks[models.RelationKindSubtask], 1)

119
pkg/user/user_test.go
View File

@ -22,6 +22,7 @@ import (
"code.vikunja.io/api/pkg/db" "code.vikunja.io/api/pkg/db"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"xorm.io/builder" "xorm.io/builder"
) )
@ -39,7 +40,7 @@ func TestCreateUser(t *testing.T) {
defer s.Close() defer s.Close()
createdUser, err := CreateUser(s, dummyuser) createdUser, err := CreateUser(s, dummyuser)
assert.NoError(t, err) require.NoError(t, err)
assert.NotZero(t, createdUser.Created) assert.NotZero(t, createdUser.Created)
}) })
t.Run("already existing", func(t *testing.T) { t.Run("already existing", func(t *testing.T) {
@ -52,7 +53,7 @@ func TestCreateUser(t *testing.T) {
Password: "12345", Password: "12345",
Email: "email@example.com", Email: "email@example.com",
}) })
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUsernameExists(err)) assert.True(t, IsErrUsernameExists(err))
}) })
t.Run("same email", func(t *testing.T) { t.Run("same email", func(t *testing.T) {
@ -65,7 +66,7 @@ func TestCreateUser(t *testing.T) {
Password: "12345", Password: "12345",
Email: "user1@example.com", Email: "user1@example.com",
}) })
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUserEmailExists(err)) assert.True(t, IsErrUserEmailExists(err))
}) })
t.Run("no username", func(t *testing.T) { t.Run("no username", func(t *testing.T) {
@ -78,7 +79,7 @@ func TestCreateUser(t *testing.T) {
Password: "12345", Password: "12345",
Email: "user1@example.com", Email: "user1@example.com",
}) })
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNoUsernamePassword(err)) assert.True(t, IsErrNoUsernamePassword(err))
}) })
t.Run("no password", func(t *testing.T) { t.Run("no password", func(t *testing.T) {
@ -91,7 +92,7 @@ func TestCreateUser(t *testing.T) {
Password: "", Password: "",
Email: "user1@example.com", Email: "user1@example.com",
}) })
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNoUsernamePassword(err)) assert.True(t, IsErrNoUsernamePassword(err))
}) })
t.Run("no email", func(t *testing.T) { t.Run("no email", func(t *testing.T) {
@ -104,7 +105,7 @@ func TestCreateUser(t *testing.T) {
Password: "12345", Password: "12345",
Email: "", Email: "",
}) })
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNoUsernamePassword(err)) assert.True(t, IsErrNoUsernamePassword(err))
}) })
t.Run("same email but different issuer", func(t *testing.T) { t.Run("same email but different issuer", func(t *testing.T) {
@ -118,7 +119,7 @@ func TestCreateUser(t *testing.T) {
Issuer: "https://some.site", Issuer: "https://some.site",
Subject: "12345", Subject: "12345",
}) })
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("same subject but different issuer", func(t *testing.T) { t.Run("same subject but different issuer", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -131,7 +132,7 @@ func TestCreateUser(t *testing.T) {
Issuer: "https://some.site", Issuer: "https://some.site",
Subject: "12345", Subject: "12345",
}) })
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("space in username", func(t *testing.T) { t.Run("space in username", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -143,7 +144,7 @@ func TestCreateUser(t *testing.T) {
Password: "12345", Password: "12345",
Email: "user1@example.com", Email: "user1@example.com",
}) })
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUsernameMustNotContainSpaces(err)) assert.True(t, IsErrUsernameMustNotContainSpaces(err))
}) })
} }
@ -161,8 +162,8 @@ func TestGetUser(t *testing.T) {
}, },
false, false,
) )
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, theuser.ID, int64(1)) assert.Equal(t, int64(1), theuser.ID)
assert.Empty(t, theuser.Email) assert.Empty(t, theuser.Email)
}) })
t.Run("by email", func(t *testing.T) { t.Run("by email", func(t *testing.T) {
@ -176,8 +177,8 @@ func TestGetUser(t *testing.T) {
Email: "user1@example.com", Email: "user1@example.com",
}, },
false) false)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, theuser.ID, int64(1)) assert.Equal(t, int64(1), theuser.ID)
assert.Empty(t, theuser.Email) assert.Empty(t, theuser.Email)
}) })
t.Run("by id", func(t *testing.T) { t.Run("by id", func(t *testing.T) {
@ -186,9 +187,9 @@ func TestGetUser(t *testing.T) {
defer s.Close() defer s.Close()
theuser, err := GetUserByID(s, 1) theuser, err := GetUserByID(s, 1)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, theuser.ID, int64(1)) assert.Equal(t, int64(1), theuser.ID)
assert.Equal(t, theuser.Username, "user1") assert.Equal(t, "user1", theuser.Username)
assert.Empty(t, theuser.Email) assert.Empty(t, theuser.Email)
}) })
t.Run("invalid id", func(t *testing.T) { t.Run("invalid id", func(t *testing.T) {
@ -197,7 +198,7 @@ func TestGetUser(t *testing.T) {
defer s.Close() defer s.Close()
_, err := GetUserByID(s, 99999) _, err := GetUserByID(s, 99999)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUserDoesNotExist(err)) assert.True(t, IsErrUserDoesNotExist(err))
}) })
t.Run("nonexistant", func(t *testing.T) { t.Run("nonexistant", func(t *testing.T) {
@ -206,7 +207,7 @@ func TestGetUser(t *testing.T) {
defer s.Close() defer s.Close()
_, err := GetUserByID(s, 0) _, err := GetUserByID(s, 0)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUserDoesNotExist(err)) assert.True(t, IsErrUserDoesNotExist(err))
}) })
t.Run("empty name", func(t *testing.T) { t.Run("empty name", func(t *testing.T) {
@ -215,7 +216,7 @@ func TestGetUser(t *testing.T) {
defer s.Close() defer s.Close()
_, err := GetUserByUsername(s, "") _, err := GetUserByUsername(s, "")
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUserDoesNotExist(err)) assert.True(t, IsErrUserDoesNotExist(err))
}) })
t.Run("with email", func(t *testing.T) { t.Run("with email", func(t *testing.T) {
@ -224,9 +225,9 @@ func TestGetUser(t *testing.T) {
defer s.Close() defer s.Close()
theuser, err := GetUserWithEmail(s, &User{ID: 1}) theuser, err := GetUserWithEmail(s, &User{ID: 1})
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, theuser.ID, int64(1)) assert.Equal(t, int64(1), theuser.ID)
assert.Equal(t, theuser.Username, "user1") assert.Equal(t, "user1", theuser.Username)
assert.NotEmpty(t, theuser.Email) assert.NotEmpty(t, theuser.Email)
}) })
} }
@ -238,7 +239,7 @@ func TestCheckUserCredentials(t *testing.T) {
defer s.Close() defer s.Close()
_, err := CheckUserCredentials(s, &Login{Username: "user1", Password: "1234"}) _, err := CheckUserCredentials(s, &Login{Username: "user1", Password: "1234"})
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("unverified email", func(t *testing.T) { t.Run("unverified email", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -246,7 +247,7 @@ func TestCheckUserCredentials(t *testing.T) {
defer s.Close() defer s.Close()
_, err := CheckUserCredentials(s, &Login{Username: "user5", Password: "1234"}) _, err := CheckUserCredentials(s, &Login{Username: "user5", Password: "1234"})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrEmailNotConfirmed(err)) assert.True(t, IsErrEmailNotConfirmed(err))
}) })
t.Run("wrong password", func(t *testing.T) { t.Run("wrong password", func(t *testing.T) {
@ -255,7 +256,7 @@ func TestCheckUserCredentials(t *testing.T) {
defer s.Close() defer s.Close()
_, err := CheckUserCredentials(s, &Login{Username: "user1", Password: "12345"}) _, err := CheckUserCredentials(s, &Login{Username: "user1", Password: "12345"})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrWrongUsernameOrPassword(err)) assert.True(t, IsErrWrongUsernameOrPassword(err))
}) })
t.Run("nonexistant user", func(t *testing.T) { t.Run("nonexistant user", func(t *testing.T) {
@ -264,7 +265,7 @@ func TestCheckUserCredentials(t *testing.T) {
defer s.Close() defer s.Close()
_, err := CheckUserCredentials(s, &Login{Username: "dfstestuu", Password: "1234"}) _, err := CheckUserCredentials(s, &Login{Username: "dfstestuu", Password: "1234"})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrWrongUsernameOrPassword(err)) assert.True(t, IsErrWrongUsernameOrPassword(err))
}) })
t.Run("empty password", func(t *testing.T) { t.Run("empty password", func(t *testing.T) {
@ -273,7 +274,7 @@ func TestCheckUserCredentials(t *testing.T) {
defer s.Close() defer s.Close()
_, err := CheckUserCredentials(s, &Login{Username: "user1"}) _, err := CheckUserCredentials(s, &Login{Username: "user1"})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNoUsernamePassword(err)) assert.True(t, IsErrNoUsernamePassword(err))
}) })
t.Run("empty username", func(t *testing.T) { t.Run("empty username", func(t *testing.T) {
@ -282,7 +283,7 @@ func TestCheckUserCredentials(t *testing.T) {
defer s.Close() defer s.Close()
_, err := CheckUserCredentials(s, &Login{Password: "1234"}) _, err := CheckUserCredentials(s, &Login{Password: "1234"})
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNoUsernamePassword(err)) assert.True(t, IsErrNoUsernamePassword(err))
}) })
t.Run("email", func(t *testing.T) { t.Run("email", func(t *testing.T) {
@ -291,7 +292,7 @@ func TestCheckUserCredentials(t *testing.T) {
defer s.Close() defer s.Close()
_, err := CheckUserCredentials(s, &Login{Username: "user1@example.com", Password: "1234"}) _, 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", Password: "LoremIpsum",
Email: "testing@example.com", Email: "testing@example.com",
}, false) }, 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, "$2a$14$dcadBoMBL9jQoOcZK8Fju.cy0Ptx2oZECkKLnaa8ekRoTFe1w7To.", uuser.Password) // Password should not change
assert.Equal(t, "user1", uuser.Username) // Username should not change either assert.Equal(t, "user1", uuser.Username) // Username should not change either
}) })
@ -319,7 +320,7 @@ func TestUpdateUser(t *testing.T) {
ID: 1, ID: 1,
Username: "changedname", Username: "changedname",
}, false) }, 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, "$2a$14$dcadBoMBL9jQoOcZK8Fju.cy0Ptx2oZECkKLnaa8ekRoTFe1w7To.", uuser.Password) // Password should not change
assert.Equal(t, "changedname", uuser.Username) assert.Equal(t, "changedname", uuser.Username)
}) })
@ -331,7 +332,7 @@ func TestUpdateUser(t *testing.T) {
_, err := UpdateUser(s, &User{ _, err := UpdateUser(s, &User{
ID: 99999, ID: 99999,
}, false) }, false)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUserDoesNotExist(err)) assert.True(t, IsErrUserDoesNotExist(err))
}) })
} }
@ -345,7 +346,7 @@ func TestUpdateUserPassword(t *testing.T) {
err := UpdateUserPassword(s, &User{ err := UpdateUserPassword(s, &User{
ID: 1, ID: 1,
}, "12345") }, "12345")
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("nonexistant user", func(t *testing.T) { t.Run("nonexistant user", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -355,7 +356,7 @@ func TestUpdateUserPassword(t *testing.T) {
err := UpdateUserPassword(s, &User{ err := UpdateUserPassword(s, &User{
ID: 9999, ID: 9999,
}, "12345") }, "12345")
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrUserDoesNotExist(err)) assert.True(t, IsErrUserDoesNotExist(err))
}) })
t.Run("empty password", func(t *testing.T) { t.Run("empty password", func(t *testing.T) {
@ -366,7 +367,7 @@ func TestUpdateUserPassword(t *testing.T) {
err := UpdateUserPassword(s, &User{ err := UpdateUserPassword(s, &User{
ID: 1, ID: 1,
}, "") }, "")
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrEmptyNewPassword(err)) assert.True(t, IsErrEmptyNewPassword(err))
}) })
} }
@ -378,9 +379,9 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "user1", nil) all, err := ListUsers(s, "user1", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, len(all) > 0) assert.NotEmpty(t, all)
assert.Equal(t, all[0].Username, "user1") assert.Equal(t, "user1", all[0].Username)
}) })
t.Run("case insensitive", func(t *testing.T) { t.Run("case insensitive", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -388,9 +389,9 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "uSEr1", nil) all, err := ListUsers(s, "uSEr1", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.True(t, len(all) > 0) assert.NotEmpty(t, len(all))
assert.Equal(t, all[0].Username, "user1") assert.Equal(t, "user1", all[0].Username)
}) })
t.Run("all users", func(t *testing.T) { t.Run("all users", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -398,7 +399,7 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListAllUsers(s) all, err := ListAllUsers(s)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 16) assert.Len(t, all, 16)
}) })
t.Run("no search term", func(t *testing.T) { t.Run("no search term", func(t *testing.T) {
@ -407,8 +408,8 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "", nil) all, err := ListUsers(s, "", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 0) assert.Empty(t, all)
}) })
t.Run("not discoverable by email", func(t *testing.T) { t.Run("not discoverable by email", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -416,8 +417,8 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "user1@example.com", nil) all, err := ListUsers(s, "user1@example.com", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 0) assert.Empty(t, all)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
"email": "user1@example.com", "email": "user1@example.com",
"discoverable_by_email": false, "discoverable_by_email": false,
@ -429,8 +430,8 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "one else", nil) all, err := ListUsers(s, "one else", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 0) assert.Empty(t, all)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
"name": "Some one else", "name": "Some one else",
"discoverable_by_name": false, "discoverable_by_name": false,
@ -442,7 +443,7 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "user7@example.com", nil) all, err := ListUsers(s, "user7@example.com", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 1) assert.Len(t, all, 1)
assert.Equal(t, int64(7), all[0].ID) assert.Equal(t, int64(7), all[0].ID)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
@ -456,7 +457,7 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "with space", nil) all, err := ListUsers(s, "with space", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 1) assert.Len(t, all, 1)
assert.Equal(t, int64(12), all[0].ID) assert.Equal(t, int64(12), all[0].ID)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
@ -470,7 +471,7 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "user7@example.com", &ProjectUserOpts{AdditionalCond: builder.In("id", 7)}) 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.Len(t, all, 1)
assert.Equal(t, int64(7), all[0].ID) assert.Equal(t, int64(7), all[0].ID)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
@ -484,7 +485,7 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "user7", nil) all, err := ListUsers(s, "user7", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 1) assert.Len(t, all, 1)
assert.Equal(t, int64(7), all[0].ID) assert.Equal(t, int64(7), all[0].ID)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
@ -497,8 +498,8 @@ func TestListUsers(t *testing.T) {
defer s.Close() defer s.Close()
all, err := ListUsers(s, "user", nil) all, err := ListUsers(s, "user", nil)
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 0) assert.Empty(t, all)
db.AssertExists(t, "users", map[string]interface{}{ db.AssertExists(t, "users", map[string]interface{}{
"username": "user7", "username": "user7",
}, false) }, false)
@ -511,7 +512,7 @@ func TestListUsers(t *testing.T) {
all, err := ListUsers(s, "user", &ProjectUserOpts{ all, err := ListUsers(s, "user", &ProjectUserOpts{
MatchFuzzily: true, MatchFuzzily: true,
}) })
assert.NoError(t, err) require.NoError(t, err)
assert.Len(t, all, 16) assert.Len(t, all, 16)
}) })
} }
@ -527,7 +528,7 @@ func TestUserPasswordReset(t *testing.T) {
NewPassword: "12345", NewPassword: "12345",
} }
err := ResetPassword(s, reset) err := ResetPassword(s, reset)
assert.NoError(t, err) require.NoError(t, err)
}) })
t.Run("without password", func(t *testing.T) { t.Run("without password", func(t *testing.T) {
db.LoadAndAssertFixtures(t) db.LoadAndAssertFixtures(t)
@ -538,7 +539,7 @@ func TestUserPasswordReset(t *testing.T) {
Token: "passwordresettesttoken", Token: "passwordresettesttoken",
} }
err := ResetPassword(s, reset) err := ResetPassword(s, reset)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNoUsernamePassword(err)) assert.True(t, IsErrNoUsernamePassword(err))
}) })
t.Run("empty token", func(t *testing.T) { t.Run("empty token", func(t *testing.T) {
@ -551,7 +552,7 @@ func TestUserPasswordReset(t *testing.T) {
NewPassword: "12345", NewPassword: "12345",
} }
err := ResetPassword(s, reset) err := ResetPassword(s, reset)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrNoPasswordResetToken(err)) assert.True(t, IsErrNoPasswordResetToken(err))
}) })
t.Run("wrong token", func(t *testing.T) { t.Run("wrong token", func(t *testing.T) {
@ -564,7 +565,7 @@ func TestUserPasswordReset(t *testing.T) {
NewPassword: "12345", NewPassword: "12345",
} }
err := ResetPassword(s, reset) err := ResetPassword(s, reset)
assert.Error(t, err) require.Error(t, err)
assert.True(t, IsErrInvalidPasswordResetToken(err)) assert.True(t, IsErrInvalidPasswordResetToken(err))
}) })
} }

4
pkg/utils/random_test.go
View File

@ -24,6 +24,6 @@ import (
func TestMakeRandomString(t *testing.T) { func TestMakeRandomString(t *testing.T) {
rand := MakeRandomString(32) rand := MakeRandomString(32)
assert.NotEqual(t, rand, "loremipsuim") assert.NotEqual(t, "loremipsuim", rand)
assert.Equal(t, len(rand), 32) assert.Len(t, rand, 32)
} }