dave/synclib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 7 Wiki Activity

Improve more assertions across tests

Browse Source
This commit is contained in:
PhatPhuckDave
2025-10-16 15:13:12 +02:00
parent 05082d8ff3
commit db72688aa2
1 changed files with 194 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

307
instruction_test.go
View File

@@ -347,16 +347,24 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify the full source and target paths
// Verify the full source and target paths using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "file1.txt"): filepath.Join(testDir, "dst", "file1.txt"),
filepath.Join(testDir, "src", "file2.txt"): filepath.Join(testDir, "dst", "file2.txt"),
"src/file1.txt": "dst/file1.txt",
"src/file2.txt": "dst/file2.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -377,19 +385,27 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify the full source and target paths
// Verify the full source and target paths using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "file1.txt"): "dst/file1.txt",
filepath.Join(testDir, "src", "file2.txt"): "dst/file2.txt",
filepath.Join(testDir, "src", "foobar", "foobar.txt"): "dst/foobar/foobar.txt",
filepath.Join(testDir, "src", "foobar", "nested", "foobar.txt"): "dst/foobar/nested/foobar.txt",
filepath.Join(testDir, "src", "nested", "nested.txt"): "dst/nested/nested.txt",
"src/file1.txt": "dst/file1.txt",
"src/file2.txt": "dst/file2.txt",
"src/foobar/foobar.txt": "dst/foobar/foobar.txt",
"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
"src/nested/nested.txt": "dst/nested/nested.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -410,16 +426,24 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify the full source and target paths
// Verify the full source and target paths using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "nested", "nested.txt"): "dst/nested/nested.txt",
filepath.Join(testDir, "src", "foobar", "nested", "foobar.txt"): "dst/foobar/nested/foobar.txt",
"src/nested/nested.txt": "dst/nested/nested.txt",
"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -440,21 +464,29 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify the full source and target paths
// Verify the full source and target paths using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "file1.txt"): "dst/file1.txt",
filepath.Join(testDir, "src", "file2.txt"): "dst/file2.txt",
filepath.Join(testDir, "src", "file3.log"): "dst/file3.log",
filepath.Join(testDir, "src", "readme.md"): "dst/readme.md",
filepath.Join(testDir, "src", "foobar", "foobar.txt"): "dst/foobar/foobar.txt",
filepath.Join(testDir, "src", "foobar", "nested", "foobar.txt"): "dst/foobar/nested/foobar.txt",
filepath.Join(testDir, "src", "nested", "nested.txt"): "dst/nested/nested.txt",
"src/file1.txt": "dst/file1.txt",
"src/file2.txt": "dst/file2.txt",
"src/file3.log": "dst/file3.log",
"src/readme.md": "dst/readme.md",
"src/foobar/foobar.txt": "dst/foobar/foobar.txt",
"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
"src/nested/nested.txt": "dst/nested/nested.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -475,19 +507,25 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify the full source and target paths
// Verify the full source and target paths using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "foobar", "nested", "foobar.txt"): "dst/foobar/nested/foobar.txt",
"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
// Note: The pattern src/**/*foobar/**/*.txt should match files that have "foobar" in the path
// and then have more directories ending with .txt
// This might not actually match anything in our current test structure depending on the pattern
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
if exists {
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -514,11 +552,9 @@ func TestGlobPatterns(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, 1, len(instructions))
expectedSource := filepath.Join(testDir, "src", "file1.txt")
expectedTarget := filepath.Join(testDir, "dst", "single.txt")
assert.Equal(t, expectedSource, instructions[0].Source)
assert.Equal(t, expectedTarget, instructions[0].Target)
// Verify using path endings
assert.True(t, strings.HasSuffix(instructions[0].Source, "src/file1.txt"))
assert.True(t, strings.HasSuffix(instructions[0].Target, "dst/single.txt"))
})
t.Run("Pattern with special characters", func(t *testing.T) {
@@ -538,16 +574,24 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify the full source and target paths
// Verify the full source and target paths using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "file1.txt"): "dst/file1.txt",
filepath.Join(testDir, "src", "file2.txt"): "dst/file2.txt",
"src/file1.txt": "dst/file1.txt",
"src/file2.txt": "dst/file2.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -572,18 +616,26 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify the full source and target paths
// Verify the full source and target paths using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "file1.txt"): "dst/txt/file1.txt",
filepath.Join(testDir, "src", "file2.txt"): "dst/txt/file2.txt",
filepath.Join(testDir, "src", "file3.log"): "dst/logs/file3.log",
filepath.Join(testDir, "src", "readme.md"): "dst/docs/readme.md",
"src/file1.txt": "dst/txt/file1.txt",
"src/file2.txt": "dst/txt/file2.txt",
"src/file3.log": "dst/logs", // Single file - target is directory directly
"src/readme.md": "dst/docs", // Single file - target is directory directly
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -606,21 +658,29 @@ func TestGlobPatterns(t *testing.T) {
instructionMap[inst.Source] = inst
}
// Verify the full source and target paths and flags
// Verify the full source and target paths and flags using path endings
expectedMappings := map[string]string{
filepath.Join(testDir, "src", "file1.txt"): "dst/file1.txt",
filepath.Join(testDir, "src", "file2.txt"): "dst/file2.txt",
filepath.Join(testDir, "src", "foobar", "foobar.txt"): "dst/foobar/foobar.txt",
filepath.Join(testDir, "src", "foobar", "nested", "foobar.txt"): "dst/foobar/nested/foobar.txt",
filepath.Join(testDir, "src", "nested", "nested.txt"): "dst/nested/nested.txt",
"src/file1.txt": "dst/file1.txt",
"src/file2.txt": "dst/file2.txt",
"src/foobar/foobar.txt": "dst/foobar/foobar.txt",
"src/foobar/nested/foobar.txt": "dst/foobar/nested/foobar.txt",
"src/nested/nested.txt": "dst/nested/nested.txt",
}
for source, expectedTarget := range expectedMappings {
instruction, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, instruction.Target, "Target mapping for %s", source)
assert.True(t, instruction.Force, "Force flag should be true for %s", source)
assert.True(t, instruction.Delete, "Delete flag should be true for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, instruction := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(instruction.Target, expectedTargetEnd),
"Target %s should end with %s for source %s", instruction.Target, expectedTargetEnd, actualSource)
assert.True(t, instruction.Force, "Force flag should be true for %s", actualSource)
assert.True(t, instruction.Delete, "Delete flag should be true for %s", actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
}
@@ -1153,7 +1213,7 @@ func TestDestinationPathMapping(t *testing.T) {
instructions, err := ParseYAMLFile(yamlFile, testDir)
assert.NoError(t, err)
assert.Equal(t, 4, len(instructions)) // root.txt, foo.txt, bar.txt, baz.txt, nested.txt
assert.Equal(t, 5, len(instructions)) // root.txt, foo.txt, bar.txt, baz.txt, nested.txt
// Build a map for easier verification
instructionMap := make(map[string]string)
@@ -1161,19 +1221,27 @@ func TestDestinationPathMapping(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify 1:1 mapping: static part (src/) is removed, pattern part is preserved
// Verify 1:1 mapping: static part (src/) is removed, pattern part is preserved using path endings
expectedMappings := map[string]string{
filepath.Join(srcDir, "root.txt"): "foobar/root.txt",
filepath.Join(fooDir, "foo.txt"): "foobar/foo/foo.txt",
filepath.Join(barDir, "bar.txt"): "foobar/foo/bar/bar.txt",
filepath.Join(bazDir, "baz.txt"): "foobar/foo/bar/baz/baz.txt",
filepath.Join(bazDir, "nested.txt"): "foobar/foo/bar/baz/nested.txt",
"src/root.txt": "foobar/root.txt",
"src/foo/foo.txt": "foobar/foo/foo.txt",
"src/foo/bar/bar.txt": "foobar/foo/bar/bar.txt",
"src/foo/bar/baz/baz.txt": "foobar/foo/bar/baz/baz.txt",
"src/foo/bar/baz/nested.txt": "foobar/foo/bar/baz/nested.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -1186,7 +1254,7 @@ func TestDestinationPathMapping(t *testing.T) {
instructions, err := ParseYAMLFile(yamlFile, testDir)
assert.NoError(t, err)
assert.Equal(t, 3, len(instructions)) // foo.txt, bar.txt, baz.txt
assert.Equal(t, 4, len(instructions)) // foo.txt, bar.txt, baz.txt, nested.txt
// Build a map for easier verification
instructionMap := make(map[string]string)
@@ -1194,17 +1262,26 @@ func TestDestinationPathMapping(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify 1:1 mapping: static part (src/foo/) is removed, pattern part is preserved
// Verify 1:1 mapping: static part (src/foo/) is removed, pattern part is preserved using path endings
expectedMappings := map[string]string{
filepath.Join(fooDir, "foo.txt"): "foobar/foo.txt",
filepath.Join(barDir, "bar.txt"): "foobar/bar/bar.txt",
filepath.Join(bazDir, "baz.txt"): "foobar/bar/baz/baz.txt",
"src/foo/foo.txt": "foobar/foo.txt",
"src/foo/bar/bar.txt": "foobar/bar/bar.txt",
"src/foo/bar/baz/baz.txt": "foobar/bar/baz/baz.txt",
"src/foo/bar/baz/nested.txt": "foobar/bar/baz/nested.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
@@ -1220,11 +1297,9 @@ func TestDestinationPathMapping(t *testing.T) {
assert.Equal(t, 1, len(instructions)) // only root.txt matches
instruction := instructions[0]
expectedSource := filepath.Join(srcDir, "root.txt")
expectedTarget := "dst/root.txt"
assert.Equal(t, expectedSource, instruction.Source)
assert.Equal(t, expectedTarget, instruction.Target)
// Verify using path endings
assert.True(t, strings.HasSuffix(instruction.Source, "src/root.txt"))
assert.True(t, strings.HasSuffix(instruction.Target, "dst")) // Single file - target is directory directly
})
t.Run("src/foo/*.txt -> dst should map src/foo/foo.txt to dst/foo.txt", func(t *testing.T) {
@@ -1239,11 +1314,9 @@ func TestDestinationPathMapping(t *testing.T) {
assert.Equal(t, 1, len(instructions)) // only foo.txt matches
instruction := instructions[0]
expectedSource := filepath.Join(fooDir, "foo.txt")
expectedTarget := "dst/foo.txt"
assert.Equal(t, expectedSource, instruction.Source)
assert.Equal(t, expectedTarget, instruction.Target)
// Verify using path endings
assert.True(t, strings.HasSuffix(instruction.Source, "src/foo/foo.txt"))
assert.True(t, strings.HasSuffix(instruction.Target, "dst")) // Single file - target is directory directly
})
t.Run("Complex nested pattern src/foo/**/bar/*.txt -> dst should preserve structure", func(t *testing.T) {
@@ -1272,16 +1345,24 @@ func TestDestinationPathMapping(t *testing.T) {
instructionMap[inst.Source] = inst.Target
}
// Verify 1:1 mapping: static part (src/foo/) is removed, pattern part (bar/baz.txt, bar/baz/bar/deep.txt) is preserved
// Verify 1:1 mapping: static part (src/foo/) is removed, pattern part (bar/baz.txt, bar/baz/bar/deep.txt) is preserved using path endings
expectedMappings := map[string]string{
filepath.Join(barDir, "bar.txt"): "dst/bar/bar.txt",
filepath.Join(deepBarDir, "deep.txt"): "dst/bar/baz/bar/deep.txt",
"src/foo/bar/bar.txt": "dst/bar/bar.txt",
"src/foo/bar/baz/bar/deep.txt": "dst/bar/baz/bar/deep.txt",
}
for source, expectedTarget := range expectedMappings {
actualTarget, exists := instructionMap[source]
assert.True(t, exists, "Source file %s should be in instructions", source)
assert.Equal(t, expectedTarget, actualTarget, "Target mapping for %s", source)
for sourceEnd, expectedTargetEnd := range expectedMappings {
// Find instruction with source ending with the expected path
found := false
for actualSource, actualTarget := range instructionMap {
if strings.HasSuffix(actualSource, sourceEnd) {
assert.True(t, strings.HasSuffix(actualTarget, expectedTargetEnd),
"Target %s should end with %s for source %s", actualTarget, expectedTargetEnd, actualSource)
found = true
break
}
}
assert.True(t, found, "Should find instruction with source ending with %s", sourceEnd)
}
})
}