117 lines
2.9 KiB
Go
117 lines
2.9 KiB
Go
package contract
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/rogeecn/renamer/internal/regex"
|
|
)
|
|
|
|
func TestRegexPreviewUsesCaptureGroups(t *testing.T) {
|
|
tmp := t.TempDir()
|
|
copyRegexFixture(t, "baseline", tmp)
|
|
|
|
req := regex.NewRequest(tmp)
|
|
req.Pattern = "^(\\w+)-(\\d+)"
|
|
req.Template = "@2_@1"
|
|
req.IncludeDirectories = false
|
|
req.Recursive = false
|
|
|
|
var buf bytes.Buffer
|
|
summary, planned, err := regex.Preview(context.Background(), req, &buf)
|
|
if err != nil {
|
|
t.Fatalf("regex preview returned error: %v", err)
|
|
}
|
|
|
|
if summary.TotalCandidates != len(summary.Entries) {
|
|
t.Fatalf("expected summary entries to equal candidates: %d vs %d", summary.TotalCandidates, len(summary.Entries))
|
|
}
|
|
|
|
expected := map[string]string{
|
|
"alpha-123.log": "123_alpha.log",
|
|
"beta-456.log": "456_beta.log",
|
|
"gamma-789.log": "789_gamma.log",
|
|
}
|
|
|
|
if summary.Changed != len(planned) {
|
|
t.Fatalf("expected changed count %d to equal plan length %d", summary.Changed, len(planned))
|
|
}
|
|
|
|
for _, entry := range summary.Entries {
|
|
target, ok := expected[filepath.Base(entry.OriginalPath)]
|
|
if !ok {
|
|
t.Fatalf("unexpected candidate in preview: %s", entry.OriginalPath)
|
|
}
|
|
if entry.ProposedPath != filepath.Join(filepath.Dir(entry.OriginalPath), target) {
|
|
t.Fatalf("expected proposed path %s, got %s", target, entry.ProposedPath)
|
|
}
|
|
if entry.Status != regex.EntryChanged {
|
|
t.Fatalf("expected entry status 'changed', got %s", entry.Status)
|
|
}
|
|
}
|
|
|
|
if len(planned) != len(expected) {
|
|
t.Fatalf("expected plan length %d, got %d", len(expected), len(planned))
|
|
}
|
|
|
|
for _, plan := range planned {
|
|
base := filepath.Base(plan.SourceRelative)
|
|
target, ok := expected[base]
|
|
if !ok {
|
|
t.Fatalf("unexpected plan entry: %s", base)
|
|
}
|
|
if plan.TargetRelative != filepath.Join(filepath.Dir(plan.SourceRelative), target) {
|
|
t.Fatalf("expected planned target %s, got %s", target, plan.TargetRelative)
|
|
}
|
|
if len(plan.MatchGroups) != 2 {
|
|
t.Fatalf("expected 2 match groups in plan, got %d", len(plan.MatchGroups))
|
|
}
|
|
}
|
|
|
|
output := buf.String()
|
|
for _, target := range expected {
|
|
if !bytes.Contains([]byte(output), []byte(target)) {
|
|
t.Fatalf("expected preview output to contain %s, got %s", target, output)
|
|
}
|
|
}
|
|
}
|
|
|
|
func copyRegexFixture(t *testing.T, name, dest string) {
|
|
t.Helper()
|
|
src := filepath.Join("..", "fixtures", "regex", name)
|
|
if err := filepath.WalkDir(src, func(path string, d fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if d.IsDir() {
|
|
return nil
|
|
}
|
|
|
|
rel, err := filepath.Rel(src, path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
targetPath := filepath.Join(dest, rel)
|
|
if err := os.MkdirAll(filepath.Dir(targetPath), 0o755); err != nil {
|
|
return err
|
|
}
|
|
|
|
content, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := os.WriteFile(targetPath, content, 0o644); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
t.Fatalf("copy fixture: %v", err)
|
|
}
|
|
}
|