diff --git a/.changes/unreleased/Fixed-20261014-083031.yaml b/.changes/unreleased/Fixed-20261014-083031.yaml new file mode 100644 index 0000000..d8379e0 --- /dev/null +++ b/.changes/unreleased/Fixed-20261014-083031.yaml @@ -0,0 +1,6 @@ +kind: Fixed +body: '`--skip-maybe-edited` also checks the files listed in the PAR2 set (covering sets not created by par2cron)' +time: 2026-10-14T08:30:31.503370391+02:00 +custom: + Issue: "" + PR: "103" diff --git a/cmd/par2cron/main.go b/cmd/par2cron/main.go index 7cf9b99..cd21785 100644 --- a/cmd/par2cron/main.go +++ b/cmd/par2cron/main.go @@ -932,10 +932,10 @@ func NewProgram( return &Program{ CreationService: create.NewService(fsys, log, r, b, p, c), - VerificationService: verify.NewService(fsys, log, r, b, c), + VerificationService: verify.NewService(fsys, log, r, b, p, c), RepairService: repair.NewService(fsys, log, r, b, p, c), - InfoService: info.NewService(fsys, log, r, b, c), - ListService: list.NewService(fsys, log, r, b, c), + InfoService: info.NewService(fsys, log, r, b, p, c), + ListService: list.NewService(fsys, log, r, b, p, c), BundlerService: bundler.NewService(fsys, log, b, p), ToolService: tool.NewService(fsys, log, b, p), diff --git a/internal/create/create.go b/internal/create/create.go index b845772..01a6c8c 100644 --- a/internal/create/create.go +++ b/internal/create/create.go @@ -665,7 +665,7 @@ func (prog *Service) runCreate(ctx context.Context, job *Job, elements []schema. } if job.par2Verify { - vs := verify.NewService(prog.fsys, prog.log, prog.runner, prog.bundler, prog.cacher) + vs := verify.NewService(prog.fsys, prog.log, prog.runner, prog.bundler, prog.par2er, prog.cacher) vj := verify.NewJob(job.par2Path, verify.Options{}, mf, job.asBundle) if err := vs.RunVerify(ctx, vj, true); err != nil { diff --git a/internal/info/info.go b/internal/info/info.go index 0c9cd12..fa73e3a 100644 --- a/internal/info/info.go +++ b/internal/info/info.go @@ -37,10 +37,11 @@ type Service struct { runner schema.CommandRunner walker schema.FilesystemWalker bundler schema.BundleHandler + par2er schema.Par2Handler cacher schema.CacheHandler } -func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, bundler schema.BundleHandler, cacher schema.CacheHandler) *Service { +func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, bundler schema.BundleHandler, par2er schema.Par2Handler, cacher schema.CacheHandler) *Service { var walker schema.FilesystemWalker if _, ok := fsys.(*afero.OsFs); ok { walker = util.OSWalker{} @@ -55,6 +56,7 @@ func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, runner: runner, walker: walker, bundler: bundler, + par2er: par2er, cacher: cacher, } } @@ -91,7 +93,7 @@ func (prog *Service) Info(ctx context.Context, rootDirs []string, opts Options) now := time.Now() - vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.cacher) + vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.par2er, prog.cacher) va := verify.Options{IncludeExternal: opts.IncludeExternal, SkipNotCreated: opts.SkipNotCreated} metas := []*verify.JobMeta{} diff --git a/internal/info/info_test.go b/internal/info/info_test.go index 14a49d7..367e682 100644 --- a/internal/info/info_test.go +++ b/internal/info/info_test.go @@ -56,7 +56,7 @@ func Test_Service_openCache_NoCacheDir_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: ""} prog.openCache("/data", opts) @@ -91,7 +91,7 @@ func Test_Service_openCache_WithCacheDir_LoadsCacheFromDisk_Success(t *testing.T }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} prog.openCache("/data", opts) @@ -123,7 +123,7 @@ func Test_Service_openCache_LoadError_LogsError_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} cache := prog.openCache("/data", opts) @@ -156,7 +156,7 @@ func Test_Service_openCache_LoadErrNotExist_NoLog_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} cache := prog.openCache("/data", opts) @@ -186,7 +186,7 @@ func Test_Service_Info_Success(t *testing.T) { _ = args.MinAge.Set("7d") _ = args.MaxDuration.Set("1h") - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.Info(t.Context(), []string{"/data"}, args)) require.Contains(t, stdoutBuf.String(), "Scanning filesystem '/data' for jobs") @@ -213,7 +213,7 @@ func Test_Service_Info_MultiRoot_Success(t *testing.T) { _ = args.MinAge.Set("7d") _ = args.MaxDuration.Set("1h") - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.Info(t.Context(), []string{"/data", "/data2"}, args)) require.Contains(t, stdoutBuf.String(), "Scanning filesystem '/data' for jobs") @@ -236,7 +236,7 @@ func Test_Service_Info_Prometheus_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -265,7 +265,7 @@ func Test_Service_Info_PrometheusWithJSON_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -301,7 +301,7 @@ func Test_Service_Info_JSON_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -370,7 +370,7 @@ func Test_Service_Info_JSON_MultiRoot_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -418,7 +418,7 @@ func Test_Service_Info_NoRunInterval_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} err := prog.Info(t.Context(), []string{"/data"}, args) @@ -445,7 +445,7 @@ func Test_Service_Info_NoKnownDurations_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -479,7 +479,7 @@ func Test_Service_Info_WithJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -514,7 +514,7 @@ func Test_Service_Info_WithAgeFlag_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -550,7 +550,7 @@ func Test_Service_Info_WithDurationFlag_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -585,7 +585,7 @@ func Test_Service_Info_HealthyBacklog_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -622,7 +622,7 @@ func Test_Service_Info_HealthyBacklog_UnknownDurations_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{IncludeExternal: true} _ = args.RunInterval.Set("24h") @@ -658,7 +658,7 @@ func Test_Service_Info_UnhealthyBacklog_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -695,7 +695,7 @@ func Test_Service_Info_LargeJobWarning_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -726,7 +726,7 @@ func Test_Service_Info_CtxCancel_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -771,7 +771,7 @@ func Test_Service_Info_WithoutCacheDir_NotLoadsCache_Success(t *testing.T) { args := Options{CacheDir: ""} _ = args.RunInterval.Set("24h") - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.Info(t.Context(), []string{"/data"}, args)) require.False(t, loadCalled) @@ -813,7 +813,7 @@ func Test_Service_Info_WithCacheDir_LoadsCache_Success(t *testing.T) { args := Options{CacheDir: "/cache"} _ = args.RunInterval.Set("24h") - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.Info(t.Context(), []string{"/data"}, args)) require.True(t, loadCalled) @@ -852,7 +852,7 @@ func Test_Service_Info_PrunesCache_Success(t *testing.T) { args := Options{CacheDir: "/cache"} _ = args.RunInterval.Set("24h") - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.Info(t.Context(), []string{"/data"}, args)) require.True(t, pruneCalled) @@ -894,7 +894,7 @@ func Test_Service_Info_DoesNotSaveCache_Success(t *testing.T) { args := Options{CacheDir: "/cache"} _ = args.RunInterval.Set("24h") - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.Info(t.Context(), []string{"/data"}, args)) require.False(t, saveCalled) @@ -924,7 +924,7 @@ func Test_Service_Info_Overdue_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -952,7 +952,7 @@ func Test_Service_printAgeInfo_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 7 * time.Hour, @@ -986,7 +986,7 @@ func Test_Service_printAgeInfo_ZeroMinAge_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1016,7 +1016,7 @@ func Test_Service_printAgeInfo_AgeLessThanInterval_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1049,7 +1049,7 @@ func Test_Service_printDurationInfo_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 3 * time.Hour, @@ -1084,7 +1084,7 @@ func Test_Service_printDurationInfo_SingleRun_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 30 * time.Minute, @@ -1117,7 +1117,7 @@ func Test_Service_printDurationInfo_ZeroMaxDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1147,7 +1147,7 @@ func Test_Service_printDurationInfo_LargeJobWarning_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 2 * time.Hour, @@ -1183,7 +1183,7 @@ func Test_Service_printBacklogInfo_Healthy_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1218,7 +1218,7 @@ func Test_Service_printBacklogInfo_HealthyWithUnknownDurations_Success(t *testin } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1252,7 +1252,7 @@ func Test_Service_printBacklogInfo_Unhealthy_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 10 * time.Hour, @@ -1286,7 +1286,7 @@ func Test_Service_printBacklogInfo_ZeroMinAge_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1317,7 +1317,7 @@ func Test_Service_printBacklogInfo_ZeroMaxDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1348,7 +1348,7 @@ func Test_Service_printCycleInfo_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) manifest := schema.NewManifest("test" + schema.Par2Extension) manifest.Verification = &schema.VerificationManifest{ @@ -1392,7 +1392,7 @@ func Test_Service_printCycleInfo_UnknownDurations_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) manifest := schema.NewManifest("test" + schema.Par2Extension) manifest.Verification = &schema.VerificationManifest{ @@ -1439,7 +1439,7 @@ func Test_Service_printCycleInfo_ZeroMinAge_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ JobCount: 1, @@ -1470,7 +1470,7 @@ func Test_Service_printCycleInfo_ZeroTotalDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ JobCount: 1, @@ -1502,7 +1502,7 @@ func Test_Service_printOverdueInfo_ZeroMinAge_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1539,7 +1539,7 @@ func Test_Service_printOverdueInfo_NoneOverdue_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1589,7 +1589,7 @@ func Test_Service_printOverdueInfo_OverdueRun_WithDuration_Success(t *testing.T) } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1633,7 +1633,7 @@ func Test_Service_printOverdueInfo_OverdueRun_NoDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1675,7 +1675,7 @@ func Test_Service_printOverdueInfo_OverdueCycle_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1718,7 +1718,7 @@ func Test_Service_printOverdueInfo_MostOverdue_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1765,7 +1765,7 @@ func Test_Service_printOverdueInfo_SkipsUnverifiedAndZeroTime_Success(t *testing } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) diff --git a/internal/info/json.go b/internal/info/json.go index 70ba162..020a51c 100644 --- a/internal/info/json.go +++ b/internal/info/json.go @@ -224,7 +224,7 @@ func (prog *Service) Result(ctx context.Context, rootDirs []string, opts Options now := time.Now() - vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.cacher) + vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.par2er, prog.cacher) va := verify.Options{IncludeExternal: opts.IncludeExternal, SkipNotCreated: opts.SkipNotCreated} result := &Result{ diff --git a/internal/info/json_test.go b/internal/info/json_test.go index c9bbc3b..59ea137 100644 --- a/internal/info/json_test.go +++ b/internal/info/json_test.go @@ -45,7 +45,7 @@ func Test_Service_openCacheJSON_NoCacheDir_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: ""} prog.openCacheJSON("/data", opts, &Result{}) @@ -80,7 +80,7 @@ func Test_Service_openCacheJSON_WithCacheDir_LoadsCacheFromDisk_Success(t *testi }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} prog.openCacheJSON("/data", opts, &Result{}) @@ -112,7 +112,7 @@ func Test_Service_openCacheJSON_LoadError_LogsError_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} result := &Result{} @@ -146,7 +146,7 @@ func Test_Service_openCacheJSON_LoadErrNotExist_NoLog_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} result := &Result{} @@ -172,7 +172,7 @@ func Test_Service_PrintJSON_NoRunInterval_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} err := prog.PrintJSON(t.Context(), []string{"/data"}, args) @@ -197,7 +197,7 @@ func Test_Service_PrintJSON_NoKnownDurations_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -244,7 +244,7 @@ func Test_Service_PrintJSON_WithOptions_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -283,7 +283,7 @@ func Test_Service_PrintJSON_WithJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -327,7 +327,7 @@ func Test_Service_PrintJSON_WithJobs_ZeroLastVerified_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -370,7 +370,7 @@ func Test_Service_PrintJSON_WithAgeFlag_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -410,7 +410,7 @@ func Test_Service_PrintJSON_WithDurationFlag_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -450,7 +450,7 @@ func Test_Service_PrintJSON_HealthyBacklog_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -491,7 +491,7 @@ func Test_Service_PrintJSON_UnhealthyBacklog_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -533,7 +533,7 @@ func Test_Service_PrintJSON_HealthyBacklog_UnknownDurations_Success(t *testing.T } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{IncludeExternal: true} _ = args.RunInterval.Set("24h") @@ -572,7 +572,7 @@ func Test_Service_PrintJSON_LargeJobWarning_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -612,7 +612,7 @@ func Test_Service_PrintJSON_AgeLessThanInterval_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -650,7 +650,7 @@ func Test_Service_PrintJSON_CycleInfo_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -693,7 +693,7 @@ func Test_Service_PrintJSON_CycleInfo_UnknownDurations_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{IncludeExternal: true} _ = args.RunInterval.Set("24h") @@ -727,7 +727,7 @@ func Test_Service_PrintJSON_CtxCancel_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -760,7 +760,7 @@ func Test_Service_PrintJSON_AllSections_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -806,7 +806,7 @@ func Test_Service_PrintJSON_MinimalSections_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -857,7 +857,7 @@ func Test_Service_PrintJSON_WithoutCacheDir_NotLoadsCache_Success(t *testing.T) }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{CacheDir: ""} _ = args.RunInterval.Set("24h") @@ -898,7 +898,7 @@ func Test_Service_PrintJSON_WithCacheDir_LoadsCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{CacheDir: "/cache"} _ = args.RunInterval.Set("24h") @@ -936,7 +936,7 @@ func Test_Service_PrintJSON_PrunesCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{CacheDir: "/cache"} _ = args.RunInterval.Set("24h") @@ -977,7 +977,7 @@ func Test_Service_PrintJSON_DoesNotSaveCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{CacheDir: "/cache"} _ = args.RunInterval.Set("24h") @@ -1000,7 +1000,7 @@ func Test_Service_buildAgeInfo_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1031,7 +1031,7 @@ func Test_Service_buildAgeInfo_AgeLessThanInterval_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1062,7 +1062,7 @@ func Test_Service_buildAgeInfo_MinRequiredDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Millisecond, @@ -1092,7 +1092,7 @@ func Test_Service_buildAgeInfo_RequiredDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 7 * time.Hour, @@ -1123,7 +1123,7 @@ func Test_Service_buildDurationInfo_SingleRun_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 30 * time.Minute, @@ -1157,7 +1157,7 @@ func Test_Service_buildDurationInfo_MultipleRuns_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 3 * time.Hour, @@ -1191,7 +1191,7 @@ func Test_Service_buildDurationInfo_LargeJobWarning_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 2 * time.Hour, @@ -1224,7 +1224,7 @@ func Test_Service_buildDurationInfo_NoWarning_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 30 * time.Minute, @@ -1256,7 +1256,7 @@ func Test_Service_buildBacklogInfo_Healthy_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1291,7 +1291,7 @@ func Test_Service_buildBacklogInfo_Unhealthy_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 10 * time.Hour, @@ -1326,7 +1326,7 @@ func Test_Service_buildBacklogInfo_UnknownJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1358,7 +1358,7 @@ func Test_Service_buildBacklogInfo_NoWarningWhenHealthy_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := verify.Stats{ TotalDuration: 1 * time.Hour, @@ -1392,7 +1392,7 @@ func Test_Service_buildCycleInfo_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Now() @@ -1441,7 +1441,7 @@ func Test_Service_buildCycleInfo_OutsideWindow_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Now() @@ -1487,7 +1487,7 @@ func Test_Service_buildCycleInfo_UnknownJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Now() @@ -1532,7 +1532,7 @@ func Test_Service_buildCycleInfo_NoVerification_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Now() @@ -1572,7 +1572,7 @@ func Test_Service_buildCycleInfo_NilManifest_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Now() @@ -1610,7 +1610,7 @@ func Test_Service_buildCycleInfo_MixedJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Now() @@ -1678,7 +1678,7 @@ func Test_Service_PrintJSON_OverdueInfo_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -1719,7 +1719,7 @@ func Test_Service_PrintJSON_OverdueInfo_OverdueCycle_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{} _ = args.RunInterval.Set("24h") @@ -1751,7 +1751,7 @@ func Test_Service_buildOverdueInfo_NoneOverdue_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1801,7 +1801,7 @@ func Test_Service_buildOverdueInfo_OverdueRun_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1842,7 +1842,7 @@ func Test_Service_buildOverdueInfo_OverdueCycle_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1882,7 +1882,7 @@ func Test_Service_buildOverdueInfo_MostOverdue_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -1928,7 +1928,7 @@ func Test_Service_buildOverdueInfo_SkipsUnverifiedAndZeroTime_Success(t *testing } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) now := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) diff --git a/internal/info/prometheus_test.go b/internal/info/prometheus_test.go index e256255..d86437b 100644 --- a/internal/info/prometheus_test.go +++ b/internal/info/prometheus_test.go @@ -144,7 +144,7 @@ func Test_Service_exportPrometheus_WithJSON_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -171,7 +171,7 @@ func Test_Service_exportPrometheus_NoRunInterval_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} err := prog.exportPrometheus(t.Context(), []string{"/data"}, args) @@ -200,7 +200,7 @@ func Test_Service_exportPrometheus_CtxCancel_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -234,7 +234,7 @@ func Test_Service_exportPrometheus_WithJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -279,7 +279,7 @@ func Test_Service_exportPrometheus_NoKnownDurations_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -325,7 +325,7 @@ func Test_Service_exportPrometheus_UnhealthyBacklog_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -367,7 +367,7 @@ func Test_Service_exportPrometheus_OverdueCycle_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Prometheus: true} _ = args.RunInterval.Set("24h") @@ -415,7 +415,7 @@ func Test_Service_exportPrometheus_SetsCached_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Prometheus: true, CacheDir: "/cache"} _ = args.RunInterval.Set("24h") @@ -442,7 +442,7 @@ func Test_Service_logResultWarnings_AllWarnings_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) result := &Result{ Warning: "warning-result", @@ -485,7 +485,7 @@ func Test_Service_logResultWarnings_CycleWarningDebug_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) result := &Result{ Summary: &Summary{}, @@ -511,7 +511,7 @@ func Test_Service_logResultWarnings_NoWarnings_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) result := &Result{ Summary: &Summary{}, diff --git a/internal/list/json.go b/internal/list/json.go index f6b203f..289bed9 100644 --- a/internal/list/json.go +++ b/internal/list/json.go @@ -136,7 +136,7 @@ func (prog *Service) openCacheJSON(rootDir string, opts Options, result *Result) } func (prog *Service) Result(ctx context.Context, rootDirs []string, opts Options) (*Result, error) { - vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.cacher) + vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.par2er, prog.cacher) va := verify.Options{IncludeExternal: false, SkipNotCreated: opts.SkipNotCreated} result := &Result{ diff --git a/internal/list/json_test.go b/internal/list/json_test.go index 85977d6..0b8879e 100644 --- a/internal/list/json_test.go +++ b/internal/list/json_test.go @@ -121,7 +121,7 @@ func Test_Service_openCacheJSON_NoCacheDir_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: ""} prog.openCacheJSON("/data", opts, &Result{}) @@ -156,7 +156,7 @@ func Test_Service_openCacheJSON_WithCacheDir_LoadsCacheFromDisk_Success(t *testi }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} prog.openCacheJSON("/data", opts, &Result{}) @@ -188,7 +188,7 @@ func Test_Service_openCacheJSON_LoadError_SetsWarning_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} result := &Result{} @@ -222,7 +222,7 @@ func Test_Service_openCacheJSON_LoadErrNotExist_NoWarning_Success(t *testing.T) }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} result := &Result{} @@ -248,7 +248,7 @@ func Test_Service_PrintJSON_NoJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{})) require.Contains(t, stdoutBuf.String(), `"jobs": []`) @@ -289,7 +289,7 @@ func Test_Service_PrintJSON_WithJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{})) var result Result @@ -330,7 +330,7 @@ func Test_Service_PrintJSON_UnverifiedJob_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{})) require.NotContains(t, stdoutBuf.String(), `"verification":`) @@ -372,7 +372,7 @@ func Test_Service_PrintJSON_SortedBySeverity_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{})) var result Result @@ -418,7 +418,7 @@ func Test_Service_PrintJSON_MultiRoot_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data", "/data2"}, Options{})) var result Result @@ -446,7 +446,7 @@ func Test_Service_PrintJSON_WithOptions_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{SkipNotCreated: true, CacheDir: "/cache"} require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, args)) @@ -478,7 +478,7 @@ func Test_Service_PrintJSON_CtxCancel_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) err := prog.PrintJSON(ctx, []string{"/data"}, Options{}) require.ErrorIs(t, err, context.Canceled) @@ -516,7 +516,7 @@ func Test_Service_PrintJSON_WithoutCacheDir_NotLoadsCache_Success(t *testing.T) }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{CacheDir: ""})) require.False(t, loadCalled) @@ -554,7 +554,7 @@ func Test_Service_PrintJSON_WithCacheDir_LoadsCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{CacheDir: "/cache"})) require.True(t, loadCalled) @@ -589,7 +589,7 @@ func Test_Service_PrintJSON_PrunesCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{CacheDir: "/cache"})) require.True(t, pruneCalled) @@ -627,7 +627,7 @@ func Test_Service_PrintJSON_DoesNotSaveCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.PrintJSON(t.Context(), []string{"/data"}, Options{CacheDir: "/cache"})) require.False(t, saveCalled) diff --git a/internal/list/list.go b/internal/list/list.go index 5fc1901..555b53b 100644 --- a/internal/list/list.go +++ b/internal/list/list.go @@ -32,10 +32,11 @@ type Service struct { runner schema.CommandRunner walker schema.FilesystemWalker bundler schema.BundleHandler + par2er schema.Par2Handler cacher schema.CacheHandler } -func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, bundler schema.BundleHandler, cacher schema.CacheHandler) *Service { +func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, bundler schema.BundleHandler, par2er schema.Par2Handler, cacher schema.CacheHandler) *Service { var walker schema.FilesystemWalker if _, ok := fsys.(*afero.OsFs); ok { walker = util.OSWalker{} @@ -50,6 +51,7 @@ func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, runner: runner, walker: walker, bundler: bundler, + par2er: par2er, cacher: cacher, } } @@ -76,7 +78,7 @@ func (prog *Service) List(ctx context.Context, rootDirs []string, opts Options) logger := prog.listLogger(ctx, nil) - vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.cacher) + vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.par2er, prog.cacher) va := verify.Options{IncludeExternal: false, SkipNotCreated: opts.SkipNotCreated} metas := []*verify.JobMeta{} diff --git a/internal/list/list_test.go b/internal/list/list_test.go index aa8ef55..192afe5 100644 --- a/internal/list/list_test.go +++ b/internal/list/list_test.go @@ -61,7 +61,7 @@ func Test_Service_openCache_NoCacheDir_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: ""} prog.openCache(t.Context(), "/data", opts) @@ -96,7 +96,7 @@ func Test_Service_openCache_WithCacheDir_LoadsCacheFromDisk_Success(t *testing.T }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} prog.openCache(t.Context(), "/data", opts) @@ -128,7 +128,7 @@ func Test_Service_openCache_LoadError_LogsError_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} cache := prog.openCache(t.Context(), "/data", opts) @@ -161,7 +161,7 @@ func Test_Service_openCache_LoadErrNotExist_NoLog_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} cache := prog.openCache(t.Context(), "/data", opts) @@ -187,7 +187,7 @@ func Test_Service_List_NoJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{})) lines := strings.Split(strings.TrimSpace(stdoutBuf.String()), "\n") @@ -222,7 +222,7 @@ func Test_Service_List_WithJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{})) lines := strings.Split(strings.TrimSpace(stdoutBuf.String()), "\n") @@ -262,7 +262,7 @@ func Test_Service_List_SortedBySeverity_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{})) lines := strings.Split(strings.TrimSpace(stdoutBuf.String()), "\n") @@ -298,7 +298,7 @@ func Test_Service_List_SortedByPath_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{})) lines := strings.Split(strings.TrimSpace(stdoutBuf.String()), "\n") @@ -341,7 +341,7 @@ func Test_Service_List_MultiRoot_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.List(t.Context(), []string{"/data", "/data2"}, Options{})) lines := strings.Split(strings.TrimSpace(stdoutBuf.String()), "\n") @@ -375,7 +375,7 @@ func Test_Service_List_WantJSON_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{})) var result Result @@ -404,7 +404,7 @@ func Test_Service_List_CtxCancel_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) err := prog.List(ctx, []string{"/data"}, Options{}) require.ErrorIs(t, err, context.Canceled) @@ -443,7 +443,7 @@ func Test_Service_List_WithoutCacheDir_NotLoadsCache_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{CacheDir: ""})) require.False(t, loadCalled) @@ -482,7 +482,7 @@ func Test_Service_List_WithCacheDir_LoadsCache_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{CacheDir: "/cache"})) require.True(t, loadCalled) @@ -518,7 +518,7 @@ func Test_Service_List_PrunesCache_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{CacheDir: "/cache"})) require.True(t, pruneCalled) @@ -557,7 +557,7 @@ func Test_Service_List_DoesNotSaveCache_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) require.NoError(t, prog.List(t.Context(), []string{"/data"}, Options{CacheDir: "/cache"})) require.False(t, saveCalled) @@ -578,7 +578,7 @@ func Test_Service_printTable_AllStatuses_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) verifiedAt := time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC) @@ -656,7 +656,7 @@ func Test_Service_printTable_Unverified_Dashes_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) unverified := newTestMeta("/data/unverified.par2") unverified.HasManifest = true @@ -683,7 +683,7 @@ func Test_Service_printTable_Aligned_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) unverified := newTestMeta("/data/short.par2") unverified.HasManifest = true @@ -721,7 +721,7 @@ func Test_Service_printTable_CachedColumn_WithCacheDir_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) cached := newTestMeta("/data/cached.par2") cached.HasManifest = true diff --git a/internal/repair/repair.go b/internal/repair/repair.go index 985d728..e75b36d 100644 --- a/internal/repair/repair.go +++ b/internal/repair/repair.go @@ -592,7 +592,7 @@ func (prog *Service) runRepair(ctx context.Context, job *Job) error { } if job.par2Verify { - vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.cacher) + vs := verify.NewService(prog.fsys, prog.logbase, prog.runner, prog.bundler, prog.par2er, prog.cacher) vj := verify.NewJob(job.par2Path, verify.Options{}, job.manifest, job.isBundle) if err := vs.RunVerify(ctx, vj, true); err != nil { diff --git a/internal/verify/util_test.go b/internal/verify/util_test.go index ba92a7d..f07e07a 100644 --- a/internal/verify/util_test.go +++ b/internal/verify/util_test.go @@ -27,7 +27,7 @@ func Test_Service_Stats_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) timeA := time.Now().Add(-5 * time.Minute) timeB := time.Now().Add(-10 * time.Minute) @@ -98,7 +98,7 @@ func Test_Service_Stats_NoJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) js := prog.Stats([]*JobMeta{}) @@ -126,7 +126,7 @@ func Test_Service_Stats_WithUnknownDurations_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -163,7 +163,7 @@ func Test_Service_Stats_IdentifyLargestDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta1 := &JobMeta{ &schema.JobMeta{ diff --git a/internal/verify/verify.go b/internal/verify/verify.go index be88df1..e9fbcde 100644 --- a/internal/verify/verify.go +++ b/internal/verify/verify.go @@ -93,10 +93,11 @@ type Service struct { runner schema.CommandRunner walker schema.FilesystemWalker bundler schema.BundleHandler + par2er schema.Par2Handler cacher schema.CacheHandler } -func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, bundler schema.BundleHandler, cacher schema.CacheHandler) *Service { +func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, bundler schema.BundleHandler, par2er schema.Par2Handler, cacher schema.CacheHandler) *Service { var walker schema.FilesystemWalker if _, ok := fsys.(*afero.OsFs); ok { walker = util.OSWalker{} @@ -110,6 +111,7 @@ func NewService(fsys afero.Fs, log *logging.Logger, runner schema.CommandRunner, runner: runner, walker: walker, bundler: bundler, + par2er: par2er, cacher: cacher, } } @@ -647,7 +649,7 @@ func (prog *Service) RunVerify(ctx context.Context, job *Job, isPreLocked bool) job.manifest.Verification.TimeLastHealthy = job.manifest.Verification.Time } else { // Determine if the files may have intentionally been edited. - job.manifest.Verification.MaybeEdited = prog.wasMaybeEdited(job) + job.manifest.Verification.MaybeEdited = prog.wasMaybeEdited(ctx, job) } job.manifest.Verification.Count++ @@ -704,28 +706,54 @@ func (prog *Service) parseExitCode(job *Job, err error) error { // wasMaybeEdited is a best-effort heuristic: it stays silent when unsure, // as the contract of the program (and PAR2 in general) is mostly WORM files. -func (prog *Service) wasMaybeEdited(job *Job) bool { - if job.manifest.Creation == nil { +func (prog *Service) wasMaybeEdited(ctx context.Context, job *Job) bool { + if (job.manifest.Creation == nil || job.manifest.Creation.Time.IsZero()) && + job.manifest.Verification.TimeLastHealthy.IsZero() { return false } - if job.manifest.Creation.Time.IsZero() && job.manifest.Verification.TimeLastHealthy.IsZero() { - return false + paths := make(map[string]struct{}) + + if job.manifest.Creation != nil { + for _, e := range job.manifest.Creation.Elements { + // Empty names resolve to the working directory, and + // directory mtimes reflect entry changes, not edits. + if e.Name == "" || e.IsDir { + continue + } + paths[filepath.Join(job.workingDir, e.Name)] = struct{}{} + } + } + + // The PAR2 set is parsed here as well, as failed verifications are rare + // and worth the cost; in the future, this should come from the manifest. + set, _, err := util.ParsePar2Set(ctx, prog.fsys, + job.par2Name, job.workingDir, prog.par2er, prog.bundler) + if set == nil && err != nil { + logger := prog.verificationLogger(ctx, job, job.par2Path) + logger.Debug("Failed to parse PAR2 set (checking creation manifest only)", "error", err) + } else if set != nil { + for _, f := range set.RecoverySet { + cleaned, err := util.SanitizePar2Path(f.Name) + if err != nil { + continue + } + cleaned, err = util.JailedJoinPath(job.workingDir, cleaned) + if err != nil { + continue + } + paths[cleaned] = struct{}{} + } } ref := job.manifest.Verification.TimeLastHealthy if job.manifest.Verification.TimeLastHealthy.IsZero() { + // Guaranteed to exist here with entry barrier of function. ref = job.manifest.Creation.Time } - for _, e := range job.manifest.Creation.Elements { - // Empty names resolve to the working directory, and - // directory mtimes reflect entry changes, not edits. - if e.Name == "" || e.IsDir { - continue - } - - info, err := util.LstatIfPossible(prog.fsys, filepath.Join(job.workingDir, e.Name)) + for path := range paths { + info, err := util.LstatIfPossible(prog.fsys, path) if err != nil { continue } diff --git a/internal/verify/verify_test.go b/internal/verify/verify_test.go index 51bed18..4b91618 100644 --- a/internal/verify/verify_test.go +++ b/internal/verify/verify_test.go @@ -15,6 +15,7 @@ import ( "github.com/desertwitch/par2cron/internal/bundle" "github.com/desertwitch/par2cron/internal/logging" + "github.com/desertwitch/par2cron/internal/par2" "github.com/desertwitch/par2cron/internal/schema" "github.com/desertwitch/par2cron/internal/testutil" "github.com/desertwitch/par2cron/internal/util" @@ -158,7 +159,7 @@ func Test_Service_openCache_NoCacheDir_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: ""} prog.openCache(t.Context(), "/data", opts) @@ -193,7 +194,7 @@ func Test_Service_openCache_WithCacheDir_LoadsCacheFromDisk_Success(t *testing.T }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} prog.openCache(t.Context(), "/data", opts) @@ -225,7 +226,7 @@ func Test_Service_openCache_LoadError_LogsError_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} cache := prog.openCache(t.Context(), "/data", opts) @@ -258,7 +259,7 @@ func Test_Service_openCache_LoadErrNotExist_NoLog_Success(t *testing.T) { }, } - prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, cacher) + prog := NewService(fsys, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) opts := Options{CacheDir: "/cache"} cache := prog.openCache(t.Context(), "/data", opts) @@ -290,7 +291,7 @@ func Test_Service_saveCache_NoCacheDir_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) opts := Options{CacheDir: ""} prog.saveCache(t.Context(), cache, opts, "/data") @@ -321,7 +322,7 @@ func Test_Service_saveCache_WithCacheDir_SavesCacheToDisk_Success(t *testing.T) }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) opts := Options{CacheDir: "/cache"} prog.saveCache(t.Context(), cache, opts, "/data") @@ -349,7 +350,7 @@ func Test_Service_saveCache_SaveError_LogsError_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) opts := Options{CacheDir: "/cache"} prog.saveCache(t.Context(), cache, opts, "/data") @@ -381,7 +382,7 @@ func Test_Service_Verify_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -415,7 +416,7 @@ func Test_Service_Verify_MultiRoot_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data", "/data2"}, args) require.NoError(t, err) @@ -450,7 +451,7 @@ func Test_Service_Verify_DurationExceeded_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} require.NoError(t, args.MaxDuration.Set("1ms")) @@ -488,7 +489,7 @@ func Test_Service_Verify_FileLocked_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -518,7 +519,7 @@ func Test_Service_Verify_Generic_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -548,7 +549,7 @@ func Test_Service_Verify_CorruptionDetected_Repairable_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -579,7 +580,7 @@ func Test_Service_Verify_CorruptionDetected_Unrepairable_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -620,7 +621,7 @@ func Test_Service_Verify_CorruptionDetected_Repairable_MaybeEdited_Error(t *test }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -661,7 +662,7 @@ func Test_Service_Verify_CorruptionDetected_Unrepairable_MaybeEdited_Error(t *te }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -696,7 +697,7 @@ func Test_Service_Verify_MultipleJobs_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -734,7 +735,7 @@ func Test_Service_Verify_MultipleJobs_OneFails_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.ErrorIs(t, err, schema.ErrExitPartialFailure) @@ -775,7 +776,7 @@ func Test_Service_Verify_MultipleJobs_EnumerationFails_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -817,7 +818,7 @@ func Test_Service_Verify_MultipleJobs_EnumerationFails_NoOtherJobs_Error(t *test }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -858,7 +859,7 @@ func Test_Service_Verify_MultipleJobs_ErrorOrdering_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.ErrorIs(t, err, schema.ErrExitUnrepairable) @@ -881,7 +882,7 @@ func Test_Service_Verify_NoJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) @@ -908,7 +909,7 @@ func Test_Service_Verify_CtxCancel_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(ctx, []string{"/data"}, args) @@ -950,7 +951,7 @@ func Test_Service_Verify_PrunesCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -999,7 +1000,7 @@ func Test_Service_Verify_UpdatesCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Par2Args: []string{"-v"}, CacheDir: "/cache"} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -1045,7 +1046,7 @@ func Test_Service_Verify_SavesCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Par2Args: []string{"-v"}, CacheDir: "/cache"} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -1090,7 +1091,7 @@ func Test_Service_Verify_NoCacheDir_DoesNotSave_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Par2Args: []string{"-v"}, CacheDir: ""} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -1123,7 +1124,7 @@ func Test_Service_Verify_LoadManifestReturnsNil_ProceedsWithNilManifest_Success( }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -1170,7 +1171,7 @@ func Test_Service_Verify_LoadManifestReadError_ContinuesWithError_Error(t *testi }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.ErrorIs(t, err, schema.ErrExitPartialFailure) @@ -1218,7 +1219,7 @@ func Test_Service_Verify_WithoutCacheDir_NotLoadsCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Par2Args: []string{"-v"}, CacheDir: ""} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -1263,7 +1264,7 @@ func Test_Service_Verify_WithCacheDir_LoadsCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Par2Args: []string{"-v"}, CacheDir: "/cache"} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.NoError(t, err) @@ -1314,7 +1315,7 @@ func Test_Service_Verify_UnknownExitCode_CacheNotUpdated_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, cacher) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, cacher) args := Options{Par2Args: []string{"-v"}, CacheDir: "/cache"} _, err := prog.Verify(t.Context(), []string{"/data"}, args) require.ErrorIs(t, err, schema.ErrExitPartialFailure) @@ -1338,7 +1339,7 @@ func Test_Service_Enumerate_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1364,7 +1365,7 @@ func Test_Service_Enumerate_InvalidManifest_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1397,7 +1398,7 @@ func Test_Service_Enumerate_NoManifest_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1428,7 +1429,7 @@ func Test_Service_Enumerate_ReadManifestFailure_Error(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1453,7 +1454,7 @@ func Test_Service_Enumerate_NoJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1480,7 +1481,7 @@ func Test_Service_Enumerate_IgnoreFile_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1508,7 +1509,7 @@ func Test_Service_Enumerate_IgnoreAllFile_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1538,7 +1539,7 @@ func Test_Service_Enumerate_IgnoreAllFile_SkipsRecursive_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1564,7 +1565,7 @@ func Test_Service_Enumerate_IncludeExternal_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{ Par2Args: []string{"-v"}, @@ -1593,7 +1594,7 @@ func Test_Service_Enumerate_IncludeExternal_Unset_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{ Par2Args: []string{"-v"}, @@ -1629,7 +1630,7 @@ func Test_Service_Enumerate_SkipNotCreated_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{ Par2Args: []string{"-v"}, @@ -1659,7 +1660,7 @@ func Test_Service_Enumerate_SkipNotCreated_InvalidManifest_Success(t *testing.T) } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{ Par2Args: []string{"-v"}, @@ -1693,7 +1694,7 @@ func Test_Service_Enumerate_NoSkipNotCreated_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{ Par2Args: []string{"-v"}, @@ -1735,7 +1736,7 @@ func Test_Service_Enumerate_BothSkipOptions_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{ Par2Args: []string{"-v"}, @@ -1767,7 +1768,7 @@ func Test_Service_Enumerate_CtxCancel_Error(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Enumerate(ctx, "/data", args, &testutil.MockCache{}) @@ -1797,7 +1798,7 @@ func Test_Service_Enumerate_MisleadingDirectory_Skipped_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1842,7 +1843,7 @@ func Test_Service_Enumerate_Bundle_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1884,7 +1885,7 @@ func Test_Service_Enumerate_Bundle_ManifestCorrupted_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1926,7 +1927,7 @@ func Test_Service_Enumerate_Bundle_ManifestReadIOFails_Error(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -1968,7 +1969,7 @@ func Test_Service_Enumerate_Bundle_InvalidManifest_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -2001,7 +2002,7 @@ func Test_Service_Enumerate_Bundle_OpenFails_Error(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} _, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -2044,7 +2045,7 @@ func Test_Service_Enumerate_Bundle_SkipNotCreated_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}, SkipNotCreated: true} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -2084,7 +2085,7 @@ func Test_Service_Enumerate_Bundle_SkipNotCreated_InvalidManifest_Success(t *tes } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}, SkipNotCreated: true} jobs, err := prog.Enumerate(t.Context(), "/data", args, &testutil.MockCache{}) @@ -2109,7 +2110,7 @@ func Test_Service_Enumerate_CacheHit_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) cachedMeta := &schema.JobMeta{ Par2Path: "/data/test" + schema.Par2Extension, @@ -2150,7 +2151,7 @@ func Test_Service_Enumerate_CacheHit_SkipNotCreated_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) cachedMeta := &schema.JobMeta{ Par2Path: "/data/test" + schema.Par2Extension, @@ -2191,7 +2192,7 @@ func Test_Service_Enumerate_CacheMiss_SetsCache_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) var setCalled bool var setKey string @@ -2255,7 +2256,7 @@ func Test_Service_Enumerate_Bundle_CacheHit_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, cache) @@ -2299,7 +2300,7 @@ func Test_Service_Enumerate_Bundle_CacheHit_SkipNotCreated_Success(t *testing.T) }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}, SkipNotCreated: true} jobs, err := prog.Enumerate(t.Context(), "/data", args, cache) @@ -2356,7 +2357,7 @@ func Test_Service_Enumerate_Bundle_CacheMiss_SetsCache_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) args := Options{Par2Args: []string{"-v"}} jobs, err := prog.Enumerate(t.Context(), "/data", args, cache) @@ -2382,7 +2383,7 @@ func Test_Service_loadManifest_FileNotFound_ReturnsNilManifest_Success(t *testin } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2414,7 +2415,7 @@ func Test_Service_loadManifest_InvalidJSON_ReturnsNilManifest_Success(t *testing } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2451,7 +2452,7 @@ func Test_Service_loadManifest_ReadError_Error(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2482,7 +2483,7 @@ func Test_Service_loadManifest_ValidManifest_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2528,7 +2529,7 @@ func Test_Service_loadBundleManifest_ManifestCorrupted_ReturnsNilManifest_Succes } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2575,7 +2576,7 @@ func Test_Service_loadBundleManifest_ManifestReadIOFails_Error(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2623,7 +2624,7 @@ func Test_Service_loadBundleManifest_InvalidJSON_ReturnsNilManifest_Success(t *t } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2661,7 +2662,7 @@ func Test_Service_loadBundleManifest_OpenFails_Error(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2713,7 +2714,7 @@ func Test_Service_loadBundleManifest_ValidManifest_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) meta := &JobMeta{ &schema.JobMeta{ @@ -2751,7 +2752,7 @@ func Test_Service_RunVerify_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -2789,7 +2790,7 @@ func Test_Service_RunVerify_HashFileFails_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -2835,7 +2836,7 @@ func Test_Service_RunVerify_CorrectArgs_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -2881,7 +2882,7 @@ func Test_Service_RunVerify_UpdatesVerificationFields_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) oldTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC) job := &Job{ @@ -2944,7 +2945,7 @@ func Test_Service_RunVerify_KeepCreateManifest_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -2995,7 +2996,7 @@ func Test_Service_RunVerify_HashMismatch_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.SHA256 = "wronghash" @@ -3039,7 +3040,7 @@ func Test_Service_RunVerify_GenericError_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.SHA256 = "wronghash" @@ -3078,7 +3079,7 @@ func Test_Service_RunVerify_ManifestWriteError_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.SHA256 = "wronghash" @@ -3139,7 +3140,7 @@ func Test_Service_RunVerify_Bundle_Success(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.BundleExtension + schema.Par2Extension) mf.SHA256 = "abc123" @@ -3215,7 +3216,7 @@ func Test_Service_RunVerify_Bundle_ManifestWriteError_Error(t *testing.T) { }, } - prog := NewService(fs, logging.NewLogger(ls), runner, bundler, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, bundler, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.BundleExtension + schema.Par2Extension) mf.SHA256 = "abc123" @@ -3263,7 +3264,7 @@ func Test_Service_RunVerify_Success_ClearsMaybeEdited_UpdatesTimeLastHealthy_Suc }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3317,7 +3318,7 @@ func Test_Service_RunVerify_Repairable_NewerFile_SetsMaybeEdited_Success(t *test }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3364,7 +3365,7 @@ func Test_Service_RunVerify_Repairable_OlderFile_NotMaybeEdited_Success(t *testi }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3411,7 +3412,7 @@ func Test_Service_RunVerify_Repairable_OlderFile_ClearsPreviousMaybeEdited_Succe }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3458,7 +3459,7 @@ func Test_Service_RunVerify_Repairable_FallbackCreationTime_SetsMaybeEdited_Succ }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3504,7 +3505,7 @@ func Test_Service_RunVerify_Repairable_NoCreation_NotMaybeEdited_Success(t *test }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3550,7 +3551,7 @@ func Test_Service_RunVerify_Unrepairable_NewerFile_SetsMaybeEdited_Success(t *te }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3597,7 +3598,7 @@ func Test_Service_RunVerify_UnhandledExitCode_KeepsMaybeEditedFields_Error(t *te }, } - prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), runner, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ workingDir: "/data", @@ -3635,7 +3636,7 @@ func Test_Service_parseExitCode_CodeSuccess_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ manifest: &schema.Manifest{ Verification: &schema.VerificationManifest{}, @@ -3664,7 +3665,7 @@ func Test_Service_parseExitCode_CodeRepairPossible_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ manifest: &schema.Manifest{ Verification: &schema.VerificationManifest{}, @@ -3694,7 +3695,7 @@ func Test_Service_parseExitCode_CodeRepairImpossible_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ manifest: &schema.Manifest{ Verification: &schema.VerificationManifest{}, @@ -3724,7 +3725,7 @@ func Test_Service_parseExitCode_UnhandledCode_Error(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) job := &Job{ manifest: &schema.Manifest{ Verification: &schema.VerificationManifest{}, @@ -3737,7 +3738,7 @@ func Test_Service_parseExitCode_UnhandledCode_Error(t *testing.T) { require.Equal(t, 99, job.manifest.Verification.ExitCode) } -// Expectation: A set without creation manifest should never be considered edited. +// Expectation: A set without creation manifest (and without a parseable PAR2 set) should not be considered edited. func Test_Service_wasMaybeEdited_NoCreation_Success(t *testing.T) { t.Parallel() @@ -3755,14 +3756,14 @@ func Test_Service_wasMaybeEdited_NoCreation_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: Without any reference time (neither creation nor verification) nothing should be considered edited. @@ -3783,7 +3784,7 @@ func Test_Service_wasMaybeEdited_NoReferenceTime_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Elements: []schema.FsElement{{Name: "file.txt"}}} @@ -3791,7 +3792,7 @@ func Test_Service_wasMaybeEdited_NoReferenceTime_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: A protected file newer than the last successful verification should be considered edited. @@ -3812,7 +3813,7 @@ func Test_Service_wasMaybeEdited_NewerThanSucceeded_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "file.txt"}}} @@ -3820,7 +3821,7 @@ func Test_Service_wasMaybeEdited_NewerThanSucceeded_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.True(t, prog.wasMaybeEdited(job)) + require.True(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: A protected file older than the last successful verification should not be considered edited. @@ -3841,7 +3842,7 @@ func Test_Service_wasMaybeEdited_OlderThanSucceeded_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "file.txt"}}} @@ -3849,7 +3850,7 @@ func Test_Service_wasMaybeEdited_OlderThanSucceeded_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: A protected file with exactly the reference time should not be considered edited. @@ -3870,7 +3871,7 @@ func Test_Service_wasMaybeEdited_EqualToSucceeded_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "file.txt"}}} @@ -3878,7 +3879,7 @@ func Test_Service_wasMaybeEdited_EqualToSucceeded_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: The last successful verification time should take precedence over the creation time. @@ -3900,7 +3901,7 @@ func Test_Service_wasMaybeEdited_PrefersSucceededOverCreation_Success(t *testing } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "file.txt"}}} @@ -3908,7 +3909,7 @@ func Test_Service_wasMaybeEdited_PrefersSucceededOverCreation_Success(t *testing job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: A missing protected file should be ignored rather than considered edited. @@ -3928,7 +3929,7 @@ func Test_Service_wasMaybeEdited_MissingElement_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "missing.txt"}}} @@ -3936,7 +3937,7 @@ func Test_Service_wasMaybeEdited_MissingElement_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: A missing protected file should not stop the check of the remaining protected files. @@ -3957,7 +3958,7 @@ func Test_Service_wasMaybeEdited_MissingElementThenNewer_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{ @@ -3968,7 +3969,7 @@ func Test_Service_wasMaybeEdited_MissingElementThenNewer_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.True(t, prog.wasMaybeEdited(job)) + require.True(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: Protected files in subfolders (deep globs) should be resolved relative to the working directory. @@ -3990,7 +3991,7 @@ func Test_Service_wasMaybeEdited_NestedElement_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "sub/file.txt"}}} @@ -3998,7 +3999,7 @@ func Test_Service_wasMaybeEdited_NestedElement_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.True(t, prog.wasMaybeEdited(job)) + require.True(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: A creation manifest without any elements should never be considered edited. @@ -4019,7 +4020,7 @@ func Test_Service_wasMaybeEdited_NoElements_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour)} @@ -4027,7 +4028,7 @@ func Test_Service_wasMaybeEdited_NoElements_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: A directory element should be skipped, as directory mtimes reflect entry changes, not edits. @@ -4048,7 +4049,7 @@ func Test_Service_wasMaybeEdited_DirectoryElement_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "sub", IsDir: true}}} @@ -4056,7 +4057,7 @@ func Test_Service_wasMaybeEdited_DirectoryElement_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) } // Expectation: An element with an empty name should be skipped rather than resolving to the working directory. @@ -4077,7 +4078,7 @@ func Test_Service_wasMaybeEdited_EmptyElementName_Success(t *testing.T) { } _ = ls.LogLevel.Set("debug") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) mf := schema.NewManifest("test" + schema.Par2Extension) mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: ""}}} @@ -4085,7 +4086,274 @@ func Test_Service_wasMaybeEdited_EmptyElementName_Success(t *testing.T) { job := &Job{workingDir: "/data", manifest: mf} - require.False(t, prog.wasMaybeEdited(job)) + require.False(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// wmService returns a [Service] with the given PAR2 and bundle handlers, logging to nowhere. +func wmService(fs afero.Fs, par2er schema.Par2Handler, bundler schema.BundleHandler) *Service { + ls := logging.Options{Logout: io.Discard, Stdout: io.Discard, Stderr: io.Discard} + + return NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, bundler, par2er, &testutil.MockCacheHandler{}) +} + +// wmSet returns a complete [par2.Set] with the given recovery file names. +func wmSet(names ...string) par2.Set { + s := par2.Set{SetID: par2.Hash{1}, MainPacket: &par2.MainPacket{SetID: par2.Hash{1}}} + for _, name := range names { + s.RecoverySet = append(s.RecoverySet, par2.FilePacket{SetID: par2.Hash{1}, Name: name}) + } + + return s +} + +// wmIndex returns a [testutil.MockPar2Handler] whose index parses to the given sets. +func wmIndex(t *testing.T, sets ...par2.Set) *testutil.MockPar2Handler { + t.Helper() + + return &testutil.MockPar2Handler{ + ParseFileFunc: func(_ afero.Fs, path string, _ bool) (*par2.File, error) { + require.Equal(t, "/data/test"+schema.Par2Extension, path) + + return &par2.File{Sets: sets}, nil + }, + ParseFileSetFunc: func(_ afero.Fs, _ []string, _ bool) (*par2.FileSet, error) { + return &par2.FileSet{SetsMerged: sets}, nil + }, + } +} + +// Expectation: A file of the PAR2 set (not in the creation manifest) newer than the reference time should be considered edited. +func Test_Service_wasMaybeEdited_SetFileNewer_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, afero.WriteFile(fs, "/data/file.txt", []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes("/data/file.txt", base.Add(time.Second), base.Add(time.Second))) + + prog := wmService(fs, wmIndex(t, wmSet("file.txt")), &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + require.True(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: A file of the PAR2 set older than the reference time should not be considered edited. +func Test_Service_wasMaybeEdited_SetFileOlder_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, afero.WriteFile(fs, "/data/file.txt", []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes("/data/file.txt", base.Add(-time.Hour), base.Add(-time.Hour))) + + prog := wmService(fs, wmIndex(t, wmSet("file.txt")), &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + require.False(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: Files of the creation manifest and of the PAR2 set should both be considered (also when listed in both). +func Test_Service_wasMaybeEdited_CreationAndSetFiles_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, afero.WriteFile(fs, "/data/old.txt", []byte("old"), 0o644)) + require.NoError(t, fs.Chtimes("/data/old.txt", base.Add(-time.Hour), base.Add(-time.Hour))) + require.NoError(t, afero.WriteFile(fs, "/data/new.txt", []byte("new"), 0o644)) + require.NoError(t, fs.Chtimes("/data/new.txt", base.Add(time.Second), base.Add(time.Second))) + + prog := wmService(fs, wmIndex(t, wmSet("old.txt", "new.txt")), &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "old.txt"}}} + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + require.True(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: PAR2 set file names with Windows separators should be resolved within the working directory. +func Test_Service_wasMaybeEdited_SetFileWindowsSeparators_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, fs.MkdirAll("/data/sub", 0o755)) + require.NoError(t, afero.WriteFile(fs, "/data/sub/file.txt", []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes("/data/sub/file.txt", base.Add(time.Second), base.Add(time.Second))) + + prog := wmService(fs, wmIndex(t, wmSet(`sub\file.txt`)), &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + require.True(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: PAR2 set file names escaping the working directory should be skipped. +func Test_Service_wasMaybeEdited_SetFileEscapes_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, fs.MkdirAll("/data", 0o755)) + for _, path := range []string{"/outside.txt", "/abs.txt"} { + require.NoError(t, afero.WriteFile(fs, path, []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes(path, base.Add(time.Second), base.Add(time.Second))) + } + + prog := wmService(fs, wmIndex(t, wmSet("../outside.txt", "/abs.txt", "", ".")), &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + require.False(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: The files of a confirmed, but incomplete PAR2 set should still be considered. +func Test_Service_wasMaybeEdited_IncompleteSetFile_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, afero.WriteFile(fs, "/data/file.txt", []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes("/data/file.txt", base.Add(time.Second), base.Add(time.Second))) + + incomplete := wmSet("file.txt") + incomplete.MissingRecoveryPackets = []par2.Hash{{0xff}} + + prog := wmService(fs, wmIndex(t, incomplete), &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + require.True(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: The files of an unconfirmed PAR2 set (unreadable index, set from the volumes) should not be considered. +func Test_Service_wasMaybeEdited_UnconfirmedSetFile_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, afero.WriteFile(fs, "/data/file.txt", []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes("/data/file.txt", base.Add(time.Second), base.Add(time.Second))) + + par2er := &testutil.MockPar2Handler{ + ParseFileFunc: func(_ afero.Fs, _ string, _ bool) (*par2.File, error) { + return nil, errors.New("simulated parse failure") + }, + ParseFileSetFunc: func(_ afero.Fs, _ []string, _ bool) (*par2.FileSet, error) { + return &par2.FileSet{SetsMerged: []par2.Set{wmSet("file.txt")}}, nil + }, + } + prog := wmService(fs, par2er, &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + require.False(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: The files of a bundle's PAR2 set should be considered. +func Test_Service_wasMaybeEdited_BundleSetFile_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, afero.WriteFile(fs, "/data/file.txt", []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes("/data/file.txt", base.Add(time.Second), base.Add(time.Second))) + + par2er := &testutil.MockPar2Handler{ + ParseFunc: func(_ io.ReadSeeker, _ bool) ([]par2.Set, error) { + return []par2.Set{wmSet("file.txt")}, nil + }, + } + bundler := &testutil.MockBundleHandler{ + OpenFunc: func(_ afero.Fs, path string) (schema.Bundle, error) { + require.Equal(t, "/data/test"+schema.BundleExtension+schema.Par2Extension, path) + + return &testutil.MockBundle{ + RecoverySetIDValue: par2.Hash{1}, + EntriesFunc: func() []bundle.IndexEntry { + return []bundle.IndexEntry{{Name: "test" + schema.Par2Extension, DataLength: 10}} + }, + ExtractEntryFunc: func(_ bundle.IndexEntry, w io.Writer) error { + _, err := w.Write([]byte("index data")) + + return err + }, + }, nil + }, + } + prog := wmService(fs, par2er, bundler) + + mf := schema.NewManifest("test" + schema.BundleExtension + schema.Par2Extension) + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.BundleExtension + schema.Par2Extension, manifest: mf} + + require.True(t, prog.wasMaybeEdited(t.Context(), job)) +} + +// Expectation: A cancelled context should still have the partial files tested for mtimes. +func Test_Service_wasMaybeEdited_CtxCancelled_Success(t *testing.T) { + t.Parallel() + + base := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + + fs := afero.NewMemMapFs() + require.NoError(t, afero.WriteFile(fs, "/data/file.txt", []byte("content"), 0o644)) + require.NoError(t, fs.Chtimes("/data/file.txt", base.Add(time.Second), base.Add(time.Second))) + + par2er := &testutil.MockPar2Handler{ + ParseFileFunc: func(_ afero.Fs, _ string, _ bool) (*par2.File, error) { + return nil, fmt.Errorf("wrapped: %w", context.Canceled) // As the real handler on cancellation. + }, + ParseFileSetFunc: func(_ afero.Fs, _ []string, _ bool) (*par2.FileSet, error) { + require.Fail(t, "should not merge after cancellation") + + return nil, errors.New("unexpected call") + }, + } + prog := wmService(fs, par2er, &testutil.MockBundleHandler{}) + + mf := schema.NewManifest("test" + schema.Par2Extension) + mf.Creation = &schema.CreationManifest{Time: base.Add(-24 * time.Hour), Elements: []schema.FsElement{{Name: "file.txt"}}} + mf.Verification = &schema.VerificationManifest{TimeLastHealthy: base} + + job := &Job{workingDir: "/data", par2Name: "test" + schema.Par2Extension, manifest: mf} + + ctx, cancel := context.WithCancel(t.Context()) + cancel() + + require.True(t, prog.wasMaybeEdited(ctx, job)) } // Expectation: A backlog warning should be thrown when the backlog is growing. @@ -4102,7 +4370,7 @@ func Test_Service_considerBacklog_InsufficientCapacity_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -4138,7 +4406,7 @@ func Test_Service_considerBacklog_NoDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -4179,7 +4447,7 @@ func Test_Service_considerDurations_FirstJobUnknownDuration_Success(t *testing.T } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -4213,7 +4481,7 @@ func Test_Service_considerDurations_FirstJobExceedsDuration_Success(t *testing.T } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -4247,7 +4515,7 @@ func Test_Service_considerDurations_SubsequentJobsUnknownDuration_Success(t *tes } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -4288,7 +4556,7 @@ func Test_Service_considerDurations_AllJobsKnownDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -4330,7 +4598,7 @@ func Test_Service_considerDurations_NoMaxDuration_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{ { @@ -4364,7 +4632,7 @@ func Test_Service_considerDurations_NoJobs_Success(t *testing.T) { } _ = ls.LogLevel.Set("info") - prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockCacheHandler{}) + prog := NewService(fs, logging.NewLogger(ls), &testutil.MockRunner{}, &util.BundleHandler{}, &testutil.MockPar2Handler{}, &testutil.MockCacheHandler{}) metas := []*JobMeta{} args := Options{}