Additional findings (outside current diff — PR may have been updated during review):

• 🔴 packages/orchestrator/pkg/sandbox/template/peerserver/seekable_test.go:17-23 — TestSeekableSource_Size mocks the wrong method, breaking CI: the test expects diff.FileSize() but seekableSource.Size (seekable.go:22) actually calls f.diff.Size(ctx). go test -run TestSeekableSource_Size ./packages/orchestrator/pkg/sandbox/template/peerserver/ fails with unexpected method call: Size(*context.cancelCtx) and FAIL: 0 out of 1 expectation(s) were met. FileSize(). Fix is one-character: change the mock to diff.EXPECT().Size(mock.Anything).Return(int64(1234), nil) (or change the production call to FileSize(), but Size(ctx) is the SeekableSource interface contract and is what other tests in the file already expect for similar code paths).

  Extended reasoning...

  What's broken

  In packages/orchestrator/pkg/sandbox/template/peerserver/seekable_test.go:20, the test sets up the mock as:

  diff := buildmocks.NewMockDiff(t)
  diff.EXPECT().FileSize().Return(int64(1234), nil)

  But the production code in packages/orchestrator/pkg/sandbox/template/peerserver/seekable.go:21-23 calls Size(ctx), not FileSize():

  func (f *seekableSource) Size(ctx context.Context) (int64, error) {
      return f.diff.Size(ctx)
  }

  build.Diff is an interface that has both methods (Size(ctx) (int64, error) from the embedded storage.SeekableReader, plus a separate FileSize() (int64, error) method). The test mocks the wrong one of the two.

  Step-by-step proof

  Reproduced directly on the PR branch:

  $ go test -run TestSeekableSource_Size ./packages/orchestrator/pkg/sandbox/template/peerserver/
  --- FAIL: TestSeekableSource_Size (0.00s)
      mock.go:361:
          assert: mock: I don't know what to return because the method call was unexpected.
              Either do Mock.On("Size").Return(...) first, or remove the Size() call.
              This method was unexpected:
                  Size(*context.cancelCtx)
              at: [...mockdiff.go:411 ...seekable.go:22 ...seekable_test.go:28]
      mockdiff.go:24: FAIL:	FileSize()
              at: [...mockdiff.go:260 ...seekable_test.go:20]
      mockdiff.go:24: FAIL: 0 out of 1 expectation(s) were met.
              The code you are testing needs to make 1 more call(s).
  FAIL
  FAIL	github.com/e2b-dev/infra/packages/orchestrator/pkg/sandbox/template/peerserver	0.017s
  

  Walking through the call:

  1. src.Size(t.Context()) is called (seekable_test.go:28).
  2. That dispatches to seekableSource.Size, which calls f.diff.Size(ctx) (seekable.go:22).
  3. The mock has no expectation for Size — only for FileSize() — so testify panics: Size(*context.cancelCtx) is unexpected.
  4. After panic recovery, mock cleanup reports the unmet FileSize() expectation as a second failure.

  Why this matters / impact

  CI-breaking. The PR's own diff (visible in this review) replaced the previously-correct Size(mock.Anything) expectation with FileSize(), but the production code at seekable.go:22 was not changed to match. This appears to be an in-flight refactor that was committed half-done.

  Fix

  The simpler/safer fix is to update the test to match the production interface contract. Size(ctx context.Context) (int64, error) is part of the storage.SeekableReader interface that build.Diff embeds and is what the rest of the codebase uses for context-cancellable size lookups. Change line 20 to:

  diff.EXPECT().Size(mock.Anything).Return(int64(1234), nil)

  Alternatively, if the intent is to use the no-context FileSize() here (it returns from the local cache without an RPC), seekable.go:22 needs to be changed to return f.diff.FileSize() and the function signature kept as Size(ctx context.Context) to satisfy the SeekableSource interface (with _ context.Context to silence unused-param). Either way, the test and the production code must agree.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 7e65a1f6d5