database: changed Notification interface name

database/database.go

@@ -167,9 +167,9 @@ type Session interface {
 	// always considered first page.
 	FindVulnerabilityNotification(name string, limit int, oldVulnerabilityPage pagination.Token, newVulnerabilityPage pagination.Token) (noti VulnerabilityNotificationWithVulnerable, found bool, err error)
 
-	// MarkNotificationNotified marks a Notification as notified now, assuming
+	// MarkNotificationAsRead marks a Notification as notified now, assuming
 	// the requested notification is in the database.
-	MarkNotificationNotified(name string) error
+	MarkNotificationAsRead(name string) error
 
 	// DeleteNotification removes a Notification in the database.
 	DeleteNotification(name string) error

database/mock.go

@@ -43,7 +43,7 @@ type MockSession struct {
 	FctFindNewNotification              func(lastNotified time.Time) (NotificationHook, bool, error)
 	FctFindVulnerabilityNotification    func(name string, limit int, oldPage pagination.Token, newPage pagination.Token) (
 		vuln VulnerabilityNotificationWithVulnerable, ok bool, err error)
-	FctMarkNotificationNotified func(name string) error
+	FctMarkNotificationAsRead func(name string) error
 	FctDeleteNotification     func(name string) error
 	FctUpdateKeyValue         func(key, value string) error
 	FctFindKeyValue           func(key string) (string, bool, error)
@@ -186,9 +186,9 @@ func (ms *MockSession) FindVulnerabilityNotification(name string, limit int, old
 	panic("required mock function not implemented")
 }
 
-func (ms *MockSession) MarkNotificationNotified(name string) error {
-	if ms.FctMarkNotificationNotified != nil {
-		return ms.FctMarkNotificationNotified(name)
+func (ms *MockSession) MarkNotificationAsRead(name string) error {
+	if ms.FctMarkNotificationAsRead != nil {
+		return ms.FctMarkNotificationAsRead(name)
 	}
 	panic("required mock function not implemented")
 }

database/pgsql/notification.go

@@ -289,23 +289,23 @@ func (tx *pgSession) FindVulnerabilityNotification(name string, limit int, oldPa
 	return noti, true, nil
 }
 
-func (tx *pgSession) MarkNotificationNotified(name string) error {
+func (tx *pgSession) MarkNotificationAsRead(name string) error {
 	if name == "" {
 		return commonerr.NewBadRequestError("Empty notification name is not allowed")
 	}
 
-	r, err := tx.Exec(updatedNotificationNotified, name)
+	r, err := tx.Exec(updatedNotificationAsRead, name)
 	if err != nil {
-		return handleError("updatedNotificationNotified", err)
+		return handleError("updatedNotificationAsRead", err)
 	}
 
 	affected, err := r.RowsAffected()
 	if err != nil {
-		return handleError("updatedNotificationNotified", err)
+		return handleError("updatedNotificationAsRead", err)
 	}
 
 	if affected <= 0 {
-		return handleError("updatedNotificationNotified", errNotificationNotFound)
+		return handleError("updatedNotificationAsRead", errNotificationNotFound)
 	}
 	return nil
 }

database/pgsql/notification_test.go

@@ -200,7 +200,7 @@ func TestFindNewNotification(t *testing.T) {
 	}
 
 	// can't find the notified
-	assert.Nil(t, tx.MarkNotificationNotified("test"))
+	assert.Nil(t, tx.MarkNotificationAsRead("test"))
 	// if the notified time is before
 	noti, ok, err = tx.FindNewNotification(time.Now().Add(-time.Duration(10 * time.Second)))
 	assert.Nil(t, err)
@@ -225,16 +225,16 @@ func TestFindNewNotification(t *testing.T) {
 	assert.False(t, ok)
 }
 
-func TestMarkNotificationNotified(t *testing.T) {
-	datastore, tx := openSessionForTest(t, "MarkNotificationNotified", true)
+func TestMarkNotificationAsRead(t *testing.T) {
+	datastore, tx := openSessionForTest(t, "MarkNotificationAsRead", true)
 	defer closeTest(t, datastore, tx)
 
 	// invalid case: notification doesn't exist
-	assert.NotNil(t, tx.MarkNotificationNotified("non-existing"))
+	assert.NotNil(t, tx.MarkNotificationAsRead("non-existing"))
 	// valid case
-	assert.Nil(t, tx.MarkNotificationNotified("test"))
+	assert.Nil(t, tx.MarkNotificationAsRead("test"))
 	// valid case
-	assert.Nil(t, tx.MarkNotificationNotified("test"))
+	assert.Nil(t, tx.MarkNotificationAsRead("test"))
 }
 
 func TestDeleteNotification(t *testing.T) {

database/pgsql/queries.go

@@ -168,7 +168,7 @@ const (
 		INSERT INTO Vulnerability_Notification(name, created_at, old_vulnerability_id, new_vulnerability_id)
 		VALUES ($1, $2, $3, $4)`
 
-	updatedNotificationNotified = `
+	updatedNotificationAsRead = `
 		UPDATE Vulnerability_Notification
 		SET notified_at = CURRENT_TIMESTAMP
 		WHERE name = $1`

database/pgsql/vulnerability.go

@@ -16,7 +16,6 @@ package pgsql
 
 import (
 	"database/sql"
-	"encoding/json"
 	"errors"
 	"time"
 
@@ -220,17 +219,6 @@ func (tx *pgSession) insertVulnerabilities(vulnerabilities []database.Vulnerabil
 	return vulnIDs, nil
 }
 
-// castMetadata marshals the given database.MetadataMap and unmarshals it again to make sure that
-// everything has the interface{} type.
-// It is required when comparing crafted MetadataMap against MetadataMap that we get from the
-// database.
-func castMetadata(m database.MetadataMap) database.MetadataMap {
-	c := make(database.MetadataMap)
-	j, _ := json.Marshal(m)
-	json.Unmarshal(j, &c)
-	return c
-}
-
 func (tx *pgSession) lockFeatureVulnerabilityCache() error {
 	_, err := tx.Exec(lockVulnerabilityAffects)
 	if err != nil {

notifier.go

@@ -93,7 +93,7 @@ func RunNotifier(config *notification.Config, datastore database.Datastore, stop
 		go func() {
 			success, interrupted := handleTask(*notification, stopper, config.Attempts)
 			if success {
-				err := markNotificationNotified(datastore, notification.Name)
+				err := markNotificationAsRead(datastore, notification.Name)
 				if err != nil {
 					log.WithError(err).Error("Failed to mark notification notified")
 				}
@@ -196,14 +196,14 @@ func findNewNotification(datastore database.Datastore, renotifyInterval time.Dur
 	return tx.FindNewNotification(time.Now().Add(-renotifyInterval))
 }
 
-func markNotificationNotified(datastore database.Datastore, name string) error {
+func markNotificationAsRead(datastore database.Datastore, name string) error {
 	tx, err := datastore.Begin()
 	if err != nil {
 		log.WithError(err).Error("an error happens when beginning database transaction")
 	}
 	defer tx.Rollback()
 
-	if err := tx.MarkNotificationNotified(name); err != nil {
+	if err := tx.MarkNotificationAsRead(name); err != nil {
 		return err
 	}
 	return tx.Commit()