package.json

{
  "name": "test",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "async": "^2.1.5",
    "neo4j-driver": "^1.1.1",
    "uuid": "^3.0.1"
  }
}

test.js

var eachLimit = require('async/eachLimit');
var uuid = require('uuid');
var neo4j = require('neo4j-driver').v1;

var driver = neo4j.driver('bolt://localhost', neo4j.auth.basic('neo4j', 'test'));

var usersCount = 50;
var queriesCount = 1000000;

var userIds = randomUuids(usersCount);
var queryParams = randomQueryParams(queriesCount, userIds);

createUsers(userIds).then(function () {
  createIndexOnUsers().then(function () {
    var stats = {
      queriesExecuted: 0,
      deadlocksDetected: 0,
      maxQueryExecutionTime: 0
    };
    eachLimit(queryParams, 12, function (params, callback) {
      executeQuery(params, callback, stats);
    }, queriesCompleted);
  });
});

driver.onError = function (error) {
  console.log('Driver instantiation failed ', error);
};

function executeQuery(params, callback, stats) {
  var query =
    'MATCH (u1:User{uid: {user1}}), (u2:User{uid: {user2}}), (u3:User{uid: {user3}}) ' +
    'CREATE (u1)-[l1:LIKE {created: {like1Created}}]->(u2), (u2)-[l2:LIKE {created: {like2Created}}]->(u3) ' +
    'RETURN (u1)-[l1]->(u2)-[l2]->(u3), range(0, 10000)';

  var session = driver.session();
  var startTime = Date.now();
  session.run(query, params).then(function (result) {
    session.close();
    var endTime = Date.now();
    var elapsedTime = endTime - startTime;

    stats.queriesExecuted++;
    if (stats.maxQueryExecutionTime < elapsedTime) {
      stats.maxQueryExecutionTime = elapsedTime;
    }
    if (stats.queriesExecuted % 1000 === 0) {
      console.log('Stats: ' + JSON.stringify(stats));
    }

    if (result.records.length === 0) {
      callback(new Error('Query did not return results'));
    } else {
      callback();
    }

  }).catch(function (error) {
    if (error.code === 'Neo.TransientError.Transaction.DeadlockDetected') {
      stats.deadlocksDetected++;
    }
    callback();
  });
}

function queriesCompleted(error) {
  if (error) {
    console.log('Async queries failed: ', error);
    process.exit(1);
  } else {
    console.log('Async queries finished');
    process.exit();
  }
}

function createUsers(userIds) {
  var session = driver.session();
  return session.run('UNWIND {userIds} AS userId CREATE (u:User{uid: userId})', {userIds: userIds})
    .then(function (result) {
      var nodesCreated = result.summary.counters.nodesCreated();
      if (nodesCreated !== userIds.length) {
        throw 'Wrong amount of users created: ' + nodesCreated;
      }
      console.log('Users created');
      session.close();
    }).catch(function (error) {
      console.log('User creation failed: ', error);
    });
}

function createIndexOnUsers() {
  var session = driver.session();
  return session.run('CREATE INDEX ON :User(uid)')
    .then(function () {
      console.log('Index created');
      session.close();
    }).catch(function (error) {
      console.log('Index creation failed: ', error);
    });
}

function randomQueryParams(count, userIds) {
  var result = [];
  for (var i = 0; i < count; i++) {
    result.push({
      user1: randomOf(userIds),
      user2: randomOf(userIds),
      user3: randomOf(userIds),
      like1Created: Date.now(),
      like2Created: Date.now()
    });
  }
  return result;
}

function randomUuids(count) {
  var result = [];
  for (var i = 0; i < count; i++) {
    result.push(uuid.v4());
  }
  return result;
}

function randomOf(array) {
  return array[Math.floor(Math.random() * array.length)];
}