azaion/satellite-provider
1
0
Fork 0
mirror of https://github.com/azaion/satellite-provider.git synced 2026-06-22 15:41:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AZ-286] [AZ-287] [AZ-288] Service-level unit tests (mocked deps)

Browse Source 
Batch 2: 27 new tests, 31/31 total passing.

AZ-286 TileService (9 tests):
- BT-01 download stores tiles via repository
- BT-02 cache reuse passes existing tiles to downloader
- BT-02b stale-version cached tiles are NOT treated as still-valid
- BT-N02 GoogleMapsDownloaderV2 rejects zoom levels not in {15..19}
- GetTileAsync known/unknown id

AZ-287 RegionService (6 tests):
- AC-1 RequestRegionAsync inserts entity and queues request
- AC-2/AC-3 ProcessRegionAsync transitions queued→processing→completed
  and writes CSV + summary files
- AC-4 stitch path is set when stitchTiles=true
- ProcessRegionAsync handles RateLimitException by writing failed
  summary with the error message preserved
- GetRegionStatusAsync mapping
- Missing region id is logged and short-circuits without DB writes

AZ-288 RouteService (12 tests):
- AC-1 every consecutive pair is ≤200m apart on 2-point route
- AC-2 first/last user points keep their roles; middles are interpolated
- BT-10 10pt route → 1 start, 1 end, 8 action, plus intermediates
- BT-12 20pt route → 1 start, 1 end, 18 action
- AC-3 TotalDistanceMeters == Σ Haversine(point[i-1], point[i])
- BT-N03 < 2 points throws ArgumentException
- regionSize <100 / >10000 throws ArgumentException
- BT-N04 (0,0) corner throws
- BT-N05 inverted NW.lat <= SE.lat throws
- BT-11 valid geofence creates region requests + links them with
  isGeofence=true
- BT-07 GetRouteAsync returns route + points
- GetRouteAsync unknown id returns null

Code review: PASS_WITH_WARNINGS — 3 Low Spec-Gap findings:
  1. BT-N01 (invalid coords) deferred to AZ-289 integration tests
     (TileService doesn't validate coordinates — API-layer concern)
  2. Point-type label drift between blackbox-tests.md ("original")
     and code ("start"/"action"/"end")
  3. Region status drift: spec "pending" vs code "queued" — initial
     state on insert

Verification: docker dotnet test — 31/31 pass in 0.83s.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Oleksandr Bezdieniezhnykh
2026-05-10 05:02:00 +03:00
parent 3d112c0f47
commit dea0b8b4c0
9 changed files with 965 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SatelliteProvider.Tests/RegionServiceTests.cs
+281
View File
@@ -0,0 +1,281 @@
using FluentAssertions;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using Moq;
using SatelliteProvider.Common.Configs;
using SatelliteProvider.Common.DTO;
using SatelliteProvider.Common.Interfaces;
using SatelliteProvider.DataAccess.Models;
using SatelliteProvider.DataAccess.Repositories;
using SatelliteProvider.Services;
namespace SatelliteProvider.Tests;
public class RegionServiceTests : IDisposable
{
private readonly string _readyDir;
public RegionServiceTests()
{
_readyDir = Path.Combine(Path.GetTempPath(), "sp-region-tests-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(_readyDir);
}
public void Dispose()
{
if (Directory.Exists(_readyDir))
{
Directory.Delete(_readyDir, recursive: true);
}
}
private RegionService BuildService(
Mock<IRegionRepository> regionRepo,
Mock<IRegionRequestQueue> queue,
Mock<ITileService> tileService)
{
var storage = Options.Create(new StorageConfig { ReadyDirectory = _readyDir, TilesDirectory = "/tiles" });
return new RegionService(regionRepo.Object, queue.Object, tileService.Object, storage, NullLogger<RegionService>.Instance);
}
[Fact]
public async Task RequestRegionAsync_InsertsEntityAndQueues_BT03_AC1()
{
// Arrange
var regionRepo = new Mock<IRegionRepository>();
var queue = new Mock<IRegionRequestQueue>();
var tileService = new Mock<ITileService>();
var service = BuildService(regionRepo, queue, tileService);
var id = Guid.NewGuid();
// Act
var status = await service.RequestRegionAsync(id, 47.461747, 37.647063, 200, 18);
// Assert
status.Id.Should().Be(id);
status.Status.Should().Be("queued");
regionRepo.Verify(r => r.InsertAsync(It.Is<RegionEntity>(re =>
re.Id == id &&
re.Status == "queued" &&
re.SizeMeters == 200 &&
re.ZoomLevel == 18)), Times.Once);
queue.Verify(q => q.EnqueueAsync(It.Is<RegionRequest>(rr =>
rr.Id == id &&
rr.SizeMeters == 200 &&
rr.ZoomLevel == 18 &&
rr.StitchTiles == false), It.IsAny<CancellationToken>()), Times.Once);
}
[Fact]
public async Task ProcessRegionAsync_HappyPath_TransitionsToCompletedAndWritesArtifacts_BT03_AC2_AC3()
{
// Arrange
var regionRepo = new Mock<IRegionRepository>();
var queue = new Mock<IRegionRequestQueue>();
var tileService = new Mock<ITileService>();
var id = Guid.NewGuid();
var entity = new RegionEntity
{
Id = id,
Latitude = 47.461747,
Longitude = 37.647063,
SizeMeters = 200,
ZoomLevel = 18,
Status = "queued",
StitchTiles = false,
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow,
};
regionRepo.Setup(r => r.GetByIdAsync(id)).ReturnsAsync(entity);
var capturedStatuses = new List<string>();
regionRepo
.Setup(r => r.UpdateAsync(It.IsAny<RegionEntity>()))
.Callback<RegionEntity>(e => capturedStatuses.Add(e.Status))
.ReturnsAsync(1);
tileService
.Setup(t => t.GetTilesByRegionAsync(entity.Latitude, entity.Longitude, entity.SizeMeters, entity.ZoomLevel))
.ReturnsAsync(Array.Empty<TileMetadata>());
tileService
.Setup(t => t.DownloadAndStoreTilesAsync(
entity.Latitude, entity.Longitude, entity.SizeMeters, entity.ZoomLevel,
It.IsAny<CancellationToken>()))
.ReturnsAsync(new List<TileMetadata>
{
new()
{
Id = Guid.NewGuid(),
Latitude = entity.Latitude,
Longitude = entity.Longitude,
TileZoom = entity.ZoomLevel,
TileSizePixels = 256,
ImageType = "jpg",
FilePath = "tiles/18/0/0/x.jpg",
},
});
var service = BuildService(regionRepo, queue, tileService);
// Act
await service.ProcessRegionAsync(id);
// Assert
capturedStatuses.Should().ContainInOrder("processing", "completed");
entity.Status.Should().Be("completed");
entity.CsvFilePath.Should().NotBeNullOrEmpty();
entity.SummaryFilePath.Should().NotBeNullOrEmpty();
entity.TilesDownloaded.Should().Be(1);
entity.TilesReused.Should().Be(0);
File.Exists(entity.CsvFilePath!).Should().BeTrue("CSV file is written to ReadyDirectory");
File.Exists(entity.SummaryFilePath!).Should().BeTrue("summary file is written to ReadyDirectory");
}
[Fact]
public async Task ProcessRegionAsync_MissingRegionId_LogsAndReturns()
{
// Arrange
var regionRepo = new Mock<IRegionRepository>();
regionRepo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((RegionEntity?)null);
var service = BuildService(regionRepo, new Mock<IRegionRequestQueue>(), new Mock<ITileService>());
// Act
await service.ProcessRegionAsync(Guid.NewGuid());
// Assert
regionRepo.Verify(r => r.UpdateAsync(It.IsAny<RegionEntity>()), Times.Never);
}
[Fact]
public async Task ProcessRegionAsync_DownloaderFailure_TransitionsToFailedAndWritesErrorSummary()
{
// Arrange
var regionRepo = new Mock<IRegionRepository>();
var queue = new Mock<IRegionRequestQueue>();
var tileService = new Mock<ITileService>();
var id = Guid.NewGuid();
var entity = new RegionEntity
{
Id = id,
Latitude = 47.461747,
Longitude = 37.647063,
SizeMeters = 200,
ZoomLevel = 18,
Status = "queued",
StitchTiles = false,
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow,
};
regionRepo.Setup(r => r.GetByIdAsync(id)).ReturnsAsync(entity);
var capturedStatuses = new List<string>();
regionRepo
.Setup(r => r.UpdateAsync(It.IsAny<RegionEntity>()))
.Callback<RegionEntity>(e => capturedStatuses.Add(e.Status))
.ReturnsAsync(1);
tileService
.Setup(t => t.GetTilesByRegionAsync(It.IsAny<double>(), It.IsAny<double>(), It.IsAny<double>(), It.IsAny<int>()))
.ReturnsAsync(Array.Empty<TileMetadata>());
tileService
.Setup(t => t.DownloadAndStoreTilesAsync(
It.IsAny<double>(), It.IsAny<double>(), It.IsAny<double>(), It.IsAny<int>(),
It.IsAny<CancellationToken>()))
.ThrowsAsync(new RateLimitException("Google Maps rate limit exceeded"));
var service = BuildService(regionRepo, queue, tileService);
// Act
await service.ProcessRegionAsync(id);
// Assert
capturedStatuses.Should().ContainInOrder("processing", "failed");
entity.Status.Should().Be("failed");
entity.SummaryFilePath.Should().NotBeNullOrEmpty();
File.Exists(entity.SummaryFilePath!).Should().BeTrue();
File.ReadAllText(entity.SummaryFilePath!).Should().Contain("Rate limit exceeded");
}
[Fact]
public async Task ProcessRegionAsync_StitchEnabled_SetsStitchedImagePath_BT05_AC4()
{
// Arrange
var regionRepo = new Mock<IRegionRepository>();
var queue = new Mock<IRegionRequestQueue>();
var tileService = new Mock<ITileService>();
var id = Guid.NewGuid();
var entity = new RegionEntity
{
Id = id,
Latitude = 47.461747,
Longitude = 37.647063,
SizeMeters = 500,
ZoomLevel = 18,
Status = "queued",
StitchTiles = true,
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow,
};
regionRepo.Setup(r => r.GetByIdAsync(id)).ReturnsAsync(entity);
regionRepo.Setup(r => r.UpdateAsync(It.IsAny<RegionEntity>())).ReturnsAsync(1);
tileService
.Setup(t => t.GetTilesByRegionAsync(It.IsAny<double>(), It.IsAny<double>(), It.IsAny<double>(), It.IsAny<int>()))
.ReturnsAsync(Array.Empty<TileMetadata>());
tileService
.Setup(t => t.DownloadAndStoreTilesAsync(
It.IsAny<double>(), It.IsAny<double>(), It.IsAny<double>(), It.IsAny<int>(),
It.IsAny<CancellationToken>()))
.ReturnsAsync(new List<TileMetadata>
{
new()
{
Id = Guid.NewGuid(),
Latitude = entity.Latitude,
Longitude = entity.Longitude,
TileZoom = entity.ZoomLevel,
TileSizePixels = 256,
ImageType = "jpg",
// Path doesn't exist on disk — stitcher will skip but still produce an empty image.
FilePath = Path.Combine(_readyDir, "missing.jpg"),
},
});
var service = BuildService(regionRepo, queue, tileService);
// Act
await service.ProcessRegionAsync(id);
// Assert
entity.Status.Should().Be("completed");
var stitchedPath = Path.Combine(_readyDir, $"region_{id}_stitched.jpg");
File.Exists(stitchedPath).Should().BeTrue("stitched image must exist when stitchTiles=true");
}
[Fact]
public async Task GetRegionStatusAsync_KnownId_ReturnsMappedStatus()
{
// Arrange
var regionRepo = new Mock<IRegionRepository>();
var id = Guid.NewGuid();
regionRepo.Setup(r => r.GetByIdAsync(id))
.ReturnsAsync(new RegionEntity { Id = id, Status = "completed", TilesDownloaded = 5, TilesReused = 2 });
var service = BuildService(regionRepo, new Mock<IRegionRequestQueue>(), new Mock<ITileService>());
// Act
var result = await service.GetRegionStatusAsync(id);
// Assert
result.Should().NotBeNull();
result!.Status.Should().Be("completed");
result.TilesDownloaded.Should().Be(5);
result.TilesReused.Should().Be(2);
}
}