def test_get_existing_session(self):
store = SessionStore(self.datadir, self.hub)
# Create a new session.
new_session = store.get('foo')
# Get the same existing session again.
got_session = store.get('foo')
self.assertEqual(new_session, got_session)
def test_get_existing_session(self):
store = SessionStore(self.datadir, self.hub)
# Create a new session.
new_session = store.get('foo')
# Get the same existing session again.
got_session = store.get('foo')
self.assertEqual(new_session, got_session)
def setUp(self):
self.datadir = _unique_dir_name()
self.hub = mock.MagicMock()
self.store = SessionStore(self.datadir, self.hub)
self.datavault = server.DataVault(self.store)
self.set_default_labrad_server_mocks(self.datavault)
self.context = MockContext()
self.datavault.initServer()
def start():
opts = labrad.util.parseServerOptions(name=DataVault.name)
cxn = yield labrad.wrappers.connectAsync(host=opts["host"], port=int(opts["port"]), password=opts["password"])
datadir = yield load_settings(cxn, opts["name"])
yield cxn.disconnect()
session_store = SessionStore(datadir, hub=None)
server = DataVault(session_store)
session_store.hub = server
# Run the server. We do not need to start the reactor, but we will
# stop it after the data_vault shuts down.
labrad.util.runServer(server, run_reactor=False, stop_reactor=True)
def start():
opts = labrad.util.parseServerOptions(name=DataVault.name)
cxn = yield labrad.wrappers.connectAsync(
host=opts['host'], port=int(opts['port']), password=opts['password'])
datadir = yield load_settings(cxn, opts['name'])
yield cxn.disconnect()
session_store = SessionStore(datadir, hub=None)
server = DataVault(session_store)
session_store.hub = server
# Run the server. We do not need to start the reactor, but we will
# stop it after the data_vault shuts down.
labrad.util.runServer(server, run_reactor=False, stop_reactor=True)
def __init__(self, path, managers):
MultiService.__init__(self)
self.path = path
self.managers = managers
self.servers = set()
self.session_store = SessionStore(path, self)
for signal in self.signals:
self.wrapSignal(signal)
for host, port, password in managers:
self.add_server(host, port, password)
def setUp(self):
self.datadir = _unique_dir_name()
self.hub = mock.MagicMock()
self.store = SessionStore(self.datadir, self.hub)
self.datavault = server.DataVault(self.store)
self.set_default_labrad_server_mocks(self.datavault)
self.context = MockContext()
self.datavault.initServer()
def test_get_all_sessions(self):
store = SessionStore(self.datadir, self.hub)
# Create a new session.
foo_session = store.get('foo')
bar_session = store.get('bar')
self.assertEqual([foo_session, bar_session], store.get_all())
def test_get_new_session(self):
store = SessionStore(self.datadir, self.hub)
self.assertFalse(store.exists('foo'))
store.get('foo')
self.assertTrue(store.exists('foo'))
def test_get_all_sessions(self):
store = SessionStore(self.datadir, self.hub)
# Create a new session.
foo_session = store.get('foo')
bar_session = store.get('bar')
self.assertEqual([foo_session, bar_session], store.get_all())
def test_get_new_session(self):
store = SessionStore(self.datadir, self.hub)
self.assertFalse(store.exists('foo'))
store.get('foo')
self.assertTrue(store.exists('foo'))
class DataVaultTest(unittest.TestCase):
'''Tests for the datavault server.'''
def setUp(self):
self.datadir = _unique_dir_name()
self.hub = mock.MagicMock()
self.store = SessionStore(self.datadir, self.hub)
self.datavault = server.DataVault(self.store)
self.set_default_labrad_server_mocks(self.datavault)
self.context = MockContext()
self.datavault.initServer()
def tearDown(self):
_empty_and_remove_dir(self.datadir)
def assertArrayEqual(self, expected, actual, msg=None):
if len(expected) == 0 and len(actual) == 0:
return
if msg is None:
msg = 'Arrays not equal\nfirst:\n{}\nsecond:\n{}'.format(
expected, actual)
self.assertTrue(np.array_equal(expected, actual), msg=msg)
def assertListOfVariablesEqual(self, expected, actual):
self.assertEqual(len(expected), len(actual))
msg_template = ('Mismatch in varianles list at position {}:'
'\nexpected:\n{}\nactual:\n{}')
items = enumerate(zip(expected, actual))
for i, (expected_var, actual_var) in items:
msg = msg_template.format(i, expected_var, actual_var)
self.assertEqual(expected_var.label, actual_var.label, msg=msg)
self.assertEqual(expected_var.datatype,
actual_var.datatype,
msg=msg)
self.assertEqual(expected_var.unit, actual_var.unit, msg=msg)
self.assertEqual(expected_var.shape, actual_var.shape, msg=msg)
if hasattr(expected_var, 'legend'):
self.assertTrue(hasattr(actual_var, 'legend'), msg=msg)
self.assertEqual(expected_var.legend,
actual_var.legend,
msg=msg)
def assertDataRowEqual(self, expected, actual):
"""Checks that data in the expected and actual rows are equal.
This is useful for the extended data format since numpy's array_equal
doens't do very well with oddly shaped data."""
msg_foot = '\nExpected:\n{}\nActual:\n{}'.format(expected, actual)
self.assertEqual(len(expected), len(actual), msg=msg_foot)
comparables = zip(expected, actual)
msg_head = 'Mismatch in entry {} of data.'
for i, (expected_entry, actual_entry) in enumerate(comparables):
msg = msg_head.format(i) + msg_foot
if isinstance(expected_entry, (int, long, float, complex)):
self.assertEqual(expected_entry, actual_entry, msg=msg)
else:
self.assertArrayEqual(expected_entry, actual_entry, msg=msg)
def set_default_labrad_server_mocks(self, labrad_server):
pass
def test_init_context(self):
self.datavault.initContext(self.context)
current_session = self.datavault.getSession(self.context)
self.assertEqual('', self.context['path'][0])
self.assertTrue(self.context.ID, current_session.listeners)
sessions_in_store = self.store.get_all()
self.assertEqual(1, len(sessions_in_store))
self.assertEqual(set([self.context.ID]),
sessions_in_store[0].listeners)
self.assertEqual(current_session, sessions_in_store[0])
def test_create_new_simple_dataset(self):
# Create the root session and a child session.
self.datavault.initContext(self.context)
# Create a dataset at root.
path, name = self.datavault.new(self.context, 'foo', [('x', 'ms')],
[('y', 'E', 'eV')])
self.assertEqual([''], path)
self.assertEqual('00001 - foo', name)
self.assertEqual('2.0.0', self.datavault.get_version(self.context))
# Check that it contains the right pieces.
# Simple variables output.
independents, dependents = self.datavault.variables(self.context)
self.assertEqual([('x', 'ms')], independents)
self.assertEqual([('y', 'E', 'eV')], dependents)
# Extended variables output.
independents_ex, dependents_ex = self.datavault.variables_ex(
self.context)
expected_independents_ex = [
backend.Independent(label='x',
shape=(1, ),
datatype='v',
unit='ms')
]
expected_dependents_ex = [
backend.Dependent(label='y',
legend='E',
shape=(1, ),
datatype='v',
unit='eV')
]
self.assertEqual(expected_independents_ex, independents_ex)
self.assertEqual(expected_dependents_ex, dependents_ex)
# Name.
self.assertEqual(name, self.datavault.get_name(self.context))
# Row and transpose type.
self.assertEqual('*(v[ms],v[eV])',
self.datavault.row_type(self.context))
self.assertEqual('(*v[ms],*v[eV])',
self.datavault.transpose_type(self.context))
def test_expire_context(self):
# Create the root session.
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new(self.context, 'foo', [('x', 'ms')],
[('y', 'E', 'eV')])
dataset = self.datavault.getDataset(self.context)
# Add the context as a listener to the dataset.
dataset.listeners.add(self.context.ID)
# Now expire the context
self.datavault.expireContext(self.context)
sessions_in_store = self.store.get_all()
self.assertEqual(1, len(sessions_in_store))
# Check the session doesn't have anymore listeners.
self.assertEqual(set([]), sessions_in_store[0].listeners)
# Check the dataset doesn't have anymore listeners.
self.assertEqual(set([]), dataset.listeners)
def test_get_dataset_not_yet_created(self):
self.datavault.initContext(self.context)
self.assertRaises(errors.NoDatasetError, self.datavault.getDataset,
self.context)
def test_add_session_with_cd(self):
# Create the root session.
self.datavault.initContext(self.context)
root_session = self.datavault.getSession(self.context)
# Create another session.
newpath = self.datavault.cd(self.context, path='first', create=True)
new_session = self.datavault.getSession(self.context)
self.assertNotEqual(root_session, new_session)
self.assertEqual(['', 'first'], newpath)
def test_directory_operations(self):
self.datavault.initContext(self.context)
self.assertEqual(([], []), self.datavault.dir(self.context))
# Create a new directory with a string.
self.datavault.mkdir(self.context, 'first')
# Check that we haven't changed the path yet.
self.assertEqual([''], self.context['path'])
# Check that the new directory is created.
self.assertEqual((['first'], []), self.datavault.dir(self.context))
# Change to the new directory.
self.datavault.cd(self.context, path='first')
self.assertEqual(['', 'first'], self.context['path'])
# Check current directory is empty.
self.assertEqual(([], []), self.datavault.dir(self.context))
# Change to new directory, creating it as we go.
self.datavault.cd(self.context, path=['second', 'third'], create=True)
self.assertEqual(['', 'first', 'second', 'third'],
self.context['path'])
self.assertEqual(([], []), self.datavault.dir(self.context))
# Change back to the root and traverse the path
self.datavault.cd(self.context, path=[''])
self.assertEqual((['first'], []), self.datavault.dir(self.context))
self.datavault.cd(self.context, path=['first'])
self.assertEqual((['second'], []), self.datavault.dir(self.context))
self.datavault.cd(self.context, path=['second'])
self.assertEqual((['third'], []), self.datavault.dir(self.context))
self.datavault.cd(self.context, path=['third'])
self.assertEqual(([], []), self.datavault.dir(self.context))
def test_dump_existing_sessions(self):
# Create the root session and a child session.
self.datavault.initContext(self.context)
self.datavault.cd(self.context, path='first', create=True)
self.datavault.cd(self.context, path=['second', 'third'], create=True)
all_sessions = self.datavault.dump_existing_sessions(self.context)
self.assertEqual(['/first/second/third'], all_sessions)
def test_add_simple_data(self):
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new(self.context, 'foo', [('x', 'ms'), ('y', 'Volt')],
[('z', 'E', 'eV')])
# Add two rows of data.
self.datavault.add(self.context, [(.1, .2, .3), (.4, .5, .6)])
# Check that the data is there.
data = self.datavault.get(self.context)
self.assertArrayEqual([[.1, .2, .3], [.4, .5, .6]], data)
more_data = self.datavault.get(self.context)
self.assertArrayEqual([], more_data)
# Check that data can be fetched incrementally.
row_1 = self.datavault.get(self.context, limit=1, startOver=True)
row_2 = self.datavault.get(self.context, limit=1)
self.assertArrayEqual([[.1, .2, .3]], row_1)
self.assertArrayEqual([[.4, .5, .6]], row_2)
# Check that the data can be fetched in extended format.
data_ex = self.datavault.get_ex(self.context, startOver=True)
self.assertArrayEqual([[.1, .2, .3], [.4, .5, .6]], data_ex)
# Check that the data can not be fetched in extended transpose format.
self.assertRaises(RuntimeError,
self.datavault.get_ex_t,
self.context,
startOver=True)
def test_add_extended_data(self):
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new_ex(self.context, 'foo', [('x', [2, 2], 'v', 'ms'),
('y', [1], 'i', '')],
[('z', 'E', [1, 2], 'c', 'eV')])
# Add two rows of data.
data_row_1 = ([[.1, .5], [.5, .9]], 2, [[.1j, 2j]])
data_row_2 = ([[.3, .4], [.4, .8]], 3, [[.3j, 5j]])
self.datavault.add_ex(self.context, [data_row_1, data_row_2])
# Check that the data is there.
data = self.datavault.get_ex(self.context)
self.assertDataRowEqual(data_row_1, data[0])
self.assertDataRowEqual(data_row_2, data[1])
more_data = self.datavault.get_ex(self.context)
self.assertArrayEqual([], more_data)
# Check that data can be fetched incrementally.
row_1 = self.datavault.get_ex(self.context, limit=1, startOver=True)
row_2 = self.datavault.get_ex(self.context, limit=1)
self.assertDataRowEqual(data_row_1, row_1[0])
self.assertDataRowEqual(data_row_2, row_2[0])
# Check that the data can be fetched in transpose format.
data_t = self.datavault.get_ex_t(self.context, startOver=True)
expected_x = [[[.1, .5], [.5, .9]], [[.3, .4], [.4, .8]]]
expected_y = [2, 3]
expected_z = [[[.1j, 2j]], [[.3j, 5j]]]
self.assertArrayEqual(expected_x, data_t[0])
self.assertArrayEqual(expected_y, data_t[1])
self.assertArrayEqual(expected_z, data_t[2])
# Extended data format cannot be read as simple data.
self.assertRaises(errors.DataVersionMismatchError, self.datavault.get,
self.context)
def test_add_extended_data_transpose(self):
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new_ex(self.context, 'foo', [('x', [2, 2], 'v', 'ms'),
('y', [1], 'i', '')],
[('z', 'E', [1, 2], 'c', 'eV')])
# Add two rows of transposed data.
x = [[[.1, .5], [.5, .9]], [[.3, .4], [.4, .8]]]
y = [2, 3]
z = [[[.1j, 2j]], [[.3j, 5j]]]
self.datavault.add_ex_t(self.context, [x, y, z])
# Check that the data is there as non-transposed data.
data_row_1 = ([[.1, .5], [.5, .9]], 2, [[.1j, 2j]])
data_row_2 = ([[.3, .4], [.4, .8]], 3, [[.3j, 5j]])
data = self.datavault.get_ex(self.context)
self.assertDataRowEqual(data_row_1, data[0])
self.assertDataRowEqual(data_row_2, data[1])
more_data = self.datavault.get_ex(self.context)
self.assertArrayEqual([], more_data)
# Check that data can be fetched incrementally.
row_1 = self.datavault.get_ex(self.context, limit=1, startOver=True)
row_2 = self.datavault.get_ex(self.context, limit=1)
self.assertDataRowEqual(data_row_1, row_1[0])
self.assertDataRowEqual(data_row_2, row_2[0])
# Check that the data can be fetched in transpose format.
data_t = self.datavault.get_ex_t(self.context, startOver=True)
self.assertArrayEqual(x, data_t[0])
self.assertArrayEqual(y, data_t[1])
self.assertArrayEqual(z, data_t[2])
# Extended data format cannot be read as simple data.
self.assertRaises(errors.DataVersionMismatchError, self.datavault.get,
self.context)
class DataVaultTest(unittest.TestCase):
"""Tests for the datavault server."""
def setUp(self):
self.datadir = _unique_dir_name()
self.hub = mock.MagicMock()
self.store = SessionStore(self.datadir, self.hub)
self.datavault = server.DataVault(self.store)
self.set_default_labrad_server_mocks(self.datavault)
self.context = MockContext()
self.datavault.initServer()
def tearDown(self):
_empty_and_remove_dir(self.datadir)
def assertArrayEqual(self, expected, actual, msg=None):
if len(expected) == 0 and len(actual) == 0:
return
if msg is None:
msg = "Arrays not equal\nfirst:\n{}\nsecond:\n{}".format(expected, actual)
self.assertTrue(np.array_equal(expected, actual), msg=msg)
def assertListOfVariablesEqual(self, expected, actual):
self.assertEqual(len(expected), len(actual))
msg_template = "Mismatch in varianles list at position {}:" "\nexpected:\n{}\nactual:\n{}"
items = enumerate(zip(expected, actual))
for i, (expected_var, actual_var) in items:
msg = msg_template.format(i, expected_var, actual_var)
self.assertEqual(expected_var.label, actual_var.label, msg=msg)
self.assertEqual(expected_var.datatype, actual_var.datatype, msg=msg)
self.assertEqual(expected_var.unit, actual_var.unit, msg=msg)
self.assertEqual(expected_var.shape, actual_var.shape, msg=msg)
if hasattr(expected_var, "legend"):
self.assertTrue(hasattr(actual_var, "legend"), msg=msg)
self.assertEqual(expected_var.legend, actual_var.legend, msg=msg)
def assertDataRowEqual(self, expected, actual):
"""Checks that data in the expected and actual rows are equal.
This is useful for the extended data format since numpy's array_equal
doens't do very well with oddly shaped data."""
msg_foot = "\nExpected:\n{}\nActual:\n{}".format(expected, actual)
self.assertEqual(len(expected), len(actual), msg=msg_foot)
comparables = zip(expected, actual)
msg_head = "Mismatch in entry {} of data."
for i, (expected_entry, actual_entry) in enumerate(comparables):
msg = msg_head.format(i) + msg_foot
if isinstance(expected_entry, (int, long, float, complex)):
self.assertEqual(expected_entry, actual_entry, msg=msg)
else:
self.assertArrayEqual(expected_entry, actual_entry, msg=msg)
def set_default_labrad_server_mocks(self, labrad_server):
pass
def test_init_context(self):
self.datavault.initContext(self.context)
current_session = self.datavault.getSession(self.context)
self.assertEqual("", self.context["path"][0])
self.assertTrue(self.context.ID, current_session.listeners)
sessions_in_store = self.store.get_all()
self.assertEqual(1, len(sessions_in_store))
self.assertEqual(set([self.context.ID]), sessions_in_store[0].listeners)
self.assertEqual(current_session, sessions_in_store[0])
def test_create_new_simple_dataset(self):
# Create the root session and a child session.
self.datavault.initContext(self.context)
# Create a dataset at root.
path, name = self.datavault.new(self.context, "foo", [("x", "ms")], [("y", "E", "eV")])
self.assertEqual([""], path)
self.assertEqual("00001 - foo", name)
self.assertEqual("2.0.0", self.datavault.get_version(self.context))
# Check that it contains the right pieces.
# Simple variables output.
independents, dependents = self.datavault.variables(self.context)
self.assertEqual([("x", "ms")], independents)
self.assertEqual([("y", "E", "eV")], dependents)
# Extended variables output.
independents_ex, dependents_ex = self.datavault.variables_ex(self.context)
expected_independents_ex = [backend.Independent(label="x", shape=(1,), datatype="v", unit="ms")]
expected_dependents_ex = [backend.Dependent(label="y", legend="E", shape=(1,), datatype="v", unit="eV")]
self.assertEqual(expected_independents_ex, independents_ex)
self.assertEqual(expected_dependents_ex, dependents_ex)
# Name.
self.assertEqual(name, self.datavault.get_name(self.context))
# Row and transpose type.
self.assertEqual("*(v[ms],v[eV])", self.datavault.row_type(self.context))
self.assertEqual("(*v[ms],*v[eV])", self.datavault.transpose_type(self.context))
def test_expire_context(self):
# Create the root session.
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new(self.context, "foo", [("x", "ms")], [("y", "E", "eV")])
dataset = self.datavault.getDataset(self.context)
# Add the context as a listener to the dataset.
dataset.listeners.add(self.context.ID)
# Now expire the context
self.datavault.expireContext(self.context)
sessions_in_store = self.store.get_all()
self.assertEqual(1, len(sessions_in_store))
# Check the session doesn't have anymore listeners.
self.assertEqual(set([]), sessions_in_store[0].listeners)
# Check the dataset doesn't have anymore listeners.
self.assertEqual(set([]), dataset.listeners)
def test_get_dataset_not_yet_created(self):
self.datavault.initContext(self.context)
self.assertRaises(errors.NoDatasetError, self.datavault.getDataset, self.context)
def test_add_session_with_cd(self):
# Create the root session.
self.datavault.initContext(self.context)
root_session = self.datavault.getSession(self.context)
# Create another session.
newpath = self.datavault.cd(self.context, path="first", create=True)
new_session = self.datavault.getSession(self.context)
self.assertNotEqual(root_session, new_session)
self.assertEqual(["", "first"], newpath)
def test_directory_operations(self):
self.datavault.initContext(self.context)
self.assertEqual(([], []), self.datavault.dir(self.context))
# Create a new directory with a string.
self.datavault.mkdir(self.context, "first")
# Check that we haven't changed the path yet.
self.assertEqual([""], self.context["path"])
# Check that the new directory is created.
self.assertEqual((["first"], []), self.datavault.dir(self.context))
# Change to the new directory.
self.datavault.cd(self.context, path="first")
self.assertEqual(["", "first"], self.context["path"])
# Check current directory is empty.
self.assertEqual(([], []), self.datavault.dir(self.context))
# Change to new directory, creating it as we go.
self.datavault.cd(self.context, path=["second", "third"], create=True)
self.assertEqual(["", "first", "second", "third"], self.context["path"])
self.assertEqual(([], []), self.datavault.dir(self.context))
# Change back to the root and traverse the path
self.datavault.cd(self.context, path=[""])
self.assertEqual((["first"], []), self.datavault.dir(self.context))
self.datavault.cd(self.context, path=["first"])
self.assertEqual((["second"], []), self.datavault.dir(self.context))
self.datavault.cd(self.context, path=["second"])
self.assertEqual((["third"], []), self.datavault.dir(self.context))
self.datavault.cd(self.context, path=["third"])
self.assertEqual(([], []), self.datavault.dir(self.context))
def test_dump_existing_sessions(self):
# Create the root session and a child session.
self.datavault.initContext(self.context)
self.datavault.cd(self.context, path="first", create=True)
self.datavault.cd(self.context, path=["second", "third"], create=True)
all_sessions = self.datavault.dump_existing_sessions(self.context)
self.assertEqual(["/first/second/third"], all_sessions)
def test_add_simple_data(self):
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new(self.context, "foo", [("x", "ms"), ("y", "Volt")], [("z", "E", "eV")])
# Add two rows of data.
self.datavault.add(self.context, [(0.1, 0.2, 0.3), (0.4, 0.5, 0.6)])
# Check that the data is there.
data = self.datavault.get(self.context)
self.assertArrayEqual([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]], data)
more_data = self.datavault.get(self.context)
self.assertArrayEqual([], more_data)
# Check that data can be fetched incrementally.
row_1 = self.datavault.get(self.context, limit=1, startOver=True)
row_2 = self.datavault.get(self.context, limit=1)
self.assertArrayEqual([[0.1, 0.2, 0.3]], row_1)
self.assertArrayEqual([[0.4, 0.5, 0.6]], row_2)
# Check that the data can be fetched in extended format.
data_ex = self.datavault.get_ex(self.context, startOver=True)
self.assertArrayEqual([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]], data_ex)
# Check that the data can not be fetched in extended transpose format.
self.assertRaises(RuntimeError, self.datavault.get_ex_t, self.context, startOver=True)
def test_add_extended_data(self):
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new_ex(
self.context, "foo", [("x", [2, 2], "v", "ms"), ("y", [1], "i", "")], [("z", "E", [1, 2], "c", "eV")]
)
# Add two rows of data.
data_row_1 = ([[0.1, 0.5], [0.5, 0.9]], 2, [[0.1j, 2j]])
data_row_2 = ([[0.3, 0.4], [0.4, 0.8]], 3, [[0.3j, 5j]])
self.datavault.add_ex(self.context, [data_row_1, data_row_2])
# Check that the data is there.
data = self.datavault.get_ex(self.context)
self.assertDataRowEqual(data_row_1, data[0])
self.assertDataRowEqual(data_row_2, data[1])
more_data = self.datavault.get_ex(self.context)
self.assertArrayEqual([], more_data)
# Check that data can be fetched incrementally.
row_1 = self.datavault.get_ex(self.context, limit=1, startOver=True)
row_2 = self.datavault.get_ex(self.context, limit=1)
self.assertDataRowEqual(data_row_1, row_1[0])
self.assertDataRowEqual(data_row_2, row_2[0])
# Check that the data can be fetched in transpose format.
data_t = self.datavault.get_ex_t(self.context, startOver=True)
expected_x = [[[0.1, 0.5], [0.5, 0.9]], [[0.3, 0.4], [0.4, 0.8]]]
expected_y = [2, 3]
expected_z = [[[0.1j, 2j]], [[0.3j, 5j]]]
self.assertArrayEqual(expected_x, data_t[0])
self.assertArrayEqual(expected_y, data_t[1])
self.assertArrayEqual(expected_z, data_t[2])
# Extended data format cannot be read as simple data.
self.assertRaises(errors.DataVersionMismatchError, self.datavault.get, self.context)
def test_add_extended_data_transpose(self):
self.datavault.initContext(self.context)
# Create a root dataset.
self.datavault.new_ex(
self.context, "foo", [("x", [2, 2], "v", "ms"), ("y", [1], "i", "")], [("z", "E", [1, 2], "c", "eV")]
)
# Add two rows of transposed data.
x = [[[0.1, 0.5], [0.5, 0.9]], [[0.3, 0.4], [0.4, 0.8]]]
y = [2, 3]
z = [[[0.1j, 2j]], [[0.3j, 5j]]]
self.datavault.add_ex_t(self.context, [x, y, z])
# Check that the data is there as non-transposed data.
data_row_1 = ([[0.1, 0.5], [0.5, 0.9]], 2, [[0.1j, 2j]])
data_row_2 = ([[0.3, 0.4], [0.4, 0.8]], 3, [[0.3j, 5j]])
data = self.datavault.get_ex(self.context)
self.assertDataRowEqual(data_row_1, data[0])
self.assertDataRowEqual(data_row_2, data[1])
more_data = self.datavault.get_ex(self.context)
self.assertArrayEqual([], more_data)
# Check that data can be fetched incrementally.
row_1 = self.datavault.get_ex(self.context, limit=1, startOver=True)
row_2 = self.datavault.get_ex(self.context, limit=1)
self.assertDataRowEqual(data_row_1, row_1[0])
self.assertDataRowEqual(data_row_2, row_2[0])
# Check that the data can be fetched in transpose format.
data_t = self.datavault.get_ex_t(self.context, startOver=True)
self.assertArrayEqual(x, data_t[0])
self.assertArrayEqual(y, data_t[1])
self.assertArrayEqual(z, data_t[2])
# Extended data format cannot be read as simple data.
self.assertRaises(errors.DataVersionMismatchError, self.datavault.get, self.context)
