Extract benchmark repo fixtures · Entire

Extract benchmark repo fixtures

9e0a8b5→main·

Soph·3mo ago·2 files·+94 added/-55 removed

Sessions

87c9e7e44eb9View transcript

Changes

2

1 unmodified line

2
3
4
5
6
7
8
9
10
11
5
6
7
8
9
10
11
12
13
14
15
16
21
22
17
18
19
20
21
27 unmodified lines

49
50
51
56
57
52
53
54
55
56
3 unmodified lines

60
61
62
67
63
64
65
66
20 unmodified lines

87
88
89
94
95
90
91
92
93
94
30 unmodified lines

125
126
127
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
128
129
130

1 unmodified line

import (
    "context"
    "fmt"
    "io"
    "testing"
    "time"

"github.com/go-git/go-billy/v6"
    "github.com/go-git/go-billy/v6/memfs"
    "github.com/go-git/go-git/v6"
    "github.com/go-git/go-git/v6/plumbing"
    "github.com/go-git/go-git/v6/plumbing/storer"
    "github.com/go-git/go-git/v6/storage/memory"
    "github.com/soph/git-sync/internal/syncertest"
)

func BenchmarkRunBootstrapEmptyTarget(b *testing.B) {
    b.ReportAllocs()

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

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

targetRepo, err := git.Init(memory.NewStorage())
        if err != nil {
            b.Fatalf("copy target baseline: %v", err)
        }

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

sourceServer := newSmartHTTPRepoServerV2(b, sourceRepo)
        targetServer := newSmartHTTPRepoServer(b, targetRepo)
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
            b.StopTimer()
            sourceRepo, sourceFS := newBenchRepo(b)
            makeBenchCommits(b, sourceRepo, sourceFS, 3)
            sourceRepo, sourceFS := syncertest.NewMemoryRepo(b)
            syncertest.MakeCommits(b, sourceRepo, sourceFS, 3)

targetRepo, err := git.Init(memory.NewStorage())
            if err != nil {
                b.Fatalf("copy target baseline: %v", err)
            }
        }
    }
}

func newBenchRepo(b *testing.B) (*git.Repository, billy.Filesystem) {
    b.Helper()
    fs := memfs.New()
    repo, err := git.Init(memory.NewStorage(), git.WithWorkTree(fs))
    if err != nil {
        b.Fatalf("init repo: %v", err)
    }
    return repo, fs
}

func makeBenchCommits(b *testing.B, repo *git.Repository, fs billy.Filesystem, count int) {
    b.Helper()
    wt, err := repo.Worktree()
    if err != nil {
        b.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 {
            b.Fatalf("create file: %v", err)
        }
        if _, err := io.WriteString(file, content); err != nil {
            b.Fatalf("write file: %v", err)
        }
        if err := file.Close(); err != nil {
            b.Fatalf("close file: %v", err)
        }
        if _, err := wt.Add("tracked.txt"); err != nil {
            b.Fatalf("add file: %v", err)
        }
        if _, err := wt.Commit(fmt.Sprintf("bench commit %d", i), &git.CommitOptions{
            Author:    &objectSignature,
            Committer: &objectSignature,
        }); err != nil {
            b.Fatalf("commit: %v", err)
        }
    }
}

func copyRefsAndObjects(src, dst storer.Storer, refs []plumbing.ReferenceName) error {
    iter, err := src.IterEncodedObjects(plumbing.AnyObject)
    if err != nil {
        return err
    }
}

package syncertest

import (
    "fmt"
    "io"
    "strings"
    "testing"
    "time"

"github.com/go-git/go-billy/v6"
    "github.com/go-git/go-billy/v6/memfs"
    "github.com/go-git/go-git/v6"
    "github.com/go-git/go-git/v6/plumbing"
    "github.com/go-git/go-git/v6/plumbing/object"
    "github.com/go-git/go-git/v6/storage/memory"
)

// NewMemoryRepo creates an in-memory repository with a memfs-backed worktree.
func NewMemoryRepo(tb testing.TB) (*git.Repository, billy.Filesystem) {
    tb.Helper()

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

// MakeCommits writes and commits tracked.txt repeatedly on the current branch.
func MakeCommits(tb testing.TB, repo *git.Repository, fs billy.Filesystem, count int) {
    b.Helper()

wt, err := repo.Worktree()
    if err != nil {
        tb.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 {
            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("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) {
    b.Helper()

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

var defaultSignature = object.Signature{
    Name:  "test",
    Email: "test@example.com",
    When:  time.Unix(1, 0).UTC(),
}