feat:#6 added tests with db for unused feed delete

backend/model/feedModel.go

@@ -2,12 +2,12 @@ package model
 
 import (
 	"github.com/pocketbase/pocketbase/models"
-	"time"
+	"github.com/pocketbase/pocketbase/tools/types"
 )
 
 type Feed struct {
-	Modules   string    `db:"modules" json:"modules"`
+	Modules   string         `db:"modules" json:"modules"`
-	Retrieved time.Time `db:"retrieved" json:"retrieved"`
+	Retrieved types.DateTime `db:"retrieved" json:"retrieved"`
 	models.BaseModel
 }
 

backend/service/addSchedule.go

@@ -4,10 +4,9 @@ import (
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/cron"
-	"htwkalender/service/db"
+	"htwkalender/service/course"
-	"htwkalender/service/events"
+	"htwkalender/service/feed"
-	"log"
+	"htwkalender/service/functions/time"
-	"time"
 )
 
 func AddSchedules(app *pocketbase.PocketBase) {
@@ -19,37 +18,13 @@ func AddSchedules(app *pocketbase.PocketBase) {
 		// Every three hours update all courses (5 segments - minute, hour, day, month, weekday) "0 */3 * * *"
 		// Every 10 minutes update all courses (5 segments - minute, hour, day, month, weekday) "*/10 * * * *"
 		scheduler.MustAdd("updateCourse", "0 */3 * * *", func() {
-			courses := events.GetAllCourses(app)
+			course.UpdateCourse(app)
-			for _, course := range courses {
-				err := events.UpdateModulesForCourse(app, course)
-				if err != nil {
-					log.Println("Update Course: " + course + " failed")
-					log.Println(err)
-				} else {
-					log.Println("Update Course: " + course + " successful")
-				}
-			}
 		})
 
 		// Every sunday at 3am clean all courses (5 segments - minute, hour, day, month, weekday) "0 3 * * 0"
 		scheduler.MustAdd("cleanFeeds", "0 3 * * 0", func() {
-			feeds, err := db.GetAllFeeds(app)
+			// clean feeds older than 6 months
-			if err != nil {
+			feed.ClearFeeds(app.Dao(), 6, time.RealClock{})
-				log.Println("CleanFeeds: get all feeds failed")
-				return
-			}
-			for _, feed := range feeds {
-				// if retrieved time is older than a half year delete feed
-				if feed.GetTime("retrieved").Before(time.Now().AddDate(0, -6, 0)) {
-					err = app.Dao().DeleteRecord(feed)
-					if err != nil {
-						log.Println("CleanFeeds: delete feed " + feed.GetId() + " failed")
-						log.Println(err)
-					} else {
-						log.Println("CleanFeeds: delete feed " + feed.GetId() + " successful")
-					}
-				}
-			}
 		})
 		scheduler.Start()
 		return nil

backend/service/course/courseFunctions.go

@@ -0,0 +1,20 @@
+package course
+
+import (
+	"github.com/pocketbase/pocketbase"
+	"htwkalender/service/events"
+	"log"
+)
+
+func UpdateCourse(app *pocketbase.PocketBase) {
+	courses := events.GetAllCourses(app)
+	for _, course := range courses {
+		err := events.UpdateModulesForCourse(app, course)
+		if err != nil {
+			log.Println("Update Course: " + course + " failed")
+			log.Println(err)
+		} else {
+			log.Println("Update Course: " + course + " successful")
+		}
+	}
+}

backend/service/db/dbFeeds.go

@@ -2,6 +2,7 @@ package db
 
 import (
 	"github.com/pocketbase/pocketbase"
+	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/models"
 	"htwkalender/model"
 	"time"
@@ -28,7 +29,7 @@ func FindFeedByToken(token string, app *pocketbase.PocketBase) (*model.Feed, err
 
 	var feed model.Feed
 	feed.Modules = record.GetString("modules")
-	feed.Retrieved = record.GetTime("retrieved")
+	feed.Retrieved = record.GetDateTime("retrieved")
 
 	//update retrieved time
 	record.Set("retrieved", time.Now())
@@ -38,8 +39,9 @@ func FindFeedByToken(token string, app *pocketbase.PocketBase) (*model.Feed, err
 	return &feed, err
 }
 
-func GetAllFeeds(app *pocketbase.PocketBase) ([]*models.Record, error) {
+func GetAllFeeds(db *daos.Dao) ([]model.Feed, error) {
-	feeds, err := app.Dao().FindRecordsByFilter("feeds", "", "", 0, 0)
+	var feeds []model.Feed
+	err := db.DB().Select("*").From("feeds").All(&feeds)
 	if err != nil {
 		return nil, err
 	}

backend/service/feed/feedFunctions.go

@@ -0,0 +1,35 @@
+package feed
+
+import (
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/daos"
+	database "htwkalender/service/db"
+	localTime "htwkalender/service/functions/time"
+	"log"
+)
+
+func ClearFeeds(db *daos.Dao, months int, clock localTime.Clock) {
+	feeds, err := database.GetAllFeeds(db)
+	if err != nil {
+		log.Println("CleanFeeds: get all feeds failed")
+		return
+	}
+	for _, feed := range feeds {
+		// if retrieved time is older than a half year delete feed
+		now := clock.Now()
+		feedRetrievedTime := feed.Retrieved.Time()
+		timeShift := now.AddDate(0, -months, 0)
+
+		if feedRetrievedTime.Before(timeShift) {
+			// delete feed
+			sqlResult, err := db.DB().Delete("feeds", dbx.NewExp("id = {:id}", dbx.Params{"id": feed.GetId()})).Execute()
+			if err != nil {
+				log.Println("CleanFeeds: delete feed " + feed.GetId() + " failed")
+				log.Println(err)
+				log.Println(sqlResult)
+			} else {
+				log.Println("CleanFeeds: delete feed " + feed.GetId() + " successful")
+			}
+		}
+	}
+}

backend/service/feed/feedFunctions_test.go

@@ -0,0 +1,83 @@
+package feed
+
+import (
+	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/tests"
+	"htwkalender/model"
+	mockTime "htwkalender/service/functions/time"
+	"testing"
+	"time"
+)
+
+const testDataDir = "./mockData"
+
+func TestClearFeeds(t *testing.T) {
+
+	setupTestApp := func(t *testing.T) *daos.Dao {
+		testApp, err := tests.NewTestApp(testDataDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dao := daos.New(testApp.Dao().DB())
+		return dao
+	}
+
+	type args struct {
+		db        *daos.Dao
+		months    int
+		mockClock mockTime.MockClock
+	}
+	testCases := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "TestClearFeeds",
+			args: args{
+				db:     setupTestApp(t),
+				months: 6,
+				mockClock: mockTime.MockClock{
+					NowTime: time.Date(2023, 12, 1, 0, 0, 0, 0, time.UTC),
+				},
+			},
+			want: 1,
+		},
+		{
+			name: "TestClearAllFeeds",
+			args: args{
+				db:     setupTestApp(t),
+				months: 1,
+				mockClock: mockTime.MockClock{
+					NowTime: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC),
+				},
+			},
+			want: 0,
+		},
+		{
+			name: "TestClearFeedsClearBeforeRetrievedTime",
+			args: args{
+				db:     setupTestApp(t),
+				months: 1,
+				mockClock: mockTime.MockClock{
+					NowTime: time.Date(2010, 1, 1, 0, 0, 0, 0, time.UTC),
+				},
+			},
+			want: 3,
+		},
+	}
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			ClearFeeds(tt.args.db, tt.args.months, tt.args.mockClock)
+			// count all feeds in db
+			var feeds []*model.Feed
+			err := tt.args.db.DB().Select("id").From("feeds").All(&feeds)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := len(feeds); got != tt.want {
+				t.Errorf("ClearFeeds() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

backend/service/functions/time/mockClock.go

@@ -0,0 +1,10 @@
+package time
+
+import "time"
+
+type MockClock struct {
+	NowTime time.Time
+}
+
+func (m MockClock) Now() time.Time                       { return m.NowTime }
+func (MockClock) After(d time.Duration) <-chan time.Time { return time.After(d) }

backend/service/functions/time/realClock.go

@@ -0,0 +1,8 @@
+package time
+
+import "time"
+
+type RealClock struct{}
+
+func (RealClock) Now() time.Time                         { return time.Now() }
+func (RealClock) After(d time.Duration) <-chan time.Time { return time.After(d) }

backend/service/functions/time/time.go

@@ -0,0 +1,8 @@
+package time
+
+import "time"
+
+type Clock interface {
+	Now() time.Time
+	After(d time.Duration) <-chan time.Time
+}