Тест, который ни разу не видели красным, ничего не гарантирует — он мог бы стоять на месте assert true и вести себя точно так же. Эта статья показывает конкретный случай, когда так и вышло: replay-тест против реальной, честно снятой истории событий, который проверял правильный, неглупый инвариант — и пропустил внесённую в Apply регрессию. Дело не в истории: регрессия сдвигает остаток вверх, а инвариант «не в минус» к таким ошибкам слеп по построению. Тест обнаружил свою слепоту не в проде, а на этапе проверки самого теста — тем самым способом, каким и положено проверять тесты: подсунуть им заведомо сломанный код и посмотреть, упадут ли они.
Пятая, финальная статья серии. Дальше — given-when-then для агрегата как чистой функции, пределы golden-сверки, вытекающие из формы свёртки, а не из пробела в данных, и тот же агрегат на Axon Framework на контрасте с самодельным store — что фреймворк берёт на себя и чего требует взамен.
В статье
- Агрегат как чистая функция: given-when-then без базы и моков
- Replay-тест, который не поймал регрессию
- Пределы golden-сверки: что она не гарантирует
- Axon на контрасте: что берёт фреймворк, что остаётся коду
- Граница вывода
- Что уносить из серии
Агрегат как чистая функция: given-when-then без базы и моков
Tank.Apply и Tank.Decide (см. проектирование агрегатов) не читают ничего, кроме своих аргументов, и не пишут ничего, кроме возвращаемого значения. Отсюда прямое следствие для тестов: given — это список прошлых событий, свёрнутый вручную циклом Apply, when — команда, then — новые события или ошибка. Ни поднятого Postgres, ни мока стора, ни асинхронности.
// Агрегат — чистая функция: given прошлые события, when команда,
// then новые события или ошибка. Без базы и без моков.
func TestTankRejectsOverConsumption(t *testing.T) {
tank := Tank{}
for _, e := range []Event{
{Type: "TankRegistered", Liters: 0},
{Type: "OxygenAdded", Liters: 100},
} {
tank = tank.Apply(e)
}
_, err := tank.Decide(Command{Type: "ConsumeOxygen", Liters: 150})
if err == nil {
t.Fatal("расход больше остатка обязан быть отвергнут, но ошибки нет")
}
if tank.Liters != 100 {
t.Fatalf("состояние изменилось при отказе: %v", tank.Liters)
}
}Второй сценарий — зеркальный: допустимый расход принимается и порождает ровно одно OxygenConsumed с ожидаемой величиной (go/aggregate_test.go, TestTankAcceptsValidConsumption). Рядом с ними — табличный TestTankRejectsInvalidCommands на одиннадцать способов подать команду, которую агрегат обязан отвергнуть: отрицательная и нулевая величина, NaN и бесконечность, команда до регистрации резервуара, повторная регистрация, превышение остатка, опечатка в типе команды. Чем опасна каждая такая пропущенная команда и почему в event-sourced-модели это дороже, чем в CRUD, разобрано во второй статье серии. Ничего изощрённого в самих тестах при этом нет — и в этом смысл: given-when-then для event-sourced-агрегата настолько прямолинеен именно потому, что модель Decide/Apply не оставляет места, куда спрятать скрытое состояние или побочный эффект. Тест агрегата отвечает на вопрос «правильно ли домен реагирует на команду при данной истории» и ничего не говорит о том, правильно ли эта история была прочитана из хранилища или правильно ли собранные события в него запишутся — это другой класс проверок, и следующий раздел — как раз о нём.
Replay-тест, который не поймал регрессию
История для replay-теста — не выдумана и не синтезирована вручную: go/testdata/history.jsonl — первые 5000 строк из 40 стримов (tank-0…tank-39), наполненных тем же командным путём, что в проде стенда (Decide → AppendEvents), снятые SELECT ... ORDER BY global_pos LIMIT 5000 из живой таблицы events после прогона -workers 16 -streams 40 -duration 10s -mode append-fine. Состав: 40 TankRegistered, 40 OxygenAdded — по одному крупному пополнению на регистрацию каждого стрима, — и 4920 OxygenConsumed.
Здесь важна одна деталь пополнения при регистрации: каждый стрим засеян OxygenAdded на 1e9 литров — это готовит стрим к нагрузке (см. go/main.go, runPostgresAppend), а не случайное число. Расход в 5000 зафиксированных строках исчисляется тысячами литров — на три порядка меньше засеянного запаса.
TestReplayAgainstRecordedHistory проигрывает history.jsonl через текущий Tank.Apply и проверяет инвариант домена: остаток ни у одного стрима не должен уйти в минус. Регрессия, внесённая в Apply (aggregate.go, ветка OxygenConsumed: t.Liters -= e.Liters заменено на t.Liters += e.Liters — расход теперь прибавляет, а не вычитает), на этой истории теста не тронула:
=== RUN TestReplayAgainstRecordedHistory
replay_test.go:54: проиграно 5000 событий по 40 стримам
--- PASS: TestReplayAgainstRecordedHistory (0.02s)
PASSPASS на сломанном коде. Причина не в невезении с данными и не в величине запаса — она структурная. Регрессия обращает знак расхода: OxygenConsumed прибавляет литры вместо того, чтобы вычитать. Тогда каждое событие истории только увеличивает остаток, и уйти в минус ему не из чего — при любом стартовом запасе, хоть 1e9 литров, как здесь, хоть ноль. Пополнили на 1, израсходовали 1: правильный остаток — 0, сломанный — 2, и инвариант по-прежнему выполнен. Проверка «остаток не уходит в минус» правильна сама по себе, но к ошибкам, которые сдвигают остаток вверх, она слепа по построению, а не из-за неудачной истории.
Усиленный вариант теста вместо единственной проверки инварианта сверяет итоговое состояние каждого из 40 стримов с golden-файлом testdata/expected.json, зафиксированным один раз на заведомо исправном Apply (генерируется флагом -update, в обычном прогоне тест только читает golden и никогда не перезаписывает). Прогон с той же регрессией, go test -run TestReplay -v ./...:
=== RUN TestReplayAgainstRecordedHistory
replay_test.go:130: контрольная сумма разошлась у 40 из 40 стримов (свёртка сломана):
tank-0: ожидали liters=999999864.000000 registered=true, получили liters=1000000136.000000 registered=true
tank-10: ожидали liters=999999874.000000 registered=true, получили liters=1000000126.000000 registered=true
tank-11: ожидали liters=999999870.000000 registered=true, получили liters=1000000130.000000 registered=true
tank-12: ожидали liters=999999872.000000 registered=true, получили liters=1000000128.000000 registered=true
tank-13: ожидали liters=999999874.000000 registered=true, получили liters=1000000126.000000 registered=true
tank-14: ожидали liters=999999877.000000 registered=true, получили liters=1000000123.000000 registered=true
tank-15: ожидали liters=999999876.000000 registered=true, получили liters=1000000124.000000 registered=true
tank-16: ожидали liters=999999868.000000 registered=true, получили liters=1000000132.000000 registered=true
tank-17: ожидали liters=999999875.000000 registered=true, получили liters=1000000125.000000 registered=true
tank-18: ожидали liters=999999887.000000 registered=true, получили liters=1000000113.000000 registered=true
…
--- FAIL: TestReplayAgainstRecordedHistory (0.02s)
FAIL
FAIL esdeep 0.024s
FAIL40 из 40 стримов упали — регрессия задевает не «границу» инварианта, а сумму, и сумма расходится у каждого стрима без исключения. Строка aggregate.go возвращена обратно (t.Liters -= e.Liters), тест снова зелёный:
=== RUN TestReplayAgainstRecordedHistory
replay_test.go:142: проиграно 5000 событий по 40 стримам, контрольные суммы совпали с golden
--- PASS: TestReplayAgainstRecordedHistory (0.02s)
PASS
ok esdeep 0.026sGolden-снимок сам по себе доказывает только внутреннюю согласованность — он сгенерирован тем же Apply, который потом с ним же сверяется, а значит теоретически мог бы зафиксировать и неправильный результат. Числа перепроверены независимо: прямым SQL-агрегатом по events в обход Apply и всего Go-кода вообще (SUM по CASE event_type с плюсом на OxygenAdded и минусом на OxygenConsumed) — 0 расхождений на 40 из 40 стримов, пропущенных или лишних стримов нет. Это подтверждает сами числа в expected.json, но не подтверждает и не может подтвердить чувствительность метода к порядку событий — SQL-сумма такая же чисто аддитивная свёртка, как и Apply, и об этом следующий раздел.
Вывод, ради которого написан этот раздел: тест, который никогда не видели падающим, ничего не гарантирует. Не то, что тест зелёный, доказывает его пригодность — а то, что он краснеет, когда в код подсунута заведомая ошибка. Здесь потребовалось два прогона на одной и той же регрессии, чтобы это увидеть: первый показал, что вера в «инвариант держит» была необоснованной для этого класса регрессий, второй — что усиленная проверка действительно ловит именно ту регрессию, ради которой её усиливали. Практический вывод переносится без изменений на любой другой replay-тест: если у него нет зафиксированного прогона с намеренно сломанным кодом, его способность ловить регрессии — недоказанное предположение, а не свойство, на которое можно полагаться.
Пределы golden-сверки: что она не гарантирует
Есть класс ошибок, обнаружение которых golden-сверка не гарантирует, — и это следствие формы Tank.Apply, а не пробел в конкретных 5000 строках, который закрылся бы другими данными. Apply — чисто аддитивная свёртка: OxygenAdded и OxygenConsumed только прибавляют и вычитают константу из Liters, TankRegistered безусловно ставит Registered = true, не читая текущее состояние. Ни одна ветка не смотрит на порядок предыдущих событий. В точной арифметике итоговое состояние стрима от порядка событий не зависит — это свойство самой формы свёртки. Оговорка про машинную арифметику: Liters имеет тип float64, а сложение с плавающей точкой не ассоциативно — 1e16 + 1 − 1e16 даёт 0, а 1e16 − 1e16 + 1 даёт 1. На числах текущей фикстуры, где значения малы и складываются точно, перестановка итог не меняет; на других величинах она может сдвинуть его в младших разрядах. Но и это не помогает ловить перестановки: итоговая сумма их обнаружение не гарантирует, и практический вывод ниже остаётся в силе.
Отсюда список того, что golden-сверка ловит и не ловит — это не вопрос «повезло с данными», а прямое следствие формы свёртки:
- ловит: пропуск события (сумма меняется), лишнее или повторно применённое событие (сумма меняется), порчу знака или величины внутри самого
Apply— именно ту регрессию, что поймана выше; - не гарантирует: обнаружение перестановки событий внутри стрима — итоговая сумма его не гарантирует, а на числах текущей фикстуры перестановку не обнаруживает вовсе;
- не ловит: событие неизвестного
event_type.Tank.Apply—switchбез веткиdefault: тип, не совпавший ни с однимcase, проходит свёртку, не меняя состояние, без ошибки и без паники. Сама golden-сверка против такой порчи бессильна в принципе: если порча случилась до генерации снимка, снимок зафиксировал бы уже испорченный итог, и сравнивать было бы не с чем.
Последний пункт стоит договорить до конца, потому что из «сверка слепа» не следует «тест пройдёт». Слепота golden-сверки — свойство метода, и она никуда не делась. Но набор тестов закрыт с другой стороны: TestRecordedHistoryHasOnlyKnownEventTypes проверяет входные данные — сканирует testdata/history.jsonl и падает, если встречает event_type вне списка допустимых. Дописанная в историю строка с OxygenLeaked роняет его с перечислением найденных типов; проверено падающим.
Разница принципиальна для того, как читать этот список. Golden-сверка сравнивает два числа и не может увидеть событие, которое обе стороны одинаково не умеют считать, — это её структурный предел. Закрывается он не улучшением сверки, а проверкой другого рода, поставленной на другую поверхность: на данные до их применения. Тот же приём и по той же причине применён к проектору и SQL-сверке в третьей статье — там неизвестный тип разбирается подробно, вместе с контрпримером, на котором проектор и сверка согласованно объявили потерю корректным состоянием.
Проверка чувствительности к порядку требует другого инструмента — не другой истории для той же проверки. Один вариант: сверка промежуточных состояний после каждого события, а не только финального, — тогда перестановка меняет траекторию, даже если конечная точка та же. Второй: свёртка, которая явно зависит от последовательности — например, включающая позицию или версию события в контрольную величину, а не только сумму. Ни то, ни другое в этом стенде не реализовано; это называние альтернативы, а не демонстрация.
Отдельно стоит развести golden-сверку и осознанное изменение бизнес-правила — оба выглядят для теста одинаково: расхождение с зафиксированным результатом. Golden-файл фиксирует то, что было правильно на момент генерации, а не то, что правильно навсегда; при намеренном изменении логики его придётся перегенерировать (-update), и ничто в самом тесте не подскажет, какой из двух случаев произошёл — регрессия это или обдуманное решение поменять правило. Это то же ограничение, что и молчание сверки о порче event_type до генерации снимка: golden-метод фиксирует один срез правильности, а не источник истины поверх него.
Axon на контрасте: что берёт фреймворк, что остаётся коду
Тот же домен, тот же инвариант, та же структура из двух чистых операций — decide и apply — переписаны на Axon Framework. Версия — 4.13.2, последняя в ветке 4.x на момент прогона, не Axon 5: аннотации @AggregateIdentifier / @CommandHandler / @EventSourcingHandler над простым POJO-агрегатом — это стиль Axon 4 (axon-modelling + AggregateTestFixture из axon-test); в Axon 5 модель агрегата и API тестового фикстура переписаны заново и не совпадают с тем, что здесь показано. Версия Java — 17.0.19 (OpenJDK): maven.compiler.release в pom.xml выставлен в 17 под фактическую версию в среде сборки.
class TankAggregateTest {
private FixtureConfiguration<TankAggregate> fixture;
@BeforeEach
void setUp() {
fixture = new AggregateTestFixture<>(TankAggregate.class);
}
@Test
void rejectsOverConsumption() {
fixture.given(
new TankEvents.TankRegistered("tank-1"),
new TankEvents.OxygenAdded("tank-1", 100))
.when(new TankCommands.ConsumeOxygen("tank-1", 150))
.expectException(IllegalArgumentException.class)
.expectNoEvents();
}
}Разница с Go-версией того же сценария не в домене — в том, что и как проверяется. В Go given — ручной цикл tank = tank.Apply(e) по списку событий; в Axon given — метод фикстура, который сам создаёт агрегат через конструктор без аргументов и проигрывает историю через @EventSourcingHandler, ровно то, что в Go делает LoadStream. Assertion в Axon идёт по опубликованным событиям (expectEvents/expectException), а не по состоянию агрегата напрямую — фреймворк не даёт лёгкого доступа к приватным полям снаружи, и это часть цены модели, а не недосмотр теста. Три теста прошли (mvn -Dmaven.repo.local=/tmp/m2-esdeep test):
[INFO] Running tech.khorost.esdeep.TankAggregateTest
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.720 s -- in tech.khorost.esdeep.TankAggregateTest
[INFO] Results:
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESSТретий сценарий (registerThenAddThenConsumeAccumulatesState), которого нет в Go-версии, проверяет накопление состояния после AddOxygen через expectState — потому что assertion по событиям одну эту проверку не закрывает: события подтверждают, что было опубликовано, а не то, во что свернулось состояние.
Что фреймворк берёт на себя. Загрузку стрима и применение истории — в Go это явный код (go/store.go, LoadStream: цикл Tank{}.Apply(e) по строкам курсора), в Axon — EventSourcingRepository, прикладной код которого не видит вообще, ни строчки. Обнаружение конкурентной записи по версии агрегата — тоже: apply() внутри @CommandHandler лишь постулирует факт, сверку версии делает инфраструктура.
Ровно здесь важно не сказать больше, чем есть. Фреймворк берёт на себя обнаружение конфликта, но не его разрешение: что делать с обнаруженным конфликтом — отклонить команду, повторить её или слить изменения — остаётся политикой, которую пишет прикладной разработчик. Документация Axon по conflict resolution требует для этого двух вещей явно: пометить поле команды аннотацией @TargetAggregateVersion (ожидаемая версия) и принять параметр ConflictResolver в обработчике, где вызовами detectConflicts перечислить, какие именно события считаются конфликтующими для этой команды. Причём умолчание там — не «само разрешится»: если потенциально конфликтующие события есть, а ни одного вызова detectConflicts не сделано, обработчик команды падает. Повтор — тоже отдельное решение, через RetryScheduler на командной шине, а не свойство репозитория. Разница с самодельным стором здесь не в том, что Axon «решает конфликты за тебя», а в том, что он даёт готовое место, куда эту политику вписать, — сама политика в обоих случаях авторская.
Что фреймворк требует взамен — это структурное наблюдение по коду и API axon-modelling/axon-eventsourcing, не измерено бенчмарком и не должно подаваться как замер:
- обязательный конструктор без аргументов для восстановления из истории — Axon создаёт им пустой экземпляр перед тем, как проиграть события; в Go
Tank{}— обычное нулевое значение структуры, ничего специального не нужно; - изменение состояния через события:
@CommandHandlerвызываетapply(event), а поля меняет@EventSourcingHandler— и при обработке команды, и при восстановлении из истории. Прямое присваивание поля в обработчике команды изменит состояние в памяти, но события не создаст: в хранилище ничего не попадёт, и при следующем восстановлении это изменение потеряется (документация Axon); - класс-агрегат как единственный держатель состояния: изменение проходит через
thisиAggregateLifecycle, а не через возвращаемое значение. Чистую функцию «состояние + команда → события» здесь написать можно — обработчик команды волен вызвать обычный статический метод домена и передать возвращённый список вapply(), — но это соглашение автора кода, а не то, что поддерживает и проверяет фреймворк: сигнатура@CommandHandlerничего не возвращает в модель, и ничто не мешает соседнему обработчику присвоить поле напрямую. В GoDecide— единственный способ породить событие, потому что другого пути к состоянию просто нет; в Axon это дисциплина поверх модели, которая устроена иначе.
Сборка вскрыла две находки, обе задокументированы прямо в pom.xml рядом с зависимостью, которая их закрывает: @EventSourcingHandler и EventSourcingRepository живут в отдельном модуле axon-eventsourcing, не в axon-modelling — без него сборка падает на compile (package org.axonframework.eventsourcing does not exist); axon-test использует Hamcrest matchers внутри ResultValidator, но объявляет зависимость как optional — без явного добавления org.hamcrest:hamcrest:2.2 сборка падает на testCompile (cannot access org.hamcrest.Matcher). Axon здесь не поднимался как runtime-сервис (Axon Server и подобное) — задача использует axon-modelling/axon-eventsourcing/axon-test как библиотеки в юнит-тесте, AggregateTestFixture держит агрегат целиком в памяти без инфраструктуры.
EventStoreDB (KurrentDB), Marten и Eventuate — без видимости замера. Все три в контексте этой статьи разбираются по документации, а не по прогону. EventStoreDB в стенде не отсутствует вообще — под именем KurrentDB она живёт в первой статье серии, event store вглубь, с живым замером записи и catch-up-подписок, — но здесь, в разделе про given-when-then и тестовые фреймворки, отдельного прогона её тестового клиента не ставилось. Для Marten причина другая — .NET в среде сборки отсутствует; для Eventuate прогон просто не ставился. Разбор всех трёх ниже — по документации, тем же способом, каким выше по коду и документации API разобран Axon.
EventStoreDB — специализированный event store, где стрим — первичная абстракция протокола, а не таблица общего назначения поверх СУБД: append/read/подписка адресуются по имени стрима напрямую, ожидаемая версия передаётся как условие записи на уровне клиента gRPC, а не выражается через SQL. Модель тестирования здесь другая, чем у Axon: изолированного внутрипроцессного фикстура в духе AggregateTestFixture, который держал бы агрегат целиком в памяти без сервера, документация не предлагает — руководство по установке для локальной разработки описывает запуск настоящего сервера, обычно одиночного узла в Docker в insecure-режиме. Это ближе к тому, что документация Marten описывает для своего клиента (ниже), чем к Axon. Оговорка на всякий случай: сказать «in-memory у KurrentDB нет» было бы неточно — у сервера есть режим хранения без записи на диск, — но это по-прежнему поднятый сервер, а не фикстур внутри тестового процесса, и на модель тестирования влияет именно второе. Проект переименован в KurrentDB (та же кодовая база, тот же протокол клиента, под новым именем) — версия, зафиксированная в первой статье серии на живом замере, 26.1.2.3778.
Marten и Eventuate. Marten (event store поверх Postgres для .NET) и Eventuate (ES + saga для микросервисов на JVM) в стенде не запускались — .NET в среде сборки отсутствует, а для Eventuate отдельного прогона не ставилось. Разбор ниже — по документации, и это явно не то же самое, что показанное выше по Go и Axon.
Marten даёт event store, снапшоты и проекции «батарейками» поверх обычной Postgres-схемы — ближе по духу к самодельному стору из первых статей серии (та же СУБД под капотом), чем к Axon, но с готовым слоем поверх таблиц, а не с ручным LoadStream/AppendEvents. Тестовый фреймворк Marten не даёт того изолированного in-memory given-when-then, что AggregateTestFixture: документация Marten описывает интеграционное тестирование через реальное подключение к Postgres, а не через фикстур, полностью держащий агрегат в памяти — структурное отличие модели тестирования, а не деталь версии.
Eventuate явно позиционируется вокруг saga и микросервисной согласованности между агрегатами, а не вокруг тестирования одного агрегата в изоляции — это другая точка на карте задач, ближе к тому, что в серии называлось сагой, чем к given-when-then этой статьи. Оценка возможностей обоих инструментов по документации, а не по эксплуатации, — это ограничение, которое стоит держать в уме при переносе выбора в собственный проект: разница между «прочитал доки» и «попробовал на своей нагрузке» никуда не девается оттого, что доки хорошо написаны.
Граница вывода
Показано: (1) реальный replay-тест на реальной, хоть и малой (5000 из 13775 сгенерированных) истории способен и проходить, и падать — конкретно на этой истории и этой регрессии; (2) какая именно проверка — инвариант или golden-снимок — ловит эту конкретную регрессию, а какая нет; (3) какую инфраструктуру берёт на себя Axon и какую модель жизненного цикла он взамен навязывает — по коду и документации API, не по замеру.
Не показано: (1) выбор фреймворка — Axon против самописного кода — этим шагом не решается и вообще не решается бенчмарком. Здесь нет и не может быть числа «на сколько Axon быстрее или медленнее» или «лучше или хуже», есть только перечень того, что он берёт на себя и что взамен требует; замер здесь ничего не доказывает, потому что вопрос не о скорости, а о распределении ответственности между фреймворком и прикладным кодом. Сказано прямо, а не подразумевается: этот раздел не даёт основания выбрать Axon, самодельный store, Marten или Eventuate — он даёт основание понимать цену каждого выбора. (2) нечувствительность инвариант-теста к другим регрессиям. Для показанной — обращённого знака расхода — она структурная: остаток только растёт, и никакой состав истории, включая почти исчерпанный стрим, эту регрессию проверкой «не в минус» не поймает. Регрессию, которая сдвигает остаток вниз, та же проверка поймала бы на истории, где остаток подходит к нулю; это не проверялось. (3) полнота golden-сверки как метода — она ловит расхождение с прошлым правильным результатом, но не отличает регрессию от осознанного изменения бизнес-правила, и ничто в самом тесте не подскажет, какой из двух случаев произошёл.
Что уносить из серии
Пятью статьями серия прошла путь от устройства хранилища до способа доказать себе, что тесты вокруг него не врут. Первая статья разобрала модель данных event store и то, где каждый из трёх движков — Postgres, EventStoreDB, Kafka — упирается в свой потолок под нагрузкой. Вторая — про самое дорогое решение, границы агрегата и форму событий, которое не чинится рефакторингом после того, как история уже записана. Третья показала, что сверка проекции, которая не умеет падать, ничего не проверяет — тот же принцип, которым закрывается и эта статья, только для другого слоя системы. Четвёртая — цена цепочки upcaster’ов и честное признание, что полевой замер этой цены не дал устойчивого направления, зато изолированный микробенчмарк дал устойчивую цифру по аллокациям.
Общая нить всех пяти статей — недоверие к собственным проверкам, доведённое до методологии: инвариант не значит правильность, зелёный тест не значит защиту от регрессии, сходимость суммы не значит сохранение порядка, полевой замер не значит окончательный ответ. Если из всей серии выносить одну привычку — это она: прежде чем полагаться на тест, инвариант или сверку, показать себе, на чём именно они падают. Тест, никогда не видевший поражения, ничего не доказывает — это верно для replay-теста агрегата так же, как для сверки проекции и для любой другой проверки, которую пишет читатель у себя.
Начало серии — ES: когда важна история (концепция) и Event Sourcing на практике: туда стоит вернуться, если что-то из пяти статей опиралось на термин или каркас, объяснённый там впервые.
Демо и версии
- Demo: digital-cookbook/architecture/event-sourcing-deep — стенд
scripts/05-testing.sh:go test -v ./...(given-when-then агрегата, replay-тест противtestdata/history.jsonlс golden-сверкойtestdata/expected.json) иmvn testвjava/(TankAggregateTestна Axon). Go, Java. - Версии на прогоне: Axon Framework
4.13.2, Java (OpenJDK)17.0.19, Postgres18.4— та же схемаevents, что и в первой статье серии.
Документация и первоисточники
- Канон: Greg Young — CQRS Documents (PDF), Martin Fowler — Event Sourcing.
- Инструменты: Axon — документация, Axon — Testing (AggregateTestFixture), EventStoreDB — docs, Marten, Marten — Testing, Eventuate.
- Смежное на сайте: ES — концепция (ворота), ES на практике, event store вглубь, проектирование агрегатов и событий, проекции вглубь, версионирование и upcasting, тестирование распределённых систем, saga на практике.
Обсуждение в Telegram
Присоединиться →