Merge pull request #127 from topcoder-platform/develop

Update topgear learn page, improved unit tests and stats component

.eslintrc

@@ -5,4 +5,4 @@
       "babel-module": {}
     }
   }
-}
+}

__tests__/client/index.jsx

@@ -86,7 +86,7 @@ jest.setMock('react-router-dom', {
 let tokenV3;
 const mockTcAccounts = {
   configureConnector: () => undefined,
-  decodeToken: () => 'Decoded user object',
+  decodeToken: () => ({ exp: Date.now() }),
   getFreshToken: () => Promise.resolve(tokenV3),
 };
 jest.setMock('tc-accounts', mockTcAccounts);
@@ -116,6 +116,15 @@ const mockStoreFactory = jest.fn(() => Promise.resolve({
 }));
 jest.setMock(`${SRC}/shared/store-factory`, mockStoreFactory);
 
+
+const mockLogger = {
+  warn: jest.fn(),
+  log: jest.fn(),
+  error: jest.fn(),
+};
+
+jest.setMock(`${SRC}/shared/utils/logger`, mockLogger);
+
 /* Some other mocks */
 
 jest.setMock(`${SRC}/shared`, {
@@ -196,5 +205,20 @@ describe('Properly starts with process.env.FRONT_ENV evaluating true', () => {
       });
     }),
   );
+
+  test('Unmock cookies generate a warning', () =>
+    new Promise((resolve) => {
+      jest.setMock('browser-cookies', {
+        get: () => {
+          throw new Error();
+        },
+      });
+      require(MODULE);
+      setImmediate(() => {
+        expect(mockLogger.warn).toHaveBeenCalledWith('Authentication failed!');
+        resolve();
+      });
+    }),
+  );
 });
 

__tests__/server/index.js

@@ -17,14 +17,37 @@ jest.setMock(`${SRC}/server/server`, {
   set: jest.fn(),
 });
 
-test('Should not throw', () => {
-  expect(() => require('server')).not.toThrow();
+// test('Should not throw', () => {
+//   expect(() => require('server')).not.toThrow();
+// });
+
+describe('port', () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  test('Positive port', () => {
+    process.env.PORT = '3456';
+    expect(() => require('server')).not.toThrow();
+  });
+
+  test('Negative port', () => {
+    process.env.PORT = '-1';
+    expect(() => require('server')).not.toThrow();
+  });
+
+  test('String port', () => {
+    process.env.PORT = 'abc';
+    expect(() => require('server')).not.toThrow();
+  });
 });
 
 describe('Successfully created server', () => {
   beforeAll(() => {
     jest.resetModules();
     jest.clearAllMocks();
+    process.env.PORT = '';
+    process.env.NODE_ENV = 'test';
     require('server');
   });
 
@@ -42,12 +65,6 @@ describe('Successfully created server', () => {
     expect(() => onError(err)).toThrow(err);
   });
 
-  test('onError throws for unknown errors', () => {
-    const err = new Error();
-    err.syscall = 'listen';
-    expect(() => onError(err)).toThrow(err);
-  });
-
   test('onError handles EACCESS error as expected', () => {
     const err = new Error();
     err.syscall = 'listen';
@@ -69,4 +86,36 @@ describe('Successfully created server', () => {
     expect(console.error).toHaveBeenCalledWith('Port 3000 is already in use');
     expect(process.exit).toHaveBeenCalledWith(1);
   });
+
+  test('onError throws for unknown errors', () => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    process.env.PORT = 'string';
+    require('server');
+    onError = mockServer.on.mock.calls.filter(call => call[0] === 'error')[0][1];
+    const err = new Error();
+    err.syscall = 'listen';
+    expect(() => onError(err)).toThrow(err);
+  });
+
+  let onListen;
+  test('A single listen handler is created', () => {
+    onListen = mockServer.on.mock.calls.filter(call => call[0] === 'listening');
+    expect(onListen.length).toBe(1);
+    onListen = onListen[0][1];
+    expect(_.isFunction(onListen)).toBe(true);
+  });
+
+  test('onListen is called with string address', () => {
+    mockServer.address = () => 'localhost';
+    console.log = jest.fn();
+    onListen();
+    expect(console.log).toHaveBeenCalledWith('Server listening on pipe localhost in test mode');
+  });
+
+  test('onListen is called with object address', () => {
+    mockServer.address = () => ({ port: 8000 });
+    onListen();
+    expect(console.log).toHaveBeenCalledWith('Server listening on port 8000 in test mode');
+  });
 });

__tests__/server/renderer.jsx

@@ -1,19 +1,27 @@
-/*
-jest.setMock('react-dom/server', {
-  renderToString: () => 'RENDER',
-});
 
-const renderer = require('server/renderer').default;
-*/
+const MODULE = require.resolve('server/renderer');
+
+const renderer = require(MODULE).default;
 
-test.skip('should not throw errors', () => {
-  /*
+const res = {
+  send: () => {},
+  status: () => {},
+};
+
+test('valid url', () => {
   const req = {
     url: '/',
+    query: {},
+    subdomains: [],
   };
-  const res = {
-    send: () => {},
+  expect(() => renderer(req, res)).not.toThrow();
+});
+
+test('invalid url', () => {
+  const req = {
+    url: '/noop',
+    query: {},
+    subdomains: [],
   };
   expect(() => renderer(req, res)).not.toThrow();
-  */
 });

__tests__/server/server.js

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import request from 'supertest';
 
 const MODULE = require.resolve('server/server');
 
@@ -7,7 +7,7 @@ jest.setMock('../../config/webpack/development', {
     publicPath: '',
   },
 });
-jest.setMock(require.resolve('server/renderer'), _.noop);
+jest.setMock(require.resolve('server/renderer'), (req, res, next) => next());
 
 afterAll(() => {
   delete process.env.DEV_TOOLS;
@@ -39,3 +39,41 @@ test('Does not throw when uses dev tools', () => {
   expect(() => require(MODULE)).not.toThrow();
   delete process.env.DEV_TOOLS;
 });
+
+describe('Api test', () => {
+  let server;
+  beforeEach(() => {
+    process.env.NODE_ENV = 'test';
+    jest.resetModules();
+    server = require(MODULE).default;
+  });
+  test('post to /api/logger', () => request(server).post('/api/logger')
+      .send({ data: 'data' })
+      .then((response) => {
+        expect(response.statusCode).toBe(200);
+      }));
+  test('post to /api/xml2json', () => request(server).post('/api/xml2json')
+      .send({ xml: '<xml></xml>' })
+      .then((response) => {
+        expect(response.text).toBe('{"xml":{}}');
+      }));
+  test('status 404', () => request(server).get('/ELB-HealthChecker/2.0')
+      .then((response) => {
+        expect(response.statusCode).toBe(404);
+      }));
+  test('status 500', () => request(server).post('/api/logger')
+      .then((response) => {
+        expect(response.statusCode).toBe(500);
+      }));
+  test('status 500 Internal Error', () => {
+    process.env.NODE_ENV = 'development';
+    jest.resetModules();
+    jest.setMock(require.resolve('server/renderer'), () => { throw new Error(); });
+    server = require(MODULE).default;
+    return request(server).post('/api/noop')
+      .then((response) => {
+        expect(response.text).toBe('Internal Server Error');
+        delete process.env.NODE_ENV;
+      });
+  });
+});

__tests__/server/tc-communities.js

@@ -0,0 +1,23 @@
+import request from 'supertest';
+
+const MODULE = require.resolve('server/server');
+
+describe('tc-communities api test', () => {
+  let server;
+  beforeEach(() => {
+    jest.resetModules();
+    server = require(MODULE).default;
+  });
+  test('get community filter', () => request(server).get('/api/tc-communities')
+      .then((response) => {
+        expect(response.statusCode).toBe(200);
+      }));
+  test('get community meta', () => request(server).get('/api/tc-communities/wipro/meta')
+      .then((response) => {
+        expect(response.statusCode).toBe(200);
+      }));
+  test('get non-exist community meta', () => request(server).get('/api/tc-communities/noop/meta')
+      .then((response) => {
+        expect(response.statusCode).toBe(404);
+      }));
+});

__tests__/shared/__snapshots__/index.jsx.snap

@@ -9,5 +9,6 @@ exports[`Snapshot match 1`] = `
 exports[`Snapshot match 2`] = `
 <div>
   <withRouter(Connect(Routes)) />
+  <res />
 </div>
 `;

__tests__/shared/actions/auth.js

@@ -27,31 +27,61 @@ jest.setMock('tc-accounts', {
 
 const actions = require('actions/auth').default;
 
-beforeEach(() => jest.clearAllMocks());
-
-test('auth.loadProfile works as expected when authenticated', () => {
-  const action = actions.auth.loadProfile('token');
-  expect(action.type).toBe('AUTH/LOAD_PROFILE');
-  return action.payload.then((res) => {
-    expect(global.fetch).toHaveBeenCalledWith(
-      PROFILE_REQ_URL, {
-        headers: {
-          Authorization: 'Bearer token',
-          'Content-Type': 'application/json',
+describe('fetch with success response', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  test('auth.loadProfile works as expected when authenticated', () => {
+    const action = actions.auth.loadProfile('token');
+    expect(action.type).toBe('AUTH/LOAD_PROFILE');
+    return action.payload.then((res) => {
+      expect(global.fetch).toHaveBeenCalledWith(
+        PROFILE_REQ_URL, {
+          headers: {
+            Authorization: 'Bearer token',
+            'Content-Type': 'application/json',
+          },
         },
-      },
-    );
-    expect(global.fetch).toHaveBeenCalledWith(
-      GROUPS_REQ_URL, {
-        headers: {
-          Authorization: 'Bearer token',
-          'Content-Type': 'application/json',
+      );
+      expect(global.fetch).toHaveBeenCalledWith(
+        GROUPS_REQ_URL, {
+          headers: {
+            Authorization: 'Bearer token',
+            'Content-Type': 'application/json',
+          },
         },
-      },
-    );
-    expect(res).toEqual({
-      groups: ['Group1', 'Group2'],
-      userId: 12345,
+      );
+      expect(res).toEqual({
+        groups: ['Group1', 'Group2'],
+        userId: 12345,
+      });
+    });
+  });
+
+  test('auth.loadProfile with empty token', () => {
+    const action = actions.auth.loadProfile('');
+    expect(action.type).toBe('AUTH/LOAD_PROFILE');
+    return action.payload.then((res) => {
+      expect(res).toBe(null);
+    });
+  });
+});
+
+describe('fetch with failed response', () => {
+  beforeAll(() => {
+    global.fetch = jest.fn(() => Promise.resolve({
+      json: () => ({
+        result: { status: 404 },
+      }),
+    }));
+  });
+
+  test('fetch return 404', () => {
+    const action = actions.auth.loadProfile('token');
+    expect(action.type).toBe('AUTH/LOAD_PROFILE');
+    return action.payload.then((res) => {
+      expect(res).toEqual({
+        groups: [],
+      });
     });
   });
 });