def exec_sync(self, elliptics_client, key, event, data=None): ''' Strictly synchronous request ''' elliptics_client.trace_id = make_trace_id('TestSession.exec_sync') async = elliptics_client.exec_(key, event=event, data=data) # wait() call not required here but its explicit (and so is better) async.wait() return async.get(), async.error()
def test_lookup_read_existent_key(simple_node): """Write a key, lookup and read it and validate fields of results.""" session = elliptics.newapi.Session(simple_node) session.trace_id = make_trace_id('test_lookup_read_existent_key') session.groups = session.routes.groups() key = 'test_lookup_read_existent_key' json_string = json.dumps({'some': 'field'}) json_checksum = elliptics.Id(hashlib.sha512(json_string).hexdigest(), 0) data = 'some data' data_checksum = elliptics.Id(hashlib.sha512(data).hexdigest(), 0) no_checksum = elliptics.Id([0] * 64, 0) i = 0 for i, result in enumerate(session.write(key, json_string, len(json_string), data, len(data)), start=1): assert result.status == 0 assert result.record_info.json_size == len(json_string) assert result.record_info.json_capacity == len(json_string) assert result.json_checksum == no_checksum assert result.record_info.data_size == len(data) assert result.data_checksum == no_checksum assert i == len(session.groups) i = 0 for i, result in enumerate(session.lookup(key), start=1): assert result.status == 0 assert result.record_info.json_size == len(json_string) assert result.record_info.json_capacity == len(json_string) assert result.json_checksum == no_checksum assert result.record_info.data_size == len(data) assert result.data_checksum == no_checksum assert i == 1 i = 0 for i, result in enumerate(session.read(key, 0, 0), start=1): assert result.status == 0 assert result.record_info.json_size == len(json_string) assert result.record_info.json_capacity == len(json_string) assert result.record_info.data_size == len(data) assert result.json == json_string assert result.data == data assert i == 1 session.cflags |= elliptics.command_flags.checksum i = 0 for i, result in enumerate(session.lookup(key), start=1): assert result.status == 0 assert result.record_info.json_size == len(json_string) assert result.record_info.json_capacity == len(json_string) assert result.json_checksum == json_checksum assert result.record_info.data_size == len(data) assert result.data_checksum == data_checksum assert i == 1
def test_session_bulk_read(simple_node): """Test bulk_read_json, bulk_read_data, bulk_read.""" session = elliptics.newapi.Session(simple_node) session.trace_id = make_trace_id('test_session_bulk_read') session.groups = session.routes.groups() # prepare test data keys = [] datas = {} def make_item(data, json): return {"data": data, "json": json} write_results = [] for group_id in session.groups: session.groups = [group_id] for i in range(10): eid = session.transform('k{}'.format(i)) eid.group_id = group_id keys.append(eid) data = "data{}_{}".format(group_id, i) json_string = json.dumps({'some': "json{}_{}".format(group_id, i)}) datas[repr(eid)] = make_item(data, json_string) result = session.write(eid, json_string, len(json_string), data, len(data)) write_results.append(result) for r in write_results: assert r.get()[0].status == 0 assert len(keys) == len(datas) # check bulk_read_json, bulk_read_data, bulk_read def check_result(method, check_json, check_data): result = method(keys) counter = 0 for r in result: counter += 1 assert repr(r.id) in datas ref = datas[repr(r.id)] if check_json: assert ref["json"] == r.json else: assert not r.json if check_data: assert ref["data"] == r.data else: assert not r.data assert counter == len(keys) check_result(session.bulk_read_json, True, False) check_result(session.bulk_read_data, False, True) check_result(session.bulk_read, True, True)
def exec_async_cb(self, elliptics_client, key, event, data=None): """ Async request using explicit callbacks """ results = [] error = [] elliptics_client.trace_id = make_trace_id("TestSession.exec_async_cb") async = elliptics_client.exec_(key, event=event, data=data) async.connect(lambda x: results.append(x), lambda x: error.append(x)) async.wait() # print '%r, %r' % (results, error) assert len(error) > 0 return results, error[0]
def exec_async_cb(self, elliptics_client, key, event, data=None): ''' Async request using explicit callbacks ''' results = [] error = [] elliptics_client.trace_id = make_trace_id('TestSession.exec_async_cb') async = elliptics_client.exec_(key, event=event, data=data) async.connect( lambda x: results.append(x), lambda x: error.append(x) ) async.wait() #print '%r, %r' % (results, error) assert len(error) > 0 return results, error[0]
def test_use_session_clone(simple_node): """Create session, clone and write a key by clone.""" session = elliptics.newapi.Session(simple_node) session.trace_id = make_trace_id('test_use_session_after_clone') session.groups = session.routes.groups() key = 'test_use_session_after_clone\'s key' clone = session.clone() clone.write(key, '{"no": "matter"}', 0, 'no matter', 0).wait() clone.lookup(key).wait() clone.read(key).wait() clone.read_json(key).wait() clone.read_data(key).wait() clone.remove(key)
def test_session_timestamps(simple_node): """Test session.timestamp and session.json_timestamp.""" session = elliptics.newapi.Session(simple_node) session.trace_id = make_trace_id('test_lookup_read_existent_key') session.groups = session.routes.groups() key = 'test_lookup_read_existent_key' json_string = json.dumps({'some': 'field'}) data = 'some data' data_ts = elliptics.Time.now() json_ts = elliptics.Time(data_ts.tsec, data_ts.tnsec + 1) assert json_ts > data_ts assert session.timestamp is None assert session.json_timestamp is None # write and check timestamps from result result = session.write(key, json_string, len(json_string), data, len(data)).get()[0] assert elliptics.Time.now() > result.record_info.data_timestamp > data_ts assert elliptics.Time.now() > result.record_info.json_timestamp > data_ts session.timestamp = data_ts assert session.timestamp == data_ts assert session.json_timestamp is None # write and check timestamps from result result = session.write(key, json_string, len(json_string), data, len(data)).get()[0] assert result.record_info.data_timestamp == data_ts assert result.record_info.json_timestamp == data_ts session.json_timestamp = json_ts assert session.timestamp == data_ts assert session.json_timestamp == json_ts # write and check timestamps from result result = session.write(key, json_string, len(json_string), data, len(data)).get()[0] assert result.record_info.data_timestamp == data_ts assert result.record_info.json_timestamp == json_ts session.timestamp = None assert session.timestamp is None assert session.json_timestamp == json_ts # write and check timestamps from result result = session.write(key, json_string, len(json_string), data, len(data)).get()[0] assert elliptics.Time.now() > result.record_info.data_timestamp > json_ts assert result.record_info.json_timestamp == json_ts
def test_exec_fanout_auto(self, elliptics_client, elliptics_groups, exec_func, server): ''' Fan out using None as id ''' elliptics_client.trace_id = make_trace_id('TestSession.test_exec_fanout_auto') nodes = elliptics_client.routes.addresses() results, error = exec_func(self, elliptics_client, None, event=EVENT) for i in results: self.print_result(i) self.print_error(error) assert error.code == 0 assert len(results) == len(nodes) for r in results: assert r.context.address assert r.address == r.context.address
def test_lookup_read_nonexistent_key(simple_node): """Try to lookup and read a non-existent key and validate fields of results.""" session = elliptics.newapi.Session(simple_node) session.trace_id = make_trace_id('test_lookup_read_nonexistent_key') session.exceptions_policy = elliptics.exceptions_policy.no_exceptions session.groups = session.routes.groups() key = 'test_lookup_read_nonexistent_key' for result in session.lookup(key): assert result.status == -errno.ENOENT assert result.record_info is None assert result.path is None for result in session.read(key): assert result.status == -errno.ENOENT assert result.record_info is None assert result.io_info is None assert result.json is None assert result.data is None
def test_exec_fanout_manual(self, elliptics_client, elliptics_groups, exec_func, server): ''' Fan out using manual lookup into routing table ''' elliptics_client.trace_id = make_trace_id('TestSession.test_exec_fanout_manual') nodes = elliptics_client.routes.get_unique_routes() collected = [] for route in nodes: print '\nFor addr %s, key %r:' % (route.address, route.id) results, error = exec_func(self, elliptics_client, route.id, event=EVENT) for i in results: self.print_result(i) self.print_error(error) assert error.code == 0 assert len(results) == 1 collected.append((route.address, route.id, results[0])) for route.address, route.id, r in collected: assert r.context.address assert r.address == r.context.address
def test_lookup_read_existent_key(simple_node): """Write a key, lookup and read it and validate fields of results.""" session = elliptics.newapi.Session(simple_node) session.trace_id = make_trace_id('test_lookup_read_existent_key') session.groups = session.routes.groups() key = 'test_lookup_read_existent_key' json_string = json.dumps({'some': 'field'}) data = 'some data' i = 0 for i, result in enumerate(session.write(key, json_string, len(json_string), data, len(data)), start=1): assert result.status == 0 assert result.record_info.json_size == len(json_string) assert result.record_info.json_capacity == len(json_string) assert result.record_info.data_size == len(data) assert i == len(session.groups) i = 0 for i, result in enumerate(session.lookup(key), start=1): assert result.status == 0 assert result.record_info.json_size == len(json_string) assert result.record_info.json_capacity == len(json_string) assert result.record_info.data_size == len(data) assert i == 1 i = 0 for i, result in enumerate(session.read(key, 0, 0), start=1): assert result.status == 0 assert result.record_info.json_size == len(json_string) assert result.record_info.json_capacity == len(json_string) assert result.record_info.data_size == len(data) assert result.json == json_string assert result.data == data assert i == 1
def exec_async_i(self, elliptics_client, key, event, data=None): ''' Async request using result iterator ''' elliptics_client.trace_id = make_trace_id('TestSession.exec_async_i') async = elliptics_client.exec_(key, event=event, data=data) return list(async), async.error()
def test_exec_arg_event_cant_be_missed(self, elliptics_client): elliptics_client.trace_id = make_trace_id("TestSession.test_exec_arg_event_cant_be_missed") with pytest.raises(TypeError): elliptics_client.exec_("some-id", event=None, data="")
def test_exec_arg_id_could_be_none(self, elliptics_client, elliptics_groups, server): elliptics_client.trace_id = make_trace_id('TestSession.test_exec_arg_id_could_be_none') nodes = elliptics_client.routes.addresses() r = elliptics_client.exec_(None, event=EVENT, data='').get() assert isinstance(r, list) and len(r) == len(nodes)
def test_exec_arg_data_could_be_none(self, elliptics_client, elliptics_groups, server): elliptics_client.trace_id = make_trace_id('TestSession.test_exec_arg_data_could_be_none') r = elliptics_client.exec_('some-id', event=EVENT, data=None).get() assert isinstance(r, list) and len(r) == len(elliptics_groups)
def test_exec_arg_event_cant_be_missed(self, elliptics_client, elliptics_groups, server): elliptics_client.trace_id = make_trace_id('TestSession.test_exec_arg_event_cant_be_missed') with pytest.raises(TypeError): elliptics_client.exec_('some-id', event=None, data='')
def test_exec_styles(self, elliptics_client, elliptics_groups, exec_func, server): elliptics_client.trace_id = make_trace_id('TestSession.test_exec_styles') results, error = exec_func(self, elliptics_client, 'some-id', event=EVENT) assert error.code == 0 assert len(results) == len(elliptics_groups)
def test_exec_styles(self, servers, elliptics_client, exec_func): elliptics_client.trace_id = make_trace_id("TestSession.test_exec_styles") results, error = exec_func(self, elliptics_client, "some-id", event=EVENT) assert error.code == 0 assert len(results) == len(servers.groups)
def test_exec_arg_data_could_be_none(self, servers, elliptics_client): elliptics_client.trace_id = make_trace_id("TestSession.test_exec_arg_data_could_be_none") r = elliptics_client.exec_("some-id", event=EVENT, data=None).get() assert isinstance(r, list) and len(r) == len(servers.groups)
def test_session_bulk_remove(simple_node): """Test bulk_remove.""" session = elliptics.newapi.Session(simple_node) session.trace_id = make_trace_id('test_session_bulk_remove') session.groups = session.routes.groups() session.set_filter(elliptics.filters.all_with_ack) session.set_timestamp(elliptics.Time.now()) # prepare test data keys = [] datas = {} def make_item(data, json): return {"data": data, "json": json} groups = session.groups def prepare_data(): del keys[:] datas = {} write_results = [] for group_id in groups: session.groups = [group_id] for i in range(10): eid = session.transform('k_br{}'.format(i)) eid.group_id = group_id keys.append(eid) data = "data{}_{}".format(group_id, i) json_string = json.dumps( {'some': "json{}_{}".format(group_id, i)}) datas[repr(eid)] = make_item(data, json_string) result = session.write(eid, json_string, len(json_string), data, len(data)) write_results.append(result) for r in write_results: assert r.get()[0].status == 0 assert len(keys) == len(datas) prepare_data() #remove data cur_ts = session.get_timestamp() keys_ts = [(key, cur_ts) for key in keys] count = 0 for result in session.bulk_remove(keys_ts): assert result.status == 0 count += 1 assert count == len(keys) # pass vector instead of vector<pair> with pytest.raises(TypeError): #TypeError: Expecting an object of type tuple; got an object of type Id instead session.bulk_remove(keys).wait() # pass empty vector with pytest.raises(Exception): #Error: send_bulk_remove: keys list is empty: No such device or address: -6 session.bulk_remove([]).wait() # restore test data prepare_data() count = 0 for result in session.bulk_remove(iter(keys_ts)): assert result.status == 0 count += 1 assert count == len(keys_ts)