单元测试连接数据库的异步函数

Question

Well I have some functions which connect to database (redis) and return some data, those functions usually are based on promises but are asynchronous and contain streams. I looked and read some things about testing and I chose to go with tape , sinon and proxyquire, if I mock this function how I would know that it works?

The following function (listKeys) returns (through promise) all the keys that exist in the redis db after completes the scanning.

let methods = {
    client: client,
    // Cache for listKeys
    cacheKeys: [],
    // Increment and return through promise all keys
    // store to cacheKeys;
    listKeys: blob => {
        return new Promise((resolve, reject) => {
            blob = blob ? blob : '*';

            let stream = methods.client.scanStream({
                match: blob,
                count: 10,
            })

            stream.on('data', keys => {
                for (var i = 0; i < keys.length; i++) {
                    if (methods.cacheKeys.indexOf(keys[i]) === -1) {
                        methods.cacheKeys.push(keys[i])
                    }
                }
            })

            stream.on('end', () => {
                resolve(methods.cacheKeys)
            })

            stream.on('error', reject)
        })
    }
}

So how do you test a function like that?

Answer 1

I think there are a couple ways To excercise this function through a test and all revolve around configuring a test stream to be used by your test.

I like to write test cases that I think are important first , then figure out a way to implement them. To me the most important is something like

it('should resolve cacheKeys on end')

Then a stream needs to be created to provide to your function

var Stream = require('stream');
var stream = new Stream();

Then scan stream needs to be controlled by your test

You could do this by creating a fake client

client = {
  scanStream: (config) => { return stream }
}

Then a test can be configured with your assertion

var testKeys = ['t'];

Method.listKeys().then((cacheKeys) => { 

  assert(cacheKeys).toEqual(testKeys);
  done() 
})

Now that your promise is waiting on your stream with an assertion Send data to stream.

stream.emit('data', testKeys)

Answer 2

A simple way to test whether the keys get saved to cacheKeys properly by mocking the DB stream, sending data over it and checking whether it got saved properly. Eg:

// Create a mock stream to substitute database
var mockStream = new require('stream').Readable();

// Create a mock client.scanStream that returns the mocked stream
var client = {
    scanStream: function () {
        return mockStream;
    }
};

// Assign the mocks to methods
methods.client = client;

// Call listKeys(), so the streams get prepared and the promise awaits resolution
methods.listKeys()
    .then(function (r) {
        // Setup asserts for correct results here
        console.log('Promise resolved with: ', r);
    });

// Send test data over the mocked stream
mockStream.emit('data', 'hello');

// End the stream to resolve the promise and execute the asserts
mockStream.emit('end');