chore(): ensured all tests pass with jest and added serve, uglifyjs tests.

Author: jthoms1

package.json

@@ -76,7 +76,6 @@
     "@types/express": "^4.0.33",
     "@types/fs-extra": "^0.0.33",
     "@types/glob": "^5.0.30",
-    "@types/jasmine": "^2.2.33",
     "@types/jest": "^16.0.1",
     "@types/mock-fs": "^3.6.29",
     "@types/node": "^6.0.38",
@@ -89,7 +88,7 @@
     "github": "0.2.4",
     "ionic-cz-conventional-changelog": "1.0.0",
     "jasmine": "2.5.2",
-    "jest": "^17.0.3",
+    "jest": "^18.0.0",
     "mock-fs": "3.11.0",
     "node-sass": "3.10.1",
     "rewire": "^2.5.2",
@@ -122,7 +121,8 @@
   },
   "typings": "dist/index.d.ts",
   "jest": {
-    "moduleFileExtensions": [
+    "testEnvironment": "node",
+        "moduleFileExtensions": [
       "ts",
       "js"
     ],

src/clean.spec.ts

@@ -4,35 +4,28 @@ import * as clean from './clean';
 describe('clean task', () => {
 
   describe('clean', () => {
-    it('should empty the build directory', (done: Function) => {
+    it('should empty the build directory', () => {
       // arrage
       spyOn(fs, fs.emptyDirSync.name).and.returnValue('things');
       const context = { buildDir: 'something' };
 
       // act
-      clean.clean(context).then(() => {
+      return clean.clean(context).then(() => {
         // assert
         expect(fs.emptyDirSync).toHaveBeenCalledWith(context.buildDir);
-        done();
       });
     });
 
-    it('should throw when failing to empty dir', async () => {
+    it('should throw when failing to empty dir', () => {
       // arrage
       spyOn(fs, fs.emptyDirSync.name).and.throwError('Simulating an error');
       const context = { buildDir: 'something' };
 
       // act
-      let error: Error = null;
-      try {
-        await clean.clean(context);
-      } catch (ex) {
-        error = ex;
-      }
-
-      // assert
-      expect(error instanceof Error).toBe(true, 'Error is not an instance of type Error');
-      expect(typeof error.message).toBe('string', 'error.message is not a string');
+      return clean.clean(context).catch((ex) => {
+        expect(ex instanceof Error).toBe(true);
+        expect(typeof ex.message).toBe('string');
+      });
     });
   });
 });

src/clean.ts

@@ -5,17 +5,18 @@ import { Logger } from './logger/logger';
 
 
 export function clean(context: BuildContext) {
-  const logger = new Logger('clean');
+  return new Promise((resolve, reject) => {
+    const logger = new Logger('clean');
 
-  try {
-    Logger.debug(`[Clean] clean: cleaning ${context.buildDir}`);
+    try {
+      Logger.debug(`[Clean] clean: cleaning ${context.buildDir}`);
 
-    emptyDirSync(context.buildDir);
-    logger.finish();
+      emptyDirSync(context.buildDir);
+      logger.finish();
 
-  } catch (ex) {
-    throw logger.fail(new BuildError(`Failed to clean directory ${context.buildDir} - ${ex.message}`));
-  }
-
-  return Promise.resolve();
+    } catch (ex) {
+      reject(logger.fail(new BuildError(`Failed to clean directory ${context.buildDir} - ${ex.message}`)));
+    }
+    resolve();
+  });
 }

src/cleancss.spec.ts

@@ -1,9 +1,8 @@
 import { join } from 'path';
-import * as rewire from 'rewire';
-
-const cleanCss = rewire('./cleancss');
+import * as cleanCss from './cleancss';
 
 import * as cleanCssFactory from './util/clean-css-factory';
+import { CleanCssConfig, getCleanCssInstance } from './util/clean-css-factory'
 import * as config from './util/config';
 import * as helpers from './util/helpers';
 import * as workerClient from './worker-client';
@@ -12,38 +11,36 @@ import * as workerClient from './worker-client';
 describe('clean css task', () => {
 
   describe('cleancss', () => {
-    it('should return when the worker returns', (done: Function) => {
+    it('should return when the worker returns', () => {
       // arrange
       const context = { };
       const configFile: any = null;
       const spy = spyOn(workerClient, workerClient.runWorker.name).and.returnValue(Promise.resolve());
       // act
-      (cleanCss as any).cleancss(context, null).then(() => {
+      return (cleanCss as any).cleancss(context, null).then(() => {
         // assert
         expect(spy).toHaveBeenCalledWith('cleancss', 'cleancssWorker', context, configFile);
-        done();
       });
     });
 
-    it('should throw when the worker throws', (done: Function) => {
+    it('should throw when the worker throws', () => {
       // arrange
       const context = { };
       const errorMessage = 'Simulating an error';
       spyOn(workerClient, workerClient.runWorker.name).and.returnValue(Promise.reject(new Error(errorMessage)));
 
       // act
-      (cleanCss as any).cleancss(context, null).then(() => {
+      return (cleanCss as any).cleancss(context, null).then(() => {
         throw new Error('Should never get here');
       }).catch((err: Error) => {
         // assert
-        expect(err.message).toEqual(errorMessage, `Expected ex.message ${err.message} to equal ${errorMessage}`);
-        done();
+        expect(err.message).toEqual(errorMessage);
       });
     });
   });
 
   describe('cleancssworker', () => {
-    it('should throw when reading the file throws', (done: Function) => {
+    it('should throw when reading the file throws', () => {
        const errorMessage = 'simulating an error';
       // arrange
       const context = { buildDir: 'www'};
@@ -53,15 +50,14 @@ describe('clean css task', () => {
       spyOn(helpers, helpers.readFileAsync.name).and.returnValue(Promise.reject(new Error(errorMessage)));
 
       // act
-      (cleanCss as any).cleancssWorker(context, null).then(() => {
+      return (cleanCss as any).cleancssWorker(context, null).then(() => {
         throw new Error('Should never get here');
       }).catch((err: Error) => {
         expect(err.message).toEqual(errorMessage);
-        done();
       });
     });
 
-    it('should return what writeFileAsync returns', (done: Function) => {
+    it('should return what writeFileAsync returns', () => {
       // arrange
       const context = { buildDir: 'www'};
       const cleanCssConfig = { sourceFileName: 'sourceFileName', destFileName: 'destFileName'};
@@ -71,26 +67,25 @@ describe('clean css task', () => {
       spyOn(config, config.fillConfigDefaults.name).and.returnValue(cleanCssConfig);
       spyOn(helpers, helpers.readFileAsync.name).and.returnValue(Promise.resolve(fileContent));
       spyOn(helpers, helpers.writeFileAsync.name).and.returnValue(Promise.resolve());
-
-      // use rewire to stub this since jasmine is insufficient
-      const spy = jasmine.createSpy('mySpy').and.returnValue(Promise.resolve(minifiedContent));
-      cleanCss.__set__('runCleanCss', spy);
+      spyOn(cleanCssFactory, 'getCleanCssInstance').and.returnValue({
+        minify: (content: string, cb: Function) => {
+          cb(null, { styles: minifiedContent });
+        }
+      });
 
       // act
-      (cleanCss as any).cleancssWorker(context, null).then(() => {
+      return (cleanCss as any).cleancssWorker(context, null).then(() => {
         // assert
         expect(config.generateContext).toHaveBeenCalledWith(context);
         expect(config.fillConfigDefaults).toHaveBeenCalledWith(null, (cleanCss as any).taskInfo.defaultConfigFile);
         expect(helpers.readFileAsync).toHaveBeenCalledWith(join(context.buildDir, cleanCssConfig.sourceFileName));
         expect(helpers.writeFileAsync).toHaveBeenCalledWith(join(context.buildDir, cleanCssConfig.destFileName), minifiedContent);
-        expect(spy).toHaveBeenCalledWith(cleanCssConfig, fileContent);
-        done();
       });
     });
   });
 
   describe('runCleanCss', () => {
-    it('should reject when minification errors out', (done: Function) => {
+    it('should reject when minification errors out', () => {
       // arrange
       const errorMessage = 'simulating an error';
       const configFile = { options: {} };
@@ -108,16 +103,15 @@ describe('clean css task', () => {
       const callback = minifySpy.calls.mostRecent().args[1];
       callback(new Error(errorMessage), null);
 
-      promise.then(() => {
+      return promise.then(() => {
         throw new Error('Should never get here');
       }).catch((err: Error) => {
         // assert
         expect(err.message).toEqual(errorMessage);
-        done();
       });
     });
 
-    it('should reject when minification has one or more errors', (done: Function) => {
+    it('should reject when minification has one or more errors', () => {
       // arrange
       const configFile = { options: {} };
       const fileContent = 'fileContent';
@@ -137,16 +131,15 @@ describe('clean css task', () => {
       const callback = minifySpy.calls.mostRecent().args[1];
       callback(null, minificationResponse);
 
-      promise.then(() => {
+      return promise.then(() => {
         throw new Error('Should never get here');
       }).catch((err: Error) => {
         // assert
         expect(err.message).toEqual(minificationResponse.errors[0]);
-        done();
       });
     });
 
-    it('should return minified content', (done: Function) => {
+    it('should return minified content', () => {
       const configFile = { options: {} };
       const fileContent = 'fileContent';
       let minifySpy: jasmine.Spy = null;
@@ -166,11 +159,10 @@ describe('clean css task', () => {
       const callback = minifySpy.calls.mostRecent().args[1];
       callback(null, minificationResponse);
 
-      promise.then((result: string) => {
+      return promise.then((result: string) => {
         expect(result).toEqual(minificationResponse.styles);
         expect(cleanCssFactory.getCleanCssInstance).toHaveBeenCalledWith(configFile.options);
         expect(minifySpy.calls.mostRecent().args[0]).toEqual(fileContent);
-        done();
       });
     });
   });

src/serve.spec.ts

@@ -0,0 +1,107 @@
+import * as serve from './serve';
+import * as config from './util/config';
+import { BuildContext } from './util/interfaces';
+import { ServeConfig } from './dev-server/serve-config';
+
+import * as watch from './watch';
+import * as open from './util/open';
+import * as notificationServer from './dev-server/notification-server';
+import * as httpServer from './dev-server/http-server';
+import * as liveReloadServer from './dev-server/live-reload';
+import * as network from './util/network';
+
+describe('test serve', () => {
+  let configResults: ServeConfig;
+  let context: BuildContext;
+
+  beforeEach(() => {
+    context = {
+      rootDir: '/',
+      wwwDir: '/www',
+      buildDir: '/build',
+    };
+    configResults = {
+      httpPort: 8100,
+      host: '0.0.0.0',
+      rootDir: '/',
+      wwwDir: '/www',
+      buildDir: '/build',
+      isCordovaServe: false,
+      launchBrowser: true,
+      launchLab: false,
+      browserToLaunch: null,
+      useLiveReload: true,
+      liveReloadPort: 35729,
+      notificationPort: 53703,
+      useServerLogs: false,
+      useProxy: true,
+      notifyOnConsoleLog: false
+    };
+    spyOn(network, 'findClosestOpenPort').and.callFake((host: string, port: number) => Promise.resolve(port));
+    spyOn(notificationServer, 'createNotificationServer');
+    spyOn(liveReloadServer, 'createLiveReloadServer');
+    spyOn(httpServer, 'createHttpServer');
+    spyOn(watch, 'watch').and.returnValue(Promise.resolve());
+    spyOn(open, 'default');
+  });
+
+  it('should work with no args on a happy path', () => {
+    return serve.serve(context).then(() => {
+      expect(network.findClosestOpenPort).toHaveBeenCalledWith('0.0.0.0', 53703);
+      expect(notificationServer.createNotificationServer).toHaveBeenCalledWith(configResults);
+      expect(liveReloadServer.createLiveReloadServer).toHaveBeenCalledWith(configResults);
+      expect(httpServer.createHttpServer).toHaveBeenCalledWith(configResults);
+      expect(open.default).toHaveBeenCalledWith('http://localhost:8100', null);
+    });
+  });
+
+  it('should include ionicplatform in the browser url if platform is passed', () => {
+    config.addArgv('--platform');
+    config.addArgv('android');
+
+    return serve.serve(context).then(() => {
+      expect(network.findClosestOpenPort).toHaveBeenCalledWith('0.0.0.0', 53703);
+      expect(notificationServer.createNotificationServer).toHaveBeenCalledWith(configResults);
+      expect(liveReloadServer.createLiveReloadServer).toHaveBeenCalledWith(configResults);
+      expect(httpServer.createHttpServer).toHaveBeenCalledWith(configResults);
+      expect(open.default).toHaveBeenCalledWith('http://localhost:8100?ionicplatform=android', null);
+    });
+  })
+
+  it('all args should be set in the config object and should be passed on to server functions', () => {
+    config.setProcessArgs([]);
+    config.addArgv('--serverlogs');
+    configResults.useServerLogs = true;
+    config.addArgv('--consolelogs');
+    configResults.notifyOnConsoleLog = true;
+    config.addArgv('--noproxy');
+    configResults.useProxy = false;
+    config.addArgv('--nolivereload');
+    configResults.useLiveReload = false;
+    config.addArgv('--lab');
+    configResults.launchLab = true;
+    config.addArgv('--browser');
+    config.addArgv('safari');
+    configResults.browserToLaunch = 'safari';
+    config.addArgv('--port');
+    config.addArgv('8101');
+    configResults.httpPort = 8101;
+    config.addArgv('--address');
+    config.addArgv('127.0.0.1');
+    configResults.host = '127.0.0.1';
+    config.addArgv('--livereload-port');
+    config.addArgv('35729');
+    configResults.liveReloadPort = 35729;
+    config.addArgv('--dev-logger-port');
+    config.addArgv('53703');
+    configResults.notificationPort = 53703;
+
+    return serve.serve(context).then(() => {
+      expect(network.findClosestOpenPort).toHaveBeenCalledWith('127.0.0.1', 53703);
+      expect(notificationServer.createNotificationServer).toHaveBeenCalledWith(configResults);
+      expect(liveReloadServer.createLiveReloadServer).toHaveBeenCalledWith(configResults);
+      expect(httpServer.createHttpServer).toHaveBeenCalledWith(configResults);
+      expect(open.default).toHaveBeenCalledWith('http://127.0.0.1:8101/ionic-lab', 'safari');
+    });
+  });
+});