< Summary

Information
Class: RoleRadar.Application.Tracking.Import.Commands.TrackerImportCoordinator
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Import/Commands/ImportTrackerCommand.cs
Line coverage
95%
Covered lines: 64
Uncovered lines: 3
Coverable lines: 67
Total lines: 161
Line coverage: 95.5%
Branch coverage
81%
Covered branches: 39
Total branches: 48
Branch coverage: 81.2%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)50%88100%
ExecuteAsync()85%202089.28%
RunPipelineAsync()100%11100%
CheckForMissingOrPartialDates(...)90%2020100%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Tracking/Import/Commands/ImportTrackerCommand.cs

#LineLine coverage
 1using RoleRadar.Application.Abstractions;
 2using RoleRadar.Application.Tracking.Import.Pipeline;
 3using RoleRadar.Application.Tracking.Import.Report;
 4using RoleRadar.Domain.Common;
 5
 6namespace RoleRadar.Application.Tracking.Import.Commands;
 7
 8public sealed record ImportTrackerCommand(
 9    string BundleDirectory,
 10    DateOnly? DefaultDate = null,
 11    bool Apply = false,
 12    string? ReportPath = null,
 13    string? OwnerId = null);
 14
 15public interface ITrackerImportCoordinator
 16{
 17    Task<Result<TrackerImportSummary>> ExecuteAsync(ImportTrackerCommand command, CancellationToken cancellationToken = 
 18}
 19
 20public sealed class TrackerImportCoordinator : ITrackerImportCoordinator
 21{
 22    private readonly ITrackerScratchManager _scratchManager;
 23    private readonly ITrackingContextFactory _contextFactory;
 24    private readonly ICsvParser _csvParser;
 25    private readonly ITrackerImportPipelineFactory _pipelineFactory;
 26
 3827    public TrackerImportCoordinator(
 3828        ITrackerScratchManager scratchManager,
 3829        ITrackingContextFactory contextFactory,
 3830        ICsvParser csvParser,
 3831        ITrackerImportPipelineFactory pipelineFactory)
 32    {
 3833        _scratchManager = scratchManager ?? throw new ArgumentNullException(nameof(scratchManager));
 3834        _contextFactory = contextFactory ?? throw new ArgumentNullException(nameof(contextFactory));
 3835        _csvParser = csvParser ?? throw new ArgumentNullException(nameof(csvParser));
 3836        _pipelineFactory = pipelineFactory ?? throw new ArgumentNullException(nameof(pipelineFactory));
 3837    }
 38
 39    public async Task<Result<TrackerImportSummary>> ExecuteAsync(
 40        ImportTrackerCommand command,
 41        CancellationToken cancellationToken = default)
 42    {
 4443        ArgumentNullException.ThrowIfNull(command);
 44
 4445        if (string.IsNullOrWhiteSpace(command.BundleDirectory) || !Directory.Exists(command.BundleDirectory))
 46        {
 047            return Result<TrackerImportSummary>.Failure(
 048                ErrorCode.ValidationError,
 049                $"Bundle directory not found: '{command.BundleDirectory}'.");
 50        }
 51
 52        // Validate --report path does not reside in a git work tree
 4453        if (!string.IsNullOrWhiteSpace(command.ReportPath))
 54        {
 455            if (TrackerImportReportGenerator.IsInsideGitWorkTree(command.ReportPath))
 56            {
 257                return Result<TrackerImportSummary>.Failure(
 258                    ErrorCode.ValidationError,
 259                    $"Refusing to write report to '{command.ReportPath}': report path must not reside inside a git worki
 60            }
 61        }
 62
 63        // Pre-scan for missing dates when --default-date is omitted
 4264        if (command.DefaultDate is null)
 65        {
 666            var dateCheckResult = CheckForMissingOrPartialDates(command.BundleDirectory);
 667            if (dateCheckResult is not null)
 68            {
 269                return Result<TrackerImportSummary>.Failure(dateCheckResult.Value);
 70            }
 71        }
 72
 4073        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 4074            ? OwnerId.Default.Value
 4075            : new OwnerId(command.OwnerId).Value;
 76
 4077        var targetDbName = _contextFactory.TargetDatabaseName;
 78
 79        Result<TrackerImportSummary> runResult;
 4080        if (!command.Apply)
 81        {
 82            // Dry-run mode: ephemerally isolated inside scratch database
 1483            await _scratchManager.CleanupOrphanedScratchDatabasesAsync(targetDbName, cancellationToken: cancellationToke
 84
 1485            await using var scratchScope = await _scratchManager.CreateScopeAsync(targetDbName, cancellationToken);
 1486            runResult = await RunPipelineAsync(scratchScope.ScratchDatabaseName, ownerId, command, isDryRun: true, cance
 1487        }
 88        else
 89        {
 90            // Apply mode: commits persistent writes to target database
 2691            runResult = await RunPipelineAsync(targetDbName, ownerId, command, isDryRun: false, cancellationToken);
 92        }
 93
 4094        if (runResult.IsSuccess && !string.IsNullOrWhiteSpace(command.ReportPath))
 95        {
 296            await TrackerImportReportGenerator.GenerateReportAsync(command.ReportPath, command, runResult.Value!, cancel
 97        }
 98
 4099        return runResult;
 44100    }
 101
 102    private async Task<Result<TrackerImportSummary>> RunPipelineAsync(
 103        string databaseName,
 104        string ownerId,
 105        ImportTrackerCommand command,
 106        bool isDryRun,
 107        CancellationToken cancellationToken)
 108    {
 40109        var context = new TrackerImportContext
 40110        {
 40111            OwnerId = ownerId,
 40112            BundleDirectory = command.BundleDirectory,
 40113            DefaultDate = command.DefaultDate,
 40114            Apply = command.Apply,
 40115            Summary = { IsDryRun = isDryRun }
 40116        };
 117
 40118        var trackingContext = _contextFactory.CreateContext(databaseName);
 40119        var pipeline = _pipelineFactory.CreatePipeline(trackingContext);
 120
 40121        return await pipeline.ExecuteAsync(context, cancellationToken);
 40122    }
 123
 124
 125
 126    private ResultError? CheckForMissingOrPartialDates(string bundleDirectory)
 127    {
 6128        var filesToCheck = new[] { "appendix-rows.csv", "applications.csv" };
 129
 30130        foreach (var file in filesToCheck)
 131        {
 10132            var fullPath = Path.Combine(bundleDirectory, file);
 10133            if (!File.Exists(fullPath))
 134            {
 135                continue;
 136            }
 137
 10138            using var reader = new StreamReader(fullPath);
 10139            var partialDateCount = 0;
 140
 32141            foreach (var row in _csvParser.Read(reader, hasHeader: true))
 142            {
 6143                var addedMd = row["applied_on"] ?? row["added_md"] ?? row["applied_date_md"] ?? row["rejected_date_md"];
 6144                if (string.IsNullOrWhiteSpace(addedMd) ||
 6145                    (!addedMd.Trim().StartsWith("20", StringComparison.Ordinal) && !addedMd.Trim().StartsWith("19", Stri
 146                {
 2147                    partialDateCount++;
 148                }
 149            }
 150
 10151            if (partialDateCount > 0)
 152            {
 2153                return new ResultError(
 2154                    ErrorCode.ValidationError,
 2155                    $"Missing required --default-date: {file} has {partialDateCount} rows with undated or partial date f
 156            }
 157        }
 158
 4159        return null;
 2160    }
 161}