senecajs/seneca-store-test

File store-test.js has 2539 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/* Copyright (c) 2014-2021 Richard Rodger, MIT License */
'use strict'

var Util = require('util')

Function upserttest has 1000 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function upserttest(settings) {
  Assert('seneca' in settings, 'settings.seneca')
  const si = settings.seneca

  // NOTE: WARNING: Side-effect - the original seneca instance will be mutated.

Function basictest has 716 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function basictest(settings) {
  var si = settings.seneca

  var script = settings.script || Lab.script()

Function limitstest has 290 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function limitstest(settings) {
  var si = settings.seneca
  var script = settings.script || Lab.script()

  var describe = script.describe

Function mergetest has 101 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function mergetest(settings) {
  const si = settings.senecaMergeFalse

  const script = settings.script || Lab.script()
  const it = make_it(script)

Function keyvalue has 100 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    keyvalue: (lab, opts) => {
      lab.describe('store-keyvalue', () => {
        lab.it('save-load-auto-id', async () => {
          let seneca = opts.seneca
          let ent0 = seneca.entity(opts.ent0)

Function sorttest has 98 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function sorttest(settings) {
  var si = settings.seneca
  var script = settings.script || Lab.script()

  var describe = script.describe

Function sqltest has 47 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function sqltest(settings) {
  var si = settings.seneca
  var script = settings.script || Lab.script()

  var describe = script.describe

Function clearDb has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function clearDb(si) {
  return () => {
    return new Promise((done) => {
      si.ready(function () {
        Async.series(

Function barverify has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

var barverify = function (bar) {
  Assert.equal(bar.str, 'aaa')
  Assert.equal(bar.int, 11)
  Assert.equal(bar.dec, 33.33)
  Assert.equal(bar.bol, false)

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should update an entity if id provided', function (done) {
        var foo = si.make('foo')
        foo.id = 'to-be-updated'
        foo.p1 = 'z1'
        foo.p2 = 'z2'

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it("should save an entity if id provided but original doesn't exist", function (done) {
        var foo = si.make('foo')
        foo.id = 'will-be-inserted'
        foo.p1 = 'z1'
        foo.p2 = 'z2'

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('updates the entity', (fin) => {
        si.test(fin)

        si.make('customers')
          .data$({

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('creates a new entity', (fin) => {
        si.test(fin)

        si.make('customers')
          .data$({ first_name: 'frank', last_name: 'nixon', credits: 7 })

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        si.make('products')
          .data$({
            label: 'a new toothbrush',
            price: '5.95',
            psst$: 'private',

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        existing_product
          .data$({ label: 'a macchiato espressionado', price: '3.95' })
          .save$({ upsert$: ['label'] }, (err) => {
            if (err) {
              return fin(err)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          .save$({ upsert$: ['id', 'username'] }, (err) => {
            if (err) {
              return fin(err)
            }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          .save$({ upsert$: ['id'] }, (err) => {
            if (err) {
              return fin(err)
            }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          si.make('foo')
            .data$({ id: null, p1: 'v1', p2: 'v2' })
            .save$(function (err, foo1) {
              if (err) {
                return done(err)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          si.make('foo')
            .data$({ id: undefined, p1: 'v1', p2: 'v2' })
            .save$(function (err, foo1) {
              if (err) {
                return done(err)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should ignore skip < 0', function (done) {
        var cl = si.make('foo')
        cl.list$(
          { skip$: -1, sort$: { p1: 1 } },
          verify(done, function (lst) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should ignore limit < 0', function (done) {
        var cl = si.make('foo')
        cl.list$(
          { limit$: -1, sort$: { p1: 1 } },
          verify(done, function (lst) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should not save modifications to entity after save completes', function (done) {
        var foo = si.make('foo')
        foo.int_arr = [37]
        foo.save$(
          verify(done, function (foo1) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should not backport modification to saved entity to the original one', function (done) {
        var foo = si.make('foo')
        foo.int_arr = [37]
        foo.save$(
          verify(done, function (foo1) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        (fin) =>
          new Promise((fin) => {
            si.make('racers')
              .data$({
                username: 'bob',

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        () =>
          new Promise((fin) => {
            si.make('racers')
              .data$({
                username: 'richard',

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        cl.remove$({ sort$: { p1: 1 } }, function (err) {
          if (err) {
            return done(err)
          }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        cl.remove$({ sort$: { p1: -1 } }, function (err) {
          if (err) {
            return done(err)
          }

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

          function (err) {
            if (err) {
              return done(err)
            }

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

          function (err) {
            if (err) {
              return done(err)
            }

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

        cl.remove$({ limit$: 1, skip$: 1, sort$: { p1: 1 } }, function (err) {
          if (err) {
            return done(err)
          }

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

        cl.remove$({ limit$: 2, sort$: { p1: 1 } }, function (err) {
          if (err) {
            return done(err)
          }

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

        cl.remove$({ skip$: -1, sort$: { p1: 1 } }, function (err) {
          if (err) {
            return done(err)
          }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should support limit, skip and sort', function (done) {
        var cl = si.make('foo')
        cl.list$(
          { limit$: 1, skip$: 1, sort$: { p1: 1 } },
          verify(done, function (lst) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should return correct number of records if limit is too high', function (done) {
        var cl = si.make('foo')
        cl.list$(
          { limit$: 5, skip$: 2, sort$: { p1: 1 } },
          verify(done, function (lst) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

          .save$({ upsert$: ['id'] }, (err) => {
            if (err) {
              return fin(err)
            }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          .save$({ upsert$: ['id'] }, (err) => {
            if (err) {
              return fin(err)
            }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          .save$({ upsert$: ['id', 'username'] }, (err) => {
            if (err) {
              return fin(err)
            }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

          .save$({ upsert$: ['id', 'username'] }, (err) => {
            if (err) {
              return fin(err)
            }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should ignore limit < 0', function (done) {
        var cl = si.make('foo')
        cl.load$(
          { limit$: -1, sort$: { p1: 1 } },
          verify(done, function (foo) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should ignore skip < 0', function (done) {
        var cl = si.make('foo')
        cl.load$(
          { skip$: -1, sort$: { p1: 1 } },
          verify(done, function (foo) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should support skip and sort', function (done) {
        var cl = si.make('foo')
        cl.load$(
          { skip$: 1, sort$: { p1: 1 } },
          verify(done, function (foo) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should not be influenced by limit', function (done) {
        var cl = si.make('foo')
        cl.load$(
          { limit$: 2, sort$: { p1: 1 } },
          verify(done, function (foo) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        foo.load$(
          { p1: 'v2' },
          verify(done, function (foo1) {
            Assert.isNotNull(foo1)
            Assert.equal(foo1.id, 'foo2')

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        () =>
          new Promise((fin) => {
            si.make('players')
              .data$({ username: 'richard', points: 0 })
              .save$((err, user) => {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        foo.load$(
          { p2: 'z2' },
          verify(done, function (foo1) {
            Assert.ok(foo1)
            Assert.equal(foo1.id, 'foo2')

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        (fin) =>
          new Promise((fin) => {
            si.make('players')
              .data$({ username: 'bob', points: 0 })
              .save$((err, user) => {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            si.make('products').list$({}, (err, products) => {
              if (err) {
                return fin(err)
              }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function make_it(lab) {
  return function it(name, opts, func) {
    if ('function' === typeof opts) {
      func = opts
      opts = {}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

          user_entity.list$((err, users) => {
            if (err) {
              return fin(err)
            }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          verify(done, function (res) {
            Assert.lengthOf(res, 1)
            Assert.equal(res[0].p1, 'v2')
            Assert.equal(res[0].p2, 'z2')
            Assert.equal(res[0].p3)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          verify(done, function (res) {
            Assert.lengthOf(res, 1)
            Assert.equal(res[0].p1, 'v2')
            Assert.equal(res[0].p2, 'z2')
            Assert.equal(res[0].p3)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  if (isJsonMaybe(bar.arr)) {
    expect(JSON.parse(bar.arr)).to.equal(expected_arr)
  } else {
    expect(bar.arr).to.equal(expected_arr)
  }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  if (isJsonMaybe(bar.obj)) {
    expect(JSON.parse(bar.obj)).to.equal(expected_obj)
  } else {
    expect(bar.obj).to.equal(expected_obj)
  }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

          function (err) {
            if (err) {
              return done(err)
            }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        cl.remove$({ all$: true, limit$: 2, skip$: 3 }, function (err) {
          if (err) {
            return done(err)
          }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    it('check setup correctly', function (done) {
      var cl = si.make('foo')
      cl.list$(
        {},
        verify(done, function (lst) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      it('should load all elements if no params 2', function (done) {
        var foo = si.make('foo')
        foo.list$(
          {},
          verify(done, function (res) {

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('customers')
              .data$({

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('products')
              .data$({

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('customers')
              .data$({

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('products')
              .data$({

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('players')
              .data$({

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('players')
              .data$({

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('customers')
              .data$({

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('users')
              .data$({ username: 'richard', email: 'rr@example.com' })

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('players')
              .data$({ username: 'bob', points: 1000 })

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('products')
              .data$({ label: 'toothbrush', price: '3.95' })

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('players')
              .data$({ username: 'bob', points: 1000 })

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('products')
              .data$({ label: 'a toothbrush', price: '3.40' })

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('products')
              .data$({ label: 'capuccino', price: '7.99' })

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

      beforeEach(
        () =>
          new Promise((fin) => {
            si.make('users')
              .data$({ username: 'richard', email: 'rr@example.com' })

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

          verify(done, function (foo1) {
            Assert.isNotNull(foo1)
            Assert.equal(foo1.id, 'foo1')
            Assert.equal(foo1.p1, 'v1')
          })

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

          verify(done, function (res) {
            Assert.ok(res)
            Assert.equal(res.p1, 'v2')
            Assert.equal(res.p2, 'z2')
          })

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        foo.remove$('foo1', function (err, res) {
          Assert.isNull(err)

          foo.list$(
            {},

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        foo.remove$({ p1: 'v1', p2: 'z2' }, function (err) {
          Assert.isNull(err)

          foo.list$(
            {},

• Read up
  Read up