simplified tests.

backend/__tests__/src/__mocks__/child_process.js

@@ -30,6 +30,9 @@ function spawn (command, args) {
               }
             })
           )
+        } else {
+          console.log()
+          this.stdoutCallback(null, JSON.stringify({ options: resp.output }))
         }
       }
     },

backend/__tests__/src/interfaces.spec.js

@@ -1,5 +1,14 @@
-jest.mock('fs')
-jest.mock('os')
+const now = new Date('1980-03-18T04:15:00')
+
+const util = require('util')
+util.promisify = jest.fn().mockImplementation(func => func)
+
+const fs = require('fs')
+fs.readdir = jest.fn()
+fs.stat = jest.fn()
+
+const os = require('os')
+os.hostname = jest.fn().mockImplementation(() => 'fakehost')
 
 /**
  * Asynchronous mock function that returns a promise witch
@@ -26,7 +35,8 @@ jest.mock('../../src/pythonWorker', () => {
 })
 
 const md5 = require('md5')
-const { resolvers, typeDefs, __test__ } = require('../../src/interfaces')
+const interfaces = require('../../src/interfaces')
+const { resolvers, typeDefs, __test__ } = interfaces
 // const child_process = require('child_process')
 // child_process.addCRPair({
 //   input: '{"type":"options"}\n',
@@ -46,12 +56,12 @@ describe('interfaces module', () => {
     const { findWorkers } = __test__
 
     // 1. Check use case
-    await expect(findWorkers('python_workers')).resolves.toEqual([
-      'test1_worker.py',
-      'test2_worker.py'
-    ])
+    const files = ['test1_worker.py', 'test2_worker.py']
+    fs.readdir.mockReturnValueOnce(files)
+    await expect(findWorkers('python_workers')).resolves.toEqual(files)
 
     // 2. Check empty directory
+    fs.readdir.mockReturnValueOnce([])
     await expect(findWorkers('/')).resolves.toEqual([])
 
     // 3. Check argument error
@@ -60,6 +70,11 @@ describe('interfaces module', () => {
     )
 
     // 4. Check non-existing path
+    fs.readdir.mockImplementation(() => {
+      throw new Error(
+        `ENOENT: no such file or directory, scandir '/DOESNTEXIST'`
+      )
+    })
     await expect(findWorkers('/DOESNTEXIST')).rejects.toThrow(
       `ENOENT: no such file or directory, scandir '/DOESNTEXIST'`
     )
@@ -99,27 +114,38 @@ describe('interfaces module', () => {
     // 1. Check the use case
     mockSpawn.mockReturnValueOnce(AsyncMock({ result: { data: 'ready!' } }))
     mockSend.mockReturnValueOnce(AsyncMock({ result: { data: [] } }))
+    fs.stat.mockReturnValueOnce({ mtime: now, size: 1234 })
     await expect(
       createInterface('python_workers', 'test1_worker.py', [])
-    ).resolves.toMatchObject({
-      id: md5(`test1python_workers/test1_worker.py1980-03-18T03:15:00.000Z`),
-      interfaceName: 'test1',
-      options: [],
-      workerProcess: expect.objectContaining({
-        send: expect.anything(),
-        spawn: expect.anything()
+    ).resolves.toContainEqual(
+      expect.objectContaining({
+        id: md5(`test1python_workers/test1_worker.py1980-03-18T03:15:00.000Z`),
+        interfaceName: 'test1',
+        options: [],
+        workerProcess: expect.objectContaining({
+          send: expect.anything(),
+          spawn: expect.anything()
+        })
       })
-      // diini: 12
-    })
+    )
     expect(mockSpawn).toHaveBeenCalled()
     expect(mockSend).toHaveBeenCalledWith({ type: 'options' })
 
-    // 2. Check argument error case
+    // 2. Check that the update property is set for existing interfaces
+
+    // 3. Check that existing interfaces are skipped
+
+    // 4. Check argument error case
     await expect(createInterface()).rejects.toThrow(
       'Directory argument must be a string.'
     )
 
-    // 3. Check missing file case
+    // 5. Check missing file case
+    fs.stat.mockImplementation(() => {
+      throw new Error(
+        `ENOENT: no such file or directory, scandir 'python_workers/testXXX_worker.py'`
+      )
+    })
     await expect(
       createInterface('python_workers', 'testXXX_worker.py', [])
     ).rejects.toThrow(
@@ -127,9 +153,14 @@ describe('interfaces module', () => {
     )
   })
 
-  const { Query, Mutation, Interface, Connection } = resolvers
-  xit('finds interfaces', async () => {
-    const resp = await Query.interfaces()
+  it('finds interfaces', async () => {
+    const { findInterfaces } = __test__
+    interfaces.findWorkers = jest.fn()
+    interfaces.findWorkers.mockReturnValueOnce([])
+    interfaces.createInterface = jest.fn()
+    interfaces.createInterface.mockReturnValueOnce([])
+    const resp = await findInterfaces()
     expect(resp).toBe([])
   })
+  const { Query, Mutation, Interface, Connection } = resolvers
 })

backend/src/interfaces.js

@@ -203,13 +203,10 @@ async function createInterface (directory, workerFile, interfaces) {
   const id = md5(`${interfaceName}${workerScript.path}${mtime.toISOString()}`)
   const options = await getOptions(workerProcess)
   // d. Save the worker in the state.
-  return {
-    id,
-    interfaceName,
-    workerScript,
-    workerProcess,
-    options
-  }
+  return [
+    ...interfaces,
+    { id, interfaceName, workerScript, workerProcess, options }
+  ]
 }
 
 /**
@@ -445,6 +442,7 @@ const __test__ = {
   findWorkers,
   createInterface,
   getOptions,
+  findInterfaces,
   serializeWorkerProcess,
   state
 }