Delete all data from user on delete

Author: jmattheis

dashboard/dashboard_test.go

@@ -83,3 +83,22 @@ func TestDashboard(t *testing.T) {
 	require.NoError(t, err)
 	require.Empty(t, dashboards)
 }
+
+func TestDeleteDashboard(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+
+	dbOne := db.User(1).Dashboard("test")
+	dbOne.Range("r")
+	dbOne.Entry("e")
+	dbTwo := db.User(2).Dashboard("test")
+	dbTwo.Range("r")
+	dbTwo.Entry("e")
+
+	resolver := NewResolverForDashboard(db.DB)
+	_, err := resolver.RemoveDashboard(fake.User(dbOne.User.ID), dbOne.Dashboard.ID)
+	require.NoError(t, err)
+
+	dbOne.AssertExists(false).AssertHasEntry("e", false).AssertHasRange("r", false)
+	dbTwo.AssertExists(true).AssertHasEntry("e", true).AssertHasRange("r", true)
+}

database/database.go

@@ -36,6 +36,7 @@ func New(dialect, connection string) (*gorm.DB, error) {
 		// concurrent writes, so we limit sqlite to one connection.
 		// see https://github.com/mattn/go-sqlite3/issues/274
 		db.DB().SetMaxOpenConns(1)
+		db.Exec("PRAGMA foreign_keys = ON")
 	}
 
 	log.Debug().Msg("Auto migrating schema's")

model/dashboard.go

@@ -9,7 +9,7 @@ import (
 type DashboardRange struct {
 	ID          int `gorm:"primary_key;unique_index;AUTO_INCREMENT"`
 	Name        string
-	DashboardID int
+	DashboardID int `gorm:"type:int REFERENCES dashboards(id) ON DELETE CASCADE"`
 	Editable    bool
 	From        string
 	To          string
@@ -18,7 +18,7 @@ type DashboardRange struct {
 // Dashboard a dashboard
 type Dashboard struct {
 	ID      int `gorm:"primary_key;unique_index;AUTO_INCREMENT"`
-	UserID  int
+	UserID  int `gorm:"type:int REFERENCES users(id) ON DELETE CASCADE"`
 	Name    string
 	Entries []DashboardEntry
 	Ranges  []DashboardRange
@@ -27,7 +27,7 @@ type Dashboard struct {
 // DashboardEntry an entry which represents a diagram in a dashboard.
 type DashboardEntry struct {
 	ID          int `gorm:"primary_key;unique_index;AUTO_INCREMENT"`
-	DashboardID int
+	DashboardID int `gorm:"type:int REFERENCES dashboards(id) ON DELETE CASCADE"`
 	Title       string
 	Type        DashboardType
 	Keys        string

model/device.go

@@ -12,7 +12,7 @@ type Device struct {
 	ID        int    `gorm:"primary_key;unique_index;AUTO_INCREMENT"`
 	Token     string `gorm:"unique"`
 	Name      string
-	UserID    int
+	UserID    int `gorm:"type:int REFERENCES users(id) ON DELETE CASCADE"`
 	CreatedAt time.Time
 	Type      DeviceType
 	ActiveAt  time.Time

model/tagdefinition.go

@@ -3,7 +3,7 @@ package model
 // TagDefinition describes a tag.
 type TagDefinition struct {
 	Key    string
-	UserID int
+	UserID int `gorm:"type:int REFERENCES users(id) ON DELETE CASCADE"`
 	Color  string
 	Type   TagDefinitionType
 }

model/timespan.go

@@ -10,13 +10,13 @@ type TimeSpan struct {
 	StartUserTime time.Time
 	EndUserTime   *time.Time
 	OffsetUTC     int
-	UserID        int
+	UserID        int `gorm:"type:int REFERENCES users(id) ON DELETE CASCADE"`
 	Tags          []TimeSpanTag
 }
 
 // TimeSpanTag is a tag for a time range
 type TimeSpanTag struct {
-	TimeSpanID  int
+	TimeSpanID  int `gorm:"type:int REFERENCES time_spans(id) ON DELETE CASCADE"`
 	Key         string
 	StringValue *string
 }

test/db.go

@@ -75,6 +75,16 @@ func (d *UserWithDatabase) AssertHasTagDefinition(key string, exist bool) *UserW
 	return d
 }
 
+// AssertHasDevice asserts if a device exists.
+func (d *UserWithDatabase) AssertHasDevice(name string, exist bool) *UserWithDatabase {
+	existActual := !d.DB.
+		Where(&model.Device{Name: name, UserID: d.User.ID}).
+		Find(new(model.Device)).
+		RecordNotFound()
+	assert.True(d.t, exist == existActual)
+	return d
+}
+
 // NewUser creates a user
 func (d *Database) NewUser(id int, name string, admin bool) model.User {
 	return d.NewUserPass(id, name, []byte{1, 2, 3}, admin)
@@ -92,6 +102,16 @@ func (d *Database) NewUserPass(id int, name string, pass []byte, admin bool) mod
 	return user
 }
 
+// AssertExists asserts if the tag exists or not.
+func (d *UserWithDatabase) AssertExists(exist bool) *UserWithDatabase {
+	existActual := !d.DB.
+		Where(&model.User{ID: d.User.ID}).
+		Find(new(model.User)).
+		RecordNotFound()
+	assert.True(d.t, exist == existActual)
+	return d
+}
+
 // RunningTimeSpan adds a time span without end.
 func (d *UserWithDatabase) RunningTimeSpan(from string) *TimeSpanWithDatabase {
 	timeSpan := model.TimeSpan{
@@ -110,6 +130,77 @@ func (d *UserWithDatabase) RunningTimeSpan(from string) *TimeSpanWithDatabase {
 	}
 }
 
+// RunningTimeSpan adds a time span without end.
+func (d *UserWithDatabase) Dashboard(name string) *DashboardWithDatabase {
+	dashboard := model.Dashboard{
+		UserID: d.User.ID,
+		Name:   name,
+	}
+
+	d.DB.Create(&dashboard)
+
+	return &DashboardWithDatabase{
+		User:      d.User,
+		Dashboard: dashboard,
+		DB:        d.DB,
+		t:         d.t,
+	}
+}
+
+// Range adds a range to the dashboard.
+func (d *DashboardWithDatabase) Range(name string) *DashboardWithDatabase {
+	dbRange := model.DashboardRange{
+		DashboardID: d.Dashboard.ID,
+		Name:        name,
+		From:        "now-1d",
+		To:          "now",
+	}
+	d.Dashboard.Ranges = append(d.Dashboard.Ranges, dbRange)
+	d.DB.Save(&dbRange)
+	return d
+}
+
+// Entry adds an entry to the dashboard.
+func (d *DashboardWithDatabase) Entry(name string) *DashboardWithDatabase {
+	entry := model.DashboardEntry{
+		DashboardID: d.Dashboard.ID,
+		Title:       name,
+	}
+	d.Dashboard.Entries = append(d.Dashboard.Entries, entry)
+	d.DB.Save(&entry)
+	return d
+}
+
+// AssertExists asserts if the dashboard exists or not.
+func (d *DashboardWithDatabase) AssertExists(exist bool) *DashboardWithDatabase {
+	existActual := !d.DB.
+		Where(&model.Dashboard{ID: d.Dashboard.ID}).
+		Find(new(model.Dashboard)).
+		RecordNotFound()
+	assert.True(d.t, exist == existActual)
+	return d
+}
+
+// AssertHasEntry asserts if the entry exists or not.
+func (d *DashboardWithDatabase) AssertHasEntry(name string, exist bool) *DashboardWithDatabase {
+	existActual := !d.DB.
+		Where(&model.DashboardEntry{DashboardID: d.Dashboard.ID, Title: name}).
+		Find(new(model.DashboardEntry)).
+		RecordNotFound()
+	assert.True(d.t, exist == existActual)
+	return d
+}
+
+// AssertHasRange asserts if the range exists or not.
+func (d *DashboardWithDatabase) AssertHasRange(name string, exist bool) *DashboardWithDatabase {
+	existActual := !d.DB.
+		Where(&model.DashboardRange{DashboardID: d.Dashboard.ID, Name: name}).
+		Find(new(model.DashboardRange)).
+		RecordNotFound()
+	assert.True(d.t, exist == existActual)
+	return d
+}
+
 // TimeSpan adds a time span.
 func (d *UserWithDatabase) TimeSpan(from string, to string) *TimeSpanWithDatabase {
 	wrapper := d.RunningTimeSpan(from)
@@ -160,3 +251,11 @@ func (d *TimeSpanWithDatabase) Tag(key string, stringValue string) *TimeSpanWith
 	d.DB.Save(tag)
 	return d
 }
+
+// DashboardWithDatabase wraps gorm.DB and provides helper methods
+type DashboardWithDatabase struct {
+	User      model.User
+	Dashboard model.Dashboard
+	t         assert.TestingT
+	*gorm.DB
+}

test/db_test.go

@@ -18,7 +18,9 @@ func TestDatabase(t *testing.T) {
 	db := test.InMemoryDB(t)
 	defer db.Close()
 	user := db.User(1)
+	user.AssertHasDevice("test device", false)
 	user.NewDevice(1, "lol", "test device")
+	user.AssertHasDevice("test device", true)
 	ts := user.TimeSpan("2009-06-30T18:30:00Z", "2009-06-30T18:40:00Z")
 
 	ts.AssertHasTag("abc", "def", false)
@@ -77,4 +79,21 @@ func TestDatabase(t *testing.T) {
 	user.NewTagDefinition("oops")
 	user.AssertHasTagDefinition("oops", true)
 
+	user.AssertExists(true)
+	db.Delete(new(model.User), "id = ?", user.User.ID)
+	user.AssertExists(false)
+
+	dash := user.Dashboard("hello")
+
+	dash.AssertHasRange("hello", false)
+	dash.Range("hello")
+	dash.AssertHasRange("hello", true)
+
+	dash.AssertHasEntry("abc", false)
+	dash.Entry("abc")
+	dash.AssertHasEntry("abc", true)
+
+	dash.AssertExists(true)
+	db.Delete(new(model.Dashboard), "id = ?", dash.Dashboard.ID)
+	dash.AssertExists(false)
 }

timespan/remove.go

@@ -16,19 +16,7 @@ func (r *ResolverForTimeSpan) RemoveTimeSpan(ctx context.Context, id int) (*gqlm
 		return nil, fmt.Errorf("timespan with id %d does not exist", timeSpan.ID)
 	}
 
-	tx := r.DB.Begin()
-
-	if err := tx.Delete(&timeSpan).Error; err != nil {
-		tx.Rollback()
-		return nil, err
-	}
-
-	if err := tx.Where(&model.TimeSpanTag{TimeSpanID: timeSpan.ID}).Delete(new(model.TimeSpanTag)).Error; err != nil {
-		tx.Rollback()
-		return nil, err
-	}
-
-	remove := tx.Commit()
+	remove := r.DB.Where(&model.TimeSpan{ID: id}).Delete(new(model.TimeSpan))
 
 	external := timeSpanToExternal(timeSpan)
 	return external, remove.Error

user/remove_test.go

@@ -20,6 +20,78 @@ func TestGQL_RemoveUser_succeeds_removesUser(t *testing.T) {
 	assertUserCount(t, db, 0)
 }
 
+func TestGQL_RemoveUser_succeeds_removesDevices(t *testing.T) {
+	test.LogDebug()
+	db := test.InMemoryDB(t)
+	defer db.Close()
+	user := db.User(1)
+	user.NewDevice(2, "abc", "devicename")
+	other := db.User(2)
+	other.NewDevice(5, "abcx", "devicename")
+
+	resolver := ResolverForUser{DB: db.DB, PassStrength: 4}
+	_, err := resolver.RemoveUser(context.Background(), 1)
+
+	require.Nil(t, err)
+	user.AssertHasDevice("devicename", false).AssertExists(false)
+	other.AssertExists(true).AssertHasDevice("devicename", true)
+}
+
+func TestGQL_RemoveUser_succeeds_removesTags(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+	user := db.User(1)
+	user.NewTagDefinition("oops")
+	other := db.User(2)
+	other.NewTagDefinition("oops")
+
+	resolver := ResolverForUser{DB: db.DB, PassStrength: 4}
+	_, err := resolver.RemoveUser(context.Background(), 1)
+
+	require.Nil(t, err)
+	user.AssertExists(false).AssertHasTagDefinition("oops", false)
+	other.AssertExists(true).AssertHasTagDefinition("oops", true)
+}
+
+func TestGQL_RemoveUser_succeeds_removesTimeSpans(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+	user := db.User(1)
+	other := db.User(2)
+	ts := user.TimeSpan("2019-06-11T18:00:00Z", "2019-06-11T18:00:00Z")
+	ts.Tag("hello", "world")
+	otherTs := other.TimeSpan("2019-06-11T18:00:00Z", "2019-06-11T18:00:00Z")
+	otherTs.Tag("hello", "world")
+
+	resolver := ResolverForUser{DB: db.DB, PassStrength: 4}
+	_, err := resolver.RemoveUser(context.Background(), 1)
+
+	require.Nil(t, err)
+	ts.AssertExists(false).AssertHasTag("hello", "world", false)
+	otherTs.AssertExists(true).AssertHasTag("hello", "world", true)
+}
+
+func TestGQL_RemoveUser_succeeds_removesDashboard(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+	user := db.User(1)
+	other := db.User(2)
+	userDB := user.Dashboard("cool")
+	userDB.Range("cool range")
+	userDB.Entry("cool entry")
+
+	otherDB := other.Dashboard("cool")
+	otherDB.Range("cool range")
+	otherDB.Entry("cool entry")
+
+	resolver := ResolverForUser{DB: db.DB, PassStrength: 4}
+	_, err := resolver.RemoveUser(context.Background(), 1)
+
+	require.Nil(t, err)
+	userDB.AssertExists(false).AssertHasRange("cool range", false).AssertHasEntry("cool entry", false)
+	otherDB.AssertExists(true).AssertHasRange("cool range", true).AssertHasEntry("cool entry", true)
+}
+
 func TestGQL_RemoveUser_fails_notExistingUser(t *testing.T) {
 	db := test.InMemoryDB(t)
 	defer db.Close()