Merge branch 'more-refactor'

Author: philnash

packages/create-twilio-function/package.json

@@ -24,7 +24,7 @@
   "license": "MIT",
   "devDependencies": {
     "jest": "^24.5.0",
-    "nock": "^10.0.6"
+    "nock": "^11.3.4"
   },
   "dependencies": {
     "boxen": "^3.0.0",

packages/create-twilio-function/src/create-twilio-function.js

@@ -48,16 +48,12 @@ async function createTwilioFunction(config) {
     switch (e.code) {
       case 'EEXIST':
         spinner.fail(
-          `A directory called '${
-            config.name
-          }' already exists. Please create your function in a new directory.`
+          `A directory called '${config.name}' already exists. Please create your function in a new directory.`
         );
         break;
       case 'EACCES':
         spinner.fail(
-          `You do not have permission to create files or directories in the path '${
-            config.path
-          }'.`
+          `You do not have permission to create files or directories in the path '${config.path}'.`
         );
         break;
       default:
@@ -122,9 +118,7 @@ async function createTwilioFunction(config) {
   } catch (err) {
     spinner.fail();
     console.log(
-      `There was an error installing the dependencies, but your project is otherwise complete in ./${
-        config.name
-      }`
+      `There was an error installing the dependencies, but your project is otherwise complete in ./${config.name}`
     );
   }
 

packages/create-twilio-function/tests/create-files.test.js

@@ -13,31 +13,34 @@ const mkdir = promisify(fs.mkdir);
 const readFile = promisify(fs.readFile);
 const stat = promisify(fs.stat);
 const readdir = promisify(fs.readdir);
+const path = require('path');
+
+const scratchDir = path.join(process.cwd(), 'scratch');
 
 beforeAll(async () => {
-  await rimraf('./scratch');
+  await rimraf(scratchDir);
 });
 
 beforeEach(async () => {
-  await mkdir('./scratch');
+  await mkdir(scratchDir);
 });
 
 afterEach(async () => {
-  await rimraf('./scratch');
+  await rimraf(scratchDir);
 });
 
 describe('createDirectory', () => {
   test('it creates a new directory with the project name', async () => {
-    await createDirectory('./scratch', 'test-project');
-    const dir = await stat('./scratch/test-project');
+    await createDirectory(scratchDir, 'test-project');
+    const dir = await stat(path.join(scratchDir, 'test-project'));
     expect(dir.isDirectory());
   });
 
   test('it throws an error if the directory exists', async () => {
-    await mkdir('./scratch/test-project');
+    await mkdir(path.join(scratchDir, 'test-project'));
     expect.assertions(1);
     try {
-      await createDirectory('./scratch', 'test-project');
+      await createDirectory(scratchDir, 'test-project');
     } catch (e) {
       expect(e.toString()).toMatch('EEXIST');
     }
@@ -46,10 +49,12 @@ describe('createDirectory', () => {
 
 describe('createPackageJSON', () => {
   test('it creates a new package.json file with the name of the project', async () => {
-    await createPackageJSON('./scratch', 'project-name');
-    const file = await stat('./scratch/package.json');
+    await createPackageJSON(scratchDir, 'project-name');
+    const file = await stat(path.join(scratchDir, 'package.json'));
     expect(file.isFile());
-    const packageJSON = JSON.parse(await readFile('./scratch/package.json'));
+    const packageJSON = JSON.parse(
+      await readFile(path.join(scratchDir, 'package.json'))
+    );
     expect(packageJSON.name).toEqual('project-name');
     expect(packageJSON.engines.node).toEqual(versions.node);
     expect(packageJSON.devDependencies['twilio-run']).toEqual(
@@ -58,38 +63,41 @@ describe('createPackageJSON', () => {
   });
 
   test('it rejects if there is already a package.json', async () => {
-    fs.closeSync(fs.openSync('./scratch/package.json', 'w'));
+    fs.closeSync(fs.openSync(path.join(scratchDir, 'package.json'), 'w'));
     expect.assertions(1);
     try {
-      await createPackageJSON('./scratch', 'project-name');
+      await createPackageJSON(scratchDir, 'project-name');
     } catch (e) {
       expect(e.toString()).toMatch('file already exists');
     }
   });
 });
 
 describe('createExampleFromTemplates', () => {
+  const templatesDir = path.join(process.cwd(), 'templates');
   test('it creates functions and assets directories', async () => {
-    await createExampleFromTemplates('./scratch');
+    await createExampleFromTemplates(scratchDir);
 
-    const dirs = await readdir('./scratch');
-    const templateDirs = await readdir('./templates');
-    expect(dirs).toEqual(templateDirs);
+    const dirs = await readdir(scratchDir);
+    const templateDirContents = await readdir(templatesDir);
+    expect(dirs).toEqual(templateDirContents);
   });
 
   test('it copies the functions from the templates/functions directory', async () => {
-    await createExampleFromTemplates('./scratch');
+    await createExampleFromTemplates(scratchDir);
 
-    const functions = await readdir('./scratch/functions');
-    const templateFunctions = await readdir('./templates/functions');
+    const functions = await readdir(path.join(scratchDir, 'functions'));
+    const templateFunctions = await readdir(
+      path.join(templatesDir, 'functions')
+    );
     expect(functions).toEqual(templateFunctions);
   });
 
   test('it rejects if there is already a functions directory', async () => {
-    await mkdir('./scratch/functions');
+    await mkdir(path.join(scratchDir, 'functions'));
     expect.assertions(1);
     try {
-      await createExampleFromTemplates('./scratch');
+      await createExampleFromTemplates(scratchDir);
     } catch (e) {
       expect(e.toString()).toMatch('file already exists');
     }
@@ -98,22 +106,24 @@ describe('createExampleFromTemplates', () => {
 
 describe('createEnvFile', () => {
   test('it creates a new .env file', async () => {
-    await createEnvFile('./scratch', {
+    await createEnvFile(scratchDir, {
       accountSid: 'AC123',
       authToken: 'qwerty123456'
     });
-    const file = await stat('./scratch/.env');
+    const file = await stat(path.join(scratchDir, '.env'));
     expect(file.isFile());
-    const contents = await readFile('./scratch/.env', { encoding: 'utf-8' });
+    const contents = await readFile(path.join(scratchDir, '.env'), {
+      encoding: 'utf-8'
+    });
     expect(contents).toMatch('ACCOUNT_SID=AC123');
     expect(contents).toMatch('AUTH_TOKEN=qwerty123456');
   });
 
   test('it rejects if there is already an .env file', async () => {
-    fs.closeSync(fs.openSync('./scratch/.env', 'w'));
+    fs.closeSync(fs.openSync(path.join(scratchDir, '.env'), 'w'));
     expect.assertions(1);
     try {
-      await createEnvFile('./scratch', {
+      await createEnvFile(scratchDir, {
         accountSid: 'AC123',
         authToken: 'qwerty123456'
       });
@@ -125,18 +135,20 @@ describe('createEnvFile', () => {
 
 describe('createNvmrcFile', () => {
   test('it creates a new .nvmrc file', async () => {
-    await createNvmrcFile('./scratch');
-    const file = await stat('./scratch/.nvmrc');
+    await createNvmrcFile(scratchDir);
+    const file = await stat(path.join(scratchDir, '.nvmrc'));
     expect(file.isFile());
-    const contents = await readFile('./scratch/.nvmrc', { encoding: 'utf-8' });
+    const contents = await readFile(path.join(scratchDir, '.nvmrc'), {
+      encoding: 'utf-8'
+    });
     expect(contents).toMatch(versions.node);
   });
 
   test('it rejects if there is already an .nvmrc file', async () => {
-    fs.closeSync(fs.openSync('./scratch/.nvmrc', 'w'));
+    fs.closeSync(fs.openSync(path.join(scratchDir, '.nvmrc'), 'w'));
     expect.assertions(1);
     try {
-      await createNvmrcFile('./scratch');
+      await createNvmrcFile(scratchDir);
     } catch (e) {
       expect(e.toString()).toMatch('file already exists');
     }

packages/create-twilio-function/tests/create-gitignore.test.js

@@ -6,9 +6,12 @@ const fs = require('fs');
 const mkdir = promisify(fs.mkdir);
 const readFile = promisify(fs.readFile);
 const stat = promisify(fs.stat);
+const path = require('path');
+
+const scratchDir = path.join(process.cwd(), 'scratch');
 
 beforeAll(async () => {
-  await rimraf('./scratch');
+  await rimraf(scratchDir);
   nock.disableNetConnect();
 });
 
@@ -17,34 +20,34 @@ afterAll(() => {
 });
 
 beforeEach(async () => {
-  await mkdir('./scratch');
+  await mkdir(scratchDir);
   nock('https://raw.githubusercontent.com')
     .get('/github/gitignore/master/Node.gitignore')
     .reply(200, '*.log\n.env');
 });
 
 afterEach(async () => {
-  await rimraf('./scratch');
+  await rimraf(scratchDir);
   nock.cleanAll();
 });
 
 describe('createGitignore', () => {
   test('it creates a new .gitignore file', async () => {
-    await createGitignore('./scratch');
-    const file = await stat('./scratch/.gitignore');
+    await createGitignore(scratchDir);
+    const file = await stat(path.join(scratchDir, '.gitignore'));
     expect(file.isFile());
-    const contents = await readFile('./scratch/.gitignore', {
+    const contents = await readFile(path.join(scratchDir, '.gitignore'), {
       encoding: 'utf-8'
     });
     expect(contents).toMatch('*.log');
     expect(contents).toMatch('.env');
   });
 
   test('it rejects if there is already a .gitignore file', async () => {
-    fs.closeSync(fs.openSync('./scratch/.gitignore', 'w'));
+    fs.closeSync(fs.openSync(path.join(scratchDir, '.gitignore'), 'w'));
     expect.assertions(1);
     try {
-      await createGitignore('./scratch');
+      await createGitignore(scratchDir);
     } catch (e) {
       expect(e.toString()).toMatch('file already exists');
     }