From 1811fb73bd7ae3499a8971a377bdbd689eaf1904 Mon Sep 17 00:00:00 2001 From: plastikfan Date: Thu, 3 Oct 2024 18:54:57 +0100 Subject: [PATCH] test(persist): fix marshal coverage (#206) --- director-resume_test.go | 2 +- internal/feat/sampling/controller.go | 4 +- .../feat/sampling/navigator-sample_test.go | 6 +- internal/opts/json/sampling-options.go | 8 +- internal/persist/equals.go | 16 +- internal/persist/json-options.go | 20 +- internal/persist/marshaler_test.go | 893 ++++++++++++++---- internal/persist/persist-suite_test.go | 21 +- pref/options-sampling.go | 10 +- pref/with-operators_test.go | 4 +- scripts/coverage-exclusion-list.txt | 1 - 11 files changed, 763 insertions(+), 222 deletions(-) diff --git a/director-resume_test.go b/director-resume_test.go index 5cf1d20..f34278b 100644 --- a/director-resume_test.go +++ b/director-resume_test.go @@ -197,7 +197,7 @@ var _ = Describe("Director(Resume)", Ordered, func() { Files: files, Folders: folders, }, - SampleType: enums.SampleTypeSlice, + Type: enums.SampleTypeSlice, Iteration: pref.SamplingIterationOptions{ Each: func(_ *core.Node) bool { return false }, While: func(_ *pref.FilteredInfo) bool { return false }, diff --git a/internal/feat/sampling/controller.go b/internal/feat/sampling/controller.go index 13e8988..71efffb 100644 --- a/internal/feat/sampling/controller.go +++ b/internal/feat/sampling/controller.go @@ -52,14 +52,14 @@ func union(r *readResult) []fs.DirEntry { ) both := lo.Ternary( - r.o.SampleInReverse, last, first, + r.o.InReverse, last, first, )(noOfFiles, r.files) noOfFolders := lo.Ternary(r.o.NoOf.Folders == 0, uint(len(r.folders)), r.o.NoOf.Folders, ) both = append(both, lo.Ternary( - r.o.SampleInReverse, last, first, + r.o.InReverse, last, first, )(noOfFolders, r.folders)...) return both diff --git a/internal/feat/sampling/navigator-sample_test.go b/internal/feat/sampling/navigator-sample_test.go index ca8ae38..9e7b906 100644 --- a/internal/feat/sampling/navigator-sample_test.go +++ b/internal/feat/sampling/navigator-sample_test.go @@ -61,7 +61,7 @@ var _ = Describe("feature", Ordered, func() { }, }, tv.WithSamplingOptions(&pref.SamplingOptions{ - SampleType: enums.SampleTypeSlice, + Type: enums.SampleTypeSlice, NoOf: pref.EntryQuantities{ Files: 2, Folders: 2, @@ -129,8 +129,8 @@ var _ = Describe("feature", Ordered, func() { }, }, tv.WithSamplingOptions(&pref.SamplingOptions{ - SampleType: entry.SampleType, - SampleInReverse: entry.Reverse, + Type: entry.SampleType, + InReverse: entry.Reverse, NoOf: pref.EntryQuantities{ Files: entry.NoOf.Files, Folders: entry.NoOf.Folders, diff --git a/internal/opts/json/sampling-options.go b/internal/opts/json/sampling-options.go index 396669b..ce82a8f 100644 --- a/internal/opts/json/sampling-options.go +++ b/internal/opts/json/sampling-options.go @@ -14,12 +14,12 @@ type ( // SamplingOptions SamplingOptions struct { - // SampleType the type of sampling to use - SampleType enums.SampleType `json:"sample-type"` + // Type the type of sampling to use + Type enums.SampleType `json:"sample-type"` - // SampleInReverse determines the direction of iteration for the sampling + // InReverse determines the direction of iteration for the sampling // operation - SampleInReverse bool `json:"sample-in-reverse"` + InReverse bool `json:"sample-in-reverse"` // NoOf specifies number of items required in each sample (only applies // when not using Custom iterator options) diff --git a/internal/persist/equals.go b/internal/persist/equals.go index 8e56629..8b844e7 100644 --- a/internal/persist/equals.go +++ b/internal/persist/equals.go @@ -153,19 +153,19 @@ func equalBehaviours(o *pref.NavigationBehaviours, jo *json.NavigationBehaviours } func equalSampling(o *pref.SamplingOptions, jo *json.SamplingOptions) (bool, error) { - if o.SampleType != jo.SampleType { + if o.Type != jo.Type { return false, fmt.Errorf("sampling %w", UnequalValueError[enums.SampleType]{ Field: "SampleType", - Value: o.SampleType, - Other: jo.SampleType, + Value: o.Type, + Other: jo.Type, }) } - if o.SampleInReverse != jo.SampleInReverse { + if o.InReverse != jo.InReverse { return false, fmt.Errorf("sampling %w", UnequalValueError[bool]{ Field: "SampleInReverse", - Value: o.SampleInReverse, - Other: jo.SampleInReverse, + Value: o.InReverse, + Other: jo.InReverse, }) } @@ -222,7 +222,7 @@ func equalFilterDef(filterName string, } if def != nil && jdef == nil { - return false, fmt.Errorf("filter-def %w", + return false, fmt.Errorf("json-filter-def %w", UnequalPtrError[core.FilterDef, json.FilterDef]{ Field: "[nil jdef]", Value: def, @@ -291,7 +291,7 @@ func equalFilterDef(filterName string, ) } - if def.Poly != nil { + if def.Poly != nil && jdef.Poly != nil { if equal, err := equalFilterDef("poly", &def.Poly.File, &jdef.Poly.File); !equal { return equal, err } diff --git a/internal/persist/json-options.go b/internal/persist/json-options.go index 11411eb..fbde0a2 100644 --- a/internal/persist/json-options.go +++ b/internal/persist/json-options.go @@ -32,8 +32,8 @@ func ToJSON(o *pref.Options) *json.Options { }, }, Sampling: json.SamplingOptions{ - SampleType: o.Sampling.SampleType, - SampleInReverse: o.Sampling.SampleInReverse, + Type: o.Sampling.Type, + InReverse: o.Sampling.InReverse, NoOf: json.EntryQuantities{ Files: o.Sampling.NoOf.Files, Folders: o.Sampling.NoOf.Folders, @@ -93,12 +93,24 @@ func NodeFilterDefToJSON(def *core.FilterDef) *json.FilterDef { Negate: def.Negate, Scope: def.Scope, IfNotApplicable: def.IfNotApplicable, + Poly: NodePolyDefToJSON(def.Poly), } }, func() *json.FilterDef { return nil }, ) } +func NodePolyDefToJSON(poly *core.PolyFilterDef) *json.PolyFilterDef { + if poly == nil { + return nil + } + + return &json.PolyFilterDef{ + File: *NodeFilterDefToJSON(&poly.File), + Folder: *NodeFilterDefToJSON(&poly.Folder), + } +} + func FromJSON(o *json.Options) *pref.Options { return &pref.Options{ Behaviours: pref.NavigationBehaviours{ @@ -115,8 +127,8 @@ func FromJSON(o *json.Options) *pref.Options { }, }, Sampling: pref.SamplingOptions{ - SampleType: o.Sampling.SampleType, - SampleInReverse: o.Sampling.SampleInReverse, + Type: o.Sampling.Type, + InReverse: o.Sampling.InReverse, NoOf: pref.EntryQuantities{ Files: o.Sampling.NoOf.Files, Folders: o.Sampling.NoOf.Folders, diff --git a/internal/persist/marshaler_test.go b/internal/persist/marshaler_test.go index 6667499..06c0031 100644 --- a/internal/persist/marshaler_test.go +++ b/internal/persist/marshaler_test.go @@ -23,10 +23,20 @@ import ( ) var _ = Describe("Marshaler", Ordered, func() { + const ( + foo = "foo" + flac = "*.flac" + bar = "*.bar" + ) + var ( - FS lfs.TraverseFS - nodeFilterDef *core.FilterDef - childFilterDef *core.ChildFilterDef + FS lfs.TraverseFS + nodeFilterDef, polyNodeFilterDef *core.FilterDef + childFilterDef *core.ChildFilterDef + samplingOptions *pref.SamplingOptions + sampleFilterDef *core.SampleFilterDef + jsonNodeFilterDef, jsonPolyNodeFilterDef json.FilterDef + polyFilterDef *core.PolyFilterDef ) BeforeAll(func() { @@ -34,7 +44,7 @@ var _ = Describe("Marshaler", Ordered, func() { nodeFilterDef = &core.FilterDef{ Type: enums.FilterTypeGlob, Description: "items without .flac suffix", - Pattern: "*.flac", + Pattern: flac, Scope: enums.ScopeAll, Negate: true, IfNotApplicable: enums.TriStateBoolTrue, @@ -43,8 +53,66 @@ var _ = Describe("Marshaler", Ordered, func() { childFilterDef = &core.ChildFilterDef{ Type: enums.FilterTypeGlob, Description: "items without .flac suffix", - Pattern: "*.flac", + Pattern: flac, + Negate: true, + } + + samplingOptions = &pref.SamplingOptions{ + Type: enums.SampleTypeFilter, + InReverse: true, + NoOf: pref.EntryQuantities{ + Files: 2, + Folders: 3, + }, + } + + sampleFilterDef = &core.SampleFilterDef{ + Type: enums.FilterTypeGlob, + Description: "items without .flac suffix", + Pattern: flac, + Scope: enums.ScopeAll, Negate: true, + Poly: &core.PolyFilterDef{ + File: *nodeFilterDef, + Folder: *nodeFilterDef, + }, + } + + jsonNodeFilterDef = json.FilterDef{ + Type: enums.FilterTypeGlob, + Description: "items without .flac suffix", + Pattern: flac, + Scope: enums.ScopeAll, + Negate: true, + IfNotApplicable: enums.TriStateBoolTrue, + } + + jsonPolyNodeFilterDef = json.FilterDef{ + Type: enums.FilterTypePoly, + Description: "items without .flac suffix", + Pattern: flac, + Scope: enums.ScopeAll, + Negate: true, + IfNotApplicable: enums.TriStateBoolTrue, + Poly: &json.PolyFilterDef{ + File: jsonNodeFilterDef, + Folder: jsonNodeFilterDef, + }, + } + + polyFilterDef = &core.PolyFilterDef{ + File: *nodeFilterDef, + Folder: *nodeFilterDef, + } + + polyNodeFilterDef = &core.FilterDef{ + Type: enums.FilterTypePoly, + Description: "items without .flac suffix", + Pattern: flac, + Scope: enums.ScopeAll, + Negate: true, + IfNotApplicable: enums.TriStateBoolTrue, + Poly: polyFilterDef, } }) @@ -61,205 +129,662 @@ var _ = Describe("Marshaler", Ordered, func() { }) Context("map-fs", func() { - Context("marshal", func() { - DescribeTable("success", - func(entry *errorTE) { - o, _, err := opts.Get( - entry.option(), - ) - Expect(err).To(Succeed()) - - writePath := to + "/" + tempFile - jo, err := persist.Marshal(&persist.MarshalState{ - O: o, - Active: &types.ActiveState{ - Root: to, - Hibernation: enums.HibernationPending, - NodePath: "/root/a/b/c", - Depth: 3, - }, + DescribeTable("marshal", + func(entry *marshalTE) { + // success: + o, _, err := opts.Get( + pref.IfOptionF(entry.option != nil, func() pref.Option { + return entry.option() + }), + ) + Expect(err).To(Succeed()) + + writePath := to + "/" + tempFile + jo, err := persist.Marshal(&persist.MarshalState{ + O: o, + Active: &types.ActiveState{ + Root: to, + Hibernation: enums.HibernationPending, + NodePath: "/root/a/b/c", + Depth: 3, }, - writePath, permFile, FS, - ) + }, + writePath, permFile, FS, + ) - Expect(err).To(Succeed()) - Expect(jo).NotTo(BeNil()) + Expect(err).To(Succeed()) + Expect(jo).NotTo(BeNil()) - equals, err := persist.Equals(o, &json.Options{}) - Expect(equals).To(BeFalse(), "should not compare equal") - Expect(err).NotTo(Succeed()) + // unequal error: + if entry.tweak != nil { + entry.tweak(jo) + } + equals, err := persist.Equals(o, jo) + Expect(equals).To(BeFalse(), "should not compare equal") + Expect(err).NotTo(Succeed()) + }, + func(entry *marshalTE) string { + return fmt.Sprintf("given: %v, ๐Ÿงช should: marshal successfully", entry.given) + }, + + // ๐Ÿ‰ NavigationBehaviours: + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.SubPathBehaviour", }, - func(entry *errorTE) string { - return fmt.Sprintf("given: %v, ๐Ÿงช should: marshal successfully", entry.given) + option: func() pref.Option { + return pref.WithSubPathBehaviour(&pref.SubPathBehaviour{ + KeepTrailingSep: false, + }) + }, + tweak: func(jo *json.Options) { + jo.Behaviours.SubPath.KeepTrailingSep = true }, + }), - // NavigationBehaviours: - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "NavigationBehaviours.SubPathBehaviour", - option: func() pref.Option { - return pref.WithSubPathBehaviour(&pref.SubPathBehaviour{ - KeepTrailingSep: false, - }) - }, - }, - }), - - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "NavigationBehaviours.WithSortBehaviour", - option: func() pref.Option { - return pref.WithSortBehaviour(&pref.SortBehaviour{ - IsCaseSensitive: true, - SortFilesFirst: true, - }) - }, - }, - }), + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.WithSortBehaviour", + }, + option: func() pref.Option { + return pref.WithSortBehaviour(&pref.SortBehaviour{ + IsCaseSensitive: true, + SortFilesFirst: true, + }) + }, + tweak: func(jo *json.Options) { + jo.Behaviours.Sort.IsCaseSensitive = false + }, + }), - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "NavigationBehaviours.CascadeBehaviour.WithDepth", - option: func() pref.Option { - return pref.WithDepth(4) - }, - }, - }), + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.CascadeBehaviour.WithDepth", + }, + option: func() pref.Option { + return pref.WithDepth(4) + }, + tweak: func(jo *json.Options) { + jo.Behaviours.Cascade.Depth = 99 + }, + }), - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "NavigationBehaviours.CascadeBehaviour.NoRecurse", - option: pref.WithNoRecurse, - }, - }), - - // SamplingOptions: - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "NavigationBehaviours.SamplingOptions", - option: func() pref.Option { - return pref.WithSamplingOptions(&pref.SamplingOptions{ - SampleType: enums.SampleTypeFilter, - SampleInReverse: true, - NoOf: pref.EntryQuantities{ - Files: 3, - Folders: 4, - }, - }) + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.CascadeBehaviour.NoRecurse", + }, + option: pref.WithNoRecurse, + tweak: func(jo *json.Options) { + jo.Behaviours.Cascade.NoRecurse = false + }, + }), + + // ๐Ÿ‰ SamplingOptions: + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.SamplingOptions.InReverse", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(&pref.SamplingOptions{ + Type: enums.SampleTypeFilter, + InReverse: true, + NoOf: pref.EntryQuantities{ + Files: 3, + Folders: 4, }, - }, - }), - - // FilterOptions: - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "FilterOptions - Node", - option: func() pref.Option { - return pref.WithFilter(&pref.FilterOptions{ - Node: nodeFilterDef, - }) + }) + }, + tweak: func(jo *json.Options) { + jo.Sampling.InReverse = false + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.SamplingOptions.SampleType", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(&pref.SamplingOptions{ + Type: enums.SampleTypeFilter, + InReverse: true, + NoOf: pref.EntryQuantities{ + Files: 3, + Folders: 4, }, - }, - }), - - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "FilterOptions - Child", - option: func() pref.Option { - return pref.WithFilter(&pref.FilterOptions{ - Child: childFilterDef, - }) + }) + }, + tweak: func(jo *json.Options) { + jo.Sampling.Type = enums.SampleTypeSlice + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.SamplingOptions.NoOf.Files", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(&pref.SamplingOptions{ + Type: enums.SampleTypeFilter, + InReverse: true, + NoOf: pref.EntryQuantities{ + Files: 3, + Folders: 4, }, - }, - }), - - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "FilterOptions - Sample", - option: func() pref.Option { - return pref.WithFilter(&pref.FilterOptions{ - Sample: &core.SampleFilterDef{ - Type: enums.FilterTypeGlob, - Description: "items without .flac suffix", - Pattern: "*.flac", - Scope: enums.ScopeAll, - Negate: true, - Poly: &core.PolyFilterDef{ - File: *nodeFilterDef, - Folder: *nodeFilterDef, - }, - }, - }) + }) + }, + tweak: func(jo *json.Options) { + jo.Sampling.NoOf.Files = 99 + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "NavigationBehaviours.SamplingOptions.NoOf.Folders", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(&pref.SamplingOptions{ + Type: enums.SampleTypeFilter, + InReverse: true, + NoOf: pref.EntryQuantities{ + Files: 3, + Folders: 4, }, - }, - }), - - // HibernateOptions: - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "HibernateOptions.Behaviour.InclusiveWake", - option: func() pref.Option { - return pref.WithHibernationFilterWake(nodeFilterDef) + }) + }, + tweak: func(jo *json.Options) { + jo.Sampling.NoOf.Folders = 99 + }, + }), + + // ๐Ÿ‰ FilterOptions.Node + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - nil:pref.Options", + }, + tweak: func(jo *json.Options) { + jo.Filter.Node = &json.FilterDef{ + Type: enums.FilterTypeRegex, + Description: foo, + Pattern: flac, + Scope: enums.ScopeFile, + } + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - nil:json.Options", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: nodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node = nil + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.Type", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: nodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.Type = enums.FilterTypeExtendedGlob + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.Description", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: nodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.Description = foo + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.Pattern", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: nodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.Pattern = bar + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.Scope", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: nodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.Scope = enums.ScopeFile + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.Negate", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: nodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.Negate = false + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.IfNotApplicable", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: nodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.IfNotApplicable = enums.TriStateBoolFalse + }, + }), + + // ๐Ÿ‰ FilterOptions.Node.Poly + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions.Node.Poly - nil:pref.Options", + }, + tweak: func(jo *json.Options) { + jo.Filter.Node = &jsonPolyNodeFilterDef + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions.Node.Poly - nil:json.Options", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: polyNodeFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node = nil + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.Poly.File", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: &core.FilterDef{ + Type: enums.FilterTypePoly, + Poly: &core.PolyFilterDef{ + File: *nodeFilterDef, + Folder: *nodeFilterDef, + }, }, - }, - }), + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.Poly.File.Description = foo + }, + }), - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "HibernateOptions.Behaviour.InclusiveSleep", - option: func() pref.Option { - return pref.WithHibernationFilterSleep(nodeFilterDef) + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Node.Poly.Folder", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Node: &core.FilterDef{ + Type: enums.FilterTypePoly, + Poly: &core.PolyFilterDef{ + File: *nodeFilterDef, + Folder: *nodeFilterDef, + }, }, - }, - }), + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Node.Poly.Folder.Description = foo + }, + }), - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "HibernateOptions.Behaviour.InclusiveWake", - option: pref.WithHibernationBehaviourExclusiveWake, - }, - }), + // ๐Ÿ‰ FilterOptions.Child + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - nil:pref.Options", + }, + tweak: func(jo *json.Options) { + jo.Filter.Child = &json.ChildFilterDef{ + Type: enums.FilterTypeGlob, + Description: "items without .flac suffix", + Pattern: flac, + Negate: true, + } + }, + }), - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "HibernateOptions.Behaviour.InclusiveSleep", - option: pref.WithHibernationBehaviourInclusiveSleep, - }, - }), - - // ConcurrencyOptions: - Entry(nil, &errorTE{ - marshalTE: marshalTE{ - given: "ConcurrencyOptions.NoW", - option: func() pref.Option { - return pref.WithNoW(5) - }, - }, - }), - ) - - Context("UnequalPtrError", func() { - When("pref.Options is nil", func() { - It("๐Ÿงช should: return UnequalPtrError", func() { - equals, err := persist.Equals(nil, &json.Options{}) - Expect(equals).To(BeFalse(), "should not compare equal") - Expect(err).NotTo(Succeed()) - Expect(errors.Is(err, locale.ErrUnEqualConversion)).To(BeTrue(), - "error should be a locale.ErrUnEqualConversion", - ) + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - nil:json.Options", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Child: childFilterDef, }) - }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Child = nil + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Child.Type", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Child: childFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Child.Type = enums.FilterTypeExtendedGlob + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Child.Description", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Child: childFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Child.Description = foo + }, + }), - When("json FilterDef is nil", func() { - It("๐Ÿงช should: return UnequalPtrError", func() { - o, _, _ := opts.Get() - equals, err := persist.Equals(o, nil) - Expect(equals).To(BeFalse(), "should not compare equal") - Expect(err).NotTo(Succeed()) - Expect(errors.Is(err, locale.ErrUnEqualConversion)).To(BeTrue(), - "error should be a locale.ErrUnEqualConversion", - ) + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Child.Pattern", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Child: childFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Child.Pattern = foo + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Child.Negate", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Child: childFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Child.Negate = false + }, + }), + + // ๐Ÿ‰ FilterOptions.Sample + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - nil:pref.Options", + }, + tweak: func(jo *json.Options) { + jo.Filter.Sample = &json.SampleFilterDef{ + Type: enums.FilterTypeRegex, + Description: foo, + Pattern: flac, + Scope: enums.ScopeFile, + } + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - nil:json.Options", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Sample: sampleFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Sample = nil + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Sample.Type", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Sample: sampleFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Sample.Type = enums.FilterTypeExtendedGlob + }, + }), + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Sample.Description", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Sample: sampleFilterDef, }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Sample.Description = foo + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Sample.Pattern", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Sample: sampleFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Sample.Pattern = bar + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Sample.Scope", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Sample: sampleFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Sample.Scope = enums.ScopeFile + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "FilterOptions - Sample.Negate", + }, + option: func() pref.Option { + return pref.WithFilter(&pref.FilterOptions{ + Sample: sampleFilterDef, + }) + }, + tweak: func(jo *json.Options) { + jo.Filter.Sample.Negate = false + }, + }), + + // SamplingOptions: + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "Sampling - SampleOptions.Type", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(samplingOptions) + }, + tweak: func(jo *json.Options) { + jo.Sampling.Type = enums.SampleTypeSlice + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "Sampling - SampleOptions.InReverse", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(samplingOptions) + }, + tweak: func(jo *json.Options) { + jo.Sampling.InReverse = false + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "Sampling - SampleOptions.NoOf.Files", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(samplingOptions) + }, + tweak: func(jo *json.Options) { + jo.Sampling.NoOf.Files = 99 + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "Sampling - SampleOptions.NoOf.Folders", + }, + option: func() pref.Option { + return pref.WithSamplingOptions(samplingOptions) + }, + tweak: func(jo *json.Options) { + jo.Sampling.NoOf.Folders = 99 + }, + }), + + // ๐Ÿ‰ HibernateOptions: + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "HibernateOptions.Behaviour.InclusiveWake", + }, + option: func() pref.Option { + return pref.WithHibernationFilterWake(nodeFilterDef) + }, + tweak: func(jo *json.Options) { + jo.Hibernate.WakeAt.Description = foo + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "HibernateOptions.Behaviour.InclusiveSleep", + }, + option: func() pref.Option { + return pref.WithHibernationFilterSleep(nodeFilterDef) + }, + tweak: func(jo *json.Options) { + jo.Hibernate.SleepAt.Description = foo + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "HibernateOptions.Behaviour.InclusiveWake", + }, + option: pref.WithHibernationBehaviourExclusiveWake, + tweak: func(jo *json.Options) { + jo.Hibernate.Behaviour.InclusiveWake = true + }, + }), + + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "HibernateOptions.Behaviour.InclusiveSleep", + }, + option: pref.WithHibernationBehaviourInclusiveSleep, + tweak: func(jo *json.Options) { + jo.Hibernate.Behaviour.InclusiveSleep = false + }, + }), + + // ๐Ÿ‰ ConcurrencyOptions: + Entry(nil, &marshalTE{ + persistTE: persistTE{ + given: "ConcurrencyOptions.NoW", + }, + option: func() pref.Option { + return pref.WithNoW(5) + }, + tweak: func(jo *json.Options) { + jo.Concurrency.NoW = 99 + }, + }), + ) + + Context("UnequalPtrError", func() { + When("pref.Options is nil", func() { + It("๐Ÿงช should: return UnequalPtrError", func() { + equals, err := persist.Equals(nil, &json.Options{}) + Expect(equals).To(BeFalse(), "should not compare equal") + Expect(err).NotTo(Succeed()) + Expect(errors.Is(err, locale.ErrUnEqualConversion)).To(BeTrue(), + "error should be a locale.ErrUnEqualConversion", + ) + }) + }) + + When("json FilterDef is nil", func() { + It("๐Ÿงช should: return UnequalPtrError", func() { + o, _, _ := opts.Get() + equals, err := persist.Equals(o, nil) + Expect(equals).To(BeFalse(), "should not compare equal") + Expect(err).NotTo(Succeed()) + Expect(errors.Is(err, locale.ErrUnEqualConversion)).To(BeTrue(), + "error should be a locale.ErrUnEqualConversion", + ) }) }) }) diff --git a/internal/persist/persist-suite_test.go b/internal/persist/persist-suite_test.go index 5d959e9..1f8d7cb 100644 --- a/internal/persist/persist-suite_test.go +++ b/internal/persist/persist-suite_test.go @@ -5,6 +5,7 @@ import ( . "github.com/onsi/ginkgo/v2" //nolint:revive // ok . "github.com/onsi/gomega" //nolint:revive // ok + "github.com/snivilised/traverse/internal/opts/json" "github.com/snivilised/traverse/pref" ) @@ -24,16 +25,20 @@ const ( ) type ( + persistTE struct { + given string + } marshalTE struct { - given string + persistTE + // option defines a single option to be defined for the unit test. When + // a test case wants to test an optional option in pref.Options (ie it + // is a pointer), then that test case will not define this option. Instead + // it will define the tweak function to contain the corresponding member + // on the json instance, such that the pref.member is nil and json.member + // is noy til, thereby triggering an unequal error. option func() pref.Option - } - - errorTE struct { - marshalTE - } - conversionTE struct { - marshalTE + // tweak allows a test case to change json.Options to provoke unequal error + tweak func(jo *json.Options) } ) diff --git a/pref/options-sampling.go b/pref/options-sampling.go index e5b4044..8675095 100644 --- a/pref/options-sampling.go +++ b/pref/options-sampling.go @@ -8,12 +8,12 @@ import ( type ( // SamplingOptions SamplingOptions struct { - // SampleType the type of sampling to use - SampleType enums.SampleType + // Type the type of sampling to use + Type enums.SampleType - // SampleInReverse determines the direction of iteration for the sampling + // InReverse determines the direction of iteration for the sampling // operation - SampleInReverse bool + InReverse bool // NoOf specifies number of items required in each sample (only applies // when not using Custom iterator options) @@ -77,7 +77,7 @@ type ( ) func (o SamplingOptions) IsSamplingActive() bool { - return o.SampleType != enums.SampleTypeUndefined + return o.Type != enums.SampleTypeUndefined } // WithSamplingOptions specifies the sampling options. diff --git a/pref/with-operators_test.go b/pref/with-operators_test.go index d910324..1711913 100644 --- a/pref/with-operators_test.go +++ b/pref/with-operators_test.go @@ -151,8 +151,8 @@ var _ = Describe("With Operators", Ordered, func() { It("๐Ÿงช should: create option", func() { Expect(tv.WithSamplingOptions( &pref.SamplingOptions{ - SampleType: enums.SampleTypeFilter, - SampleInReverse: true, + Type: enums.SampleTypeFilter, + InReverse: true, NoOf: pref.EntryQuantities{ Files: 2, Folders: 3, diff --git a/scripts/coverage-exclusion-list.txt b/scripts/coverage-exclusion-list.txt index ff91fa1..914b755 100644 --- a/scripts/coverage-exclusion-list.txt +++ b/scripts/coverage-exclusion-list.txt @@ -1,4 +1,3 @@ github.com/snivilised/traverse/enums github.com/snivilised/traverse/internal/third github.com/snivilised/traverse/internal/laboratory/ -github.com/snivilised/traverse/internal/persist/equals.go