create-platformatic 1.49.1 → 1.51.8

package/test/cli/composer.test.mjs

@@ -0,0 +1,80 @@
+import { test } from 'node:test'
+import { equal } from 'node:assert'
+import { timeout } from './timeout.mjs'
+import { isFileAccessible } from '../../src/utils.mjs'
+import { join } from 'node:path'
+import { tmpdir } from 'os'
+import { mkdtemp, rm } from 'fs/promises'
+import {
+  executeCreatePlatformatic,
+  startMarketplace,
+  keys,
+  walk,
+  getServices
+} from './helper.mjs'
+
+let tmpDir
+test.beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
+})
+
+test.afterEach(async () => {
+  try {
+    await rm(tmpDir, { recursive: true, force: true })
+  } catch (e) {
+    // on purpose, in win the resource might be still "busy"
+  }
+})
+
+test('Creates a Platformatic Composer', { timeout }, async (t) => {
+  const marketplaceHost = await startMarketplace(t)
+  // The actions must match IN ORDER
+  const actions = [{
+    match: 'What kind of project do you want to create?',
+    do: [keys.ENTER] // Application
+  }, {
+    match: 'Where would you like to create your project?',
+    do: [keys.ENTER],
+    waitAfter: 8000
+  }, {
+    match: 'Which kind of project do you want to create?',
+    do: [keys.UP, keys.UP, keys.ENTER] // Composer
+  }, {
+    match: 'What is the name of the service?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to create another service?',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
+    match: 'Do you want to use TypeScript',
+    do: [keys.ENTER], // no
+    waitAfter: 8000
+  }, {
+    match: 'What port do you want to use?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to init the git repository',
+    do: [keys.DOWN, keys.ENTER] // yes
+  }]
+  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
+
+  const baseProjectDir = join(tmpDir, 'platformatic')
+  const files = await walk(baseProjectDir)
+  console.log('==> created files', files)
+  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
+
+  // Here check the generated service
+  const services = await getServices(join(baseProjectDir, 'services'))
+  equal(services.length, 1)
+  const baseServiceDir = join(baseProjectDir, 'services', services[0])
+  console.log(baseServiceDir)
+  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.js')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.js')), true)
+})

package/test/cli/db.test.mjs

@@ -0,0 +1,86 @@
+import { test } from 'node:test'
+import { equal } from 'node:assert'
+import { timeout } from './timeout.mjs'
+import { isFileAccessible } from '../../src/utils.mjs'
+import { join } from 'node:path'
+import { tmpdir } from 'os'
+import { mkdtemp, rm } from 'fs/promises'
+import {
+  executeCreatePlatformatic,
+  startMarketplace,
+  keys,
+  walk,
+  getServices
+} from './helper.mjs'
+
+let tmpDir
+test.beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
+})
+
+test.afterEach(async () => {
+  try {
+    await rm(tmpDir, { recursive: true, force: true })
+  } catch (e) {
+    // on purpose, in win the resource might be still "busy"
+  }
+})
+
+test('Creates a Platformatic DB service with no migrations', { timeout }, async (t) => {
+  const marketplaceHost = await startMarketplace(t)
+  // The actions must match IN ORDER
+  const actions = [{
+    match: 'What kind of project do you want to create?',
+    do: [keys.ENTER] // Application
+  }, {
+    match: 'Where would you like to create your project?',
+    do: [keys.ENTER],
+    waitAfter: 8000
+  }, {
+    match: 'Which kind of project do you want to create?',
+    do: [keys.UP, keys.ENTER] // DB
+  }, {
+    match: 'What is the name of the service?',
+    do: [keys.ENTER]
+  }, {
+    match: 'What is the connection string?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to create default migrations',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    match: 'Do you want to create another service?',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
+    match: 'Do you want to use TypeScript',
+    do: [keys.ENTER] // no
+  }, {
+    match: 'What port do you want to use?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to init the git repository',
+    do: [keys.DOWN, keys.ENTER] // yes
+  }]
+  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
+
+  const baseProjectDir = join(tmpDir, 'platformatic')
+  const files = await walk(baseProjectDir)
+  console.log('==> created files', files)
+  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
+
+  // Here check the generated service
+  const services = await getServices(join(baseProjectDir, 'services'))
+  equal(services.length, 1)
+  const baseServiceDir = join(baseProjectDir, 'services', services[0])
+  console.log(baseServiceDir)
+  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'migrations')), false)
+  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.js')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.js')), true)
+})

package/test/cli/helper.mjs

@@ -0,0 +1,159 @@
+import os from 'node:os'
+import { execa } from 'execa'
+import { join } from 'desm'
+import stripAnsi from 'strip-ansi'
+import { promisify } from 'node:util'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import fastify from 'fastify'
+
+const sleep = promisify(setTimeout)
+
+export const keys = {
+  DOWN: '\x1B\x5B\x42',
+  UP: '\x1B\x5B\x41',
+  ENTER: '\x0D',
+  SPACE: '\x20'
+}
+
+export const createPath = join(import.meta.url, '..', '..', 'create-platformatic.mjs')
+
+const match = (str, match) => {
+  if (Array.isArray(match)) {
+    return match.some((m) => str.includes(m))
+  }
+  return str.includes(match)
+}
+
+export const walk = async (dir) => {
+  let files = await fs.readdir(dir)
+  files = await Promise.all(files.map(async file => {
+    const filePath = path.join(dir, file)
+    const stats = await fs.stat(filePath)
+    if (stats.isDirectory()) return walk(filePath)
+    else if (stats.isFile()) return filePath
+  }))
+  return files.reduce((all, folderContents) => all.concat(folderContents), [])
+}
+
+export const getServices = async (dir) => {
+  const files = await fs.readdir(dir)
+  const services = []
+  for (const file of files) {
+    services.push(file)
+  }
+  return services
+}
+
+// Actions are in the form:
+// {
+//    match: 'Server listening at',
+//    do: [keys.DOWN, keys.ENTER]
+// }
+export async function executeCreatePlatformatic (dir, actions = [], options = {}) {
+  const done = options.done || 'You are all set!'
+  const pkgMgrInstall = options.pkgMgrInstall || false
+  const pkgManager = options.pkgManager || 'npm'
+  const marketplaceHost = options.marketplaceHost
+
+  const runCreatePlatformatic = async () => {
+    const questions = [...actions]
+    try {
+      const execaOptions = {
+        cwd: dir
+      }
+
+      if (pkgManager === 'pnpm') {
+        execaOptions.env = {
+          npm_config_user_agent: 'pnpm/6.14.1 npm/? node/v16.4.2 darwin x64'
+        }
+      }
+
+      const child = execa('node', [
+        createPath,
+        `--install=${pkgMgrInstall.toString()}`,
+        `--marketplace-host=${marketplaceHost}`
+      ], execaOptions)
+
+      // We just need the "lastPrompt" printed before the process stopped to wait for an answer
+      // If we don't have any outptu from process for more than 500ms, we assume it's waiting for an answer
+      let lastPrompt = ''
+
+      child.stdout.on('data', (chunk) => {
+        const str = stripAnsi(chunk.toString()).trim()
+        if (str) {
+          lastPrompt = str
+        }
+      })
+
+      let expectedQuestion = questions.shift()
+
+      // We need this because the prompt prints an introduction before asking anything.
+      // If we don't like this, we could use a flag to recognize when the introduction is done
+      await sleep(5000)
+
+      while (true) {
+        if (!expectedQuestion) {
+          await sleep(500)
+          // We processed all expected questions, so now we wait for the process to be done.
+          // If the "done" string is not printed, the test will timeout
+          if (lastPrompt && lastPrompt.includes(done)) {
+            safeKill(child)
+            return
+          }
+        } else if (match(lastPrompt, expectedQuestion.match)) {
+          console.log('==> MATCH', expectedQuestion.match)
+          lastPrompt = ''
+
+          for (const key of expectedQuestion.do) {
+            child.stdin?.write(key)
+            const waitAfter = expectedQuestion.waitAfter || 500
+            await sleep(waitAfter)
+          }
+          expectedQuestion = questions.shift()
+        } else {
+          throw new Error(`Expected ${expectedQuestion.match}, got ${lastPrompt}`)
+        }
+      }
+    } catch (err) {
+      console.error(err)
+      throw err
+    }
+  }
+  await runCreatePlatformatic()
+}
+
+export async function safeKill (child) {
+  child.kill('SIGINT')
+  if (os.platform() === 'win32') {
+    try {
+      await execa('taskkill', ['/pid', child.pid, '/f', '/t'])
+    } catch (err) {
+      if (err.stderr.indexOf('not found') === 0) {
+        console.error(`Failed to kill process ${child.pid}`)
+        console.error(err)
+      }
+    }
+  }
+}
+
+export async function startMarketplace (t, opts = {}) {
+  const marketplace = fastify()
+
+  marketplace.get('/templates', async (request, reply) => {
+    if (opts.templatesCallback) {
+      return opts.templatesCallback(request, reply)
+    }
+    return [
+      { name: '@platformatic/composer' },
+      { name: '@platformatic/db' },
+      { name: '@platformatic/service' }
+    ]
+  })
+
+  await marketplace.listen({ port: 0 })
+  t.after(() => marketplace.close())
+
+  const address = marketplace.server.address()
+  return `http://127.0.0.1:${address.port}`
+}

package/test/cli/runtime.test.mjs

@@ -0,0 +1,104 @@
+import { test } from 'node:test'
+import { equal } from 'node:assert'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { timeout } from './timeout.mjs'
+import { isFileAccessible } from '../../src/utils.mjs'
+import {
+  executeCreatePlatformatic,
+  startMarketplace,
+  keys,
+  walk,
+  getServices
+} from './helper.mjs'
+
+let tmpDir
+test.beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
+})
+
+test.afterEach(async () => {
+  try {
+    await rm(tmpDir, { recursive: true, force: true })
+  } catch (e) {
+    // on purpose, in win the resource might be still "busy"
+  }
+})
+
+test('Creates a Platformatic Runtime with two Services', { timeout }, async (t) => {
+  const marketplaceHost = await startMarketplace(t)
+  // The actions must match IN ORDER
+  const actions = [{
+    match: 'What kind of project do you want to create?',
+    do: [keys.ENTER] // Application
+  }, {
+    match: 'Where would you like to create your project?',
+    do: [keys.ENTER],
+    waitAfter: 8000
+  }, {
+    match: 'Which kind of project do you want to create?',
+    do: [keys.ENTER] // Service
+  }, {
+    match: 'What is the name of the service?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to create another service?',
+    do: [keys.ENTER] // yes
+  }, {
+    match: 'Which kind of project do you want to create?',
+    do: [keys.ENTER] // Service
+  }, {
+    match: 'What is the name of the service?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to create another service?',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    match: 'Which service should be exposed?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to use TypeScript',
+    do: [keys.DOWN, keys.ENTER] // yes
+  }, {
+    match: 'What port do you want to use?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to init the git repository',
+    do: [keys.DOWN, keys.ENTER] // yes
+  }]
+  await executeCreatePlatformatic(tmpDir, actions, {
+    marketplaceHost,
+    pkgManager: 'pnpm'
+  })
+
+  const baseProjectDir = join(tmpDir, 'platformatic')
+  const files = await walk(baseProjectDir)
+  console.log('==> created files', files)
+  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.git', 'config')), true)
+
+  // using pnpm will create workspace file
+  equal(await isFileAccessible(join(baseProjectDir, 'pnpm-workspace.yaml')), true)
+
+  // Here check the generated services
+  const services = await getServices(join(baseProjectDir, 'services'))
+  equal(services.length, 2)
+  const baseService0Dir = join(baseProjectDir, 'services', services[0])
+  equal(await isFileAccessible(join(baseService0Dir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseService0Dir, 'README.md')), true)
+  equal(await isFileAccessible(join(baseService0Dir, 'routes', 'root.ts')), true)
+  equal(await isFileAccessible(join(baseService0Dir, 'plugins', 'example.ts')), true)
+  equal(await isFileAccessible(join(baseService0Dir, 'global.d.ts')), true)
+
+  const baseService1Dir = join(baseProjectDir, 'services', services[1])
+  equal(await isFileAccessible(join(baseService1Dir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseService1Dir, 'README.md')), true)
+  equal(await isFileAccessible(join(baseService1Dir, 'routes', 'root.ts')), true)
+  equal(await isFileAccessible(join(baseService1Dir, 'plugins', 'example.ts')), true)
+  equal(await isFileAccessible(join(baseService1Dir, 'global.d.ts')), true)
+})

package/test/cli/service.test.mjs

@@ -0,0 +1,200 @@
+import { test } from 'node:test'
+import { equal, notEqual } from 'node:assert'
+import { timeout } from './timeout.mjs'
+import { isFileAccessible, safeMkdir } from '../../src/utils.mjs'
+import { join } from 'node:path'
+import { tmpdir } from 'os'
+import { readFile, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import {
+  executeCreatePlatformatic,
+  startMarketplace,
+  keys,
+  walk,
+  getServices
+} from './helper.mjs'
+
+let tmpDir
+test.beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
+})
+
+test.afterEach(async () => {
+  try {
+    await rm(tmpDir, { recursive: true, force: true })
+  } catch (e) {
+    // on purpose, in win the resource might be still "busy"
+  }
+})
+
+test('Creates a Platformatic Service with no typescript', { timeout }, async (t) => {
+  const marketplaceHost = await startMarketplace(t)
+  // The actions must match IN ORDER
+  const actions = [{
+    match: 'What kind of project do you want to create?',
+    do: [keys.ENTER] // Application
+  }, {
+    match: 'Where would you like to create your project?',
+    do: [keys.ENTER],
+    waitAfter: 8000
+  }, {
+    match: 'Which kind of project do you want to create?',
+    do: [keys.ENTER] // Service
+  }, {
+    match: 'What is the name of the service?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to create another service?',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
+    match: 'Do you want to use TypeScript',
+    do: [keys.ENTER] // no
+  }, {
+    match: 'What port do you want to use?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to init the git repository',
+    do: [keys.DOWN, keys.ENTER] // yes
+  }]
+  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
+
+  const baseProjectDir = join(tmpDir, 'platformatic')
+  const files = await walk(baseProjectDir)
+  console.log('==> created files', files)
+  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
+
+  // Here check the generated service
+  const services = await getServices(join(baseProjectDir, 'services'))
+  equal(services.length, 1)
+  const baseServiceDir = join(baseProjectDir, 'services', services[0])
+  console.log(baseServiceDir)
+  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.js')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.js')), true)
+})
+
+test('Creates a Platformatic Service with typescript', { timeout }, async (t) => {
+  const marketplaceHost = await startMarketplace(t)
+  // The actions must match IN ORDER
+  const actions = [{
+    match: 'What kind of project do you want to create?',
+    do: [keys.ENTER] // Application
+  }, {
+    match: 'Where would you like to create your project?',
+    do: [keys.ENTER],
+    waitAfter: 8000
+  }, {
+    match: 'Which kind of project do you want to create?',
+    do: [keys.ENTER] // Service
+  }, {
+    match: 'What is the name of the service?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to create another service?',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
+    match: 'Do you want to use TypeScript',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    match: 'What port do you want to use?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to init the git repository',
+    do: [keys.DOWN, keys.ENTER] // yes
+  }]
+  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
+
+  const baseProjectDir = join(tmpDir, 'platformatic')
+  const files = await walk(baseProjectDir)
+  console.log('==> created files', files)
+  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
+  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
+
+  // Here check the generated service
+  const services = await getServices(join(baseProjectDir, 'services'))
+  equal(services.length, 1)
+  const baseServiceDir = join(baseProjectDir, 'services', services[0])
+  console.log(baseServiceDir)
+  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.ts')), true)
+  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.ts')), true)
+})
+
+test('Creates a Platformatic Service in a non empty directory', { timeout, skip: true }, async (t) => {
+  const marketplaceHost = await startMarketplace(t)
+  const targetDirectory = join(tmpdir(), 'platformatic-service-test')
+  // const targetDirectory = '/tmp/tst'
+  async function generateServiceFileStructure (dir) {
+    const servicesDir = join(dir, 'services')
+    await safeMkdir(servicesDir)
+
+    const serviceDir = join(servicesDir, 'foo')
+    await safeMkdir(join(serviceDir, 'plugins'))
+    await safeMkdir(join(serviceDir, 'routes'))
+
+    await writeFile(join(dir, '.env'), 'SAMPLE_ENV=foobar\n')
+
+    // creates 2 files. root.js will be overwritten
+    await writeFile(join(serviceDir, 'routes', 'root.js'), 'console.log(\'hello world\')')
+    await writeFile(join(serviceDir, 'routes', 'sample.js'), 'console.log(\'hello world\')')
+  }
+  // generate a sample file structure
+  await generateServiceFileStructure(targetDirectory)
+
+  test.after(async () => {
+    await rm(targetDirectory, { recursive: true })
+  })
+  // The actions must match IN ORDER
+  const actions = [{
+    match: 'What kind of project do you want to create?',
+    do: [keys.ENTER] // Application
+  }, {
+    match: 'Where would you like to create your project?',
+    do: [targetDirectory, keys.ENTER],
+    waitAfter: 8000
+  }, {
+    match: 'Confirm you want to use',
+    do: [keys.ENTER] // confirm use existing directory
+  }, {
+    // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
+    match: 'Do you want to use TypeScript',
+    do: [keys.DOWN, keys.ENTER] // no
+  }, {
+    match: 'What port do you want to use?',
+    do: [keys.ENTER]
+  }, {
+    match: 'Do you want to create the github action to deploy',
+    do: [keys.DOWN, keys.ENTER]
+  }, {
+    match: 'Do you want to enable PR Previews in your application',
+    do: [keys.DOWN, keys.ENTER]
+  }, {
+    match: 'Do you want to init the git repository',
+    do: [keys.DOWN, keys.ENTER] // yes
+  }]
+  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
+
+  equal(await isFileAccessible(join(targetDirectory, '.gitignore')), true)
+  equal(await isFileAccessible(join(targetDirectory, '.env')), true)
+  equal(await isFileAccessible(join(targetDirectory, '.env.sample')), true)
+  equal(await isFileAccessible(join(targetDirectory, 'platformatic.service.json')), true)
+  equal(await isFileAccessible(join(targetDirectory, 'README.md')), true)
+  equal(await isFileAccessible(join(targetDirectory, 'routes', 'root.js')), true)
+  equal(await isFileAccessible(join(targetDirectory, 'routes', 'sample.js')), true)
+  equal(await isFileAccessible(join(targetDirectory, 'plugins', 'example.js')), true)
+  equal(await isFileAccessible(join(targetDirectory, '.git', 'config')), true)
+
+  // check file contents
+  notEqual(await readFile(join(targetDirectory, 'routes', 'root.js'), 'utf8'), 'console.log(\'hello world\')')
+  equal(await readFile(join(targetDirectory, 'routes', 'sample.js'), 'utf8'), 'console.log(\'hello world\')')
+})