ZeroTierOne/ext/librethinkdbxx/test/upstream/changefeeds/edge.yaml

desc: Test edge cases of changefeed operations
table_variable_name: tbl
tests:

    - def: common_prefix = r.expr([0,1,2,3,4,5,6,7,8])

    - js: tbl.indexCreate('sindex', function (row) { return common_prefix.append(row('value')); })
      py: tbl.index_create('sindex', lambda row:common_prefix.append(row['value']))
      rb: tbl.index_create('sindex'){ |row| common_prefix.append(row['value']) }
      ot: ({'created':1})
    - cd: tbl.index_wait('sindex')

    # create target values
    - cd: pre = r.range(7).coerce_to('array').add(r.range(10,70).coerce_to('array')).append(100).map(r.row.coerce_to('string'))
      rb: pre = r.range(7).coerce_to('array').add(r.range(10,70).coerce_to('array')).append(100).map{ |row| row.coerce_to('string') }
    - cd: mid = r.range(2,9).coerce_to('array').add(r.range(20,90).coerce_to('array')).map(r.row.coerce_to('string'))
      rb: mid = r.range(2,9).coerce_to('array').add(r.range(20,90).coerce_to('array')).map{ |row| row.coerce_to('string') }
    - cd: post = r.range(3,10).coerce_to('array').add(r.range(30,100).coerce_to('array')).map(r.row.coerce_to('string'))
      rb: post = r.range(3,10).coerce_to('array').add(r.range(30,100).coerce_to('array')).map{ |row| row.coerce_to('string') }

    - cd: erroredres = r.range(2).coerce_to('array').add(r.range(10, 20).coerce_to('array')).append(100).map(r.row.coerce_to('string'))
      rb: erroredres = r.range(2).coerce_to('array').add(r.range(10, 20).coerce_to('array')).append(100).map{ |val| val.coerce_to('string') }

    # Start overlapping changefeeds
    - js: pre_changes = tbl.between(r.minval, commonPrefix.append('7'), {index:'sindex'}).changes({squash:false}).limit(pre.length)('new_val')('value')
      py: pre_changes = tbl.between(r.minval, common_prefix.append('7'), index='sindex').changes(squash=False).limit(len(pre))['new_val']['value']
      rb: pre_changes = tbl.between(r.minval, common_prefix.append('7'), index:'sindex').changes(squash:false).limit(pre.length)['new_val']['value']
    - js: mid_changes = tbl.between(commonPrefix.append('2'), common_prefix.append('9'), {index:'sindex'}).changes({squash:false}).limit(post.length)('new_val')('value')
      py: mid_changes = tbl.between(common_prefix.append('2'), common_prefix.append('9'), index='sindex').changes(squash=False).limit(len(post))['new_val']['value']
      rb: mid_changes = tbl.between(common_prefix.append('2'), common_prefix.append('9'), index:'sindex').changes(squash:false).limit(post.length)['new_val']['value']
    - js: post_changes = tbl.between(commonPrefix.append('3'), r.maxval, {index:'sindex'}).changes({squash:false}).limit(mid.length)('new_val')('value')
      py: post_changes = tbl.between(common_prefix.append('3'), r.maxval, index='sindex').changes(squash=False).limit(len(mid))['new_val']['value']
      rb: post_changes = tbl.between(common_prefix.append('3'), r.maxval, index:'sindex').changes(squash:false).limit(mid.length)['new_val']['value']

    # Start changefeeds with non-existence errors

    - js: premap_changes1 = tbl.map(r.branch(r.row('value').lt('2'), r.row, r.row("dummy"))).changes({squash:false}).limit(erroredres.length)('new_val')('value')
      py: premap_changes1 = tbl.map(r.branch(r.row['value'].lt('2'), r.row, r.row["dummy"])).changes(squash=False).limit(len(erroredres))['new_val']['value']
      rb: premap_changes1 = tbl.map{ |row| r.branch(row['value'].lt('2'), row, row["dummy"]) }.changes(squash:false).limit(erroredres.length)['new_val']['value']

    - js: postmap_changes1 = tbl.changes({squash:false}).map(r.branch(r.row('new_val')('value').lt('2'), r.row, r.row("dummy"))).limit(erroredres.length)('new_val')('value')
      py: postmap_changes1 = tbl.changes(squash=False).map(r.branch(r.row['new_val']['value'].lt('2'), r.row, r.row["dummy"])).limit(len(erroredres))['new_val']['value']
      rb: postmap_changes1 = tbl.changes(squash:false).map{ |row| r.branch(row['new_val']['value'].lt('2'), row, row["dummy"]) }.limit(erroredres.length)['new_val']['value']

    - js: prefilter_changes1 = tbl.filter(r.branch(r.row('value').lt('2'), true, r.row("dummy"))).changes({squash:false}).limit(erroredres.length)('new_val')('value')
      py: prefilter_changes1 = tbl.filter(r.branch(r.row['value'].lt('2'), True, r.row["dummy"])).changes(squash=False).limit(len(erroredres))['new_val']['value']
      rb: prefilter_changes1 = tbl.filter{ |row| r.branch(row['value'].lt('2'), true, row["dummy"]) }.changes(squash:false).limit(erroredres.length)['new_val']['value']

    - js: postfilter_changes1 = tbl.changes({squash:false}).filter(r.branch(r.row('new'+'_'+'val')('value').lt('2'), true, r.row("dummy"))).limit(erroredres.length)('new_val')('value')
      py: postfilter_changes1 = tbl.changes(squash=False).filter(r.branch(r.row['new_val']['value'].lt('2'), True, r.row["dummy"])).limit(len(erroredres))['new_val']['value']
      rb: postfilter_changes1 = tbl.changes(squash:false).filter{ |row| r.branch(row['new_val']['value'].lt('2'), true, row["dummy"]) }.limit(erroredres.length)['new_val']['value']

    # Start changefeeds with runtime errors 

    - js: premap_changes2 = tbl.map(r.branch(r.row('value').lt('2'), r.row, r.expr([]).nth(1))).changes({squash:false}).limit(erroredres.length)('new_val')('value')
      py: premap_changes2 = tbl.map(r.branch(r.row['value'].lt('2'), r.row, r.expr([])[1])).changes(squash=False).limit(len(erroredres))['new_val']['value']
      rb: premap_changes2 = tbl.map{ |row| r.branch(row['value'].lt('2'), row, r.expr([])[1]) }.changes(squash:false).limit(erroredres.length)['new_val']['value']

    - js: postmap_changes2 = tbl.changes({squash:false}).map(r.branch(r.row('new'+'_'+'val')('value').lt('2'), r.row, r.expr([]).nth(1))).limit(erroredres.length)('new_val')('value')
      py: postmap_changes2 = tbl.changes(squash=False).map(r.branch(r.row['new_val']['value'].lt('2'), r.row, r.expr([])[1])).limit(len(erroredres))['new_val']['value']
      rb: postmap_changes2 = tbl.changes(squash:false).map{ |row| r.branch(row['new_val']['value'].lt('2'), row, r.expr([])[1]) }.limit(erroredres.length)['new_val']['value']

    - js: prefilter_changes2 = tbl.filter(r.branch(r.row('value').lt('2'), true, r.expr([]).nth(1))).changes({squash:false}).limit(erroredres.length)('new_val')('value')
      py: prefilter_changes2 = tbl.filter(r.branch(r.row['value'].lt('2'), True, r.expr([])[1])).changes(squash=False).limit(len(erroredres))['new_val']['value']
      rb: prefilter_changes2 = tbl.filter{ |row| r.branch(row['value'].lt('2'), true, r.expr([])[1]) }.changes(squash:false).limit(erroredres.length)['new_val']['value']

    - js: postfilter_changes2 = tbl.changes({squash:false}).filter(r.branch(r.row('new'+'_'+'val')('value').lt('2'), true, r.expr([]).nth(1))).limit(erroredres.length)('new_val')('value')
      py: postfilter_changes2 = tbl.changes(squash=False).filter(r.branch(r.row['new_val']['value'].lt('2'), True, r.expr([])[1])).limit(len(erroredres))['new_val']['value']
      rb: postfilter_changes2 = tbl.changes(squash:false).filter{ |row| r.branch(row['new_val']['value'].lt('2'), true, r.expr([])[1]) }.limit(erroredres.length)['new_val']['value']

    # Start non-deterministic changefeeds - very small chance of these hanging due to not enough results
    - def:
        py: nondetermmap = r.branch(r.random().gt(0.5), r.row, r.error("dummy"))
        js: nondetermmap = function (row) { return r.branch(r.random().gt(0.5), row, r.error("dummy")); }
        rb: nondetermmap = Proc.new { |row| r.branch(r.random().gt(0.5), row, r.error("dummy")) }
    - def:
        py: nondetermfilter = lambda row:r.random().gt(0.5)
        js: nondetermfilter = function (row) { return r.random().gt(0.5); }
        rb: nondetermfilter = Proc.new { |row| r.random().gt(0.5) }

    - rb: tbl.map(nondetermmap).changes(squash:false)
      js: tbl.map(nondetermmap).changes({squash:false})
      py: tbl.map(nondetermmap).changes(squash=False)
      ot: err('ReqlQueryLogicError', 'Cannot call `changes` after a non-deterministic function.')

    - rb: postmap_changes3 = tbl.changes(squash:false).map(nondetermmap).limit(100)
      js: postmap_changes3 = tbl.changes({squash:false}).map(nondetermmap).limit(100)
      py: postmap_changes3 = tbl.changes(squash=False).map(nondetermmap).limit(100)

    - rb: tbl.filter(nondetermfilter).changes(squash:false)
      js: tbl.filter(nondetermfilter).changes({squash:false})
      py: tbl.filter(nondetermfilter).changes(squash=False)
      ot: err('ReqlQueryLogicError', 'Cannot call `changes` after a non-deterministic function.')

    - rb: postfilter_changes3 = tbl.changes(squash:false).filter(nondetermfilter).limit(4)
      js: postfilter_changes3 = tbl.changes({squash:false}).filter(nondetermfilter).limit(4)
      py: postfilter_changes3 = tbl.changes(squash=False).filter(nondetermfilter).limit(4)

    # Insert several rows that will and will not be returned
    - cd: tbl.insert(r.range(101).map({'id':r.uuid().coerce_to('binary').slice(0,r.random(4,24)).coerce_to('string'),'value':r.row.coerce_to('string')}))
      rb: tbl.insert(r.range(101).map{ |row| {'id'=>r.uuid().coerce_to('binary').slice(0,r.random(4,24)).coerce_to('string'),'value'=>row.coerce_to('string')}})
      ot: ({'skipped':0,'deleted':0,'unchanged':0,'errors':0,'replaced':0,'inserted':101})

    # Check that our limited watchers have been satified
    - cd: pre_changes
      ot: bag(pre)

    - cd: mid_changes
      ot: bag(mid)

    - cd: post_changes
      ot: bag(post)

    - cd: premap_changes1
      ot: bag(erroredres)

    - cd: premap_changes2
      ot: bag(erroredres)

    - cd: postmap_changes1
      ot: err('ReqlNonExistenceError', "No attribute `dummy` in object:")

    - cd: postmap_changes2
      ot: err('ReqlNonExistenceError', "Index out of bounds:" + " 1")

    - cd: postmap_changes3
      ot: err('ReqlUserError', "dummy")

    - cd: prefilter_changes1
      ot: bag(erroredres)

    - cd: prefilter_changes2
      ot: bag(erroredres)

    - cd: postfilter_changes1
      ot: bag(erroredres)

    - cd: postfilter_changes2
      ot: bag(erroredres)

    - ot: arrlen(postfilter_changes3)
      ot: 4