внутренняя модель перестроена вокруг аудиозаписи
- audiorecords вместо transcribe_jobs: приложения (texts, structures, recognitions, record_events, topics) живут своими коллекциями, ссылки на исходник и на приведённую копию перестали переставляться - рубеж называет достигнутое, отказ стал признаком остановки с причиной, а сторожей стало двое: число отказов и время в рубеже - воркеры потеряли специализацию, их число задаётся [pipeline] workers, шаг выбирается по рубежу, а захват отдаёт идентификатор и признак захвата
This commit is contained in:
+547
-210
@@ -8,6 +8,7 @@ import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
@@ -24,10 +25,22 @@ import (
|
||||
"git.vakhrushev.me/av/transcriber/internal/entity"
|
||||
)
|
||||
|
||||
// Проверки конвейера идут против настоящего хранилища: захват, число попыток и
|
||||
// переход в «мертва» держатся на запросе, и подставной репозиторий проверял бы
|
||||
// Проверки конвейера идут против настоящего хранилища: захват, число отказов и
|
||||
// остановка держатся на запросе, и подставной репозиторий проверял бы
|
||||
// собственную заглушку, а не то, что делает база.
|
||||
|
||||
// okConverter переливает исходник в результат — так это выглядит у настоящего
|
||||
// приведения к рабочему формату.
|
||||
type okConverter struct{}
|
||||
|
||||
func (c *okConverter) Convert(_ context.Context, src, dest string) error {
|
||||
content, err := os.ReadFile(src)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return os.WriteFile(dest, content, 0o600)
|
||||
}
|
||||
|
||||
// failingConverter отказывает на каждой попытке.
|
||||
type failingConverter struct{}
|
||||
|
||||
@@ -47,26 +60,50 @@ func (m *failingMetaViewer) GetInfo(context.Context, string) (*contract.AudioInf
|
||||
return nil, errors.New("запись не читается")
|
||||
}
|
||||
|
||||
// recordingSender запоминает, что и куда отправлено.
|
||||
// recordingSender запоминает, что отправлено.
|
||||
type recordingSender struct {
|
||||
mu sync.Mutex
|
||||
messages []string
|
||||
}
|
||||
|
||||
func (s *recordingSender) Send(text string, chatId int64, replyMsgId *int) error {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
s.messages = append(s.messages, text)
|
||||
return nil
|
||||
}
|
||||
|
||||
type pipelineEnv struct {
|
||||
app core.App
|
||||
service *TranscribeService
|
||||
jobRepo *pbrepo.TranscriptJobRepository
|
||||
fileRepo *pbrepo.FileRepository
|
||||
sender *recordingSender
|
||||
func (s *recordingSender) sent() []string {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
return append([]string(nil), s.messages...)
|
||||
}
|
||||
|
||||
type pipelineEnv struct {
|
||||
app core.App
|
||||
service *TranscribeService
|
||||
repos Repositories
|
||||
recordRepo *pbrepo.AudioRecordRepository
|
||||
fileRepo *pbrepo.FileRepository
|
||||
sender *recordingSender
|
||||
}
|
||||
|
||||
// testLimits — пределы простоя проверок. Числа боевые; проверка застревания
|
||||
// двигает не их, а время входа записи в рубеж: сторож меряет именно его.
|
||||
var testLimits = entity.StuckLimits{Own: time.Hour, Foreign: 24 * time.Hour}
|
||||
|
||||
func newPipelineEnv(t *testing.T, metaviewer contract.AudioMetaViewer, converter contract.AudioFileConverter) *pipelineEnv {
|
||||
t.Helper()
|
||||
return newPipelineEnvWith(t, metaviewer, converter, &recognizer.MemoryAudioRecognizer{})
|
||||
}
|
||||
|
||||
func newPipelineEnvWith(
|
||||
t *testing.T,
|
||||
metaviewer contract.AudioMetaViewer,
|
||||
converter contract.AudioFileConverter,
|
||||
rec contract.AudioRecognizer,
|
||||
) *pipelineEnv {
|
||||
t.Helper()
|
||||
|
||||
app, err := pbrepo.New(t.TempDir())
|
||||
require.NoError(t, err)
|
||||
@@ -81,158 +118,410 @@ func newPipelineEnv(t *testing.T, metaviewer contract.AudioMetaViewer, converter
|
||||
// нет.
|
||||
pbrepo.BindPanelRules(app)
|
||||
|
||||
jobRepo := pbrepo.NewTranscriptJobRepository(app)
|
||||
recordRepo := pbrepo.NewAudioRecordRepository(app)
|
||||
fileRepo := pbrepo.NewFileRepository(app)
|
||||
repos := Repositories{
|
||||
Records: recordRepo,
|
||||
Files: fileRepo,
|
||||
Texts: pbrepo.NewTextRepository(app),
|
||||
Structures: pbrepo.NewStructureRepository(app),
|
||||
Recognitions: pbrepo.NewRecognitionRepository(app),
|
||||
Events: pbrepo.NewRecordEventRepository(app),
|
||||
}
|
||||
sender := &recordingSender{}
|
||||
|
||||
svc := NewTranscribeService(
|
||||
jobRepo,
|
||||
fileRepo,
|
||||
metaviewer,
|
||||
converter,
|
||||
&recognizer.MemoryAudioRecognizer{},
|
||||
sender,
|
||||
slog.New(slog.DiscardHandler),
|
||||
)
|
||||
svc := NewTranscribeService(repos, metaviewer, converter, rec, sender, testLimits, slog.New(slog.DiscardHandler))
|
||||
|
||||
return &pipelineEnv{app: app, service: svc, jobRepo: jobRepo, fileRepo: fileRepo, sender: sender}
|
||||
return &pipelineEnv{
|
||||
app: app,
|
||||
service: svc,
|
||||
repos: repos,
|
||||
recordRepo: recordRepo,
|
||||
fileRepo: fileRepo,
|
||||
sender: sender,
|
||||
}
|
||||
}
|
||||
|
||||
// newTelegramJob заводит задачу с записью — так, как её завёл бы приём.
|
||||
func newTelegramJob(t *testing.T, env *pipelineEnv) *entity.TranscribeJob {
|
||||
// newTelegramRecord заводит запись — так, как её завёл бы приём из бота.
|
||||
func newTelegramRecord(t *testing.T, env *pipelineEnv) *entity.AudioRecord {
|
||||
t.Helper()
|
||||
|
||||
chatId := int64(100)
|
||||
job, err := env.service.CreateJobFromTelegram(t.Context(), strings.NewReader("запись"), "voice.ogg", chatId, 1)
|
||||
record, err := env.service.CreateJobFromTelegram(t.Context(), strings.NewReader("запись"), "voice.ogg", 100, 1)
|
||||
require.NoError(t, err)
|
||||
return job
|
||||
return record
|
||||
}
|
||||
|
||||
// clearDelay снимает паузу, чтобы следующий прогон взял задачу сразу: проверка
|
||||
// судит счётчик попыток, а не то, умеет ли она ждать.
|
||||
func clearDelay(t *testing.T, env *pipelineEnv, jobID string) {
|
||||
// clearDelay снимает паузу, чтобы следующий прогон взял запись сразу.
|
||||
func clearDelay(t *testing.T, env *pipelineEnv, recordID string) {
|
||||
t.Helper()
|
||||
|
||||
record, err := env.app.FindRecordById(migrations.JobsCollection, jobID)
|
||||
record, err := env.app.FindRecordById(migrations.RecordsCollection, recordID)
|
||||
require.NoError(t, err)
|
||||
record.Set("delay_time", "")
|
||||
require.NoError(t, env.app.Save(record))
|
||||
}
|
||||
|
||||
// rotAcquisition отодвигает время захвата так, чтобы он протух: так это
|
||||
// выглядит, когда шаг оборвался вместе с процессом.
|
||||
func rotAcquisition(t *testing.T, env *pipelineEnv, jobID string) {
|
||||
// enteredStateAt отодвигает время входа записи в рубеж: так это выглядит, когда
|
||||
// запись простояла в нём дольше предела.
|
||||
func enteredStateAt(t *testing.T, env *pipelineEnv, recordID string, moment time.Time) {
|
||||
t.Helper()
|
||||
|
||||
record, err := env.app.FindRecordById(migrations.JobsCollection, jobID)
|
||||
record, err := env.app.FindRecordById(migrations.RecordsCollection, recordID)
|
||||
require.NoError(t, err)
|
||||
record.Set("acquire_time", types.NowDateTime().Add(-24*time.Hour))
|
||||
record.Set("state_entered_at", types.DateTime{}.Add(0))
|
||||
stamp, err := types.ParseDateTime(moment)
|
||||
require.NoError(t, err)
|
||||
record.Set("state_entered_at", stamp)
|
||||
require.NoError(t, env.app.Save(record))
|
||||
}
|
||||
|
||||
// Задача, падающая на каждой попытке, уходит в «мертва»: из выборки исчезает,
|
||||
// видна отбором по состоянию, а отправитель узнаёт о неудаче. Инвариант
|
||||
// «Принятая запись не теряется молча» допускает два исхода, и молчаливая смерть
|
||||
// не подходит ни под один.
|
||||
func TestJobDiesAfterAttemptLimit(t *testing.T) {
|
||||
// drain крутит конвейер, пока он двигает записи. Паузы опроса снимаются: они
|
||||
// проверяются отдельно, а здесь мешают дойти до конца.
|
||||
func drain(t *testing.T, env *pipelineEnv, recordID string) {
|
||||
t.Helper()
|
||||
|
||||
for range 20 {
|
||||
clearDelay(t, env, recordID)
|
||||
err := env.service.RunStep(t.Context())
|
||||
var noop *contract.NoopJobError
|
||||
if errors.As(err, &noop) {
|
||||
return
|
||||
}
|
||||
require.NoError(t, err)
|
||||
|
||||
after := readRecord(t, env, recordID)
|
||||
if after.State == entity.StateDone || after.IsHalted() {
|
||||
return
|
||||
}
|
||||
}
|
||||
t.Fatal("конвейер не дошёл до исхода за отведённое число прогонов")
|
||||
}
|
||||
|
||||
// readRecord читает запись мимо сужения владельцем.
|
||||
//
|
||||
// Читающий метод сервиса отдаёт запись только её владельцу, а проверки конвейера
|
||||
// смотрят записи, принятые ботом: владельца у таких нет вовсе. Проверке нужно не
|
||||
// право, а состояние записи после шага.
|
||||
func readRecord(t *testing.T, env *pipelineEnv, id string) *entity.AudioRecord {
|
||||
t.Helper()
|
||||
|
||||
record, err := env.recordRepo.Get(id)
|
||||
require.NoError(t, err)
|
||||
return record
|
||||
}
|
||||
|
||||
// Запись, отказывающая на каждой попытке, останавливается признаком: из выборки
|
||||
// исчезает, рубеж сохраняет, а отправитель узнаёт о неудаче. Инвариант «Принятая
|
||||
// запись не теряется молча» допускает два исхода, и молчаливая остановка не
|
||||
// подходит ни под один.
|
||||
func TestRecordHaltsAfterAttemptLimit(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
|
||||
job := newTelegramJob(t, env)
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
// Отказ конвертации переводит задачу в `failed` сразу, поэтому предел
|
||||
// попыток проверяем на шаге, который отказывает *не* приговором: подменяем
|
||||
// его отказом источника метаданных внутри самого шага конвертации нельзя, и
|
||||
// вместо этого гоняем захват без выполнения шага — так же, как это выглядит
|
||||
// при гибели процесса.
|
||||
for i := 0; i < maxAttempts; i++ {
|
||||
_, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(time.Hour))
|
||||
// Захват без выполнения шага — так это выглядит при гибели процесса: отказа
|
||||
// шаг объявить не успевает, а попытка засчитана.
|
||||
for range maxAttempts {
|
||||
_, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
|
||||
require.NoError(t, err)
|
||||
expireAcquisition(t, env, record.Id)
|
||||
}
|
||||
rotAcquisition(t, env, job.Id)
|
||||
|
||||
// Следующий захват видит перебор и хоронит задачу.
|
||||
err := env.service.FindAndRunConversionJob(t.Context())
|
||||
err := env.service.RunStep(t.Context())
|
||||
|
||||
var noop *contract.NoopJobError
|
||||
require.ErrorAs(t, err, &noop, "мёртвая задача шагу не отдаётся")
|
||||
require.ErrorAs(t, err, &noop, "остановленная запись шагу не отдаётся")
|
||||
|
||||
after, err := readJob(env.app, job.Id)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, entity.StateDead, after.State, "задача видна отбором по состоянию")
|
||||
assert.Greater(t, after.Attempts, maxAttempts, "число попыток сохранено")
|
||||
after := readRecord(t, env, record.Id)
|
||||
assert.True(t, after.IsHalted(), "запись остановлена признаком")
|
||||
require.NotNil(t, after.HaltReason)
|
||||
assert.Equal(t, entity.HaltReasonAttempts, *after.HaltReason)
|
||||
assert.Equal(t, entity.StateUploaded, after.State, "рубеж пережил остановку")
|
||||
assert.Greater(t, after.Attempts, maxAttempts, "число отказов сохранено")
|
||||
|
||||
require.Len(t, env.sender.messages, 1, "отправитель узнал о неудаче")
|
||||
assert.Contains(t, env.sender.messages[0], "попытки исчерпаны")
|
||||
require.Len(t, env.sender.sent(), 1, "отправитель узнал о неудаче")
|
||||
assert.Contains(t, env.sender.sent()[0], "попытки исчерпаны")
|
||||
|
||||
// И из выборки она исчезла.
|
||||
_, err = env.jobRepo.FindAndAcquire(entity.StateCreated, "next", time.Now().Add(time.Hour))
|
||||
_, err = env.recordRepo.FindAndAcquire(entity.WorkingStages())
|
||||
var missing *contract.JobNotFoundError
|
||||
assert.ErrorAs(t, err, &missing)
|
||||
}
|
||||
|
||||
// Мёртвая задача возвращается в работу правкой состояния.
|
||||
func TestDeadJobReturnsAfterStateEdit(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
// expireAcquisition отодвигает срок протухания захвата в прошлое: так это
|
||||
// выглядит, когда шаг оборвался вместе с процессом.
|
||||
func expireAcquisition(t *testing.T, env *pipelineEnv, recordID string) {
|
||||
t.Helper()
|
||||
|
||||
job := newTelegramJob(t, env)
|
||||
record, err := env.app.FindRecordById(migrations.RecordsCollection, recordID)
|
||||
require.NoError(t, err)
|
||||
record.Set("acquire_expires_at", types.NowDateTime().Add(-time.Hour))
|
||||
require.NoError(t, env.app.Save(record))
|
||||
}
|
||||
|
||||
for i := 0; i < maxAttempts; i++ {
|
||||
_, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(time.Hour))
|
||||
// Критерий приёмки 1. Остановленная на шаге запись перезапускается снятием
|
||||
// признака и продолжает с того рубежа, где стояла, — следующим идёт отправка на
|
||||
// распознавание, а не повторное приведение.
|
||||
func TestHaltedRecordResumesFromItsStage(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
// Доводим до рубежа приведения и останавливаем на нём.
|
||||
require.NoError(t, env.service.RunStep(t.Context()))
|
||||
after := readRecord(t, env, record.Id)
|
||||
require.Equal(t, entity.StateNormalized, after.State)
|
||||
|
||||
after.Halt(entity.HaltReasonStepFailed, "проверочная остановка")
|
||||
require.NoError(t, env.recordRepo.Save(after, ""))
|
||||
|
||||
// Остановленная запись захвату не выдаётся.
|
||||
_, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
|
||||
var missing *contract.JobNotFoundError
|
||||
require.ErrorAs(t, err, &missing, "остановленная запись из выборки исчезла")
|
||||
|
||||
// Снятие признака возвращает её в работу с сохранённого рубежа.
|
||||
halted := readRecord(t, env, record.Id)
|
||||
halted.Resume()
|
||||
require.NoError(t, env.recordRepo.Save(halted, ""))
|
||||
|
||||
resumed := readRecord(t, env, record.Id)
|
||||
assert.Equal(t, entity.StateNormalized, resumed.State, "рубеж сохранён")
|
||||
assert.Equal(t, 0, resumed.Attempts, "отказы сброшены")
|
||||
|
||||
// Следующим идёт отправка на распознавание, а не повторное приведение.
|
||||
require.NoError(t, env.service.RunStep(t.Context()))
|
||||
next := readRecord(t, env, record.Id)
|
||||
assert.Equal(t, entity.StateSubmitted, next.State, "продолжили с места остановки")
|
||||
assert.NotNil(t, next.RecognitionID, "отправка состоялась")
|
||||
}
|
||||
|
||||
// Критерий приёмки 2. У прошедшей конвейер записи ссылки на исходник и на
|
||||
// приведённую копию ведут на разные существующие файлы: прежде ссылка была одна,
|
||||
// и каждый шаг переставлял её на свой результат.
|
||||
func TestBothFileLinksSurvivePipeline(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
drain(t, env, record.Id)
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
require.Equal(t, entity.StateDone, after.State)
|
||||
|
||||
require.NotNil(t, after.OriginalFileID, "ссылка на принятую копию заполнена")
|
||||
require.NotNil(t, after.NormalizedFileID, "ссылка на приведённую копию заполнена")
|
||||
assert.NotEqual(t, *after.OriginalFileID, *after.NormalizedFileID, "копии разные")
|
||||
|
||||
for _, id := range []string{*after.OriginalFileID, *after.NormalizedFileID} {
|
||||
reader, err := env.fileRepo.Open(id)
|
||||
require.NoError(t, err, "обе копии открываются")
|
||||
content, err := io.ReadAll(reader)
|
||||
require.NoError(t, err)
|
||||
assert.NotEmpty(t, content)
|
||||
require.NoError(t, reader.Close())
|
||||
}
|
||||
require.Error(t, env.service.FindAndRunConversionJob(t.Context()))
|
||||
|
||||
record, err := env.app.FindRecordById(migrations.JobsCollection, job.Id)
|
||||
require.NoError(t, err)
|
||||
record.Set("state", entity.StateCreated)
|
||||
require.NoError(t, env.app.Save(record))
|
||||
|
||||
again, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "next", time.Now().Add(time.Hour))
|
||||
require.NoError(t, err, "снятое состояние возвращает задачу в работу")
|
||||
assert.Equal(t, job.Id, again.Id)
|
||||
}
|
||||
|
||||
// Отказ шага не оставляет задачу захваченной до конца срока: захват снимается,
|
||||
// и задача ждёт нарастающую паузу. Иначе повтор наступал бы через восемь часов.
|
||||
func TestFailedStepSchedulesRetryWithGrowingDelay(t *testing.T) {
|
||||
// Источник метаданных отказывает — это отказ шага, а не приговор записи.
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
// Критерий приёмки 3. Поведение записи не зависит от числа воркеров: при одном
|
||||
// и при нескольких она доходит до конечного рубежа.
|
||||
func TestOutcomeDoesNotDependOnWorkerCount(t *testing.T) {
|
||||
for _, workers := range []int{1, 4} {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
job := newTelegramJob(t, env)
|
||||
for range 20 {
|
||||
clearDelay(t, env, record.Id)
|
||||
|
||||
// Ссылку переставляем на запись без содержимого: шаг отказывает на получении
|
||||
// рабочей копии — то есть отказом, а не приговором записи.
|
||||
empty, err := env.fileRepo.CreateRemote("object-key", 1, "")
|
||||
require.NoError(t, err)
|
||||
var wg sync.WaitGroup
|
||||
for range workers {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
// Исход прогона здесь не судится: воркеров несколько, и всем,
|
||||
// кроме одного, работы не достаётся. Судится состояние записи.
|
||||
if err := env.service.RunStep(t.Context()); err != nil {
|
||||
t.Log(err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
|
||||
record, err := env.app.FindRecordById(migrations.JobsCollection, job.Id)
|
||||
require.NoError(t, err)
|
||||
record.Set("file", empty.Id)
|
||||
require.NoError(t, env.app.Save(record))
|
||||
if readRecord(t, env, record.Id).State == entity.StateDone {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Первый отказ.
|
||||
require.Error(t, env.service.FindAndRunConversionJob(t.Context()))
|
||||
|
||||
after, err := readJob(env.app, job.Id)
|
||||
require.NoError(t, err)
|
||||
require.Nil(t, after.AcquisitionID, "захват снят: задача пригодна к повтору")
|
||||
require.NotNil(t, after.DelayTime, "пауза поставлена")
|
||||
|
||||
firstDelay := time.Until(*after.DelayTime)
|
||||
|
||||
// Второй отказ — с той же задачи, пауза снята вручную.
|
||||
clearDelay(t, env, job.Id)
|
||||
require.Error(t, env.service.FindAndRunConversionJob(t.Context()))
|
||||
|
||||
after, err = readJob(env.app, job.Id)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, after.DelayTime)
|
||||
|
||||
secondDelay := time.Until(*after.DelayTime)
|
||||
assert.Greater(t, secondDelay, firstDelay, "вторая пауза длиннее первой")
|
||||
after := readRecord(t, env, record.Id)
|
||||
assert.Equalf(t, entity.StateDone, after.State, "запись дошла до конца при %d воркерах", workers)
|
||||
assert.Falsef(t, after.IsHalted(), "запись не остановлена при %d воркерах", workers)
|
||||
}
|
||||
}
|
||||
|
||||
// Пауза растёт с числом попыток и упирается в потолок.
|
||||
// Тот же критерий, вторая половина: нулевое число воркеров — законное значение.
|
||||
// Записи принимаются и не двигаются, и это режим, а не поломка.
|
||||
func TestZeroWorkersLeaveRecordUntouched(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
// Пул нулевого размера ни одного прогона не делает — потому запись остаётся
|
||||
// там, где её оставил приём.
|
||||
after := readRecord(t, env, record.Id)
|
||||
assert.Equal(t, entity.StateUploaded, after.State, "запись принята и стоит на первом рубеже")
|
||||
assert.False(t, after.IsHalted(), "и не потеряна")
|
||||
assert.Equal(t, record.Id, after.Id)
|
||||
}
|
||||
|
||||
// Критерий приёмки 5, первая половина. Откладывание опроса не двигает время
|
||||
// входа в рубеж и не обнуляет отсчёт застревания: иначе запись, чью чужую
|
||||
// операцию опрашивают раз в несколько секунд, не достигла бы предела никогда.
|
||||
func TestPostponeKeepsStuckCountdown(t *testing.T) {
|
||||
entered := time.Date(2026, 8, 14, 10, 0, 0, 0, time.UTC)
|
||||
record := &entity.AudioRecord{State: entity.StateSubmitted, StateEnteredAt: entered}
|
||||
|
||||
for range 100 {
|
||||
record.Postpone(time.Now().Add(5 * time.Second))
|
||||
}
|
||||
|
||||
assert.Equal(t, entered, record.StateEnteredAt, "сотня откладываний не двигает отсчёт")
|
||||
assert.Equal(t, entity.StateSubmitted, record.State, "и рубежа не трогает")
|
||||
assert.Nil(t, record.AcquisitionID, "захват при этом снят")
|
||||
assert.NotNil(t, record.DelayTime, "а пауза поставлена")
|
||||
}
|
||||
|
||||
// Критерий приёмки 5, вторая половина. Запись, простоявшая в рубеже дольше
|
||||
// предела, останавливается признаком с причиной «застряла».
|
||||
func TestStuckRecordIsHalted(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
enteredStateAt(t, env, record.Id, time.Now().Add(-2*testLimits.Own))
|
||||
|
||||
err := env.service.RunStep(t.Context())
|
||||
var noop *contract.NoopJobError
|
||||
require.ErrorAs(t, err, &noop, "застрявшая запись шагу не отдаётся")
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
require.True(t, after.IsHalted())
|
||||
require.NotNil(t, after.HaltReason)
|
||||
assert.Equal(t, entity.HaltReasonStuck, *after.HaltReason, "причина названа")
|
||||
assert.Equal(t, entity.StateUploaded, after.State, "рубеж сохранён")
|
||||
|
||||
require.Len(t, env.sender.sent(), 1, "отправитель узнал о неудаче")
|
||||
assert.Contains(t, env.sender.sent()[0], "застряла")
|
||||
}
|
||||
|
||||
// Конечный рубеж под предел простоя не подпадает: стоять в нём запись будет
|
||||
// вечно по построению, и сторож остановил бы всякую доведённую запись.
|
||||
func TestDoneRecordIsNeverStuck(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
drain(t, env, record.Id)
|
||||
enteredStateAt(t, env, record.Id, time.Now().Add(-10*24*time.Hour))
|
||||
|
||||
err := env.service.RunStep(t.Context())
|
||||
var noop *contract.NoopJobError
|
||||
require.ErrorAs(t, err, &noop, "доведённая запись в работу не берётся")
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
assert.Equal(t, entity.StateDone, after.State)
|
||||
assert.False(t, after.IsHalted(), "признака остановки у доведённой записи нет")
|
||||
}
|
||||
|
||||
// Критерий приёмки 6. Держатель захвата отличим значением, а не занятостью
|
||||
// записи: шаг, чей захват достался другому, результата не пишет и отправителю
|
||||
// ничего не шлёт.
|
||||
func TestOnlyHolderWritesResult(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
first, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, record.Id, first.ID)
|
||||
|
||||
// Человек снял признак остановки — панель чистит признак захвата, — и запись
|
||||
// достаётся другому воркеру.
|
||||
expireAcquisition(t, env, record.Id)
|
||||
second, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
|
||||
require.NoError(t, err)
|
||||
require.NotEqual(t, first.Holder, second.Holder, "признак нового захвата отличается")
|
||||
|
||||
// Первый доходит до записи результата и получает отказ.
|
||||
stale := readRecord(t, env, record.Id)
|
||||
stale.MoveToState(entity.StateNormalized)
|
||||
err = env.recordRepo.Save(stale, first.Holder)
|
||||
|
||||
var lost *contract.LostAcquisitionError
|
||||
require.ErrorAs(t, err, &lost, "потерявший захват не пишет")
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
assert.Equal(t, entity.StateUploaded, after.State, "рубеж не сдвинут потерявшим захват")
|
||||
assert.Empty(t, env.sender.sent(), "и отправителю от него ничего не ушло")
|
||||
}
|
||||
|
||||
// Критерий приёмки 7. Всякий способ вывести запись из работы сообщает
|
||||
// отправителю: причин остановки больше одной, и обязанность у них общая.
|
||||
func TestEveryHaltReasonNotifiesSender(t *testing.T) {
|
||||
reasons := []struct {
|
||||
name string
|
||||
halt func(t *testing.T, env *pipelineEnv, recordID string)
|
||||
}{
|
||||
{
|
||||
name: "приговор шага",
|
||||
halt: func(t *testing.T, env *pipelineEnv, recordID string) {
|
||||
require.NoError(t, env.service.RunStep(t.Context()))
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "застревание",
|
||||
halt: func(t *testing.T, env *pipelineEnv, recordID string) {
|
||||
enteredStateAt(t, env, recordID, time.Now().Add(-2*testLimits.Own))
|
||||
var noop *contract.NoopJobError
|
||||
require.ErrorAs(t, env.service.RunStep(t.Context()), &noop)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, reason := range reasons {
|
||||
t.Run(reason.name, func(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
reason.halt(t, env, record.Id)
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
require.True(t, after.IsHalted(), "запись остановлена")
|
||||
require.Len(t, env.sender.sent(), 1, "отправитель узнал о неудаче")
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Критерий приёмки 8. Повтор шага не создаёт второго приложения: пара «запись и
|
||||
// вид» уникальна, и вопрос «какой текст отдавать человеку» не становится
|
||||
// вопросом порядка записи.
|
||||
func TestRepeatedStoreKeepsSingleText(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
first, err := env.repos.Texts.Put(record.Id, entity.TextKindTranscript, "первый разбор")
|
||||
require.NoError(t, err)
|
||||
second, err := env.repos.Texts.Put(record.Id, entity.TextKindTranscript, "второй разбор")
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, first.Id, second.Id, "строка та же, а не вторая")
|
||||
|
||||
stored, err := env.repos.Texts.GetByID(first.Id)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "второй разбор", stored.Contents)
|
||||
|
||||
count, err := env.app.CountRecords(migrations.TextsCollection)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, int64(1), count, "второго комплекта строк не завелось")
|
||||
}
|
||||
|
||||
// Пауза растёт с числом отказов и упирается в потолок.
|
||||
func TestRetryDelayGrowsAndCaps(t *testing.T) {
|
||||
assert.Equal(t, retryDelayBase, retryDelay(1))
|
||||
assert.Equal(t, 2*retryDelayBase, retryDelay(2))
|
||||
@@ -241,6 +530,42 @@ func TestRetryDelayGrowsAndCaps(t *testing.T) {
|
||||
assert.Equal(t, retryDelayBase, retryDelay(0), "нулевая попытка не даёт нулевой паузы")
|
||||
}
|
||||
|
||||
// Отказ шага не оставляет запись захваченной до конца срока: захват снимается,
|
||||
// и запись ждёт нарастающую паузу. Иначе повтор наступал бы через часы.
|
||||
func TestFailedStepSchedulesRetryWithGrowingDelay(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
// Ссылка переставляется на запись о файле без содержимого: шаг отказывает на
|
||||
// получении рабочей копии — то есть отказом, а не приговором записи.
|
||||
files, err := env.app.FindCollectionByNameOrId(migrations.FilesCollection)
|
||||
require.NoError(t, err)
|
||||
empty := core.NewRecord(files)
|
||||
empty.Set("location", entity.LocationLocal)
|
||||
empty.Set("size", 1)
|
||||
require.NoError(t, env.app.Save(empty))
|
||||
|
||||
stored, err := env.app.FindRecordById(migrations.RecordsCollection, record.Id)
|
||||
require.NoError(t, err)
|
||||
stored.Set("original_file", empty.Id)
|
||||
require.NoError(t, env.app.Save(stored))
|
||||
|
||||
require.Error(t, env.service.RunStep(t.Context()))
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
require.Nil(t, after.AcquisitionID, "захват снят: запись пригодна к повтору")
|
||||
require.NotNil(t, after.DelayTime, "пауза поставлена")
|
||||
firstDelay := time.Until(*after.DelayTime)
|
||||
|
||||
clearDelay(t, env, record.Id)
|
||||
require.Error(t, env.service.RunStep(t.Context()))
|
||||
|
||||
after = readRecord(t, env, record.Id)
|
||||
require.NotNil(t, after.DelayTime)
|
||||
assert.Greater(t, time.Until(*after.DelayTime), firstDelay, "вторая пауза длиннее первой")
|
||||
}
|
||||
|
||||
// Рабочая копия убирается на любом исходе, включая отказ. Забытая копия — это
|
||||
// шестичасовая запись во временном каталоге, и узнать о ней неоткуда.
|
||||
func TestWorkFileRemovedAfterIntakeFailure(t *testing.T) {
|
||||
@@ -273,24 +598,43 @@ func TestWorkFileRemovedAfterSuccessfulIntake(t *testing.T) {
|
||||
assert.Empty(t, leftovers, "рабочей копии после успеха не остаётся")
|
||||
}
|
||||
|
||||
// Задача не остаётся ссылающейся на файл, которого нет: ссылка переставляется
|
||||
// только после того, как запись о новом файле существует.
|
||||
func TestJobNeverPointsToMissingFile(t *testing.T) {
|
||||
// Уборка проверяется и на шаге приведения: репозиторий даёт единственный способ
|
||||
// убрать копию, но зовёт его шаг. Копий здесь две — исходник и результат.
|
||||
func TestWorkFilesRemovedAfterConversionFailure(t *testing.T) {
|
||||
tempDir := t.TempDir()
|
||||
t.Setenv("TMPDIR", tempDir)
|
||||
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
|
||||
job := newTelegramJob(t, env)
|
||||
newTelegramRecord(t, env)
|
||||
|
||||
// Конвертация отказывает — задача уходит в `failed`, но ссылка остаётся на
|
||||
// исходную запись, а не на несозданный результат.
|
||||
require.NoError(t, env.service.FindAndRunConversionJob(t.Context()))
|
||||
|
||||
after, err := readJob(env.app, job.Id)
|
||||
leftovers, err := filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, entity.StateFailed, after.State)
|
||||
require.NotNil(t, after.FileID)
|
||||
require.Empty(t, leftovers, "приём убрал свою рабочую копию")
|
||||
|
||||
file, err := env.fileRepo.GetByID(*after.FileID)
|
||||
require.NoError(t, err, "ссылка задачи ведёт на существующую запись о файле")
|
||||
require.NoError(t, env.service.RunStep(t.Context()))
|
||||
|
||||
leftovers, err = filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, leftovers, "ни исходной копии, ни копии под результат не осталось")
|
||||
}
|
||||
|
||||
// Запись не остаётся ссылающейся на файл, которого нет: ссылка ставится только
|
||||
// после того, как запись о файле существует.
|
||||
func TestRecordNeverPointsToMissingFile(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
|
||||
require.NoError(t, env.service.RunStep(t.Context()))
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
assert.True(t, after.IsHalted(), "приговор шага остановил запись")
|
||||
require.NotNil(t, after.OriginalFileID)
|
||||
assert.Nil(t, after.NormalizedFileID, "ссылки на несозданный результат не появилось")
|
||||
|
||||
file, err := env.fileRepo.GetByID(*after.OriginalFileID)
|
||||
require.NoError(t, err, "ссылка ведёт на существующую запись о файле")
|
||||
assert.NotEmpty(t, file.FileName)
|
||||
}
|
||||
|
||||
@@ -300,11 +644,11 @@ func TestStoredContentSurvivesRoundTrip(t *testing.T) {
|
||||
|
||||
content := strings.Repeat("запись ", 1000)
|
||||
|
||||
job, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader(content), "sample.mp3", newOwner(t, env.app))
|
||||
record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader(content), "sample.mp3", newOwner(t, env.app))
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, job.FileID)
|
||||
require.NotNil(t, record.OriginalFileID)
|
||||
|
||||
reader, err := env.fileRepo.Open(*job.FileID)
|
||||
reader, err := env.fileRepo.Open(*record.OriginalFileID)
|
||||
require.NoError(t, err)
|
||||
defer reader.Close()
|
||||
|
||||
@@ -312,22 +656,22 @@ func TestStoredContentSurvivesRoundTrip(t *testing.T) {
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, content, string(stored))
|
||||
|
||||
// И длина в учёте совпадает с длиной принятого.
|
||||
file, err := env.fileRepo.GetByID(*job.FileID)
|
||||
file, err := env.fileRepo.GetByID(*record.OriginalFileID)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, int64(len(content)), file.Size)
|
||||
assert.Equal(t, "mp3", file.Format, "формат копии записан")
|
||||
}
|
||||
|
||||
// Рабочая копия хранимого файла отдаётся именем на диске — так её получают
|
||||
// шаги, отдающие файл внешней программе.
|
||||
// Рабочая копия хранимого файла отдаётся именем на диске — так её получают шаги,
|
||||
// отдающие файл внешней программе.
|
||||
func TestLocalizeGivesReadableCopy(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
|
||||
job, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("содержимое"), "sample.mp3", newOwner(t, env.app))
|
||||
record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("содержимое"), "sample.mp3", newOwner(t, env.app))
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, job.FileID)
|
||||
require.NotNil(t, record.OriginalFileID)
|
||||
|
||||
work, err := env.fileRepo.Localize(*job.FileID)
|
||||
work, err := env.fileRepo.Localize(*record.OriginalFileID)
|
||||
require.NoError(t, err)
|
||||
|
||||
content, err := os.ReadFile(work.Path())
|
||||
@@ -339,86 +683,10 @@ func TestLocalizeGivesReadableCopy(t *testing.T) {
|
||||
assert.True(t, os.IsNotExist(err), "закрытая копия убрана")
|
||||
}
|
||||
|
||||
// Уборка рабочей копии проверяется и на шаге конвертации: репозиторий даёт
|
||||
// единственный способ убрать копию, но зовёт его шаг, и норма держится
|
||||
// проверкой, а не построением. Копий здесь две — исходник и результат.
|
||||
func TestWorkFilesRemovedAfterConversionFailure(t *testing.T) {
|
||||
tempDir := t.TempDir()
|
||||
t.Setenv("TMPDIR", tempDir)
|
||||
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
|
||||
newTelegramJob(t, env)
|
||||
|
||||
// Приём уже отработал — убеждаемся, что за собой он прибрал, иначе остаток
|
||||
// от него зачёлся бы шагу конвертации.
|
||||
leftovers, err := filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
|
||||
require.NoError(t, err)
|
||||
require.Empty(t, leftovers, "приём убрал свою рабочую копию")
|
||||
|
||||
// Конвертация отказывает — задача уходит в `failed`, копии убраны.
|
||||
require.NoError(t, env.service.FindAndRunConversionJob(t.Context()))
|
||||
|
||||
leftovers, err = filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, leftovers, "ни исходной копии, ни копии под результат не осталось")
|
||||
}
|
||||
|
||||
// readJob читает задачу мимо сужения владельцем.
|
||||
//
|
||||
// Читающий метод хранилища отдаёт задачу только её владельцу, а проверки
|
||||
// конвейера смотрят задачи, принятые ботом: владельца у таких нет вовсе, и по
|
||||
// правилу разграничения они не достаются никому. Проверке нужен не доступ, а
|
||||
// состояние записи после шага, поэтому она берёт его прямо из хранилища. Это
|
||||
// не второй способ читать задачу в сервисе — в сервисе способ по-прежнему один.
|
||||
func readJob(app core.App, id string) (*entity.TranscribeJob, error) {
|
||||
record, err := app.FindRecordById(migrations.JobsCollection, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
job := &entity.TranscribeJob{
|
||||
Id: record.Id,
|
||||
State: record.GetString("state"),
|
||||
Source: record.GetString("source"),
|
||||
Attempts: record.GetInt("attempts"),
|
||||
CreatedAt: record.GetDateTime("created").Time(),
|
||||
UpdatedAt: record.GetDateTime("updated").Time(),
|
||||
}
|
||||
|
||||
for _, field := range []struct {
|
||||
name string
|
||||
dst **string
|
||||
}{
|
||||
{"owner", &job.OwnerID},
|
||||
{"file", &job.FileID},
|
||||
{"error_text", &job.ErrorText},
|
||||
{"acquisition_id", &job.AcquisitionID},
|
||||
{"recognition_op_id", &job.RecognitionOpID},
|
||||
{"transcription_text", &job.TranscriptionText},
|
||||
} {
|
||||
if value := record.GetString(field.name); value != "" {
|
||||
stored := value
|
||||
*field.dst = &stored
|
||||
}
|
||||
}
|
||||
|
||||
if delay := record.GetDateTime("delay_time"); !delay.IsZero() {
|
||||
moment := delay.Time()
|
||||
job.DelayTime = &moment
|
||||
}
|
||||
if acquired := record.GetDateTime("acquire_time"); !acquired.IsZero() {
|
||||
moment := acquired.Time()
|
||||
job.AcquireTime = &moment
|
||||
}
|
||||
|
||||
return job, nil
|
||||
}
|
||||
|
||||
// newOwner заводит учётную запись и отдаёт её идентификатор.
|
||||
//
|
||||
// Владелец — связь с коллекцией пользователей, и хранилище проверяет, что такая
|
||||
// запись есть: выдуманный идентификатор задачу завести не даст.
|
||||
// запись есть: выдуманный идентификатор запись завести не даст.
|
||||
func newOwner(t *testing.T, app core.App) string {
|
||||
t.Helper()
|
||||
|
||||
@@ -428,8 +696,77 @@ func newOwner(t *testing.T, app core.App) string {
|
||||
record := core.NewRecord(users)
|
||||
record.Set("email", uuid.NewString()+"@example.test")
|
||||
record.Set("verified", true)
|
||||
record.SetPassword(uuid.NewString())
|
||||
record.Set("password", uuid.NewString())
|
||||
require.NoError(t, app.Save(record))
|
||||
|
||||
return record.Id
|
||||
}
|
||||
|
||||
// Остановка приговором шага засчитывается **отказом**, а не успехом, и пишет в
|
||||
// журнал записи одну строку, а не две.
|
||||
//
|
||||
// Пока исход шага выводился из «шаг не вернул ошибку», остановленная запись
|
||||
// получала событием `done` вслед за `halted` и растила счётчик успехов — то есть
|
||||
// единственный канал владельца молчал ровно там, где запись встала.
|
||||
func TestHaltIsCountedAsFailureAndLoggedOnce(t *testing.T) {
|
||||
env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
|
||||
|
||||
beforeOk := stageCount(t, entity.StateUploaded, "false")
|
||||
beforeErr := stageCount(t, entity.StateUploaded, "true")
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
require.NoError(t, env.service.RunStep(t.Context()))
|
||||
|
||||
after := readRecord(t, env, record.Id)
|
||||
require.True(t, after.IsHalted(), "приговор шага остановил запись")
|
||||
|
||||
assert.InDelta(t, beforeErr+1, stageCount(t, entity.StateUploaded, "true"), 0,
|
||||
"остановка засчитана отказом")
|
||||
assert.InDelta(t, beforeOk, stageCount(t, entity.StateUploaded, "false"), 0,
|
||||
"и успехом не засчитана")
|
||||
|
||||
events := recordEvents(t, env, record.Id)
|
||||
require.Len(t, events, 1, "одна строка журнала, а не две")
|
||||
assert.Equal(t, entity.EventOutcomeFailed, events[0].GetString("outcome"),
|
||||
"исход назван приговором, а не сделанной работой")
|
||||
}
|
||||
|
||||
// Откладывание опроса в журнал событий не пишется: часовое ожидание чужой
|
||||
// операции дало бы там сотни строк ни о чём, и журнал, заведённый для человека,
|
||||
// стал бы нечитаемым ровно у долгой записи.
|
||||
func TestPostponeWritesNoEvent(t *testing.T) {
|
||||
rec := &countingRecognizer{}
|
||||
rec.inProgress.Store(5)
|
||||
env := newPipelineEnvWith(t, &okMetaViewer{}, &okConverter{}, rec)
|
||||
|
||||
record := newTelegramRecord(t, env)
|
||||
require.NoError(t, env.service.RunStep(t.Context())) // приведение
|
||||
require.NoError(t, env.service.RunStep(t.Context())) // отправка
|
||||
require.Equal(t, entity.StateSubmitted, readRecord(t, env, record.Id).State)
|
||||
|
||||
before := len(recordEvents(t, env, record.Id))
|
||||
|
||||
for range 5 {
|
||||
clearDelay(t, env, record.Id)
|
||||
require.NoError(t, env.service.RunStep(t.Context()))
|
||||
}
|
||||
|
||||
assert.Len(t, recordEvents(t, env, record.Id), before,
|
||||
"пять откладываний не оставили в журнале ни строки")
|
||||
}
|
||||
|
||||
// recordEvents читает журнал событий одной записи в порядке заведения.
|
||||
func recordEvents(t *testing.T, env *pipelineEnv, recordID string) []*core.Record {
|
||||
t.Helper()
|
||||
|
||||
all, err := env.app.FindAllRecords(migrations.RecordEventsCollection)
|
||||
require.NoError(t, err)
|
||||
|
||||
var own []*core.Record
|
||||
for _, event := range all {
|
||||
if event.GetString("record") == recordID {
|
||||
own = append(own, event)
|
||||
}
|
||||
}
|
||||
return own
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user