@linaframework/arango-orm/dist/index.test.js

> Please check out https://github.com/awesome-graphql-space/lina and https://github.com/oknoah/final/packages/arangolize for similar projects that MAY be more up to date

'use strict';

var _taggedTemplateLiteral2 = require('babel-runtime/helpers/taggedTemplateLiteral');

var _taggedTemplateLiteral3 = _interopRequireDefault(_taggedTemplateLiteral2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _templateObject = (0, _taggedTemplateLiteral3.default)(['for u in User limit 10 return u'], ['for u in User limit 10 return u']);

var _dotenv = require('dotenv');

var _dotenv2 = _interopRequireDefault(_dotenv);

var _crypto = require('crypto');

var _index = require('./index');

var _index2 = _interopRequireDefault(_index);

var _moment = require('moment');

var _moment2 = _interopRequireDefault(_moment);

var _lodash = require('lodash');

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : { default: obj };
}

_dotenv2.default.config();

var _process$env = process.env,
    NAME = _process$env.NAME,
    TEST_EXTERNAL_HOST = _process$env.TEST_EXTERNAL_HOST;

var username = 'test' + (0, _crypto.randomBytes)(8).toString('hex');

var db = _index2.default.connect({
  database: NAME || 'test'
});

var User = function (_db$Model) {
  (0, _inherits3.default)(User, _db$Model);

  function User() {
    (0, _classCallCheck3.default)(this, User);
    return (0, _possibleConstructorReturn3.default)(this, (User.__proto__ || (0, _getPrototypeOf2.default)(User)).apply(this, arguments));
  }

  return User;
}(db.Model);

User.schema = {
  name: { $type: String, index: true, unique: true },
  profile: {
    vegan: { $type: Boolean, optional: true }
  }
};

var Post = function (_db$Model2) {
  (0, _inherits3.default)(Post, _db$Model2);

  function Post() {
    (0, _classCallCheck3.default)(this, Post);
    return (0, _possibleConstructorReturn3.default)(this, (Post.__proto__ || (0, _getPrototypeOf2.default)(Post)).apply(this, arguments));
  }

  return Post;
}(db.Model);

Post.schema = {
  body: { $type: String, optional: true },
  creator: { $type: User, optional: false }
};

var Likes = function (_db$Edge) {
  (0, _inherits3.default)(Likes, _db$Edge);

  function Likes() {
    (0, _classCallCheck3.default)(this, Likes);
    return (0, _possibleConstructorReturn3.default)(this, (Likes.__proto__ || (0, _getPrototypeOf2.default)(Likes)).apply(this, arguments));
  }

  return Likes;
}(db.Edge);

test('initialize ormjs', function () {
  expect(db).toHaveProperty('Edge');
  expect(db).toHaveProperty('Model');
});

test('create new model instance', async function () {
  var newUser = await User.add({ name: username });

  expect(newUser._id).toBeTruthy();
});

test('check name must be unique', async function () {
  try {
    await User.add({ name: username });
  } catch (error) {
    expect(error).not.toHaveProperty('_id');
  }
});

test('create test post', async function () {
  var user = await User.findOne({ where: { name: username } });
  var post = await Post.add({ body: username, creator: user });

  expect(post.body === username).toBeTruthy();
  expect(post.body.length > 4).toBeTruthy();
});

test('create edge collection relationship', async function () {
  var user = await User.findOne({ where: { name: username } });
  var post = await Post.findOne({ where: { body: username } });
  var like = await Likes.add(user, post);

  expect(like._from).toBe(user._id);
});

test('find collections by example', async function () {
  var user = await User.findOne({ where: { name: username } });

  expect(user).toHaveProperty('_key');
});

test('find edge collections by example', async function () {
  var user = await User.findOne({ where: { name: username } });
  var edge = await Likes.findOne({ where: { _from: user._id } });

  expect(edge._from).toBe(user._id);
});

test('find only certain attributes', async function () {
  var user = await User.findOne({
    where: { name: username },
    attributes: ['_id', 'createdAt']
  });

  expect(user.name).toBe(undefined);
  expect(user._id).not.toBe(undefined);
});

test('make sure all documents have createdAt field', async function () {
  var user = await User.findOne({
    where: { name: username }
  });

  expect(user).toHaveProperty('createdAt');
  expect((0, _moment2.default)(user.createdAt).isValid()).toBe(true);
});

test('make sure all documents have updatedAt field', async function () {
  var post = await Post.findOne({
    body: username
  });

  post.body = 'Updated!';
  await post.save();

  expect(post).toHaveProperty('updatedAt');
  expect((0, _moment2.default)(post.updatedAt).isValid()).toBe(true);
});

test('use aql query', async function () {
  var _ref = await db.Model,
      aql = _ref.aql,
      _database = _ref._database;

  var cursor = await _database.query(aql(_templateObject));
  var users = await cursor.all();
  expect(users.length).toBe(10);
});

test('check list is sorted', async function () {
  var posts = await Post.find({
    sort: 'createdAt asc',
    limit: 100
  });

  var sorted = await (0, _lodash.sortBy)(posts, ['createdAt']);

  expect((0, _lodash.isEqual)(posts, sorted)).toBe(true);
  expect((0, _lodash.isEqual)(posts, sorted.reverse())).not.toBe(true);
});

test('find with include', async function () {
  var posts = await Post.find({
    include: {
      model: User,
      as: 'creator'
    }
  });

  expect(posts[0]).toHaveProperty('creator');
  expect(posts[0]).toHaveProperty('_key');
  expect(posts[0]).toHaveProperty('body');
});

test('find and count include', async function () {
  var included = await Post.findAndCount({
    include: {
      model: User,
      as: 'creator'
    }
  });

  var posts = included.data,
      count = included.meta.count;

  expect(posts[0]).toHaveProperty('creator');
  expect(posts[0]).toHaveProperty('_key');
  expect(posts[0]).toHaveProperty('body');
  expect(typeof count === 'number').toBeTruthy();
});

// test('remove item', async () => {
//   const userToRemove = await User.findOne({
//     where: { name: username }
//   })
//   await userToRemove.remove()
//   const user = await User.findOne({
//     where: { name: username }
//   })

//   expect(user).toBe(null)
// })

test('do not allow injection', async function () {
  var users = await User.find({
    where: { name: '123" || user._id == \'User/4627980\' || user.name == "hi' },
    limit: 100
  });

  expect((0, _lodash.isEmpty)(users)).toBe(true);
  // expect(statuses.includes(true) !== true).toBe(true)
});

test('find by include where', async function () {
  var post = await Post.findOne({
    include: {
      as: 'creator',
      where: { name: username }
    }
  });

  expect(post.creator.name).toBe(username);
});

test('complex query', async function () {
  var posts = await Post.findAndCount({
    limit: 5,
    skip: 0,
    sort: 'createdAt DESC',
    attributes: ['creator', 'createdAt'],
    include: {
      as: 'creator',
      where: { name: username }
    }
  });

  expect(posts.data[0].creator.name).toBe(username);
});

test('connect without localhost', async function () {
  /*
    The purpose of this test is to be sure other hosts work. I use ngrok like so
     bash> ngrok http 127.0.0.1:8529
     ngrok will output a WAN address like `123abc.ngrok.io` which you should make TEST_EXTERNAL_HOST in your env.
     https://github.com/OKNoah/final-orm/issues/16
  */
  db = _index2.default.connect({
    host: TEST_EXTERNAL_HOST,
    protocol: 'https',
    port: 443,
    user: 'root',
    password: '',
    database: NAME || 'test'
  });

  var User2 = function (_db$Model3) {
    (0, _inherits3.default)(User2, _db$Model3);

    function User2() {
      (0, _classCallCheck3.default)(this, User2);
      return (0, _possibleConstructorReturn3.default)(this, (User2.__proto__ || (0, _getPrototypeOf2.default)(User2)).apply(this, arguments));
    }

    return User2;
  }(db.Model);

  User2.schema = {
    name: { $type: String, index: true, unique: true },
    profile: {
      vegan: { $type: Boolean, optional: true }
    }
  };

  var newUserName = username + '123';

  await User2.add({ name: newUserName });

  var user = await User2.findOne({
    where: { name: newUserName }
  });

  expect(TEST_EXTERNAL_HOST).not.toBe(undefined);
  expect(user).toHaveProperty('createdAt');
  expect((0, _moment2.default)(user.createdAt).isValid()).toBe(true);
});

test('make a class that dont exist', async function () {
  db = _index2.default.connect({
    host: TEST_EXTERNAL_HOST,
    protocol: 'https',
    port: 443,
    user: 'root',
    password: '',
    database: NAME || 'test'
  });

  var User3 = function (_db$Model4) {
    (0, _inherits3.default)(User3, _db$Model4);

    function User3() {
      (0, _classCallCheck3.default)(this, User3);
      return (0, _possibleConstructorReturn3.default)(this, (User3.__proto__ || (0, _getPrototypeOf2.default)(User3)).apply(this, arguments));
    }

    return User3;
  }(db.Model);

  User3.schema = {
    name: { $type: String, index: true, unique: true },
    profile: {
      vegan: { $type: Boolean, optional: true }
    }
  };

  var newUserName = username + '123';

  await User3.add({ name: newUserName });

  var user = await User3.findOne({
    where: { name: newUserName }
  });

  expect(TEST_EXTERNAL_HOST).not.toBe(undefined);
  expect(user).toHaveProperty('createdAt');
  expect((0, _moment2.default)(user.createdAt).isValid()).toBe(true);
});