alexei.dolgolyov/maraphon-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(phase-8-backend): per-event results harvesting + EventPath plumbing

Browse Source 
Implements Phase 8 Amendment 1: marathonbet.by has no public results archive
endpoint, so results must be harvested per-event by re-fetching the event
detail page until eventJsonInfo.matchIsComplete=true.

Backend changes:

* IOddsScraper:
  - ScrapeResultsAsync(DateRange) replaced with ScrapeEventResultAsync(Event)
    returning a nullable EventResult — null when match still in progress.
  - ScrapeEventOddsAsync now takes the full Event (so EventPath drives URL
    construction) instead of bare EventId.
  - New ScrapeLiveAsync() for the /su/live listing.

* Domain:
  - Event gains EventPath (nullable string) — the data-event-path attribute
    captured during scraping; required for reliable URL construction.

* Infrastructure:
  - New migration 20260506000000_AddEventPath adds the column.
  - EventEntity / EventConfiguration / Mapping / model-snapshot updated.
  - MarathonbetScraper: new ScrapeLiveAsync + ScrapeEventResultAsync; URL
    builder prefers EventPath, falls back to numeric ID for legacy rows.
  - EventListingParserBase extracts data-event-path on every listing row.

* Application:
  - PullResultsUseCase: branches on selection vs date-range, emits IProgress<
    PullResultsProgress>, returns ResultLoadOutcome (Loaded / AlreadyLoaded /
    NotYetComplete / Failed); idempotent (skips events whose result already
    exists).
  - PullLiveOddsUseCase now drives off the live listing (auto-discovers
    events that go live without ever appearing in the upcoming list) and
    backfills EventPath on legacy rows.
  - PullUpcomingEventsUseCase wires EventPath on persisted events.

* Workers: UpcomingEventsPoller updates persistence path accordingly.

* Tests: 17 net-new tests across Application + Infrastructure + Domain;
  all 293 still pass.
This commit is contained in:
Admin
2026-05-09 15:10:27 +03:00
parent 1bbf4fcfed
commit 9c5d3df1f2
18 changed files with 638 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/Marathon.Application.Tests/UseCases/PullLiveOddsUseCaseTests.cs
+90 -27
View File
@@ -21,22 +21,22 @@ public sealed class PullLiveOddsUseCaseTests
NullLogger<PullLiveOddsUseCase>.Instance);
[Fact]
public async Task Should_CaptureOneSnapshotPerEvent_When_TwoLiveEventsExistInDatabase()
public async Task Should_CaptureOneSnapshotPerEvent_When_LiveListingReturnsTwoEvents()
{
// Arrange: 2 events in the database
// Arrange: 2 events from the live listing; both already known to the DB
var ev1 = TestFixtures.MakeEvent("11111111");
var ev2 = TestFixtures.MakeEvent("22222222");
var storedEvents = new List<Event> { ev1, ev2 }.AsReadOnly();
var live = new List<Event> { ev1, ev2 }.AsReadOnly();
_eventRepo.ListAsync(Arg.Any<CancellationToken>()).Returns(storedEvents);
_scraper.ScrapeLiveAsync(Arg.Any<CancellationToken>()).Returns(live);
_eventRepo.GetAsync(ev1.Id, Arg.Any<CancellationToken>()).Returns(ev1);
_eventRepo.GetAsync(ev2.Id, Arg.Any<CancellationToken>()).Returns(ev2);
// ScrapeUpcomingAsync is also called (by implementation) — return empty to keep test focused
_scraper.ScrapeUpcomingAsync(null, Arg.Any<CancellationToken>())
.Returns(Array.Empty<Event>());
_scraper.ScrapeEventOddsAsync(ev1.Id, OddsSource.Live, Arg.Any<CancellationToken>())
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev1.Id), OddsSource.Live, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeSnapshot(ev1.Id, OddsSource.Live));
_scraper.ScrapeEventOddsAsync(ev2.Id, OddsSource.Live, Arg.Any<CancellationToken>())
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev2.Id), OddsSource.Live, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeSnapshot(ev2.Id, OddsSource.Live));
var sut = CreateSut();
@@ -47,46 +47,65 @@ public sealed class PullLiveOddsUseCaseTests
// Assert
snapshotsCaptured.Should().Be(2);
await _scraper.Received(1).ScrapeEventOddsAsync(ev1.Id, OddsSource.Live, Arg.Any<CancellationToken>());
await _scraper.Received(1).ScrapeEventOddsAsync(ev2.Id, OddsSource.Live, Arg.Any<CancellationToken>());
await _eventRepo.DidNotReceive().AddAsync(Arg.Any<Event>(), Arg.Any<CancellationToken>());
await _snapshotRepo.Received(2).AddAsync(Arg.Any<OddsSnapshot>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task Should_PersistNewLiveEvent_When_NotYetInDatabase()
{
// Arrange: live listing returns one event the DB has never seen
var live = TestFixtures.MakeEvent("99999999");
_scraper.ScrapeLiveAsync(Arg.Any<CancellationToken>())
.Returns(new List<Event> { live }.AsReadOnly());
_eventRepo.GetAsync(live.Id, Arg.Any<CancellationToken>()).Returns((Event?)null);
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == live.Id), OddsSource.Live, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeSnapshot(live.Id, OddsSource.Live));
var sut = CreateSut();
// Act
var snapshotsCaptured = await sut.ExecuteAsync(CancellationToken.None);
// Assert
snapshotsCaptured.Should().Be(1);
await _eventRepo.Received(1).AddAsync(live, Arg.Any<CancellationToken>());
}
[Fact]
public async Task Should_ContinueAfterSnapshotFailure_And_NotPropagateException()
{
// Arrange: 2 events — scraping the first throws
// Arrange: 2 live events — scraping the first throws
var ev1 = TestFixtures.MakeEvent("11111111");
var ev2 = TestFixtures.MakeEvent("22222222");
var storedEvents = new List<Event> { ev1, ev2 }.AsReadOnly();
_scraper.ScrapeLiveAsync(Arg.Any<CancellationToken>())
.Returns(new List<Event> { ev1, ev2 }.AsReadOnly());
_eventRepo.GetAsync(ev1.Id, Arg.Any<CancellationToken>()).Returns(ev1);
_eventRepo.GetAsync(ev2.Id, Arg.Any<CancellationToken>()).Returns(ev2);
_eventRepo.ListAsync(Arg.Any<CancellationToken>()).Returns(storedEvents);
_scraper.ScrapeUpcomingAsync(null, Arg.Any<CancellationToken>())
.Returns(Array.Empty<Event>());
_scraper.ScrapeEventOddsAsync(ev1.Id, OddsSource.Live, Arg.Any<CancellationToken>())
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev1.Id), OddsSource.Live, Arg.Any<CancellationToken>())
.ThrowsAsync(new HttpRequestException("timeout"));
_scraper.ScrapeEventOddsAsync(ev2.Id, OddsSource.Live, Arg.Any<CancellationToken>())
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev2.Id), OddsSource.Live, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeSnapshot(ev2.Id, OddsSource.Live));
var sut = CreateSut();
// Act — must not throw
var act = async () => await sut.ExecuteAsync(CancellationToken.None);
// Assert
await act.Should().NotThrowAsync();
// Re-execute to assert the count (mocks are still primed)
var result = await sut.ExecuteAsync(CancellationToken.None);
result.Should().Be(1, "only ev2 succeeded; ev1 failed silently");
}
[Fact]
public async Task Should_ReturnZero_When_NoEventsInDatabase()
public async Task Should_ReturnZero_When_LiveListingIsEmpty()
{
_eventRepo.ListAsync(Arg.Any<CancellationToken>())
.Returns(Array.Empty<Event>());
_scraper.ScrapeUpcomingAsync(null, Arg.Any<CancellationToken>())
_scraper.ScrapeLiveAsync(Arg.Any<CancellationToken>())
.Returns(Array.Empty<Event>());
var sut = CreateSut();
@@ -95,6 +114,50 @@ public sealed class PullLiveOddsUseCaseTests
result.Should().Be(0);
await _scraper.DidNotReceive()
.ScrapeEventOddsAsync(Arg.Any<EventId>(), Arg.Any<OddsSource>(), Arg.Any<CancellationToken>());
.ScrapeEventOddsAsync(Arg.Any<Event>(), Arg.Any<OddsSource>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task Should_ReturnZeroAndSwallow_When_LiveListingFetchThrows()
{
_scraper.ScrapeLiveAsync(Arg.Any<CancellationToken>())
.ThrowsAsync(new HttpRequestException("listing unavailable"));
var sut = CreateSut();
var result = await sut.ExecuteAsync(CancellationToken.None);
result.Should().Be(0);
await _scraper.DidNotReceive()
.ScrapeEventOddsAsync(Arg.Any<Event>(), Arg.Any<OddsSource>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task Should_BackfillEventPath_When_ExistingRowMissedIt()
{
// Arrange: DB row pre-dates the EventPath column (EventPath = null);
// live listing supplies a path.
var withoutPath = TestFixtures.MakeEvent("55555555");
var withPath = withoutPath with { EventPath = "Football/Some+Path/Team+vs+Team+-+99" };
_scraper.ScrapeLiveAsync(Arg.Any<CancellationToken>())
.Returns(new List<Event> { withPath }.AsReadOnly());
_eventRepo.GetAsync(withPath.Id, Arg.Any<CancellationToken>()).Returns(withoutPath);
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.EventPath == withPath.EventPath),
OddsSource.Live, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeSnapshot(withPath.Id, OddsSource.Live));
var sut = CreateSut();
// Act
var result = await sut.ExecuteAsync(CancellationToken.None);
// Assert — the DB row was updated with the new path before scraping odds
result.Should().Be(1);
await _eventRepo.Received(1).UpdateAsync(
Arg.Is<Event>(e => e.Id == withPath.Id && e.EventPath == withPath.EventPath),
Arg.Any<CancellationToken>());
}
}
tests/Marathon.Application.Tests/UseCases/PullResultsUseCaseTests.cs
+142 -35
View File
@@ -3,9 +3,11 @@ using Marathon.Application.Abstractions;
using Marathon.Application.Storage;
using Marathon.Application.UseCases;
using Marathon.Domain.Entities;
using Marathon.Domain.Enums;
using Marathon.Domain.ValueObjects;
using Microsoft.Extensions.Logging.Abstractions;
using NSubstitute;
using NSubstitute.ExceptionExtensions;
namespace Marathon.Application.Tests.UseCases;
@@ -23,13 +25,15 @@ public sealed class PullResultsUseCaseTests
new(_scraper, _eventRepo, _resultRepo,
NullLogger<PullResultsUseCase>.Instance);
// ── Selection mode ──────────────────────────────────────────────────────
[Fact]
public async Task Should_InspectOnlySelectedEvents_When_SelectionIsProvided()
{
// Arrange: 3 events in DB; only 2 are in the selection
// Arrange: 3 events in the DB; only 2 in the selection
var ev1 = TestFixtures.MakeEvent("11111111");
var ev2 = TestFixtures.MakeEvent("22222222");
var ev3 = TestFixtures.MakeEvent("33333333"); // not selected
var ev3 = TestFixtures.MakeEvent("33333333");
_eventRepo.GetAsync(ev1.Id, Arg.Any<CancellationToken>()).Returns(ev1);
_eventRepo.GetAsync(ev2.Id, Arg.Any<CancellationToken>()).Returns(ev2);
@@ -37,10 +41,8 @@ public sealed class PullResultsUseCaseTests
_resultRepo.GetAsync(Arg.Any<EventId>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
// Scraper returns no results (Phase 3 no-op)
_scraper.ScrapeResultsAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(Array.Empty<EventResult>());
_scraper.ScrapeEventResultAsync(Arg.Any<Event>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
var selection = new List<EventId> { ev1.Id, ev2.Id };
var sut = CreateSut();
@@ -48,19 +50,20 @@ public sealed class PullResultsUseCaseTests
// Act
var (inspected, loaded, skipped) = await sut.ExecuteAsync(AnyRange, selection, CancellationToken.None);
// Assert: only ev1 and ev2 inspected; ev3 not fetched via GetAsync lookup for range
// Assert: ev3 never resolved; only ev1+ev2 inspected
inspected.Should().Be(2);
loaded.Should().Be(0, "scraper returns no results in Phase 3");
loaded.Should().Be(0);
skipped.Should().Be(0);
// ev3 was never resolved
await _eventRepo.DidNotReceive().GetAsync(ev3.Id, Arg.Any<CancellationToken>());
await _eventRepo.DidNotReceive().ListByDateRangeAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>());
}
// ── Bulk mode ───────────────────────────────────────────────────────────
[Fact]
public async Task Should_InspectAllEventsInRange_When_SelectionIsNull()
{
// Arrange: 3 events returned by date-range query
var ev1 = TestFixtures.MakeEvent("11111111");
var ev2 = TestFixtures.MakeEvent("22222222");
var ev3 = TestFixtures.MakeEvent("33333333");
@@ -68,84 +71,188 @@ public sealed class PullResultsUseCaseTests
_eventRepo.ListByDateRangeAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(allEvents);
_resultRepo.GetAsync(Arg.Any<EventId>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_scraper.ScrapeResultsAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(Array.Empty<EventResult>());
_scraper.ScrapeEventResultAsync(Arg.Any<Event>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
var sut = CreateSut();
// Act
var (inspected, loaded, skipped) = await sut.ExecuteAsync(AnyRange, selection: null, CancellationToken.None);
// Assert
inspected.Should().Be(3);
loaded.Should().Be(0);
loaded.Should().Be(0, "scraper says none of them are complete yet");
skipped.Should().Be(0);
await _eventRepo.Received(1).ListByDateRangeAsync(AnyRange, Arg.Any<CancellationToken>());
}
[Fact]
public async Task Should_InspectAllEventsInRange_When_SelectionIsEmpty()
{
var ev1 = TestFixtures.MakeEvent("11111111");
_eventRepo.ListByDateRangeAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(new List<Event> { ev1 }.AsReadOnly());
_resultRepo.GetAsync(Arg.Any<EventId>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_scraper.ScrapeEventResultAsync(Arg.Any<Event>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
var sut = CreateSut();
var (inspected, _, _) = await sut.ExecuteAsync(
AnyRange,
selection: Array.Empty<EventId>(),
CancellationToken.None);
inspected.Should().Be(1);
await _eventRepo.Received(1).ListByDateRangeAsync(AnyRange, Arg.Any<CancellationToken>());
}
// ── Idempotency ─────────────────────────────────────────────────────────
[Fact]
public async Task Should_SkipEventsWithExistingResult_And_BeIdempotent()
{
// Arrange: 2 events — ev1 already has a result stored
var ev1 = TestFixtures.MakeEvent("11111111");
var ev2 = TestFixtures.MakeEvent("22222222");
var allEvents = new List<Event> { ev1, ev2 }.AsReadOnly();
_eventRepo.ListByDateRangeAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(allEvents);
.Returns(new List<Event> { ev1, ev2 }.AsReadOnly());
_resultRepo.GetAsync(ev1.Id, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeResult(ev1.Id)); // ev1 already has result
.Returns(TestFixtures.MakeResult(ev1.Id));
_resultRepo.GetAsync(ev2.Id, Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_scraper.ScrapeResultsAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(Array.Empty<EventResult>());
_scraper.ScrapeEventResultAsync(Arg.Any<Event>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
var sut = CreateSut();
// Act — run twice to verify idempotency
var (_, _, skipped1) = await sut.ExecuteAsync(AnyRange, null, CancellationToken.None);
var (_, _, skipped2) = await sut.ExecuteAsync(AnyRange, null, CancellationToken.None);
// Assert
skipped1.Should().Be(1, "ev1 already has a result");
skipped2.Should().Be(1, "idempotent: ev1 still skipped on second run");
// No new results persisted
await _resultRepo.DidNotReceive().AddAsync(Arg.Any<EventResult>(), Arg.Any<CancellationToken>());
await _scraper.DidNotReceive()
.ScrapeEventResultAsync(
Arg.Is<Event>(e => e.Id == ev1.Id),
Arg.Any<CancellationToken>());
}
// ── Successful loads ────────────────────────────────────────────────────
[Fact]
public async Task Should_PersistResults_When_ScraperReturnsMatchingResults()
public async Task Should_PersistResults_When_ScraperReturnsCompletedMatch()
{
// Arrange: 1 event; scraper returns a result for it
var ev1 = TestFixtures.MakeEvent("11111111");
var result1 = TestFixtures.MakeResult(ev1.Id);
var allEvents = new List<Event> { ev1 }.AsReadOnly();
_eventRepo.ListByDateRangeAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(allEvents);
.Returns(new List<Event> { ev1 }.AsReadOnly());
_resultRepo.GetAsync(ev1.Id, Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_scraper.ScrapeResultsAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(new List<EventResult> { result1 }.AsReadOnly());
_scraper.ScrapeEventResultAsync(
Arg.Is<Event>(e => e.Id == ev1.Id),
Arg.Any<CancellationToken>())
.Returns(result1);
var sut = CreateSut();
// Act
var (inspected, loaded, skipped) = await sut.ExecuteAsync(AnyRange, null, CancellationToken.None);
// Assert
inspected.Should().Be(1);
loaded.Should().Be(1);
skipped.Should().Be(0);
await _resultRepo.Received(1).AddAsync(result1, Arg.Any<CancellationToken>());
await _resultRepo.Received(1).SaveChangesAsync(Arg.Any<CancellationToken>());
}
// ── Progress reporting ──────────────────────────────────────────────────
[Fact]
public async Task Should_ReportProgress_OncePerCandidate_With_CorrectOutcome()
{
var ev1 = TestFixtures.MakeEvent("11111111"); // already has result → AlreadyLoaded
var ev2 = TestFixtures.MakeEvent("22222222"); // scrape returns null → NotYetComplete
var ev3 = TestFixtures.MakeEvent("33333333"); // scrape returns res3 → Loaded
var result3 = TestFixtures.MakeResult(ev3.Id);
_eventRepo.ListByDateRangeAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(new List<Event> { ev1, ev2, ev3 }.AsReadOnly());
_resultRepo.GetAsync(ev1.Id, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeResult(ev1.Id));
_resultRepo.GetAsync(ev2.Id, Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_resultRepo.GetAsync(ev3.Id, Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_scraper.ScrapeEventResultAsync(
Arg.Is<Event>(e => e.Id == ev2.Id), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_scraper.ScrapeEventResultAsync(
Arg.Is<Event>(e => e.Id == ev3.Id), Arg.Any<CancellationToken>())
.Returns(result3);
var ticks = new List<PullResultsProgress>();
var progress = new Progress<PullResultsProgress>(ticks.Add);
var sut = CreateSut();
await sut.ExecuteAsync(AnyRange, null, progress, CancellationToken.None);
// Progress callback runs on the synchronization context — pump it
await Task.Delay(50);
ticks.Should().HaveCount(3);
ticks.Select(t => t.Total).Should().AllBeEquivalentTo(3);
ticks.Select(t => t.Processed).Should().Equal(1, 2, 3);
ticks.Select(t => t.Outcome).Should().Equal(
ResultLoadOutcome.AlreadyLoaded,
ResultLoadOutcome.NotYetComplete,
ResultLoadOutcome.Loaded);
ticks[2].Result.Should().Be(result3);
}
// ── Failure isolation ───────────────────────────────────────────────────
[Fact]
public async Task Should_ContinueAfterScrapeFailure_AndReportFailedOutcome()
{
var ev1 = TestFixtures.MakeEvent("11111111");
var ev2 = TestFixtures.MakeEvent("22222222");
var result2 = TestFixtures.MakeResult(ev2.Id);
_eventRepo.ListByDateRangeAsync(Arg.Any<DateRange>(), Arg.Any<CancellationToken>())
.Returns(new List<Event> { ev1, ev2 }.AsReadOnly());
_resultRepo.GetAsync(Arg.Any<EventId>(), Arg.Any<CancellationToken>())
.Returns((EventResult?)null);
_scraper.ScrapeEventResultAsync(
Arg.Is<Event>(e => e.Id == ev1.Id), Arg.Any<CancellationToken>())
.ThrowsAsync(new HttpRequestException("network down"));
_scraper.ScrapeEventResultAsync(
Arg.Is<Event>(e => e.Id == ev2.Id), Arg.Any<CancellationToken>())
.Returns(result2);
var ticks = new List<PullResultsProgress>();
var progress = new Progress<PullResultsProgress>(ticks.Add);
var sut = CreateSut();
var (inspected, loaded, _) = await sut.ExecuteAsync(AnyRange, null, progress, CancellationToken.None);
await Task.Delay(50);
inspected.Should().Be(2);
loaded.Should().Be(1, "ev1 failed, ev2 loaded");
ticks.Should().HaveCount(2);
ticks[0].Outcome.Should().Be(ResultLoadOutcome.Failed);
ticks[1].Outcome.Should().Be(ResultLoadOutcome.Loaded);
}
}
tests/Marathon.Application.Tests/UseCases/PullUpcomingEventsUseCaseTests.cs
+8 -6
View File
@@ -30,8 +30,8 @@ public sealed class PullUpcomingEventsUseCaseTests
_scraper.ScrapeUpcomingAsync(null, Arg.Any<CancellationToken>()).Returns(events);
_eventRepo.GetAsync(Arg.Any<EventId>(), Arg.Any<CancellationToken>()).Returns((Event?)null);
_scraper.ScrapeEventOddsAsync(Arg.Any<EventId>(), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.Returns(ci => TestFixtures.MakeSnapshot(ci.Arg<EventId>()));
_scraper.ScrapeEventOddsAsync(Arg.Any<Event>(), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.Returns(ci => TestFixtures.MakeSnapshot(ci.Arg<Event>().Id));
var sut = CreateSut();
@@ -63,8 +63,8 @@ public sealed class PullUpcomingEventsUseCaseTests
_eventRepo.GetAsync(ev2.Id, Arg.Any<CancellationToken>()).Returns((Event?)null);
_eventRepo.GetAsync(ev3.Id, Arg.Any<CancellationToken>()).Returns((Event?)null);
_scraper.ScrapeEventOddsAsync(Arg.Any<EventId>(), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.Returns(ci => TestFixtures.MakeSnapshot(ci.Arg<EventId>()));
_scraper.ScrapeEventOddsAsync(Arg.Any<Event>(), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.Returns(ci => TestFixtures.MakeSnapshot(ci.Arg<Event>().Id));
var sut = CreateSut();
@@ -91,9 +91,11 @@ public sealed class PullUpcomingEventsUseCaseTests
_scraper.ScrapeUpcomingAsync(null, Arg.Any<CancellationToken>()).Returns(events);
_eventRepo.GetAsync(Arg.Any<EventId>(), Arg.Any<CancellationToken>()).Returns((Event?)null);
_scraper.ScrapeEventOddsAsync(ev1.Id, OddsSource.PreMatch, Arg.Any<CancellationToken>())
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev1.Id), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.ThrowsAsync(new HttpRequestException("site down"));
_scraper.ScrapeEventOddsAsync(ev2.Id, OddsSource.PreMatch, Arg.Any<CancellationToken>())
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev2.Id), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeSnapshot(ev2.Id));
var sut = CreateSut();