test.js

'use strict'

var test = require('tape')
var bloomrun = require('./')

test('null is returned if pattern is not found', function (t) {
  t.plan(3)

  var instance = bloomrun()
  var pattern = { cmd: 'set-policy' }

  t.equal(instance.lookup(pattern), null)
  t.equal(instance.lookup([]), null)
  t.equal(instance.lookup(new Date()), null)
})

test('pattern is returned on match', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = { cmd: 'set-policy' }

  instance.add(pattern)

  t.deepEqual(instance.lookup(pattern), pattern)
})

test('default match is supported', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var payload = { cmd: 'set-policy' }

  instance.default(payload)

  t.deepEqual(instance.lookup({foo: 'bar'}), payload)
})

test('payload is returned instead of pattern if it exists', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = { prefs: 'userId' }
  var payload = '1234'

  instance.add(pattern, payload)

  t.deepEqual(instance.lookup(pattern), payload)
})

test('regexp support in the pattern', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = { prefs: /user.*/ }
  var payload = '1234'

  instance.add(pattern, payload)

  t.deepEqual(instance.lookup({ prefs: 'userId' }), payload)
})

test('regexp plus props support in the pattern', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = { cmd: 'save', prefs: /user.*/ }
  var payload = '1234'

  instance.add(pattern, payload)

  t.deepEqual(instance.lookup({ cmd: 'save', prefs: 'userId' }), payload)
})

test('functions are supported as payloads', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = { prefs: 'userId' }
  var payload = function () { return '1234' }

  instance.add(pattern, payload)

  t.deepEqual(instance.lookup(pattern)(), payload())
})

test('partial matching should not be supported', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var pattern = {
    cmd: 'add-user',
    username: 'mcollina'
  }

  instance.add(pattern)

  t.notOk(instance.lookup({ cmd: 'add-user' }))
  t.notOk(instance.lookup({ username: 'mcollina' }))
})

// see https://github.com/mcollina/bloomrun/issues/18
test('do not match if not fully matching - #18', function (t) {
  t.plan(1)

  var instance = bloomrun()

  instance.add({ role: 'auth', cmd: 'login' }, 42)

  instance.add({ role: 'auth', query: 'isAuthenticated' }, 24)

  t.equal(instance.lookup({
    role: 'auth', query: 'isAuthenticated'
  }), 24)
})

test('multiple matches are supported', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var firstPattern = {
    group: '123',
    userId: 'ABC'
  }
  var secondPattern = {
    group: '123',
    userId: 'ABC'
  }

  instance.add(firstPattern)
  instance.add(secondPattern)

  t.deepEqual(instance.list({ group: '123', userId: 'ABC' }), [firstPattern, secondPattern])
})

test('iterator based retrieval is supported', function (t) {
  t.plan(3)

  var instance = bloomrun()
  var pattern1 = { hello: 'world' }
  var pattern2 = { hello: 'world' }

  instance.add(pattern1)
  instance.add(pattern2)

  var iterator = instance.iterator({ hello: 'world' })

  t.equal(iterator.next(), pattern1)
  t.equal(iterator.next(), pattern2)

  t.notOk(iterator.next())
})

test('removing patterns is supported', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var pattern = { group: '123' }

  instance.add(pattern)

  t.deepEqual(instance.lookup({ group: '123' }), pattern)

  instance.remove(pattern)

  t.equal(instance.lookup({ group: '123' }), null)
})

test('removing regex pattern without other keys is supported', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var pattern = { to: /.*/ }

  instance.add(pattern)

  t.deepEqual(instance.lookup({ to: 'you' }), pattern)

  instance.remove(pattern)

  t.equal(instance.lookup({ to: 'you' }), null)
})

test('removing regex pattern without other keys is supported - wildcard case', function (t) {
  t.plan(3)

  var instance = bloomrun()
  var regExPattern1 = { to: /^[a-zA-Z0-9-.]+$/i }
  var regExPattern2 = { to: /^[0-9]+$/i }

  instance.add(regExPattern1)
  instance.add(regExPattern2)

  t.deepEqual(instance.lookup({ to: 'you' }), regExPattern1)

  instance.remove(regExPattern1)

  t.equal(instance.lookup({ to: 'you' }), null)
  // second pattern should be still there because it doesn't match
  t.ok(instance.lookup({ to: '123' }))
})

test('remove deletes all matches', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var pattern = { group: '123' }

  instance.add(pattern)
  instance.add(pattern, 'TEST')

  t.deepEqual(instance.list({ group: '123' }), [pattern, 'TEST'])

  instance.remove(pattern)

  t.equal(instance.lookup({ group: '123' }), null)
})

test('payload is considered when removing', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var pattern = { group: '123' }

  instance.add(pattern, 'XYZ')
  instance.add(pattern, '567')

  t.deepEqual(instance.list({ group: '123' }), ['XYZ', '567'])

  instance.remove(pattern, '567')

  t.equal(instance.lookup({ group: '123' }), 'XYZ')
})

test('complex payloads are matched correctly', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var pattern = { group: '123' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern, payloadOne)
  instance.add(pattern, payloadTwo)
  instance.add(pattern, '567')

  t.deepEqual(instance.list({ group: '123' }), [payloadOne, payloadTwo, '567'])

  instance.remove(pattern, payloadOne)
  instance.remove(pattern, payloadTwo)

  t.equal(instance.lookup({ group: '123' }), '567')
})

test('removing causes filters to be rebuilt', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var firstPattern = { group: '123' }
  var secondPattern = { group: '123' }

  instance.add(firstPattern, 42)
  instance.add(secondPattern, 24)

  t.equal(instance.lookup({ group: '123' }), 42)

  instance.remove(firstPattern, 42)

  t.equal(instance.lookup({ group: '123' }), 24)
})

test('patterns can be listed while using payloads', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = { group: '123' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern, payloadOne)
  instance.add(pattern, payloadTwo)

  t.deepEqual(instance.list({ group: '123' }, { patterns: true }), [pattern, pattern])
})

test('patterns can be looked up while using payloads', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern1 = { group: '123' }
  var pattern2 = { group: '123' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern1, payloadOne)
  instance.add(pattern2, payloadTwo)

  t.equal(instance.lookup({ group: '123' }, { patterns: true }), pattern1)
})

test('iterators can be used to fetch only patterns', function (t) {
  t.plan(3)

  var instance = bloomrun()
  var pattern1 = { group: '123' }
  var pattern2 = { group: '123' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern1, payloadOne)
  instance.add(pattern2, payloadTwo)

  var iterator = instance.iterator({ group: '123' }, { patterns: true })

  t.equal(iterator.next(), pattern1)
  t.equal(iterator.next(), pattern2)
  t.equal(iterator.next(), null)
})

test('listing all payloads', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern1 = { group: '123', userId: 'ABC' }
  var pattern2 = { group: '123', userId: 'DEF' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern1, payloadOne)
  instance.add(pattern2, payloadTwo)

  t.deepEqual(instance.list(), [payloadOne, payloadTwo])
})

test('listing all patterns', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern1 = { group: '123', userId: 'ABC' }
  var pattern2 = { group: '123', userId: 'DEF' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern1, payloadOne)
  instance.add(pattern2, payloadTwo)

  t.deepEqual(instance.list(null, { patterns: true }), [pattern1, pattern2])
})

test('matching numbers', function (t) {
  t.plan(2)

  var instance = bloomrun()
  var pattern = {
    something: 'else',
    answer: 42
  }

  instance.add(pattern)

  t.deepEqual(instance.lookup(pattern), pattern)
  t.deepEqual(instance.list(pattern), [pattern])
})

test('order support', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern1 = { group: '123' }
  var pattern2 = { group: '123', another: 'value' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern1, payloadOne)
  instance.add(pattern2, payloadTwo)

  t.equal(instance.lookup({ group: '123', another: 'value' }), payloadOne)
})

test('depth support', function (t) {
  t.plan(1)

  var instance = bloomrun({ indexing: 'depth' })
  var pattern1 = { group: '123' }
  var pattern2 = { group: '123', another: 'value' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern1, payloadOne)
  instance.add(pattern2, payloadTwo)

  t.equal(instance.lookup({ group: '123', another: 'value' }), payloadTwo)
})

test('boolean matching', function (t) {
  t.plan(5)

  var instance = bloomrun()
  var s1 = { say: true }
  var s2 = { say: false }

  instance.add(s1)
  instance.add(s2)
  instance.default('Global')

  t.deepEqual(instance.lookup({ say: true }), s1, 'copied equivalence on s1')
  t.deepEqual(instance.lookup(s1), s1, '=== equivalence on s1')
  t.deepEqual(instance.lookup({ say: false }), s2, 'copied equivalence on s2')
  t.deepEqual(instance.lookup(s2), s2, '=== equivalence on s2')
  t.deepEqual(instance.lookup({ hello: 'world' }), 'Global')
})

test('mad string equality', function (t) {
  t.plan(2)

  var instance = bloomrun()

  instance.add({
    to: '1',
    some: 'pattern'
  }, 'first')

  instance.add({
    to: '2',
    some: 'pattern'
  }, 'second')

  t.deepEqual(instance.lookup({ to: '1', some: 'pattern' }), 'first')
  t.deepEqual(instance.lookup({ to: '2', some: 'pattern' }), 'second')
})

test('List matches partially, regardless of key order (1)', function (t) {
  t.plan(1)
  var instance = bloomrun({ indexing: 'depth' })

  instance.add({ c: 'CCC' }, 1)
  instance.add({ b: 'BBB' }, 2)
  instance.add({ a: 'AAA', b: 'BBB', c: 'CCC' }, 3)
  instance.add({ a: 'AAA' }, 4)

  t.deepEqual(instance.list({ a: 'AAA', b: 'BBB', c: 'CCC', d: 'DDD' }), [
    3,
    1,
    2,
    4
  ])
})

test('List matches partially, regardless of key order (2)', function (t) {
  t.plan(1)
  var instance = bloomrun({ indexing: 'depth' })

  instance.add({ c: 'CCC' }, 2)
  instance.add({ c: 'CCC', d: 'DDD' }, 1)
  instance.add({ a: 'AAA' }, 3)

  t.deepEqual(instance.list({ a: 'AAA', b: 'BBB', c: 'CCC', d: 'DDD' }), [
    1,
    2,
    3
  ])
})

test('List matches partially, in key order (2)', function (t) {
  t.plan(1)
  var instance = bloomrun()

  instance.add({ c: 'CCC' }, 2)
  instance.add({ c: 'CCC', d: 'DDD' }, 1)
  instance.add({ a: 'AAA' }, 3)

  t.deepEqual(instance.list({ a: 'AAA', b: 'BBB', c: 'CCC', d: 'DDD' }), [
    2,
    1,
    3
  ])
})

test('patterns and data can be listed while using payloads', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = { group: '123' }

  function payloadOne () { }
  function payloadTwo () { }

  instance.add(pattern, payloadOne)
  instance.add(pattern, payloadTwo)

  t.deepEqual(instance.list({ group: '123' }, { patterns: true, payloads: true }), [{
    pattern: pattern,
    payload: payloadOne
  }, {
    pattern: pattern,
    payload: payloadTwo
  }])
})

test('list should return the default', function (t) {
  t.plan(3)

  var instance = bloomrun()
  var payload = { cmd: 'set-policy' }

  instance.default(payload)

  t.deepEqual(instance.list(), [payload])
  t.deepEqual(instance.list(null, { patterns: true }), [])
  t.deepEqual(instance.list(null, { patterns: true, payloads: true }), [{
    default: true,
    payload: payload
  }])
})

test('issue#46 - pattern is not equals', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var pattern = {
    topic: 'math',
    cmd: 'add1'
  }
  var payload = '1234'

  instance.add(pattern, payload)

  var pattern2 = {
    topic: 'math',
    cmd: 'add10'
  }

  t.deepEqual(instance.lookup(pattern2), null)
})

test('issue#55 - unexpected behaviour using indexing:depth', function (t) {
  t.plan(2)

  var instance = bloomrun({ indexing: 'depth' })
  instance.add({ role: 'tag', cmd: 'find' }, 'tag,find')
  instance.add({ role: 'location', cmd: 'find' }, 'location,find')

  instance.add({ role: 'tag', cmd: 'find', count: /.*/ }, 'tag,find,count')
  instance.add({ role: 'location', cmd: 'find', count: /.*/ }, 'location,find,count')

  t.deepEqual(instance.lookup({ role: 'location', cmd: 'find', count: 'true' }), 'location,find,count')
  t.deepEqual(instance.lookup({ role: 'location', cmd: 'find' }), 'location,find')
})

test('issue#57 - Removing many pattern should not lead to finite recursion', function (t) {
  t.plan(1)

  var instance = bloomrun()
  var noop = function () { return 'test' }

  instance.add({ topic: 'math', cmd: 'add1' }, noop)
  instance.add({ topic: 'math', cmd: 'add2' }, noop)
  instance.add({ topic: 'math', cmd: 'add3' }, noop)
  instance.add({ topic: 'math', cmd: 'add4' }, noop)
  instance.add({ topic: 'math', cmd: 'add5' }, noop)
  instance.add({ topic: 'math', cmd: 'add6' }, noop)
  instance.add({ topic: 'math', cmd: 'add7' }, noop)
  instance.add({ topic: 'math', cmd: 'add8' }, noop)
  instance.add({ topic: 'math', cmd: 'add9' }, noop)
  instance.add({ topic: 'math', cmd: 'add10' }, noop)
  instance.add({ topic: 'math', cmd: 'add11' }, noop)
  instance.add({ topic: 'math', cmd: 'add12' }, noop)
  instance.add({ topic: 'math', cmd: 'add13' }, noop)
  instance.add({ topic: 'math', cmd: 'add14' }, noop)
  instance.add({ topic: 'math', cmd: 'add15' }, noop)
  instance.add({ topic: 'math', cmd: 'add16' }, noop)
  instance.add({ topic: 'math', cmd: 'add17' }, noop)

  instance.list(null, {
    patterns: true
  }).forEach(function (element) {
    instance.remove(element)
  })

  t.deepEqual(instance.list().length, 0)
})

test('issue#64 - Add `for of` support for iterator', function (t) {
  t.plan(3)

  var instance = bloomrun()

  var patterns = [{ hello: 'world', num: 0 }, { hello: 'world', num: 1 }, { hello: 'world', num: 2 }]

  for (var pattern of patterns) {
    instance.add(pattern)
  }

  var iterator = instance.iterator()

  var index = 0
  for (var it of iterator) {
    t.equal(it, patterns[index++])
  }
})

test('`for of` support for main bloomrun object', function (t) {
  t.plan(3)

  var instance = bloomrun()

  var patterns = [{ hello: 'world', num: 0 }, { hello: 'world', num: 1 }, { hello: 'world', num: 2 }]

  for (var pattern of patterns) {
    instance.add(pattern)
  }

  var index = 0
  for (var it of instance) {
    t.equal(it, patterns[index++])
  }
})