azaion/satellite-provider
1
0
Fork 0
mirror of https://github.com/azaion/satellite-provider.git synced 2026-06-22 19:11:15 +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/RouteServiceTests.cs
+303
View File
@@ -0,0 +1,303 @@
using FluentAssertions;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using SatelliteProvider.Common.DTO;
using SatelliteProvider.Common.Interfaces;
using SatelliteProvider.Common.Utils;
using SatelliteProvider.DataAccess.Models;
using SatelliteProvider.DataAccess.Repositories;
using SatelliteProvider.Services;
using SatelliteProvider.Tests.Fixtures;
namespace SatelliteProvider.Tests;
public class RouteServiceTests
{
private static RouteService BuildService(
Mock<IRouteRepository> routeRepo,
Mock<IRegionService> regionService)
{
return new RouteService(routeRepo.Object, regionService.Object, NullLogger<RouteService>.Instance);
}
private static CreateRouteRequest BuildRequest(IEnumerable<(double Lat, double Lon)> points, double regionSize = 500, int zoom = 18, bool requestMaps = false, Geofences? geofences = null)
{
return new CreateRouteRequest
{
Id = Guid.NewGuid(),
Name = "test route",
Description = "unit test route",
RegionSizeMeters = regionSize,
ZoomLevel = zoom,
Points = points.Select(p => new RoutePoint { Latitude = p.Lat, Longitude = p.Lon }).ToList(),
RequestMaps = requestMaps,
Geofences = geofences,
};
}
[Fact]
public async Task CreateRouteAsync_TwoPointRoute_GeneratesIntermediatePointsAtMax200mSpacing_BT06_AC1()
{
// Arrange
var routeRepo = new Mock<IRouteRepository>();
var regionService = new Mock<IRegionService>();
var service = BuildService(routeRepo, regionService);
var request = BuildRequest(TestCoordinates.Route.Route01Points, regionSize: 500, zoom: 18);
// Act
var result = await service.CreateRouteAsync(request);
// Assert
result.TotalPoints.Should().BeGreaterThan(2, "intermediate points must be inserted between user-supplied points");
result.Points.Should().HaveCount(result.TotalPoints);
// Spacing AC: every consecutive pair within a segment must be ≤200m apart.
for (int i = 1; i < result.Points.Count; i++)
{
var prev = result.Points[i - 1];
var cur = result.Points[i];
var distance = GeoUtils.CalculateDistance(
new GeoPoint(prev.Latitude, prev.Longitude),
new GeoPoint(cur.Latitude, cur.Longitude));
distance.Should().BeLessThanOrEqualTo(200.5, $"point {i - 1}→{i} must be ≤200m");
}
}
[Fact]
public async Task CreateRouteAsync_TwoPointRoute_FirstAndLastUserPointsKeepTheirRoles_BT06_AC2()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var request = BuildRequest(TestCoordinates.Route.Route01Points);
// Act
var result = await service.CreateRouteAsync(request);
// Assert
result.Points.First().PointType.Should().Be("start", "first user-supplied point");
result.Points.Last().PointType.Should().Be("end", "last user-supplied point");
result.Points.Skip(1).Take(result.Points.Count - 2).Should().OnlyContain(p => p.PointType == "intermediate",
"every middle point in a 2-point route is interpolated");
}
[Fact]
public async Task CreateRouteAsync_TenPointRoute_HasOneStartOneEndAndOnlyIntermediatesBetween_BT10()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var request = BuildRequest(TestCoordinates.Route.Route04Points, regionSize: 300);
// Act
var result = await service.CreateRouteAsync(request);
// Assert
result.Points.Count(p => p.PointType == "start").Should().Be(1);
result.Points.Count(p => p.PointType == "end").Should().Be(1);
result.Points.Count(p => p.PointType == "action").Should().Be(8, "8 middle user-supplied waypoints in a 10-point route");
result.Points.Should().Contain(p => p.PointType == "intermediate", "long route always interpolates");
}
[Fact]
public async Task CreateRouteAsync_TwentyPointRoute_HasOneStartOneEndAndEighteenAction_BT12()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var request = BuildRequest(TestCoordinates.Route.Route06Points, regionSize: 300);
// Act
var result = await service.CreateRouteAsync(request);
// Assert
result.Points.Count(p => p.PointType == "start").Should().Be(1);
result.Points.Count(p => p.PointType == "end").Should().Be(1);
result.Points.Count(p => p.PointType == "action").Should().Be(18, "18 middle user-supplied waypoints in a 20-point route");
}
[Fact]
public async Task CreateRouteAsync_ComputesTotalDistanceViaHaversine_AC3()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var request = BuildRequest(TestCoordinates.Route.Route01Points);
// Act
var result = await service.CreateRouteAsync(request);
// Assert: distance is positive and equals the sum of consecutive spacings ± rounding.
result.TotalDistanceMeters.Should().BeGreaterThan(0);
var summed = 0.0;
for (int i = 1; i < result.Points.Count; i++)
{
var prev = result.Points[i - 1];
var cur = result.Points[i];
summed += GeoUtils.CalculateDistance(
new GeoPoint(prev.Latitude, prev.Longitude),
new GeoPoint(cur.Latitude, cur.Longitude));
}
result.TotalDistanceMeters.Should().BeApproximately(summed, 1.0,
"TotalDistanceMeters must equal Σ Haversine(point[i-1], point[i])");
}
[Fact]
public async Task CreateRouteAsync_LessThanTwoPoints_Throws_BTN03_AC4()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var request = BuildRequest(new[] { (47.461747, 37.647063) });
// Act
Func<Task> act = () => service.CreateRouteAsync(request);
// Assert
await act.Should().ThrowAsync<ArgumentException>()
.WithMessage("*at least 2 points*");
}
[Fact]
public async Task CreateRouteAsync_InvalidRegionSize_Throws()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var request = BuildRequest(TestCoordinates.Route.Route01Points, regionSize: 50);
// Act
Func<Task> act = () => service.CreateRouteAsync(request);
// Assert
await act.Should().ThrowAsync<ArgumentException>()
.WithMessage("*Region size must be between 100 and 10000*");
}
[Fact]
public async Task CreateRouteAsync_GeofenceWithZeroZeroCorner_Throws_BTN04()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var geofences = new Geofences
{
Polygons = new List<GeofencePolygon>
{
new() { NorthWest = new GeoPoint(0, 0), SouthEast = new GeoPoint(0, 0) },
},
};
var request = BuildRequest(TestCoordinates.Route.Route01Points, geofences: geofences);
// Act
Func<Task> act = () => service.CreateRouteAsync(request);
// Assert
await act.Should().ThrowAsync<ArgumentException>()
.WithMessage("*coordinates cannot be (0,0)*");
}
[Fact]
public async Task CreateRouteAsync_GeofenceWithInvertedCorners_Throws_BTN05()
{
// Arrange
var service = BuildService(new Mock<IRouteRepository>(), new Mock<IRegionService>());
var geofences = new Geofences
{
Polygons = new List<GeofencePolygon>
{
// northWest.Lat (48.250) <= southEast.Lat (48.280) → invalid
new() { NorthWest = new GeoPoint(48.250, 37.370), SouthEast = new GeoPoint(48.280, 37.395) },
},
};
var request = BuildRequest(TestCoordinates.Route.Route01Points, geofences: geofences);
// Act
Func<Task> act = () => service.CreateRouteAsync(request);
// Assert
await act.Should().ThrowAsync<ArgumentException>()
.WithMessage("*northWest latitude*");
}
[Fact]
public async Task CreateRouteAsync_ValidGeofence_QueuesGeofenceRegions_BT11()
{
// Arrange
var routeRepo = new Mock<IRouteRepository>();
var regionService = new Mock<IRegionService>();
regionService
.Setup(r => r.RequestRegionAsync(It.IsAny<Guid>(), It.IsAny<double>(), It.IsAny<double>(), It.IsAny<double>(), It.IsAny<int>(), false))
.ReturnsAsync(new RegionStatus { Status = "queued" });
var service = BuildService(routeRepo, regionService);
var geofences = new Geofences
{
Polygons = new List<GeofencePolygon>
{
new() { NorthWest = new GeoPoint(48.280, 37.370), SouthEast = new GeoPoint(48.265, 37.395) },
},
};
var request = BuildRequest(TestCoordinates.Route.Route04Points, regionSize: 300, geofences: geofences);
// Act
var result = await service.CreateRouteAsync(request);
// Assert
result.TotalPoints.Should().BeGreaterThan(0);
regionService.Verify(r => r.RequestRegionAsync(
It.IsAny<Guid>(), It.IsAny<double>(), It.IsAny<double>(),
300, It.IsAny<int>(), false), Times.AtLeastOnce,
"geofence creates at least one region request");
routeRepo.Verify(r => r.LinkRouteToRegionAsync(
request.Id, It.IsAny<Guid>(), true, 0), Times.AtLeastOnce,
"geofence regions are linked to the route with isGeofence=true");
}
[Fact]
public async Task GetRouteAsync_KnownId_ReturnsRouteWithPoints_BT07()
{
// Arrange
var routeRepo = new Mock<IRouteRepository>();
var id = Guid.NewGuid();
var routeEntity = new RouteEntity
{
Id = id,
Name = "test",
RegionSizeMeters = 500,
ZoomLevel = 18,
TotalDistanceMeters = 1234,
TotalPoints = 4,
};
routeRepo.Setup(r => r.GetByIdAsync(id)).ReturnsAsync(routeEntity);
routeRepo.Setup(r => r.GetRoutePointsAsync(id)).ReturnsAsync(new List<RoutePointEntity>
{
new() { Id = Guid.NewGuid(), RouteId = id, SequenceNumber = 0, Latitude = 1, Longitude = 2, PointType = "start", SegmentIndex = 0 },
new() { Id = Guid.NewGuid(), RouteId = id, SequenceNumber = 1, Latitude = 3, Longitude = 4, PointType = "end", SegmentIndex = 1 },
});
var service = BuildService(routeRepo, new Mock<IRegionService>());
// Act
var result = await service.GetRouteAsync(id);
// Assert
result.Should().NotBeNull();
result!.Id.Should().Be(id);
result.Points.Should().HaveCount(2);
result.Points[0].PointType.Should().Be("start");
result.Points[1].PointType.Should().Be("end");
}
[Fact]
public async Task GetRouteAsync_UnknownId_ReturnsNull()
{
// Arrange
var routeRepo = new Mock<IRouteRepository>();
routeRepo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((RouteEntity?)null);
var service = BuildService(routeRepo, new Mock<IRegionService>());
// Act
var result = await service.GetRouteAsync(Guid.NewGuid());
// Assert
result.Should().BeNull();
}
}