Unify repo test fixtures · Entire

Unify repo test fixtures

c567560→main·

Soph·3mo ago·3 files·+85 added/-98 removed

Sessions

c980720ba4e1View transcript

[?
Can you take a look at the go code (wasm) in /Users/soph/Work/entire/devenv/entire-io-worktree1 based a bit on that I wonder if something like this can be build:Codex·GPT-5.4·1 step](/content/gh/entireio/git-sync/session/019d6d29-8cf7-7fe3-adc9-8c3e4d9d5603#timeline-c980720ba4e1/index.html)

Changes

3

14 unmodified lines

15
16
17
18
18
19
20
21
28 unmodified lines

50
51
52
53
53
54
55
56
3 unmodified lines

60
61
62
63
63
64
65
66
21 unmodified lines

88
89
90
91
91
92
93
94

14 unmodified lines

b.ReportAllocs()

sourceRepo, sourceFS := syncertest.NewMemoryRepo(b)
    syncertest.MakeCommits(b, sourceRepo, sourceFS, 8)
    syncertest.MakeBenchmarkCommits(b, sourceRepo, sourceFS, 8)
    sourceServer := newSmartHTTPRepoServerV2(b, sourceRepo)
    defer sourceServer.Close()

28 unmodified lines

for i := 0; i < b.N; i++ {
        b.StopTimer()
        sourceRepo, sourceFS := syncertest.NewMemoryRepo(b)
        syncertest.MakeCommits(b, sourceRepo, sourceFS, 2)
        syncertest.MakeBenchmarkCommits(b, sourceRepo, sourceFS, 2)

targetRepo, err := git.Init(memory.NewStorage())
        if err != nil {
3 unmodified lines

b.Fatalf("copy target baseline: %v", err)
        }

syncertest.MakeCommits(b, sourceRepo, sourceFS, 1)
        syncertest.MakeBenchmarkCommits(b, sourceRepo, sourceFS, 1)

sourceServer := newSmartHTTPRepoServerV2(b, sourceRepo)
        targetServer := newSmartHTTPRepoServer(b, targetRepo)
21 unmodified lines

for i := 0; i < b.N; i++ {
        b.StopTimer()
        sourceRepo, sourceFS := syncertest.NewMemoryRepo(b)
        syncertest.MakeCommits(b, sourceRepo, sourceFS, 3)
        syncertest.MakeBenchmarkCommits(b, sourceRepo, sourceFS, 3)

targetRepo, err := git.Init(memory.NewStorage())
        if err != nil {

Minternal/syncer/benchmark_test.go+4/-4

15 unmodified lines

16
17
18
19
19
20
21
10 unmodified lines

32
33
34
35
36
37
38
1169 unmodified lines

1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1211
1212
1213
1214
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1215
1216
1217
1218
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1219
1220
1221
1222
7 unmodified lines

1230
1231
1232
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1233
1234
1235
1236

15 unmodified lines

"time"

billy "github.com/go-git/go-billy/v6"
    "github.com/go-git/go-billy/v6/memfs"
    git "github.com/go-git/go-git/v6"
    "github.com/go-git/go-git/v6/plumbing"
    "github.com/go-git/go-git/v6/plumbing/format/packfile"
10 unmodified lines

"github.com/soph/git-sync/internal/gitproto"
    "github.com/soph/git-sync/internal/planner"
    bstrap "github.com/soph/git-sync/internal/strategy/bootstrap"
    "github.com/soph/git-sync/internal/syncertest"
)

const testBranch = "master"
1169 unmodified lines

}

func newSourceRepo(t *testing.T) (*git.Repository, billy.Filesystem) {

t.Helper()

fs := memfs.New()
    repo, err := git.Init(memory.NewStorage(), git.WithWorkTree(fs))
    if err != nil {
        t.Fatalf("init source repo: %v", err)
    }

return repo, fs
    return syncertest.NewMemoryRepo(t)
}

func makeCommits(t *testing.T, repo *git.Repository, fs billy.Filesystem, count int) {

t.Helper()

wt, err := repo.Worktree()
    if err != nil {
        t.Fatalf("open worktree: %v", err)
    }

for i := 0; i < count; i++ {
        content := strings.Repeat(fmt.Sprintf("line %d %d\n", i, time.Now().UnixNano()), 24)
        file, err := fs.Create("tracked.txt")
        if err != nil {
        t.Fatalf("create file: %v", err)
        }
        if _, err := io.WriteString(file, content); err != nil {
        t.Fatalf("write file: %v", err)
        }
        if err := file.Close(); err != nil {
        t.Fatalf("close file: %v", err)
        }

if _, err := wt.Add("tracked.txt"); err != nil {
        t.Fatalf("add file: %v", err)
        }

_, err = wt.Commit(fmt.Sprintf("commit %d", i), &git.CommitOptions{
            Author:    &objectSignature,
            Committer: &objectSignature,
        })
        if err != nil {
        t.Fatalf("commit: %v", err)
        }
    }
    syncertest.MakeCommits(t, repo, fs, count)
}

func makeLargeCommits(t *testing.T, repo *git.Repository, fs billy.Filesystem, count int, blobSize int) {

t.Helper()

wt, err := repo.Worktree()
    if err != nil {
        t.Fatalf("open worktree: %v", err)
    }

for i := 0; i < count; i++ {
        name := fmt.Sprintf("blob-%d.bin", i)
        file, err := fs.Create(name)
        if err != nil {
        t.Fatalf("create file: %v", err)
        }
        content := make([]byte, blobSize)
        state := uint32(0x9e3779b9) + uint32(i)*uint32(2654435761)
        for idx := range content {
            state ^= state << 13
            state ^= state >> 17
            state ^= state << 5
            content[idx] = byte(state >> 24)
        }
        if _, err := file.Write(content); err != nil {
        t.Fatalf("write file: %v", err)
        }
        if err := file.Close(); err != nil {
        t.Fatalf("close file: %v", err)
        }
        if _, err := wt.Add(name); err != nil {
        t.Fatalf("add file: %v", err)
        }

_, err = wt.Commit(fmt.Sprintf("large commit %d", i), &git.CommitOptions{
            Author:    &objectSignature,
            Committer: &objectSignature,
        })
        if err != nil {
        t.Fatalf("commit: %v", err)
        }
    }
    syncertest.MakeLargeCommits(t, repo, fs, count, blobSize)
}

var objectSignature = signature()
7 unmodified lines

}

func assertHeadsMatch(t *testing.T, sourceRepo, targetRepo *git.Repository, branch string) {

t.Helper()

sourceRef, err := sourceRepo.Reference(plumbing.NewBranchReferenceName(branch), true)
    if err != nil {
        t.Fatalf("resolve source ref: %v", err)
    }
    targetRef, err := targetRepo.Reference(plumbing.NewBranchReferenceName(branch), true)
    if err != nil {
        t.Fatalf("resolve target ref: %v", err)
    }
    if sourceRef.Hash() != targetRef.Hash() {
        t.Fatalf("branch %s mismatch: source=%s target=%s", branch, sourceRef.Hash(), targetRef.Hash())
    }
    syncertest.AssertBranchHeadsMatch(t, sourceRepo, targetRepo, branch)
}

type metricKind string

Minternal/syncer/integration_test.go+5/-94

59 unmodified lines

60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

59 unmodified lines

}
}

// MakeBenchmarkCommits preserves the smaller benchmark-specific commit shape so
// benchmark series remain comparable across refactors.
func MakeBenchmarkCommits(tb testing.TB, repo *git.Repository, fs billy.Filesystem, count int) {

tb.Helper()

wt, err := repo.Worktree()
    if err != nil {
        tb.Fatalf("open worktree: %v", err)
    }

for i := 0; i < count; i++ {
        content := fmt.Sprintf("bench line %d %d\n", i, time.Now().UnixNano())
        file, err := fs.Create("tracked.txt")
        if err != nil {
        tb.Fatalf("create file: %v", err)
        }
        if _, err := io.WriteString(file, content); err != nil {
        tb.Fatalf("write file: %v", err)
        }
        if err := file.Close(); err != nil {
        tb.Fatalf("close file: %v", err)
        }
        if _, err := wt.Add("tracked.txt"); err != nil {
        tb.Fatalf("add file: %v", err)
        }
        if _, err := wt.Commit(fmt.Sprintf("bench commit %d", i), &git.CommitOptions{
            Author:    &defaultSignature,
            Committer: &defaultSignature,
        }); err != nil {
        tb.Fatalf("commit: %v", err)
        }
    }
}

// MakeLargeCommits creates large pseudo-random blob commits to exercise pack
// sizing and batching paths.
func MakeLargeCommits(tb testing.TB, repo *git.Repository, fs billy.Filesystem, count int, blobSize int) {

tb.Helper()

wt, err := repo.Worktree()
    if err != nil {
        tb.Fatalf("open worktree: %v", err)
    }

for i := 0; i < count; i++ {
        name := fmt.Sprintf("blob-%d.bin", i)
        file, err := fs.Create(name)
        if err != nil {
        tb.Fatalf("create file: %v", err)
        }
        content := make([]byte, blobSize)
        state := uint32(0x9e3779b9) + uint32(i)*uint32(2654435761)
        for idx := range content {
            state ^= state << 13
            state ^= state >> 17
            state ^= state << 5
            content[idx] = byte(state >> 24)
        }
        if _, err := file.Write(content); err != nil {
        tb.Fatalf("write file: %v", err)
        }
        if err := file.Close(); err != nil {
        tb.Fatalf("close file: %v", err)
        }
        if _, err := wt.Add(name); err != nil {
        tb.Fatalf("add file: %v", err)
        }
        if _, err := wt.Commit(fmt.Sprintf("large commit %d", i), &git.CommitOptions{
            Author:    &defaultSignature,
            Committer: &defaultSignature,
        }); err != nil {
        tb.Fatalf("commit: %v", err)
        }
    }
}

// AssertBranchHeadsMatch verifies that two repos agree on the named branch tip.
func AssertBranchHeadsMatch(tb testing.TB, sourceRepo, targetRepo *git.Repository, branch string) {

tb.Helper()