< Summary - ZhEaIsNsAaBn.Libraries coverage (affected: 23 packages)

Information
Class: ZhEaIsNsAaBn.DbSeeder.Design.ValidateCommand
Assembly: ZhEaIsNsAaBn.DbSeeder.Design
File(s): /home/runner/work/ZhEaIsNsAaBn.Libraries.V1/ZhEaIsNsAaBn.Libraries.V1/src/DataBasePackages/ZhEaIsNsAaBn.DbSeeder.Design/Commands/DesignCommands.cs
Line coverage
100%
Covered lines: 2
Uncovered lines: 0
Coverable lines: 2
Total lines: 123
Line coverage: 100%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
ExecuteAsync(...)100%11100%

File(s)

/home/runner/work/ZhEaIsNsAaBn.Libraries.V1/ZhEaIsNsAaBn.Libraries.V1/src/DataBasePackages/ZhEaIsNsAaBn.DbSeeder.Design/Commands/DesignCommands.cs

#LineLine coverage
 1namespace ZhEaIsNsAaBn.DbSeeder.Design;
 2
 3// Thin Spectre shells over SeedDesigner; exit code 0 = success, 1 = errors.
 4
 5internal sealed class ProfileListCommand : AsyncCommand<DesignSettings>
 6{
 7    private readonly DesignSession _session;
 8
 9    public ProfileListCommand( DesignSession session ) => _session = session;
 10
 11    public override Task<int> ExecuteAsync( CommandContext context, DesignSettings settings, CancellationToken cancellat
 12        => Task.FromResult( _session.Report( _session.Designer( settings ).ProfileList() ) );
 13}
 14
 15internal sealed class ProfileAddCommand : AsyncCommand<ProfileSettings>
 16{
 17    private readonly DesignSession _session;
 18
 19    public ProfileAddCommand( DesignSession session ) => _session = session;
 20
 21    public override Task<int> ExecuteAsync( CommandContext context, ProfileSettings settings, CancellationToken cancella
 22        => Task.FromResult( _session.Report( _session.Designer( settings ).ProfileAdd( settings.Name, settings.Tables, s
 23}
 24
 25internal sealed class ProfileEditCommand : AsyncCommand<ProfileSettings>
 26{
 27    private readonly DesignSession _session;
 28
 29    public ProfileEditCommand( DesignSession session ) => _session = session;
 30
 31    public override Task<int> ExecuteAsync( CommandContext context, ProfileSettings settings, CancellationToken cancella
 32        => Task.FromResult( _session.Report( _session.Designer( settings ).ProfileEdit( settings.Name, settings.Tables, 
 33}
 34
 35internal sealed class ProfileRemoveCommand : AsyncCommand<ProfileSettings>
 36{
 37    private readonly DesignSession _session;
 38
 39    public ProfileRemoveCommand( DesignSession session ) => _session = session;
 40
 41    public override Task<int> ExecuteAsync( CommandContext context, ProfileSettings settings, CancellationToken cancella
 42        => Task.FromResult( _session.Report( _session.Designer( settings ).ProfileRemove( settings.Name ) ) );
 43}
 44
 45internal sealed class BaselineCommand : AsyncCommand<BaselineSettings>
 46{
 47    private readonly DesignSession _session;
 48
 49    public BaselineCommand( DesignSession session ) => _session = session;
 50
 51    public override async Task<int> ExecuteAsync( CommandContext context, BaselineSettings settings, CancellationToken c
 52        => _session.Report( await _session.Designer( settings ).BaselineAsync( settings.Profile, settings.Name, cancella
 53}
 54
 55internal sealed class AddCommand : AsyncCommand<AddSettings>
 56{
 57    private readonly DesignSession _session;
 58
 59    public AddCommand( DesignSession session ) => _session = session;
 60
 61    public override async Task<int> ExecuteAsync( CommandContext context, AddSettings settings, CancellationToken cancel
 62        => _session.Report( await _session.Designer( settings ).AddAsync( settings.Name, settings.Profile, cancellationT
 63}
 64
 65internal sealed class SnapshotRebuildCommand : AsyncCommand<DesignSettings>
 66{
 67    private readonly DesignSession _session;
 68
 69    public SnapshotRebuildCommand( DesignSession session ) => _session = session;
 70
 71    public override async Task<int> ExecuteAsync( CommandContext context, DesignSettings settings, CancellationToken can
 72        => _session.Report( await _session.Designer( settings ).RebuildSnapshotAsync( settings.Profile, cancellationToke
 73}
 74
 75internal sealed class ListCommand : AsyncCommand<FolderSettings>
 76{
 77    private readonly DesignSession _session;
 78
 79    public ListCommand( DesignSession session ) => _session = session;
 80
 81    public override async Task<int> ExecuteAsync( CommandContext context, FolderSettings settings, CancellationToken can
 82        => SeedOperator.For( _session, settings ) is { } seeds ? await seeds.ListAsync( cancellationToken ).ConfigureAwa
 83}
 84
 85internal sealed class UpdateCommand : AsyncCommand<UpdateSettings>
 86{
 87    private readonly DesignSession _session;
 88
 89    public UpdateCommand( DesignSession session ) => _session = session;
 90
 91    public override async Task<int> ExecuteAsync( CommandContext context, UpdateSettings settings, CancellationToken can
 92        => SeedOperator.For( _session, settings ) is { } seeds ? await seeds.UpdateAsync( settings.To, cancellationToken
 93}
 94
 95internal sealed class DownCommand : AsyncCommand<DownSettings>
 96{
 97    private readonly DesignSession _session;
 98
 99    public DownCommand( DesignSession session ) => _session = session;
 100
 101    public override async Task<int> ExecuteAsync( CommandContext context, DownSettings settings, CancellationToken cance
 102        => SeedOperator.For( _session, settings ) is { } seeds ? await seeds.DownAsync( settings, cancellationToken ).Co
 103}
 104
 105internal sealed class ScriptCommand : AsyncCommand<ScriptSettings>
 106{
 107    private readonly DesignSession _session;
 108
 109    public ScriptCommand( DesignSession session ) => _session = session;
 110
 111    public override Task<int> ExecuteAsync( CommandContext context, ScriptSettings settings, CancellationToken cancellat
 112        => Task.FromResult( SeedOperator.For( _session, settings ) is { } seeds ? seeds.Script( settings.From, settings.
 113}
 114
 115internal sealed class ValidateCommand : AsyncCommand<ValidateSettings>
 116{
 117    private readonly DesignSession _session;
 118
 18119    public ValidateCommand( DesignSession session ) => _session = session;
 120
 121    public override Task<int> ExecuteAsync( CommandContext context, ValidateSettings settings, CancellationToken cancell
 9122        => Task.FromResult( _session.Report( _session.Designer( settings ).Validate( settings.Folder ) ) );
 123}
Generated by: ReportGenerator 5.5.12.0
11/15/2026 - 06:05:16
GitHub | reportgenerator.io

Methods/Properties

.ctor(ZhEaIsNsAaBn.DbSeeder.Design.DesignSession)
ExecuteAsync(Spectre.Console.Cli.CommandContext,ZhEaIsNsAaBn.DbSeeder.Design.ValidateSettings,System.Threading.CancellationToken)