def test_delete_multiple(self, conn):
expected = [{
'id': 'sally-id',
'name': 'sally'
}, {
'id': 'joe-id',
'name': 'joe'
}]
expected_changes = [{
'old_val': {
'id': 'sam-id',
'name': 'sam'
},
'new_val': None
}, {
'old_val': {
'id': 'tom-id',
'name': 'tom'
},
'new_val': None
}]
report = r.db('ephemeral').table('people').get_all(
'sam-id', 'tom-id').delete(return_changes=True).run(conn)
assertEqUnordered(expected_changes, report['changes'])
assertEqual(2, report['deleted'])
result = r.db('ephemeral').table('people').run(conn)
assertEqUnordered(expected, list(result))
def test_insert_one(self, conn):
expected = [{
'id': 'kermit-id',
'species': 'frog',
'name': 'Kermit'
}, {
'id': 'piggy-id',
'species': 'pig',
'name': 'Ms. Piggy'
}, {
'id': 'elmo-id',
'species': 'methhead',
'name': 'Elmo'
}]
elmo_doc = {'id': 'elmo-id', 'species': 'methhead', 'name': 'Elmo'}
expected_changes = [{'old_val': None, 'new_val': elmo_doc}]
result_obj = r.db('things').table('muppets').insert(
elmo_doc, return_changes=True).run(conn)
assertEqual(result_obj['changes'], expected_changes)
result = r.db('things').table('muppets').run(conn)
assertEqUnordered(expected, list(result))
def test_error1(self, conn):
try:
r.error('msg').run(conn)
except RqlRuntimeError as err:
rql_err = err
assertEqual('msg', err.message)
assert (isinstance(rql_err, RqlRuntimeError))
def test_update_merge_deep(self, conn):
# this behavior is pretty weird, but it's what rethink does
expected = {
'id': 'one',
'points': {
'pt1': {
'x': 'x-1',
'y': 'y-1'
}
},
'pt1': {
'x': 'x-1',
'y': 'y-1',
'z': 'z-1'
}
}
r.db('things').table('points').filter({
'id': 'one'
}).update(r.row['points'].merge({'pt1': {
'z': 'z-1'
}})).run(conn)
result = r.db('things').table('points').get('one').run(conn)
pprint({'merge_deep': result})
assertEqual(expected, result)
def test_error1(self, conn):
try:
r.error('msg').run(conn)
except RqlRuntimeError as err:
rql_err = err
assertEqual('msg', err.message)
assert(isinstance(rql_err, RqlRuntimeError))
def test_index_drop_works(self, conn):
r.db('s').table('people').index_create('last_name').run(conn)
indexes = list(r.db('s').table('people').index_list().run(conn))
assertEqual(['last_name'], indexes)
r.db('s').table('people').index_drop('last_name').run(conn)
indexes = list(r.db('s').table('people').index_list().run(conn))
assertEqual([], indexes)
def test_filter_by_bracket(self, conn):
res = r.db('x').table('farms').filter(
lambda doc: doc['id'] < 2
).run(conn)
expected = [1]
results = [doc['id'] for doc in res]
assertEqual(expected, results)
def test_ungroup_grouped_by_func(self, conn):
expected = [
{
'group': 'bro',
'reduction': [
{'id': 'joe', 'type': 'bro'},
{'id': 'sam', 'type': 'bro'}
]
},
{
'group': 'hipster',
'reduction': [
{'id': 'bill', 'type': 'hipster'},
{'id': 'todd', 'type': 'hipster'}
]
},
{
'group': 'unknown',
'reduction': [
{'id': 'glenn', 'type': 'unknown'},
]
}
]
result = r.db('x').table('people').group(lambda d: d['type']).ungroup().run(conn)
result = list(result)
assertEqual(3, len(result))
assertEqual(set(['bro', 'hipster', 'unknown']), set([doc['group'] for doc in result]))
is_group = lambda group: lambda doc: doc['group'] == group
for group in ('bro', 'hipster', 'unknown'):
result_group = list(filter(is_group(group), result))[0]
expected_group = list(filter(is_group(group), expected))[0]
assertEqUnordered(expected_group['reduction'], result_group['reduction'])
def test_eq(self, conn):
expected = [
{'id': 'sam'}
]
result = r.db('pdb').table('p').filter(
lambda doc: doc['hair_color'] == 'bald'
).pluck('id').run(conn)
assertEqual(expected, list(result))
def test_reduce_1(self, conn):
expected = 191
result = r.db('d').table('nums').map(
lambda doc: doc['points']
).reduce(
lambda elem, acc: elem + acc
).run(conn)
assertEqual(expected, result)
def test_sort_1_attr_2_desc(self, conn):
expected = [
{'id': 'bill', 'age': 35, 'score': 78},
{'id': 'joe', 'age': 26, 'score': 60},
{'id': 'todd', 'age': 52, 'score': 15},
]
result = r.db('y').table('scores').order_by(r.desc('score')).run(conn)
assertEqual(expected, list(result))
def test_epoch_time(self, conn):
results = r.db('d').table('people').map(lambda d: d.merge(
{'as_epoch': d['last_updated'].to_epoch_time()})).run(conn)
results = list(results)
jan1 = datetime.datetime(1970, 1, 1, tzinfo=r.make_timezone('00:00'))
for doc in results:
expected = int((doc['last_updated'] - jan1).total_seconds())
assertEqual(expected, doc['as_epoch'])
def test_day_of_week(self, conn):
expected = set([
1, # 2014 August 25 -> Monday
2 # 2014 June 3 -> Tuesday
])
result = r.db('d').table('people').map(
lambda doc: doc['last_updated'].day_of_week()).run(conn)
assertEqual(expected, set(list(result)))
def test_distinct_secondary_index(self, conn):
r.db('d').table('people').index_create('last_name').run(conn)
r.db('d').table('people').index_wait().run(conn)
result = r.db('d').table('people').distinct(index='last_name').run(conn)
result = list(result)
pprint({'result': result})
assertEqual(2, len(result))
assertEqual(set(['Sanders', 'Fudd']), set(result))
def test_sum_of_seq_field(self, conn):
expected = [93]
result = r.db('x').table('people').filter({
'id': 'todd'
}).map(
lambda doc: doc['nums2'].sum('val')
).run(conn)
assertEqual(expected, list(result))
def test_and(self, conn):
expected = [
{'id': 'sam'}
]
result = r.db('pdb').table('p').filter(
lambda doc: doc['has_eyes'].and_(doc['age'].lt(20))
).pluck('id').run(conn)
assertEqual(expected, list(result))
def test_date(self, conn):
expected = set([
datetime.datetime(2014, 8, 25, tzinfo=r.make_timezone('00:00')),
datetime.datetime(2014, 6, 3, tzinfo=r.make_timezone('00:00'))
])
result = r.db('d').table('people').map(
lambda doc: doc['last_updated'].date()).run(conn)
assertEqual(expected, set(list(result)))
def test_index_wait_one_works(self, conn):
expected = [{'id': 'bob', 'first_name': 'Bob', 'last_name': 'Builder'}]
r.db('s').table('people').index_create('last_name').run(conn)
r.db('s').table('people').index_wait('last_name').run(conn)
result = r.db('s').table('people').get_all('Builder',
index='last_name').run(conn)
assertEqual(expected, list(result))
def test_simple(self, conn):
res = r.db('x').table('farms').map(
lambda doc: doc['animals'][0]
).run(conn)
assertEqual(
set(['frog', 'horse']),
set(list(res))
)
def test_max_of_left_seq_no_args(self, conn):
expected = [900]
result = r.db('x').table('people').filter(
lambda doc: doc['id'] == 'todd'
).map(
lambda doc: doc['nums'].max()
).run(conn)
assertEqual(expected, list(result))
def test_max_of_sequence_field(self, conn):
expected = [{'val': 110}]
result = r.db('x').table('people').filter({
'id': 'todd'
}).map(
lambda doc: doc['nums2'].max('val')
).run(conn)
assertEqual(expected, list(result))
def test_sequence_eq_elem_count(self, conn):
expected = [2]
result = r.db('x').table('people').filter(
{'id': 'todd'}
).map(
lambda doc: doc['nums'].count(40)
).run(conn)
assertEqual(expected, list(result))
def test_table_eq_elem_count(self, conn):
expected = 1
result = r.db('x').table('people').count({
'id': 'bill',
'age': 48,
'hobbies': ['watermelon']
}).run(conn)
assertEqual(expected, result)
def test_contains_table_dict_multi_false(self, conn):
result = r.db('d').table('people').contains({
'id': 'sam-id',
'age': 45
}, {
'id': 'tara-muse-id',
'age': 'timeless'
}).run(conn)
assertEqual(False, result)
def test_contains_table_dict_multi_true(self, conn):
result = r.db('d').table('people').contains({
'id': 'sam-id',
'age': 45
}, {
'id': 'joe-id',
'age': 36
}).run(conn)
assertEqual(True, result)
def test_do_three(self, conn):
base = r.db('generic').table('table')
result = r.do(
base.get('one'),
base.get('two'),
base.get('three'),
lambda d1, d2, d3: [d1['name'], d2['name'], d3['name']]
).run(conn)
assertEqual(['One', 'Two', 'Three'], result)
def test_map_merge_literal(self, conn):
expected = {'id': 'one', 'points': {'pt1': {'z': 'z-1'}}}
result = r.db('things').table('points').filter({
'id': 'one'
}).map(
lambda doc: doc.merge({'points': {
'pt1': r.literal({'z': 'z-1'})
}})).run(conn)
assertEqual(expected, list(result)[0])
def test_date(self, conn):
expected = set([
datetime.datetime(2014, 8, 25, tzinfo=r.make_timezone('00:00')),
datetime.datetime(2014, 6, 3, tzinfo=r.make_timezone('00:00'))
])
result = r.db('d').table('people').map(
lambda doc: doc['last_updated'].date()
).run(conn)
assertEqual(expected, set(list(result)))
def test_table_drop_2(self, conn):
expected_1 = set(['one_x', 'one_y'])
expected_2 = set(['two_x'])
r.db('db_two').table_drop('two_y').run(conn)
result_1 = r.db('db_one').table_list().run(conn)
assertEqual(expected_1, set(list(result_1)))
result_2 = r.db('db_two').table_list().run(conn)
assertEqual(expected_2, set(list(result_2)))
def test_time_of_day(self, conn):
expected = set([
((((12 * 60) + 10) * 60) + 32),
((((17 * 60) + 3) * 60) + 54)
])
result = r.db('d').table('people').map(
lambda doc: doc['last_updated'].time_of_day()
).run(conn)
assertEqual(expected, set(list(result)))
def test_day_of_week(self, conn):
expected = set([
1, # 2014 August 25 -> Monday
2 # 2014 June 3 -> Tuesday
])
result = r.db('d').table('people').map(
lambda doc: doc['last_updated'].day_of_week()
).run(conn)
assertEqual(expected, set(list(result)))
def test_epoch_time(self, conn):
results = r.db('d').table('people').map(
lambda d: d.merge({'as_epoch': d['last_updated'].to_epoch_time()})
).run(conn)
results = list(results)
jan1 = datetime.datetime(1970, 1, 1, tzinfo=r.make_timezone('00:00'))
for doc in results:
expected = int((doc['last_updated'] - jan1).total_seconds())
assertEqual(expected, doc['as_epoch'])
def test_get_all_just_one(self, conn):
expected = [
{
'id': 'bob-id',
'name': 'bob'
},
]
result = r.db('x').table('people').get_all('bob-id').run(conn)
assertEqual(expected, list(result))
def test_insert_one_no_id(self, conn):
r.db('things').table('muppets').insert({'name': 'joe'}).run(conn)
result = r.db('things').table('muppets').filter({
'name': 'joe'
}).run(conn)
result = list(result)
assertEqual(1, len(result))
joe = result[0]
assert (isinstance(joe['id'], text_type))
def test_sort_multi_1_asc(self, conn):
expected = [
{'id': 'glen', 'age': 26, 'score': 15},
{'id': 'joe', 'age': 26, 'score': 60},
{'id': 'bill', 'age': 35, 'score': 78},
{'id': 'todd', 'age': 52, 'score': 15},
{'id': 'pale', 'age': 52, 'score': 30}
]
result = r.db('y').table('scores').order_by(r.asc('age'), r.asc('score')).run(conn)
assertEqual(expected, list(result))
def test_downcase(self, conn):
expected = set([
'something with spaces',
'some,csv,file',
'someething'
])
result = r.db('library').table('texts').map(
lambda doc: doc['text'].downcase()
).run(conn)
assertEqual(expected, set(list(result)))
def test_filter_during(self, conn):
table = r.db('d').table('people')
result = table.filter(
lambda doc: doc['last_updated'].during(
r.time(2014, 6, 1, 'Z'),
r.time(2014, 6, 30, 'Z')
)
).run(conn)
result = list(result)
assertEqual(2, len(result))
def test_avg_of_sequence_func(self, conn):
expected = [15]
result = r.db('x').table('people').filter(
{'id': 'todd'}
).map(
lambda doc: doc['nums2'].avg(
lambda num: num['val']
)
).run(conn)
assertEqual(expected, list(result))
def test_as_obj(self):
expected = {
'x': 'x-val',
'y': 'y-val'
}
pairs = [
['x', 'x-val'],
['y', 'y-val']
]
assertEqual(expected, util.as_obj(pairs))
def test_upcase(self, conn):
expected = set([
'SOMETHING WITH SPACES',
'SOME,CSV,FILE',
'SOMEETHING'
])
result = r.db('library').table('texts').map(
lambda doc: doc['text'].upcase()
).run(conn)
assertEqual(expected, set(list(result)))
def test_eq_join(self):
left = [
{
'id': 'left-1',
'rel_field': 'right-1-name'
},
{
'id': 'left-2',
'rel_field': 'right-4-name'
}
]
right = [
{
'id': 'right-1',
'name': 'right-1-name'
},
{
'id': 'right-2',
'name': 'right-2-name'
},
{
'id': 'right-3',
'name': 'right-3-name'
},
{
'id': 'right-4',
'name': 'right-4-name'
}
]
expected = [
{
'left': {
'id': 'left-1',
'rel_field': 'right-1-name'
},
'right': {
'id': 'right-1',
'name': 'right-1-name'
}
},
{
'left': {
'id': 'left-2',
'rel_field': 'right-4-name'
},
'right': {
'id': 'right-4',
'name': 'right-4-name'
}
}
]
assertEqual(
expected,
joins.do_eq_join('rel_field', left, 'name', right)
)
def test_index_rename_works(self, conn):
r.db('s').table('people').index_create(
'last_name'
).run(conn)
indexes = list(r.db('s').table('people').index_list().run(conn))
assertEqual(['last_name'], indexes)
r.db('s').table('people').index_rename(
'last_name', 'new_last_name'
).run(conn)
indexes = list(r.db('s').table('people').index_list().run(conn))
assertEqual(['new_last_name'], indexes)
def test_getter_obj(self):
class Thing(object):
def __init__(self, a_dict):
for k, v in iteritems(a_dict):
setattr(self, k, v)
thing = Thing({'x': 'x-val'})
assertEqual('x-val', util.getter('x')(thing))
assertEqual(None, util.getter('y')(thing))
def test_max_mapped(self):
sequence = [
{'val': 5},
{'val': 10},
{'val': 17},
{'val': 2},
{'val': 28},
{'val': 8}
]
get_val = lambda doc: doc['val']
assertEqual({'val': 28}, util.max_mapped(get_val, sequence))
def test_contains_table_dict_multi_true(self, conn):
result = r.db('d').table('people').contains(
{
'id': 'sam-id',
'age': 45
},
{
'id': 'joe-id',
'age': 36
}
).run(conn)
assertEqual(True, result)
def test_maybe_map_dict(self):
def set_y_by_x(thing):
return {'x': thing['x'], 'y': thing['x'] + 1}
assertEqual(
{'x': 5, 'y': 6},
util.maybe_map(set_y_by_x, {'x': 5})
)
assertEqual(
[{'x': 5, 'y': 6}, {'x': 10, 'y': 11}],
util.maybe_map(set_y_by_x, [{'x': 5}, {'x': 10}])
)
def test_contains_table_dict_multi_false(self, conn):
result = r.db('d').table('people').contains(
{
'id': 'sam-id',
'age': 45
},
{
'id': 'tara-muse-id',
'age': 'timeless'
}
).run(conn)
assertEqual(False, result)
def test_index_wait_all_works(self, conn):
expected = [
{'id': 'bob', 'first_name': 'Bob', 'last_name': 'Builder'}
]
r.db('s').table('people').index_create(
'last_name'
).run(conn)
r.db('s').table('people').index_wait().run(conn)
result = r.db('s').table('people').get_all(
'Builder', index='last_name'
).run(conn)
assertEqual(expected, list(result))
def test_pluck_with(self):
obj = {
'x': 'x-val',
'y': 'y-val',
'z': 'z-val'
}
assertEqual({
'x': 'x-val',
}, util.pluck_with('x')(obj))
assertEqual({
'x': 'x-val',
'y': 'y-val',
}, util.pluck_with('x', 'y')(obj))
def test_distinct_nested(self, conn):
ex1 = set([1, 2, 5, 3])
ex2 = DictableSet([{'val': 1}, {'val': 2}, {'val': 5}, {'val': 3}])
result = r.db('d').table('people').map(
lambda doc: doc['nums'].distinct()
).run(conn)
result = list(result)
for elem in result:
if isinstance(elem[0], dict):
for dict_elem in elem:
assert(ex2.has(dict_elem))
else:
assertEqual(ex1, set(elem))
