Testing improvements (#666)

Change method names to avoid doubling db

Assert team test exists

Assert team member test exists

Assert task test exists

Assert task relation test exists

Assert task comment test exists

Better tests for team namespaces

Assert exists in namespace users tests

Assert exists in namespace tests

Assert exists in user list tests

Assert exists in list tests

Better team list tests

Assert label tests exist in db

Assert label task tests exist in db

Assert label task tests exist in db

Assert kanban tests exist in db

Co-authored-by: kolaente <k@knt.li>
Reviewed-on: vikunja/api#666
Co-Authored-By: konrad <konrad@kola-entertainments.de>
Co-Committed-By: konrad <konrad@kola-entertainments.de>

pkg/db/test.go

@@ -73,8 +73,8 @@ func InitTestFixtures(tablenames ...string) (err error) {
 	return nil
 }
 
-// AssertDBExists checks and asserts the existence of certain entries in the db
+// AssertExists checks and asserts the existence of certain entries in the db
-func AssertDBExists(t *testing.T, table string, values map[string]interface{}, custom bool) {
+func AssertExists(t *testing.T, table string, values map[string]interface{}, custom bool) {
 	var exists bool
 	var err error
 	v := make(map[string]interface{})
@@ -94,8 +94,8 @@ func AssertDBExists(t *testing.T, table string, values map[string]interface{}, c
 	assert.True(t, exists, fmt.Sprintf("Entries %v do not exist in table %s", values, table))
 }
 
-// AssertDBMissing checks and asserts the nonexiste nce of certain entries in the db
+// AssertMissing checks and asserts the nonexiste nce of certain entries in the db
-func AssertDBMissing(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{})
 	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))

pkg/models/kanban_test.go

@@ -78,6 +78,10 @@ func TestBucket_Delete(t *testing.T) {
 		err = x.Where("bucket_id = ?", 1).Find(&tasks)
 		assert.NoError(t, err)
 		assert.Len(t, tasks, 15)
+		db.AssertMissing(t, "buckets", map[string]interface{}{
+			"id":      2,
+			"list_id": 1,
+		})
 	})
 	t.Run("last bucket in list", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -88,5 +92,9 @@ func TestBucket_Delete(t *testing.T) {
 		err := b.Delete()
 		assert.Error(t, err)
 		assert.True(t, IsErrCannotRemoveLastBucket(err))
+		db.AssertExists(t, "buckets", map[string]interface{}{
+			"id":      34,
+			"list_id": 18,
+		}, false)
 	})
 }

pkg/models/label_task_test.go

@@ -202,6 +202,13 @@ func TestLabelTask_Create(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("LabelTask.Create() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "label_task", map[string]interface{}{
+					"id":       l.ID,
+					"task_id":  l.TaskID,
+					"label_id": l.LabelID,
+				}, false)
+			}
 		})
 	}
 }
@@ -291,6 +298,12 @@ func TestLabelTask_Delete(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("LabelTask.Delete() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantForbidden {
+				db.AssertMissing(t, "label_task", map[string]interface{}{
+					"label_id": l.LabelID,
+					"task_id":  l.TaskID,
+				})
+			}
 		})
 	}
 }

pkg/models/label_test.go

@@ -314,6 +314,14 @@ func TestLabel_Create(t *testing.T) {
 			if err := l.Create(tt.args.a); (err != nil) != tt.wantErr {
 				t.Errorf("Label.Create() error = %v, wantErr %v", err, tt.wantErr)
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "labels", map[string]interface{}{
+					"id":          l.ID,
+					"title":       l.Title,
+					"description": l.Description,
+					"hex_color":   l.HexColor,
+				}, false)
+			}
 		})
 	}
 }
@@ -396,6 +404,12 @@ func TestLabel_Update(t *testing.T) {
 			if err := l.Update(); (err != nil) != tt.wantErr {
 				t.Errorf("Label.Update() error = %v, wantErr %v", err, tt.wantErr)
 			}
+			if !tt.wantErr && !tt.wantForbidden {
+				db.AssertExists(t, "labels", map[string]interface{}{
+					"id":    tt.fields.ID,
+					"title": tt.fields.Title,
+				}, false)
+			}
 		})
 	}
 }
@@ -474,6 +488,11 @@ func TestLabel_Delete(t *testing.T) {
 			if err := l.Delete(); (err != nil) != tt.wantErr {
 				t.Errorf("Label.Delete() error = %v, wantErr %v", err, tt.wantErr)
 			}
+			if !tt.wantErr && !tt.wantForbidden {
+				db.AssertMissing(t, "labels", map[string]interface{}{
+					"id": l.ID,
+				})
+			}
 		})
 	}
 }

pkg/models/list_team_test.go

@@ -27,92 +27,150 @@ import (
 	"time"
 )
 
-func TestTeamList(t *testing.T) {
+func TestTeamList_ReadAll(t *testing.T) {
-	db.LoadAndAssertFixtures(t)
+	u := &user.User{ID: 1}
 
-	// Dummy relation
+	t.Run("normal", func(t *testing.T) {
-	tl := TeamList{
+		tl := TeamList{
-		TeamID: 1,
+			TeamID: 1,
-		ListID: 1,
+			ListID: 3,
-		Right:  RightAdmin,
+		}
-	}
+		db.LoadAndAssertFixtures(t)
+		teams, _, _, err := tl.ReadAll(u, "", 1, 50)
+		assert.NoError(t, err)
+		assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice)
+		s := reflect.ValueOf(teams)
+		assert.Equal(t, s.Len(), 1)
+	})
+	t.Run("nonexistant list", func(t *testing.T) {
+		tl := TeamList{
+			ListID: 99999,
+		}
+		db.LoadAndAssertFixtures(t)
+		_, _, _, err := tl.ReadAll(u, "", 1, 50)
+		assert.Error(t, err)
+		assert.True(t, IsErrListDoesNotExist(err))
+	})
+	t.Run("namespace owner", func(t *testing.T) {
+		tl := TeamList{
+			TeamID: 1,
+			ListID: 2,
+			Right:  RightAdmin,
+		}
+		db.LoadAndAssertFixtures(t)
+		_, _, _, err := tl.ReadAll(u, "", 1, 50)
+		assert.NoError(t, err)
+	})
+	t.Run("no access", func(t *testing.T) {
+		tl := TeamList{
+			TeamID: 1,
+			ListID: 5,
+			Right:  RightAdmin,
+		}
+		db.LoadAndAssertFixtures(t)
+		_, _, _, err := tl.ReadAll(u, "", 1, 50)
+		assert.Error(t, err)
+		assert.True(t, IsErrNeedToHaveListReadAccess(err))
+	})
+}
 
-	// Dummyuser
+func TestTeamList_Create(t *testing.T) {
-	u, err := user.GetUserByID(1)
+	u := &user.User{ID: 1}
-	assert.NoError(t, err)
+	t.Run("normal", func(t *testing.T) {
+		db.LoadAndAssertFixtures(t)
+		tl := TeamList{
+			TeamID: 1,
+			ListID: 1,
+			Right:  RightAdmin,
+		}
+		allowed, _ := tl.CanCreate(u)
+		assert.True(t, allowed)
+		err := tl.Create(u)
+		assert.NoError(t, err)
+		db.AssertExists(t, "team_list", map[string]interface{}{
+			"team_id": 1,
+			"list_id": 1,
+			"right":   RightAdmin,
+		}, false)
+	})
+	t.Run("team already has access", func(t *testing.T) {
+		db.LoadAndAssertFixtures(t)
+		tl := TeamList{
+			TeamID: 1,
+			ListID: 3,
+			Right:  RightAdmin,
+		}
+		err := tl.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrTeamAlreadyHasAccess(err))
+	})
+	t.Run("wrong rights", func(t *testing.T) {
+		db.LoadAndAssertFixtures(t)
+		tl := TeamList{
+			TeamID: 1,
+			ListID: 1,
+			Right:  RightUnknown,
+		}
+		err := tl.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrInvalidRight(err))
+	})
+	t.Run("nonexistant team", func(t *testing.T) {
+		db.LoadAndAssertFixtures(t)
+		tl := TeamList{
+			TeamID: 9999,
+			ListID: 1,
+		}
+		err := tl.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrTeamDoesNotExist(err))
+	})
+	t.Run("nonexistant list", func(t *testing.T) {
+		db.LoadAndAssertFixtures(t)
+		tl := TeamList{
+			TeamID: 1,
+			ListID: 9999,
+		}
+		err := tl.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrListDoesNotExist(err))
+	})
+}
 
-	// Check normal creation
+func TestTeamList_Delete(t *testing.T) {
-	allowed, _ := tl.CanCreate(u)
+	t.Run("normal", func(t *testing.T) {
-	assert.True(t, allowed)
+		db.LoadAndAssertFixtures(t)
-	err = tl.Create(u)
+		tl := TeamList{
-	assert.NoError(t, err)
+			TeamID: 1,
-
+			ListID: 3,
-	// Check again
+		}
-	err = tl.Create(u)
+		err := tl.Delete()
-	assert.Error(t, err)
+		assert.NoError(t, err)
-	assert.True(t, IsErrTeamAlreadyHasAccess(err))
+		db.AssertMissing(t, "team_list", map[string]interface{}{
-
+			"team_id": 1,
-	// Check with wrong rights
+			"list_id": 3,
-	tl2 := tl
+		})
-	tl2.Right = RightUnknown
+	})
-	err = tl2.Create(u)
+	t.Run("nonexistant team", func(t *testing.T) {
-	assert.Error(t, err)
+		db.LoadAndAssertFixtures(t)
-	assert.True(t, IsErrInvalidRight(err))
+		tl := TeamList{
-
+			TeamID: 9999,
-	// Check with inexistant team
+			ListID: 1,
-	tl3 := tl
+		}
-	tl3.TeamID = 3253
+		err := tl.Delete()
-	err = tl3.Create(u)
+		assert.Error(t, err)
-	assert.Error(t, err)
+		assert.True(t, IsErrTeamDoesNotExist(err))
-	assert.True(t, IsErrTeamDoesNotExist(err))
+	})
-
+	t.Run("nonexistant list", func(t *testing.T) {
-	// Check with inexistant list
+		db.LoadAndAssertFixtures(t)
-	tl4 := tl
+		tl := TeamList{
-	tl4.ListID = 3252
+			TeamID: 1,
-	err = tl4.Create(u)
+			ListID: 9999,
-	assert.Error(t, err)
+		}
-	assert.True(t, IsErrListDoesNotExist(err))
+		err := tl.Delete()
-
+		assert.Error(t, err)
-	// Test Read all
+		assert.True(t, IsErrTeamDoesNotHaveAccessToList(err))
-	teams, _, _, err := tl.ReadAll(u, "", 1, 50)
+	})
-	assert.NoError(t, err)
-	assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice)
-	s := reflect.ValueOf(teams)
-	assert.Equal(t, s.Len(), 1)
-
-	// Test Read all for nonexistant list
-	_, _, _, err = tl4.ReadAll(u, "", 1, 50)
-	assert.Error(t, err)
-	assert.True(t, IsErrListDoesNotExist(err))
-
-	// Test Read all for a list where the user is owner of the namespace this list belongs to
-	tl5 := tl
-	tl5.ListID = 2
-	_, _, _, err = tl5.ReadAll(u, "", 1, 50)
-	assert.NoError(t, err)
-
-	// Test read all for a list where the user not has access
-	tl6 := tl
-	tl6.ListID = 5
-	_, _, _, err = tl6.ReadAll(u, "", 1, 50)
-	assert.Error(t, err)
-	assert.True(t, IsErrNeedToHaveListReadAccess(err))
-
-	// Delete
-	allowed, _ = tl.CanDelete(u)
-	assert.True(t, allowed)
-	err = tl.Delete()
-	assert.NoError(t, err)
-
-	// Delete a nonexistant team
-	err = tl3.Delete()
-	assert.Error(t, err)
-	assert.True(t, IsErrTeamDoesNotExist(err))
-
-	// Delete with a nonexistant list
-	err = tl4.Delete()
-	assert.Error(t, err)
-	assert.True(t, IsErrTeamDoesNotHaveAccessToList(err))
 }
 
 func TestTeamList_Update(t *testing.T) {
@@ -188,6 +246,13 @@ func TestTeamList_Update(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("TeamList.Update() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "team_list", map[string]interface{}{
+					"list_id": tt.fields.ListID,
+					"team_id": tt.fields.TeamID,
+					"right":   tt.fields.Right,
+				}, false)
+			}
 		})
 	}
 }

pkg/models/list_test.go

@@ -41,6 +41,12 @@ func TestList_CreateOrUpdate(t *testing.T) {
 			}
 			err := list.Create(usr)
 			assert.NoError(t, err)
+			db.AssertExists(t, "list", map[string]interface{}{
+				"id":           list.ID,
+				"title":        list.Title,
+				"description":  list.Description,
+				"namespace_id": list.NamespaceID,
+			}, false)
 		})
 		t.Run("nonexistant namespace", func(t *testing.T) {
 			db.LoadAndAssertFixtures(t)
@@ -88,6 +94,12 @@ func TestList_CreateOrUpdate(t *testing.T) {
 			}
 			err := list.Create(usr)
 			assert.NoError(t, err)
+			db.AssertExists(t, "list", map[string]interface{}{
+				"id":           list.ID,
+				"title":        list.Title,
+				"description":  list.Description,
+				"namespace_id": list.NamespaceID,
+			}, false)
 		})
 	})
 
@@ -103,7 +115,12 @@ func TestList_CreateOrUpdate(t *testing.T) {
 			list.Description = "Lorem Ipsum dolor sit amet."
 			err := list.Update()
 			assert.NoError(t, err)
-
+			db.AssertExists(t, "list", map[string]interface{}{
+				"id":           list.ID,
+				"title":        list.Title,
+				"description":  list.Description,
+				"namespace_id": list.NamespaceID,
+			}, false)
 		})
 		t.Run("nonexistant", func(t *testing.T) {
 			db.LoadAndAssertFixtures(t)
@@ -139,6 +156,9 @@ func TestList_Delete(t *testing.T) {
 	}
 	err := list.Delete()
 	assert.NoError(t, err)
+	db.AssertMissing(t, "list", map[string]interface{}{
+		"id": 1,
+	})
 }
 
 func TestList_ReadAll(t *testing.T) {

pkg/models/list_users_test.go

@@ -126,6 +126,12 @@ func TestListUser_Create(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("ListUser.Create() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "users_list", map[string]interface{}{
+					"user_id": ul.UserID,
+					"list_id": tt.fields.ListID,
+				}, false)
+			}
 		})
 	}
 }
@@ -299,6 +305,13 @@ func TestListUser_Update(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("ListUser.Update() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "users_list", map[string]interface{}{
+					"list_id": tt.fields.ListID,
+					"user_id": lu.UserID,
+					"right":   tt.fields.Right,
+				}, false)
+			}
 		})
 	}
 }
@@ -307,6 +320,7 @@ func TestListUser_Delete(t *testing.T) {
 	type fields struct {
 		ID       int64
 		Username string
+		UserID   int64
 		ListID   int64
 		Right    Right
 		Created  time.Time
@@ -342,6 +356,7 @@ func TestListUser_Delete(t *testing.T) {
 			name: "Try deleting normally",
 			fields: fields{
 				Username: "user1",
+				UserID:   1,
 				ListID:   3,
 			},
 		},
@@ -367,6 +382,12 @@ func TestListUser_Delete(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("ListUser.Delete() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertMissing(t, "users_list", map[string]interface{}{
+					"user_id": tt.fields.UserID,
+					"list_id": tt.fields.ListID,
+				})
+			}
 		})
 	}
 }

pkg/models/namespace_team_test.go

@@ -27,84 +27,142 @@ import (
 	"time"
 )
 
-func TestTeamNamespace(t *testing.T) {
+func TestTeamNamespace_ReadAll(t *testing.T) {
-	db.LoadAndAssertFixtures(t)
+	u := &user.User{ID: 1}
 
-	// Dummy team <-> namespace relation
+	t.Run("normal", func(t *testing.T) {
-	tn := TeamNamespace{
+		tn := TeamNamespace{
-		TeamID:      1,
+			NamespaceID: 3,
-		NamespaceID: 1,
+		}
-		Right:       RightAdmin,
+		db.LoadAndAssertFixtures(t)
-	}
+		teams, _, _, err := tn.ReadAll(u, "", 1, 50)
+		assert.NoError(t, err)
+		assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice)
+		s := reflect.ValueOf(teams)
+		assert.Equal(t, s.Len(), 2)
+	})
+	t.Run("nonexistant namespace", func(t *testing.T) {
+		tn := TeamNamespace{
+			NamespaceID: 9999,
+		}
+		db.LoadAndAssertFixtures(t)
+		_, _, _, err := tn.ReadAll(u, "", 1, 50)
+		assert.Error(t, err)
+		assert.True(t, IsErrNamespaceDoesNotExist(err))
+	})
+	t.Run("no right for namespace", func(t *testing.T) {
+		tn := TeamNamespace{
+			NamespaceID: 17,
+		}
+		db.LoadAndAssertFixtures(t)
+		_, _, _, err := tn.ReadAll(u, "", 1, 50)
+		assert.Error(t, err)
+		assert.True(t, IsErrNeedToHaveNamespaceReadAccess(err))
+	})
+}
 
-	dummyuser, err := user.GetUserByID(1)
+func TestTeamNamespace_Create(t *testing.T) {
-	assert.NoError(t, err)
+	u := &user.User{ID: 1}
 
-	// Test normal creation
+	t.Run("normal", func(t *testing.T) {
-	allowed, _ := tn.CanCreate(dummyuser)
+		tn := TeamNamespace{
-	assert.True(t, allowed)
+			TeamID:      1,
-	err = tn.Create(dummyuser)
+			NamespaceID: 1,
-	assert.NoError(t, err)
+			Right:       RightAdmin,
+		}
+		db.LoadAndAssertFixtures(t)
+		allowed, _ := tn.CanCreate(u)
+		assert.True(t, allowed)
+		err := tn.Create(u)
+		assert.NoError(t, err)
+		db.AssertExists(t, "team_namespaces", map[string]interface{}{
+			"team_id":      1,
+			"namespace_id": 1,
+			"right":        RightAdmin,
+		}, false)
+	})
+	t.Run("team already has access", func(t *testing.T) {
+		tn := TeamNamespace{
+			TeamID:      1,
+			NamespaceID: 3,
+			Right:       RightRead,
+		}
+		db.LoadAndAssertFixtures(t)
+		err := tn.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrTeamAlreadyHasAccess(err))
+	})
+	t.Run("invalid team right", func(t *testing.T) {
+		tn := TeamNamespace{
+			TeamID:      1,
+			NamespaceID: 3,
+			Right:       RightUnknown,
+		}
+		db.LoadAndAssertFixtures(t)
+		err := tn.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrInvalidRight(err))
+	})
+	t.Run("nonexistant team", func(t *testing.T) {
+		tn := TeamNamespace{
+			TeamID:      9999,
+			NamespaceID: 1,
+		}
+		db.LoadAndAssertFixtures(t)
+		err := tn.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrTeamDoesNotExist(err))
+	})
+	t.Run("nonexistant namespace", func(t *testing.T) {
+		tn := TeamNamespace{
+			TeamID:      1,
+			NamespaceID: 9999,
+		}
+		db.LoadAndAssertFixtures(t)
+		err := tn.Create(u)
+		assert.Error(t, err)
+		assert.True(t, IsErrNamespaceDoesNotExist(err))
+	})
+}
 
-	// Test again (should fail)
+func TestTeamNamespace_Delete(t *testing.T) {
-	err = tn.Create(dummyuser)
+	u := &user.User{ID: 1}
-	assert.Error(t, err)
-	assert.True(t, IsErrTeamAlreadyHasAccess(err))
 
-	// Test with invalid team right
+	t.Run("normal", func(t *testing.T) {
-	tn2 := tn
+		tn := TeamNamespace{
-	tn2.Right = RightUnknown
+			TeamID:      7,
-	err = tn2.Create(dummyuser)
+			NamespaceID: 9,
-	assert.Error(t, err)
+		}
-	assert.True(t, IsErrInvalidRight(err))
+		db.LoadAndAssertFixtures(t)
-
+		allowed, _ := tn.CanDelete(u)
-	// Check with inexistant team
+		assert.True(t, allowed)
-	tn3 := tn
+		err := tn.Delete()
-	tn3.TeamID = 324
+		assert.NoError(t, err)
-	err = tn3.Create(dummyuser)
+		db.AssertMissing(t, "team_namespaces", map[string]interface{}{
-	assert.Error(t, err)
+			"team_id":      7,
-	assert.True(t, IsErrTeamDoesNotExist(err))
+			"namespace_id": 9,
-
+		})
-	// Check with a namespace which does not exist
+	})
-	tn4 := tn
+	t.Run("nonexistant team", func(t *testing.T) {
-	tn4.NamespaceID = 423
+		tn := TeamNamespace{
-	err = tn4.Create(dummyuser)
+			TeamID:      9999,
-	assert.Error(t, err)
+			NamespaceID: 3,
-	assert.True(t, IsErrNamespaceDoesNotExist(err))
+		}
-
+		db.LoadAndAssertFixtures(t)
-	// Check readall
+		err := tn.Delete()
-	teams, _, _, err := tn.ReadAll(dummyuser, "", 1, 50)
+		assert.Error(t, err)
-	assert.NoError(t, err)
+		assert.True(t, IsErrTeamDoesNotExist(err))
-	assert.Equal(t, reflect.TypeOf(teams).Kind(), reflect.Slice)
+	})
-	s := reflect.ValueOf(teams)
+	t.Run("nonexistant namespace", func(t *testing.T) {
-	assert.Equal(t, s.Len(), 1)
+		tn := TeamNamespace{
-
+			TeamID:      1,
-	// Check readall for a nonexistant namespace
+			NamespaceID: 9999,
-	_, _, _, err = tn4.ReadAll(dummyuser, "", 1, 50)
+		}
-	assert.Error(t, err)
+		db.LoadAndAssertFixtures(t)
-	assert.True(t, IsErrNamespaceDoesNotExist(err))
+		err := tn.Delete()
-
+		assert.Error(t, err)
-	// Check with no right to read the namespace
+		assert.True(t, IsErrTeamDoesNotHaveAccessToNamespace(err))
-	nouser := &user.User{ID: 393}
+	})
-	_, _, _, err = tn.ReadAll(nouser, "", 1, 50)
-	assert.Error(t, err)
-	assert.True(t, IsErrNeedToHaveNamespaceReadAccess(err))
-
-	// Delete it
-	allowed, _ = tn.CanDelete(dummyuser)
-	assert.True(t, allowed)
-	err = tn.Delete()
-	assert.NoError(t, err)
-
-	// Try deleting with a nonexisting team
-	err = tn3.Delete()
-	assert.Error(t, err)
-	assert.True(t, IsErrTeamDoesNotExist(err))
-
-	// Try deleting with a nonexistant namespace
-	err = tn4.Delete()
-	assert.Error(t, err)
-	assert.True(t, IsErrTeamDoesNotHaveAccessToNamespace(err))
 }
 
 func TestTeamNamespace_Update(t *testing.T) {
@@ -180,6 +238,13 @@ func TestTeamNamespace_Update(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("TeamNamespace.Update() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "team_namespaces", map[string]interface{}{
+					"team_id":      tt.fields.TeamID,
+					"namespace_id": tt.fields.NamespaceID,
+					"right":        tt.fields.Right,
+				}, false)
+			}
 		})
 	}
 }

pkg/models/namespace_test.go

@@ -37,6 +37,10 @@ func TestNamespace_Create(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
 		err := dummynamespace.Create(user1)
 		assert.NoError(t, err)
+		db.AssertExists(t, "namespaces", map[string]interface{}{
+			"title":       "Test",
+			"description": "Lorem Ipsum",
+		}, false)
 	})
 	t.Run("no title", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -81,6 +85,10 @@ func TestNamespace_Update(t *testing.T) {
 		}
 		err := n.Update()
 		assert.NoError(t, err)
+		db.AssertExists(t, "namespaces", map[string]interface{}{
+			"id":    1,
+			"title": "Lorem Ipsum",
+		}, false)
 	})
 	t.Run("nonexisting", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -122,6 +130,9 @@ func TestNamespace_Delete(t *testing.T) {
 		}
 		err := n.Delete()
 		assert.NoError(t, err)
+		db.AssertMissing(t, "namespaces", map[string]interface{}{
+			"id": 1,
+		})
 	})
 	t.Run("nonexisting", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)

pkg/models/namespace_users_test.go

@@ -31,6 +31,7 @@ func TestNamespaceUser_Create(t *testing.T) {
 	type fields struct {
 		ID          int64
 		Username    string
+		UserID      int64
 		NamespaceID int64
 		Right       Right
 		Created     time.Time
@@ -52,6 +53,7 @@ func TestNamespaceUser_Create(t *testing.T) {
 			name: "NamespaceUsers Create normally",
 			fields: fields{
 				Username:    "user1",
+				UserID:      1,
 				NamespaceID: 2,
 			},
 		},
@@ -123,6 +125,12 @@ func TestNamespaceUser_Create(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("NamespaceUser.Create() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "users_namespace", map[string]interface{}{
+					"user_id":      tt.fields.UserID,
+					"namespace_id": tt.fields.NamespaceID,
+				}, false)
+			}
 		})
 	}
 }
@@ -228,6 +236,7 @@ func TestNamespaceUser_Update(t *testing.T) {
 	type fields struct {
 		ID          int64
 		Username    string
+		UserID      int64
 		NamespaceID int64
 		Right       Right
 		Created     time.Time
@@ -246,6 +255,7 @@ func TestNamespaceUser_Update(t *testing.T) {
 			fields: fields{
 				NamespaceID: 3,
 				Username:    "user1",
+				UserID:      1,
 				Right:       RightAdmin,
 			},
 		},
@@ -254,6 +264,7 @@ func TestNamespaceUser_Update(t *testing.T) {
 			fields: fields{
 				NamespaceID: 3,
 				Username:    "user1",
+				UserID:      1,
 				Right:       RightWrite,
 			},
 		},
@@ -262,6 +273,7 @@ func TestNamespaceUser_Update(t *testing.T) {
 			fields: fields{
 				NamespaceID: 3,
 				Username:    "user1",
+				UserID:      1,
 				Right:       RightRead,
 			},
 		},
@@ -297,6 +309,13 @@ func TestNamespaceUser_Update(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("NamespaceUser.Update() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertExists(t, "users_namespace", map[string]interface{}{
+					"user_id":      tt.fields.UserID,
+					"namespace_id": tt.fields.NamespaceID,
+					"right":        tt.fields.Right,
+				}, false)
+			}
 		})
 	}
 }
@@ -305,6 +324,7 @@ func TestNamespaceUser_Delete(t *testing.T) {
 	type fields struct {
 		ID          int64
 		Username    string
+		UserID      int64
 		NamespaceID int64
 		Right       Right
 		Created     time.Time
@@ -340,6 +360,7 @@ func TestNamespaceUser_Delete(t *testing.T) {
 			name: "Try deleting normally",
 			fields: fields{
 				Username:    "user1",
+				UserID:      1,
 				NamespaceID: 3,
 			},
 		},
@@ -365,6 +386,12 @@ func TestNamespaceUser_Delete(t *testing.T) {
 			if (err != nil) && tt.wantErr && !tt.errType(err) {
 				t.Errorf("NamespaceUser.Delete() Wrong error type! Error = %v, want = %v", err, runtime.FuncForPC(reflect.ValueOf(tt.errType).Pointer()).Name())
 			}
+			if !tt.wantErr {
+				db.AssertMissing(t, "users_namespace", map[string]interface{}{
+					"user_id":      tt.fields.UserID,
+					"namespace_id": tt.fields.NamespaceID,
+				})
+			}
 		})
 	}
 }

pkg/models/saved_filters_test.go

@@ -65,7 +65,7 @@ func TestSavedFilter_Create(t *testing.T) {
 		vals["filters::jsonb"] = vals["filters"].(string) + "::jsonb"
 		delete(vals, "filters")
 	}
-	db.AssertDBExists(t, "saved_filters", vals, true)
+	db.AssertExists(t, "saved_filters", vals, true)
 }
 
 func TestSavedFilter_ReadOne(t *testing.T) {
@@ -92,7 +92,7 @@ func TestSavedFilter_Update(t *testing.T) {
 	}
 	err := sf.Update()
 	assert.NoError(t, err)
-	db.AssertDBExists(t, "saved_filters", map[string]interface{}{
+	db.AssertExists(t, "saved_filters", map[string]interface{}{
 		"id":          1,
 		"title":       "NewTitle",
 		"description": "",
@@ -106,7 +106,7 @@ func TestSavedFilter_Delete(t *testing.T) {
 	}
 	err := sf.Delete()
 	assert.NoError(t, err)
-	db.AssertDBMissing(t, "saved_filters", map[string]interface{}{
+	db.AssertMissing(t, "saved_filters", map[string]interface{}{
 		"id": 1,
 	})
 }

pkg/models/task_comments_test.go

@@ -35,6 +35,12 @@ func TestTaskComment_Create(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, "test", tc.Comment)
 		assert.Equal(t, int64(1), tc.Author.ID)
+		db.AssertExists(t, "task_comments", map[string]interface{}{
+			"id":        tc.ID,
+			"author_id": u.ID,
+			"comment":   "test",
+			"task_id":   1,
+		}, false)
 	})
 	t.Run("nonexisting task", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -54,6 +60,9 @@ func TestTaskComment_Delete(t *testing.T) {
 		tc := &TaskComment{ID: 1}
 		err := tc.Delete()
 		assert.NoError(t, err)
+		db.AssertMissing(t, "task_comments", map[string]interface{}{
+			"id": 1,
+		})
 	})
 	t.Run("nonexisting comment", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -73,6 +82,10 @@ func TestTaskComment_Update(t *testing.T) {
 		}
 		err := tc.Update()
 		assert.NoError(t, err)
+		db.AssertExists(t, "task_comments", map[string]interface{}{
+			"id":      1,
+			"comment": "testing",
+		}, false)
 	})
 	t.Run("nonexisting comment", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)

pkg/models/task_relation_test.go

@@ -35,6 +35,12 @@ func TestTaskRelation_Create(t *testing.T) {
 		}
 		err := rel.Create(&user.User{ID: 1})
 		assert.NoError(t, err)
+		db.AssertExists(t, "task_relations", map[string]interface{}{
+			"task_id":       1,
+			"other_task_id": 2,
+			"relation_kind": RelationKindSubtask,
+			"created_by_id": 1,
+		}, false)
 	})
 	t.Run("Two Tasks In Different Lists", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -46,6 +52,12 @@ func TestTaskRelation_Create(t *testing.T) {
 		}
 		err := rel.Create(&user.User{ID: 1})
 		assert.NoError(t, err)
+		db.AssertExists(t, "task_relations", map[string]interface{}{
+			"task_id":       1,
+			"other_task_id": 13,
+			"relation_kind": RelationKindSubtask,
+			"created_by_id": 1,
+		}, false)
 	})
 	t.Run("Already Existing", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -83,6 +95,11 @@ func TestTaskRelation_Delete(t *testing.T) {
 		}
 		err := rel.Delete()
 		assert.NoError(t, err)
+		db.AssertMissing(t, "task_relations", map[string]interface{}{
+			"task_id":       1,
+			"other_task_id": 29,
+			"relation_kind": RelationKindSubtask,
+		})
 	})
 	t.Run("Not existing", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)

pkg/models/tasks_test.go

@@ -49,6 +49,14 @@ func TestTask_Create(t *testing.T) {
 		assert.Equal(t, int64(18), task.Index)
 		// Assert moving it into the default bucket
 		assert.Equal(t, int64(1), task.BucketID)
+		db.AssertExists(t, "tasks", map[string]interface{}{
+			"id":            task.ID,
+			"title":         "Lorem",
+			"description":   "Lorem Ipsum Dolor",
+			"list_id":       1,
+			"created_by_id": 1,
+			"bucket_id":     1,
+		}, false)
 
 	})
 	t.Run("empty title", func(t *testing.T) {
@@ -110,6 +118,12 @@ func TestTask_Update(t *testing.T) {
 		}
 		err := task.Update()
 		assert.NoError(t, err)
+		db.AssertExists(t, "tasks", map[string]interface{}{
+			"id":          1,
+			"title":       "test10000",
+			"description": "Lorem Ipsum Dolor",
+			"list_id":     1,
+		}, false)
 	})
 	t.Run("nonexistant task", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -159,6 +173,9 @@ func TestTask_Delete(t *testing.T) {
 		}
 		err := task.Delete()
 		assert.NoError(t, err)
+		db.AssertMissing(t, "tasks", map[string]interface{}{
+			"id": 1,
+		})
 	})
 }
 

pkg/models/team_members_test.go

@@ -37,6 +37,11 @@ func TestTeamMember_Create(t *testing.T) {
 		}
 		err := tm.Create(doer)
 		assert.NoError(t, err)
+		db.AssertExists(t, "team_members", map[string]interface{}{
+			"id":      tm.ID,
+			"team_id": 1,
+			"user_id": 3,
+		}, false)
 	})
 	t.Run("already existing", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -79,6 +84,10 @@ func TestTeamMember_Delete(t *testing.T) {
 		}
 		err := tm.Delete()
 		assert.NoError(t, err)
+		db.AssertMissing(t, "team_members", map[string]interface{}{
+			"team_id": 1,
+			"user_id": 1,
+		})
 	})
 }
 
@@ -92,7 +101,12 @@ func TestTeamMember_Update(t *testing.T) {
 		}
 		err := tm.Update()
 		assert.NoError(t, err)
-		assert.False(t, tm.Admin)
+		assert.False(t, tm.Admin) // Since this endpoint toggles the right, we should get a false for admin back.
+		db.AssertExists(t, "team_members", map[string]interface{}{
+			"team_id": 1,
+			"user_id": 1,
+			"admin":   false,
+		}, false)
 	})
 	// This should have the same result as the normal run as the update function
 	// should ignore what was passed.
@@ -106,5 +120,10 @@ func TestTeamMember_Update(t *testing.T) {
 		err := tm.Update()
 		assert.NoError(t, err)
 		assert.False(t, tm.Admin)
+		db.AssertExists(t, "team_members", map[string]interface{}{
+			"team_id": 1,
+			"user_id": 1,
+			"admin":   false,
+		}, false)
 	})
 }

pkg/models/teams_test.go

@@ -37,6 +37,11 @@ func TestTeam_Create(t *testing.T) {
 		}
 		err := team.Create(doer)
 		assert.NoError(t, err)
+		db.AssertExists(t, "teams", map[string]interface{}{
+			"id":          team.ID,
+			"name":        "Testteam293",
+			"description": "Lorem Ispum",
+		}, false)
 	})
 	t.Run("empty name", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -95,6 +100,10 @@ func TestTeam_Update(t *testing.T) {
 		}
 		err := team.Update()
 		assert.NoError(t, err)
+		db.AssertExists(t, "teams", map[string]interface{}{
+			"id":   team.ID,
+			"name": "SomethingNew",
+		}, false)
 	})
 	t.Run("empty name", func(t *testing.T) {
 		db.LoadAndAssertFixtures(t)
@@ -126,6 +135,9 @@ func TestTeam_Delete(t *testing.T) {
 		}
 		err := team.Delete()
 		assert.NoError(t, err)
+		db.AssertMissing(t, "teams", map[string]interface{}{
+			"id": 1,
+		})
 	})
 }