test: split Template suites into mocked unit and e2e tiers (4/4)

packages/js-sdk/tests/template/backgroundBuild.test.ts

@@ -1,25 +1,30 @@
 import { randomUUID } from 'node:crypto'
-import { expect, test } from 'vitest'
+import { expect } from 'vitest'
 import { Template, waitForTimeout } from '../../src'
+import { e2eTest } from '../setup'
 
-test('build template in background', async () => {
-  const template = Template()
-    .fromImage('ubuntu:22.04')
-    .skipCache()
-    .runCmd('sleep 5') // Add a delay to ensure build takes time
-    .setStartCmd('echo "Hello"', waitForTimeout(10_000))
+e2eTest(
+  'build template in background',
+  async () => {
+    const template = Template()
+      .fromImage('ubuntu:22.04')
+      .skipCache()
+      .runCmd('sleep 5') // Add a delay to ensure build takes time
+      .setStartCmd('echo "Hello"', waitForTimeout(10_000))
 
-  const name = `e2b-test:v1-${randomUUID()}`
+    const name = `e2b-test:v1-${randomUUID()}`
 
-  const buildInfo = await Template.buildInBackground(template, name, {
-    cpuCount: 1,
-    memoryMB: 1024,
-  })
+    const buildInfo = await Template.buildInBackground(template, name, {
+      cpuCount: 1,
+      memoryMB: 1024,
+    })
 
-  // Should return quickly (within a few seconds), not wait for the full build
-  expect(buildInfo).toBeDefined()
+    // Should return quickly (within a few seconds), not wait for the full build
+    expect(buildInfo).toBeDefined()
 
-  // Verify the build is actually running
-  const status = await Template.getBuildStatus(buildInfo)
-  expect(status.status).toEqual('building')
-}, 10_000)
+    // Verify the build is actually running
+    const status = await Template.getBuildStatus(buildInfo)
+    expect(status.status).toEqual('building')
+  },
+  10_000
+)

packages/js-sdk/tests/template/build.test.ts

@@ -3,7 +3,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { afterAll, beforeAll } from 'vitest'
 import { defaultBuildLogger, Template, waitForTimeout } from '../../src'
-import { buildTemplateTest } from '../setup'
+import { e2eBuildTemplateTest } from '../setup'
 
 // The file context lives in a temp directory so a test run never writes into
 // the repository tree. It is created in beforeAll rather than at module load so
@@ -35,7 +35,7 @@ afterAll(() => {
   }
 })
 
-buildTemplateTest('build template', async ({ buildTemplate }) => {
+e2eBuildTemplateTest('build template', async ({ buildTemplate }) => {
   const template = Template({ fileContextPath: contextPath })
     // using base image to avoid re-building ubuntu:22.04 image
     .fromBaseImage()
@@ -47,25 +47,28 @@ buildTemplateTest('build template', async ({ buildTemplate }) => {
   await buildTemplate(template, { skipCache: true }, defaultBuildLogger())
 })
 
-buildTemplateTest(
+e2eBuildTemplateTest(
   'build template from base template',
   async ({ buildTemplate }) => {
     const template = Template().fromTemplate('base')
     await buildTemplate(template, { skipCache: true })
   }
 )
 
-buildTemplateTest('build template with symlinks', async ({ buildTemplate }) => {
-  const template = Template({ fileContextPath: contextPath })
-    .fromImage('ubuntu:22.04')
-    .skipCache()
-    .copy('folder/*', 'folder', { forceUpload: true })
-    .runCmd('cat folder/symlink.txt')
+e2eBuildTemplateTest(
+  'build template with symlinks',
+  async ({ buildTemplate }) => {
+    const template = Template({ fileContextPath: contextPath })
+      .fromImage('ubuntu:22.04')
+      .skipCache()
+      .copy('folder/*', 'folder', { forceUpload: true })
+      .runCmd('cat folder/symlink.txt')
 
-  await buildTemplate(template)
-})
+    await buildTemplate(template)
+  }
+)
 
-buildTemplateTest(
+e2eBuildTemplateTest(
   'build template with resolveSymlinks',
   async ({ buildTemplate }) => {
     const template = Template({ fileContextPath: contextPath })

packages/js-sdk/tests/template/exists.test.ts

@@ -1,14 +1,15 @@
 import { randomUUID } from 'node:crypto'
-import { expect, test } from 'vitest'
+import { expect } from 'vitest'
 import { Template } from '../../src'
+import { e2eTest } from '../setup'
 
-test('check if base template name exists', async () => {
+e2eTest('check if base template name exists', async () => {
   const exists = await Template.exists('base')
   expect(exists).toBe(true)
 })
 
-test('check non existing name', async () => {
+e2eTest('check non existing name', async () => {
   const nonExistingName = `nonexistent-${randomUUID()}`
   const exists = await Template.exists(nonExistingName)
   expect(exists).toBe(false)
 })

packages/js-sdk/tests/template/methods/makeSymlink.test.ts

@@ -1,7 +1,7 @@
 import { Template } from '../../../src'
-import { buildTemplateTest } from '../../setup'
+import { e2eBuildTemplateTest } from '../../setup'
 
-buildTemplateTest('make symlink', async ({ buildTemplate }) => {
+e2eBuildTemplateTest('make symlink', async ({ buildTemplate }) => {
   const template = Template()
     .fromImage('ubuntu:22.04')
     .skipCache()
@@ -11,7 +11,7 @@ buildTemplateTest('make symlink', async ({ buildTemplate }) => {
   await buildTemplate(template)
 })
 
-buildTemplateTest('make symlink (force)', async ({ buildTemplate }) => {
+e2eBuildTemplateTest('make symlink (force)', async ({ buildTemplate }) => {
   const template = Template()
     .fromImage('ubuntu:22.04')
     .makeSymlink('.bashrc', '.bashrc.local')

packages/js-sdk/tests/template/methods/runCmd.test.ts

@@ -1,8 +1,8 @@
 import { expect } from 'vitest'
 import { Template } from '../../../src'
-import { buildTemplateTest } from '../../setup'
+import { e2eBuildTemplateTest } from '../../setup'
 
-buildTemplateTest('run command', async ({ buildTemplate }) => {
+e2eBuildTemplateTest('run command', async ({ buildTemplate }) => {
   const template = Template()
     .fromImage('ubuntu:22.04')
     .skipCache()
@@ -11,7 +11,7 @@ buildTemplateTest('run command', async ({ buildTemplate }) => {
   await buildTemplate(template)
 })
 
-buildTemplateTest(
+e2eBuildTemplateTest(
   'run command as a different user',
   async ({ buildTemplate }) => {
     const template = Template()
@@ -23,7 +23,7 @@ buildTemplateTest(
   }
 )
 
-buildTemplateTest(
+e2eBuildTemplateTest(
   'run command as user that does not exist',
   async ({ buildTemplate }) => {
     const template = Template()

packages/js-sdk/tests/template/serialization.test.ts

@@ -0,0 +1,112 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, assert, beforeAll, expect, test } from 'vitest'
+
+import { Template } from '../../src'
+import { InstructionType } from '../../src/template/types'
+import { calculateFilesHash } from '../../src/template/utils'
+
+let contextPath: string
+
+beforeAll(async () => {
+  contextPath = await mkdtemp(join(tmpdir(), 'template-serialization-'))
+  await writeFile(join(contextPath, 'app.txt'), 'hello')
+  await writeFile(join(contextPath, 'other.txt'), 'hello')
+})
+
+afterAll(async () => {
+  await rm(contextPath, { recursive: true, force: true })
+})
+
+const filesHash = (src: string, dest: string) =>
+  calculateFilesHash(src, dest, contextPath, [], false, undefined)
+
+test('hash is stable and content-dependent', async () => {
+  const before = await filesHash('app.txt', '/app/')
+  assert.equal(await filesHash('app.txt', '/app/'), before)
+
+  await writeFile(join(contextPath, 'app.txt'), 'hello again')
+  const after = await filesHash('app.txt', '/app/')
+
+  assert.notEqual(after, before)
+  assert.match(after, /^[0-9a-f]{64}$/)
+})
+
+test('hash covers the source and destination paths', async () => {
+  // Identical content, different instruction — the hash seeds on `COPY src dest`.
+  assert.notEqual(
+    await filesHash('app.txt', '/app/'),
+    await filesHash('other.txt', '/app/')
+  )
+  assert.notEqual(
+    await filesHash('app.txt', '/app/'),
+    await filesHash('app.txt', '/srv/')
+  )
+})
+
+test('hashing a source that matches no file fails', async () => {
+  // TODO: should reject with TemplateError once calculateFilesHash stops
+  // throwing a bare Error.
+  await expect(filesHash('nope.txt', '/app/')).rejects.toThrow()
+})
+
+test('serializes a build payload from the builder', async () => {
+  const template = Template({ fileContextPath: contextPath })
+    .fromImage('ubuntu:22.04')
+    .runCmd('echo hello')
+    .setWorkdir('/app')
+    .setStartCmd('python main.py', 'curl -f http://localhost:8000')
+
+  const payload = JSON.parse(await Template.toJSON(template, false))
+
+  assert.equal(payload.fromImage, 'ubuntu:22.04')
+  assert.equal(payload.startCmd, 'python main.py')
+  assert.equal(payload.readyCmd, 'curl -f http://localhost:8000')
+  assert.isUndefined(payload.fromTemplate)
+  assert.deepEqual(
+    payload.steps.map((step: { type: string }) => step.type),
+    [InstructionType.RUN, InstructionType.WORKDIR]
+  )
+})
+
+test('serializes fromTemplate instead of fromImage', async () => {
+  const payload = JSON.parse(
+    await Template.toJSON(Template().fromTemplate('base'))
+  )
+
+  assert.equal(payload.fromTemplate, 'base')
+  assert.isUndefined(payload.fromImage)
+})
+
+test('serializes a registry config next to the image', async () => {
+  const template = Template().fromImage('registry.example.com/app:latest', {
+    username: 'user',
+    password: 'pass',
+  })
+
+  const payload = JSON.parse(await Template.toJSON(template))
+
+  assert.equal(payload.fromImage, 'registry.example.com/app:latest')
+  assert.equal(payload.fromImageRegistry.type, 'registry')
+  assert.equal(payload.fromImageRegistry.username, 'user')
+})
+
+test('computeHashes adds the copy hash to the payload', async () => {
+  const template = Template({ fileContextPath: contextPath })
+    .fromImage('ubuntu:22.04')
+    .copy('app.txt', '/app/')
+
+  const withoutHashes = JSON.parse(await Template.toJSON(template, false))
+  const withHashes = JSON.parse(await Template.toJSON(template, true))
+
+  const copyStep = (payload: {
+    steps: { type: string; filesHash?: string }[]
+  }) => payload.steps.find((step) => step.type === InstructionType.COPY)
+
+  assert.isUndefined(copyStep(withoutHashes)?.filesHash)
+  assert.equal(
+    copyStep(withHashes)?.filesHash,
+    await filesHash('app.txt', '/app/')
+  )
+})

packages/js-sdk/tests/template/tags.test.ts

@@ -1,11 +1,10 @@
-import { randomUUID } from 'node:crypto'
 import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest'
 
 import { http, HttpResponse } from 'msw'
 import { setupServer } from 'msw/node'
 
 import { Template } from '../../src'
-import { apiUrl, buildTemplateTest, isDebug } from '../setup'
+import { apiUrl } from '../setup'
 
 // Mock handlers for tag API endpoints
 const mockHandlers = [
@@ -121,82 +120,3 @@ describe('Template tags unit tests', () => {
     })
   })
 })
-
-// Integration tests
-buildTemplateTest.skipIf(isDebug)(
-  'build template with tags, assign and delete',
-  { timeout: 300_000 },
-  async ({ buildTemplate }) => {
-    const templateName = 'e2b-tags-test'
-    const initialTag = `${templateName}:v1-${randomUUID()}`
-
-    // Build a template with initial tag
-    const template = Template().fromBaseImage()
-    const buildInfo = await buildTemplate(template, { name: initialTag })
-
-    expect(buildInfo.buildId).toBeTruthy()
-    expect(buildInfo.templateId).toBeTruthy()
-
-    // Assign additional tags (just tag names, not full alias:tag format)
-    const tagInfo = await Template.assignTags(initialTag, [
-      'production',
-      'latest',
-    ])
-
-    expect(tagInfo.buildId).toBeTruthy()
-    expect(tagInfo.tags).toContain('production')
-    expect(tagInfo.tags).toContain('latest')
-  }
-)
-
-buildTemplateTest.skipIf(isDebug)(
-  'assign single tag to existing template',
-  { timeout: 300_000 },
-  async ({ buildTemplate }) => {
-    const templateName = 'e2b-tags-test'
-    const initialTag = `${templateName}:v1-${randomUUID()}`
-
-    const template = Template().fromBaseImage()
-    await buildTemplate(template, { name: initialTag })
-
-    // Assign single tag (just tag name, not full alias:tag format)
-    const tagInfo = await Template.assignTags(initialTag, 'stable')
-
-    expect(tagInfo.buildId).toBeTruthy()
-    expect(tagInfo.tags).toContain('stable')
-  }
-)
-
-buildTemplateTest.skipIf(isDebug)(
-  'rejects invalid tag format - missing alias',
-  { timeout: 300_000 },
-  async ({ buildTemplate }) => {
-    const templateName = 'e2b-tags-test'
-    const initialTag = `${templateName}:v1-${randomUUID()}`
-
-    const template = Template().fromBaseImage()
-    await buildTemplate(template, { name: initialTag })
-
-    // Tag without alias (starts with colon) should be rejected
-    await expect(
-      Template.assignTags(initialTag, ':invalid-tag')
-    ).rejects.toThrow()
-  }
-)
-
-buildTemplateTest.skipIf(isDebug)(
-  'rejects invalid tag format - missing tag',
-  { timeout: 300_000 },
-  async ({ buildTemplate }) => {
-    const templateName = 'e2b-tags-test'
-    const initialTag = `${templateName}:v1-${randomUUID()}`
-
-    const template = Template().fromBaseImage()
-    await buildTemplate(template, { name: initialTag })
-
-    // Tag without tag portion (ends with colon) should be rejected
-    await expect(
-      Template.assignTags(initialTag, `${templateName}:`)
-    ).rejects.toThrow()
-  }
-)