def test_addTemplate_with_no_fragments(self):
"""
Add a template that has no fragments. This must still create a
'meta.json' file (but nothing else).
"""
# Create a Dibbler instance and flush all data.
dibbler = self.dibbler
assert dibbler.getNumFiles() == (True, None, 0)
# Define a template for this test.
t_raw = getTemplate('_templateEmpty')
# Add the template and verify that the database now contains
# exactly one file.
ret = dibbler.addTemplate(t_raw)
assert ret.ok
assert dibbler.getNumFiles() == (True, None, 1)
url = ret.data['url_frag']
# Download the one- and only meta file and verify that it reports an
# empty 'fragment' list.
ret = self.dibbler.getFile('{}/meta.json'.format(url))
assert ret.ok
ret = json.loads(ret.data.decode('utf8'))
assert ret['fragments'] == {}
def test_spawnTemplate(self):
"""
Add two templates, then spawn the first one twice and the second
one once.
"""
dibbler = self.dibbler
# Define two templates.
frag_raw = {'fraw': getFragRaw()}
frag_dae = {'fdae': getFragDae()}
t_raw = getTemplate('t_name_raw', fragments=frag_raw)
t_dae = getTemplate('t_name_dae', fragments=frag_dae)
# Add the templates and verify there are 6 files in the DB now. The
# first template has two files (1 meta.json plus 1 for the raw data)
# and the second has 4 files (1 meta.json plus 3 for the Collada data).
dibbler.addTemplate(t_raw)
dibbler.addTemplate(t_dae)
assert dibbler.getNumFiles() == (True, None, 2 + 4)
# Spawn some instances.
ret_1 = dibbler.spawnTemplate(1, t_raw.aid)
ret_2 = dibbler.spawnTemplate(2, t_raw.aid)
ret_3 = dibbler.spawnTemplate(3, t_dae.aid)
assert ret_1.ok and ret_2.ok and ret_3.ok
# Dibbler must now hold the original 6 files plus an additional 8 files
# (2x2 for the two Raw instances, and another 4 for the one Collada
# instance).
assert dibbler.getNumFiles() == (True, None, (2 + 4) + (2 * 2 + 1 * 4))
# Verify that all files are correct.
self.verifyRaw(ret_1.data['url_frag'], 'fraw', frag_raw)
self.verifyRaw(ret_2.data['url_frag'], 'fraw', frag_raw)
self.verifyDae(ret_3.data['url_frag'], 'fdae', frag_dae)
# Attempt to spawn a non-existing template. This must fail and the
# number of files in Dibbler must not change.
assert not dibbler.spawnTemplate(10, 'blah').ok
assert dibbler.getNumFiles() == (True, None, (2 + 4) + (2 * 2 + 1 * 4))
def test_updateFragments_partial(self):
"""
Simliar to previous test in the sense that it spawns and updates
fragments. However, this time some fragments will be removed
altogether, instead of just being updated.
"""
dibbler = self.dibbler
# The original template has the following three fragments:
frags_orig = {
'f1': getFragRaw(),
'f2': getFragDae(),
'f3': getFragRaw()
}
t1 = getTemplate('t1', fragments=frags_orig)
# The fragment update will use the following data. It translates to
# keeping the first intact, removing the second, and modifying the
# fragment type for the third one.
frags_new = {
'f2': getFragNone(),
'f3': getFragDae(),
}
# Add the template, spawn one instance, and verify all fragments.
assert dibbler.addTemplate(t1).ok
ret = dibbler.spawnTemplate(1, t1.aid)
assert ret.ok
self.verifyRaw(ret.data['url_frag'], 'f1', frags_orig)
self.verifyDae(ret.data['url_frag'], 'f2', frags_orig)
self.verifyRaw(ret.data['url_frag'], 'f3', frags_orig)
# Record the current number of files in Dibbler. There must be one
# 'meta.json', two raw files (one each), 3 Collada files (dae + 2
# textures). These files exist twice, once in the template store and
# once in the instance store.
file_cnt = dibbler.getNumFiles().data
assert file_cnt == 2 * (1 + 2 * 1 + 1 * 3)
# Update the fragments: keep first (raw, +0), delete second (dae, -3),
# convert third from raw to dae (-1 + 3).
assert dibbler.updateFragments(1, frags_new).ok
# Record the current number of files in Dibbler.
assert dibbler.getNumFiles().data == file_cnt + (0) + (-3) + (-1 + 3)
# Verify that the first fragment is still intact, the second does not
# exist anymore, and the third was updated.
self.verifyRaw(ret.data['url_frag'], 'f1', frags_orig)
with pytest.raises(AssertionError):
self.verifyDae(ret.data['url_frag'], 'f2', frags_orig)
self.verifyDae(ret.data['url_frag'], 'f3', frags_new)
def test_updateFragments_all(self):
"""
Spawn a template and update all its fragments.
"""
dibbler = self.dibbler
# The original template has two fragments, and we will update one of
# them.
frags_orig = {'o1': getFragRaw(),
'o2': getFragDae()}
frags_new = {'o1': getFragDae()}
t1 = getTemplate('t1', fragments=frags_orig)
# Add the template and spawn two instances.
assert dibbler.addTemplate(t1).ok
ret_11 = dibbler.spawnTemplate(11, t1.aid)
ret_2 = dibbler.spawnTemplate(2, t1.aid)
assert ret_11.ok and ret_2.ok
self.verifyRaw(ret_11.data['url_frag'], 'o1', frags_orig)
self.verifyDae(ret_11.data['url_frag'], 'o2', frags_orig)
self.verifyRaw(ret_2.data['url_frag'], 'o1', frags_orig)
self.verifyDae(ret_2.data['url_frag'], 'o2', frags_orig)
# Attempt to change the fragment of a non-existing object.
assert not dibbler.updateFragments(20, frags_new).ok
# Attempt to change the fragment of another non-existing object, but
# the object ID of this one is '1', which means it is available at
# '/somewhere/1/...'. However, an object at '/somewhere/11/...' already
# exists, and without the trailing '/' the first would be a sub-string
# of the latter. The update method must therefore take care to properly
# test for existence, especially since directories, internally, do not
# have a trailing '/'.
assert not dibbler.updateFragments(1, frags_new).ok
# The previous attempts to modify fragments of non-existing objectst
# must not have modified the fragments.
self.verifyRaw(ret_11.data['url_frag'], 'o1', frags_orig)
self.verifyDae(ret_11.data['url_frag'], 'o2', frags_orig)
self.verifyRaw(ret_2.data['url_frag'], 'o1', frags_orig)
self.verifyDae(ret_2.data['url_frag'], 'o2', frags_orig)
# Change the first fragments of the first object.
assert dibbler.updateFragments(11, frags_new).ok
# Verify that only the first fragment of the '11' object has changed.
self.verifyDae(ret_11.data['url_frag'], 'o1', frags_new)
self.verifyDae(ret_11.data['url_frag'], 'o2', frags_orig)
self.verifyRaw(ret_2.data['url_frag'], 'o1', frags_orig)
self.verifyDae(ret_2.data['url_frag'], 'o2', frags_orig)
def test_addDaeTemplate(self):
"""
Add a Collada template and fetch the individual files again afterwards.
"""
dibbler = self.dibbler
# Define a template for this test.
frag = {'foo': getFragDae()}
t_dae = getTemplate('_templateEmpty', fragments=frag)
# Create a Dibbler instance and flush all data.
assert dibbler.getNumFiles() == (True, None, 0)
# Add the first template and verify that the database now contains
# extactly fourc files (a meta file, the DAE file, and two textures).
ret = dibbler.addTemplate(t_dae)
assert dibbler.getNumFiles() == (True, None, 4)
# Fetch- and verify the model.
self.verifyDae(ret.data['url_frag'], 'foo', frag)
def test_addRawTemplate(self):
"""
Add a raw template and fetch the individual files again afterwards.
"""
# Create a Dibbler instance and flush all data.
dibbler = self.dibbler
assert dibbler.getNumFiles() == (True, None, 0)
# Define a template for this test.
frags = {'foo': getFragRaw()}
t_raw = getTemplate('_templateEmpty', fragments=frags)
# Add the first template and verify that the database now contains
# exactly two files (a meta file, and the actual fragment data).
ret = dibbler.addTemplate(t_raw)
assert ret.ok
assert dibbler.getNumFiles() == (True, None, 2)
# Fetch- and verify the model.
self.verifyRaw(ret.data['url_frag'], 'foo', frags)
def test_deleteInstance(self):
"""
Add and remove an instance.
"""
dibbler = self.dibbler
# Define two templates.
frag_raw = {'foo': getFragRaw()}
frag_dae = {'bar': getFragDae()}
t_raw = getTemplate('temp_raw', fragments=frag_raw)
t_dae = getTemplate('temp_dae', fragments=frag_dae)
# Verify that Dibbler is empty.
assert dibbler.getNumFiles() == (True, None, 0)
# Add- and verify a Raw- and Collada template. The raw template 2 files
# (meta.json plus model.json) whereas the Collada template has 4 files
# (meta.json plus 1 dae file plus 2 textures).
ret = dibbler.addTemplate(t_raw)
assert dibbler.getNumFiles() == (True, None, 2)
self.verifyRaw(ret.data['url_frag'], 'foo', frag_raw)
ret = dibbler.addTemplate(t_dae)
assert dibbler.getNumFiles() == (True, None, 2 + 4)
self.verifyDae(ret.data['url_frag'], 'bar', frag_dae)
# Spawn some instances.
assert dibbler.spawnTemplate(1, 'temp_raw').ok
assert dibbler.spawnTemplate(2, 'temp_dae').ok
assert dibbler.spawnTemplate(3, 'temp_raw').ok
self.verifyRaw('{}/1'.format(config.url_instances), 'foo', frag_raw)
self.verifyDae('{}/2'.format(config.url_instances), 'bar', frag_dae)
self.verifyRaw('{}/3'.format(config.url_instances), 'foo', frag_raw)
base_cnt = (2 + 4) + 2 * 2 + 1 * 4
assert dibbler.getNumFiles() == (True, None, base_cnt)
# Remove a non-existing object. This must succeed but Dibbler must not
# have removed any files.
assert dibbler.deleteInstance(10) == (True, None, 0)
assert dibbler.getNumFiles() == (True, None, base_cnt)
# Remove the first Raw object. This must remove two files and leave the
# other two instances intact.
assert dibbler.deleteInstance(1) == (True, None, 2)
base_cnt -= 2
assert dibbler.getNumFiles() == (True, None, base_cnt)
with pytest.raises(AssertionError):
self.verifyRaw('{}/1'.format(config.url_instances), 'foo', frag_raw)
self.verifyDae('{}/2'.format(config.url_instances), 'bar', frag_dae)
self.verifyRaw('{}/3'.format(config.url_instances), 'foo', frag_raw)
# Remove the same instance again. This must succeed but Dibbler must
# not remove any files.
assert dibbler.deleteInstance(1) == (True, None, 0)
# Remove the Collada instance. This must delete four files (meta.json +
# dae + 2 textures).
assert dibbler.deleteInstance(2) == (True, None, 4)
base_cnt -= 4
assert dibbler.getNumFiles() == (True, None, base_cnt)
with pytest.raises(AssertionError):
self.verifyRaw('{}/1'.format(config.url_instances), 'foo', frag_raw)
with pytest.raises(AssertionError):
self.verifyDae('{}/2'.format(config.url_instances), 'bar', frag_dae)
self.verifyRaw('{}/3'.format(config.url_instances), 'foo', frag_raw)
# Remove the second Raw instance.
assert dibbler.deleteInstance(3) == (True, None, 2)
base_cnt -= 2
assert dibbler.getNumFiles() == (True, None, base_cnt)
with pytest.raises(AssertionError):
self.verifyRaw('{}/1'.format(config.url_instances), 'foo', frag_raw)
with pytest.raises(AssertionError):
self.verifyDae('{}/2'.format(config.url_instances), 'bar', frag_dae)
with pytest.raises(AssertionError):
self.verifyRaw('{}/3'.format(config.url_instances), 'foo', frag_raw)
def test_deleteTemplate(self):
"""
Add two templates and then delete them. This functions also tests some
corner cases where the delete-request is a substring of another
template.
"""
dibbler = self.dibbler
# Define two templates.
frag_raw = {'foo': getFragRaw()}
frag_dae = {'bar': getFragDae()}
t1 = getTemplate('name1', fragments=frag_dae)
t11 = getTemplate('name11', fragments=frag_raw)
# Verify that Dibbler's database is pristine.
assert dibbler.getNumFiles() == (True, None, 0)
# Add- and verify the Raw template.
ret = dibbler.addTemplate(t11)
assert dibbler.getNumFiles() == (True, None, 2)
self.verifyRaw(ret.data['url_frag'], 'foo', frag_raw)
# Remove the Raw template and ensure it does not exist anymore.
assert dibbler.deleteTemplate('name11').ok
assert dibbler.getNumFiles() == (True, None, 0)
with pytest.raises(AssertionError):
self.verifyRaw(ret.data['url_frag'], 'foo', frag_raw)
# Attempt to remove the Raw template once more. Dibbler must not delete
# any files, albeit the call itself must succeed.
assert dibbler.deleteTemplate('blah').ok
assert dibbler.getNumFiles() == (True, None, 0)
# Add- and verify the Raw- and Collada templates.
del ret
ret_raw = dibbler.addTemplate(t11)
ret_dae = dibbler.addTemplate(t1)
assert dibbler.getNumFiles() == (True, None, 6)
self.verifyRaw(ret_raw.data['url_frag'], 'foo', frag_raw)
self.verifyDae(ret_dae.data['url_frag'], 'bar', frag_dae)
# Remove the Collada template whose name is a substring of the first.
assert dibbler.deleteTemplate('name1') == (True, None, 4)
assert dibbler.getNumFiles() == (True, None, 2)
self.verifyRaw(ret_raw.data['url_frag'], 'foo', frag_raw)
with pytest.raises(AssertionError):
self.verifyRaw(ret_dae.data['url_frag'], 'bar', frag_dae)
# Remove the Collada template again. No files must be deleted this
# time.
assert dibbler.deleteTemplate('name1') == (True, None, 0)
assert dibbler.getNumFiles() == (True, None, 2)
# Attempt to remove a non-existing template. The call must succeed but
# Dibbler must not delete any files.
assert dibbler.deleteTemplate('blah') == (True, None, 0)
assert dibbler.getNumFiles() == (True, None, 2)
# Delete the one remaining template (Raw template) and verify that
# Dibbler does not hold any files anymore whatsoever afterwards.
assert dibbler.deleteTemplate('name11') == (True, None, 2)
assert dibbler.getNumFiles() == (True, None, 0)
with pytest.raises(AssertionError):
self.verifyRaw(ret_raw.data['url_frag'], 'foo', frag_raw)
with pytest.raises(AssertionError):
self.verifyRaw(ret_dae.data['url_frag'], 'bar', frag_dae)
