88 lines
2.7 KiB
Go
88 lines
2.7 KiB
Go
package moderation
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"telesrv/internal/domain"
|
|
"telesrv/internal/store"
|
|
"telesrv/internal/store/memory"
|
|
)
|
|
|
|
type legacyEphemeralReader struct {
|
|
rows []store.LegacyEphemeralReport
|
|
}
|
|
|
|
func (r *legacyEphemeralReader) ListUnmigratedEphemeralReports(_ context.Context, limit int) ([]store.LegacyEphemeralReport, error) {
|
|
if len(r.rows) == 0 {
|
|
return nil, nil
|
|
}
|
|
if limit > len(r.rows) {
|
|
limit = len(r.rows)
|
|
}
|
|
out := append([]store.LegacyEphemeralReport(nil), r.rows[:limit]...)
|
|
r.rows = r.rows[limit:]
|
|
return out, nil
|
|
}
|
|
|
|
type legacyModerationImporter struct {
|
|
*memory.ModerationReportStore
|
|
mappings map[int64]int64
|
|
}
|
|
|
|
func (s *legacyModerationImporter) ImportLegacyEphemeralReport(ctx context.Context, legacyID int64, report domain.ModerationReport) (domain.ModerationReport, bool, error) {
|
|
if reportID, ok := s.mappings[legacyID]; ok {
|
|
existing, _, err := s.GetModerationReport(ctx, reportID)
|
|
return existing, false, err
|
|
}
|
|
stored, created, err := s.CreateModerationReport(ctx, report)
|
|
if err == nil {
|
|
s.mappings[legacyID] = stored.ID
|
|
}
|
|
return stored, created, err
|
|
}
|
|
|
|
func TestMigrateLegacyEphemeralReportsPreservesEvidenceAndMediaHolds(t *testing.T) {
|
|
now := time.Now().UTC()
|
|
reporter := int64(101)
|
|
message := domain.EphemeralMessage{
|
|
ID: 44, Peer: domain.Peer{Type: domain.PeerTypeChannel, ID: 303},
|
|
SenderUserID: 202, ReceiverUserID: reporter, Date: int(now.Unix()),
|
|
Content: domain.EphemeralContent{
|
|
Message: "evidence",
|
|
Media: &domain.MessageMedia{
|
|
Kind: domain.MessageMediaKindDocument,
|
|
Document: &domain.Document{
|
|
ID: 909, AccessHash: 1, MimeType: "text/plain", Size: 8,
|
|
},
|
|
},
|
|
},
|
|
Version: 1, CreatedAt: now, ExpiresAt: now.Add(time.Hour),
|
|
}
|
|
legacy := domain.NewEphemeralAbuseReport(reporter, "spam", "review", message, now)
|
|
source := &legacyEphemeralReader{rows: []store.LegacyEphemeralReport{{ID: 7, Report: legacy}}}
|
|
target := &legacyModerationImporter{
|
|
ModerationReportStore: memory.NewModerationReportStore(),
|
|
mappings: make(map[int64]int64),
|
|
}
|
|
service := NewService(target)
|
|
count, err := service.MigrateLegacyEphemeralReports(context.Background(), source, 10)
|
|
if err != nil || count != 1 {
|
|
t.Fatalf("migrate count=%d err=%v", count, err)
|
|
}
|
|
reports := target.Reports()
|
|
if len(reports) != 1 {
|
|
t.Fatalf("reports=%d, want 1", len(reports))
|
|
}
|
|
got := reports[0]
|
|
if got.Source != domain.ModerationSourceEphemeral ||
|
|
got.Target != message.Peer || len(got.Items) != 1 ||
|
|
got.Items[0].AuthorUserID != message.SenderUserID {
|
|
t.Fatalf("migrated report=%+v", got)
|
|
}
|
|
if len(got.MediaHolds) != 1 ||
|
|
got.MediaHolds[0].StorageKey != "doc:909" {
|
|
t.Fatalf("media holds=%+v", got.MediaHolds)
|
|
}
|
|
}
|