252 lines
8.4 KiB
Go
252 lines
8.4 KiB
Go
// Vikunja is a todo-list application to facilitate your life.
|
|
// Copyright 2019 Vikunja and contributors. All rights reserved.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package integrations
|
|
|
|
import (
|
|
"code.vikunja.io/api/pkg/models"
|
|
"github.com/labstack/echo"
|
|
"github.com/stretchr/testify/assert"
|
|
"net/url"
|
|
"testing"
|
|
)
|
|
|
|
func TestList(t *testing.T) {
|
|
testHandler := webHandlerTest{
|
|
user: &testuser1,
|
|
str: &models.List{},
|
|
t: t,
|
|
}
|
|
t.Run("ReadAll", func(t *testing.T) {
|
|
t.Run("Normal", func(t *testing.T) {
|
|
rec, err := testHandler.testReadAll(nil, nil)
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `Test1`)
|
|
assert.NotContains(t, rec.Body.String(), `Test2`)
|
|
assert.Contains(t, rec.Body.String(), `Test3`) // Shared directly via users_list
|
|
assert.Contains(t, rec.Body.String(), `Test4`) // Shared via namespace
|
|
assert.NotContains(t, rec.Body.String(), `Test5`)
|
|
})
|
|
t.Run("Search", func(t *testing.T) {
|
|
rec, err := testHandler.testReadAll(url.Values{"s": []string{"Test1"}}, nil)
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `Test1`)
|
|
assert.NotContains(t, rec.Body.String(), `Test2`)
|
|
assert.NotContains(t, rec.Body.String(), `Test3`)
|
|
assert.NotContains(t, rec.Body.String(), `Test4`)
|
|
assert.NotContains(t, rec.Body.String(), `Test5`)
|
|
})
|
|
})
|
|
t.Run("ReadOne", func(t *testing.T) {
|
|
t.Run("Normal", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "1"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test1"`)
|
|
assert.NotContains(t, rec.Body.String(), `"title":"Test2"`)
|
|
assert.Contains(t, rec.Body.String(), `"owner":{"id":1,"username":"user1",`)
|
|
assert.NotContains(t, rec.Body.String(), `"owner":{"id":2,"username":"user2",`)
|
|
assert.Contains(t, rec.Body.String(), `"tasks":[{"id":1,"text":"task #1",`)
|
|
})
|
|
t.Run("Nonexisting", func(t *testing.T) {
|
|
_, err := testHandler.testReadOne(nil, map[string]string{"list": "9999"})
|
|
assert.Error(t, err)
|
|
assertHandlerErrorCode(t, err, models.ErrCodeListDoesNotExist)
|
|
})
|
|
t.Run("Rights check", func(t *testing.T) {
|
|
t.Run("Forbidden", func(t *testing.T) {
|
|
// Owned by user3
|
|
_, err := testHandler.testReadOne(nil, map[string]string{"list": "2"})
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.(*echo.HTTPError).Message, `You don't have the right to see this`)
|
|
})
|
|
t.Run("Shared Via Team readonly", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "6"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test6"`)
|
|
})
|
|
t.Run("Shared Via Team write", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "7"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test7"`)
|
|
})
|
|
t.Run("Shared Via Team admin", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "8"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test8"`)
|
|
})
|
|
|
|
t.Run("Shared Via User readonly", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "9"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test9"`)
|
|
})
|
|
t.Run("Shared Via User write", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "10"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test10"`)
|
|
})
|
|
t.Run("Shared Via User admin", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "11"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test11"`)
|
|
})
|
|
|
|
t.Run("Shared Via NamespaceTeam readonly", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "12"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test12"`)
|
|
})
|
|
t.Run("Shared Via NamespaceTeam write", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "13"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test13"`)
|
|
})
|
|
t.Run("Shared Via NamespaceTeam admin", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "14"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test14"`)
|
|
})
|
|
|
|
t.Run("Shared Via NamespaceUser readonly", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "15"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test15"`)
|
|
})
|
|
t.Run("Shared Via NamespaceUser write", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "16"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test16"`)
|
|
})
|
|
t.Run("Shared Via NamespaceUser admin", func(t *testing.T) {
|
|
rec, err := testHandler.testReadOne(nil, map[string]string{"list": "17"})
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"Test17"`)
|
|
})
|
|
})
|
|
})
|
|
t.Run("Update", func(t *testing.T) {
|
|
t.Run("Normal", func(t *testing.T) {
|
|
// Check the list was loaded sucessfully afterwards, see testReadOne
|
|
rec, err := testHandler.testUpdate(nil, map[string]string{"list": "1"}, `{"title":"TestLoremIpsum"}`)
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), `"title":"TestLoremIpsum"`)
|
|
})
|
|
// TODO: empty title, min/maxlength of the title & description
|
|
// Also test with only one parameter
|
|
// Test chaning the owner
|
|
t.Run("Nonexisting", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Empty list title", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Nonexisting namespace", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Rights check", func(t *testing.T) {
|
|
t.Run("Forbidden", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Team", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via User", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Namespace-Team", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Namespace-User", func(t *testing.T) {
|
|
|
|
})
|
|
})
|
|
})
|
|
t.Run("Delete", func(t *testing.T) {
|
|
t.Run("Normal", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Nonexisting", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Rights check", func(t *testing.T) {
|
|
t.Run("Forbidden", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Team", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via User", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Namespace-Team", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Namespace-User", func(t *testing.T) {
|
|
|
|
})
|
|
})
|
|
})
|
|
t.Run("Create", func(t *testing.T) {
|
|
t.Run("Normal", func(t *testing.T) {
|
|
// Check the list was loaded sucessfully after update, see testReadOne
|
|
|
|
})
|
|
t.Run("Nonexisting", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Empty list title", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Nonexisting namespace", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Rights check", func(t *testing.T) {
|
|
t.Run("Forbidden", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Team", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via User", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Namespace-Team", func(t *testing.T) {
|
|
|
|
})
|
|
t.Run("Shared Via Namespace-User", func(t *testing.T) {
|
|
|
|
})
|
|
})
|
|
})
|
|
|
|
/*
|
|
t.Run("Normal test", func(t *testing.T) {
|
|
rec, err := newTestRequestWithUser(t, http.MethodPost, apiv1.List, &testuser1, `{}`)
|
|
assert.NoError(t, err)
|
|
assert.Contains(t, rec.Body.String(), ``)
|
|
})
|
|
t.Run("Empty payload", func(t *testing.T) {
|
|
_, err := newTestRequestWithUser(t, http.MethodPost, apiv1.List, &testuser1, `{}`)
|
|
assert.Error(t, err)
|
|
assert.Equal(t, http.StatusBadRequest, err.(*echo.HTTPError).Code)
|
|
})
|
|
t.Run("No ", func(t *testing.T) {
|
|
_, err := newTestRequestWithUser(t, http.MethodPost, apiv1.List, &testuser1, `{}`)
|
|
assert.Error(t, err)
|
|
assertHandlerErrorCode(t, err, models.ErrCode)
|
|
})*/
|
|
}
|