def test_deleting_a_project_deletes_the_related_sequences(self):
"""testing if deleting a project will also delete the related sequences
"""
proj1 = Project("Test Project 1")
proj1.save()
proj2 = Project("Test Project 2")
proj2.save()
seq1 = Sequence(proj1, "Test Sequence 1")
seq1.save()
seq2 = Sequence(proj1, "Test Sequence 2")
seq2.save()
seq3 = Sequence(proj2, "Test Sequence 3")
seq3.save()
self.assertIn(proj1, db.session)
self.assertIn(seq1, db.session)
self.assertIn(seq2, db.session)
db.session.delete(proj1)
db.session.commit()
self.assertNotIn(proj1, db.session)
self.assertNotIn(seq1, db.session)
self.assertNotIn(seq2, db.session)
self.assertIn(proj2, db.session)
self.assertIn(seq3, db.session)
def test_deleting_a_project_deletes_the_related_assets(self):
"""testing if deleting a project also deletes all Assets related to it
"""
proj1 = Project("Test Project1")
proj1.save()
proj2 = Project("Test Project2")
proj2.save()
asset1 = Asset(proj1, "Test Asset 1")
asset1.save()
asset2 = Asset(proj1, "Test Asset 2")
asset2.save()
asset3 = Asset(proj2, "Test Asset 3")
asset3.save()
# confirm assets are in session
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
db.session.delete(proj1)
db.session.commit()
# now check if asset1 and asset2 are also deleted
assets = db.session.query(Asset).all()
self.assertNotIn(asset1, assets)
self.assertNotIn(asset2, assets)
self.assertNotIn(asset1, db.session)
self.assertNotIn(asset2, db.session)
# check if proj2 and asset3 are still there
self.assertIn(proj2, db.session)
self.assertIn(asset3, db.session)
def test_deleting_a_shot_will_not_delete_the_other_shots_in_the_related_sequence(self):
"""testing if deleting a shot will not delete the other shots in the
sequence
"""
proj1 = Project('test project 1')
proj1.save()
seq1 = Sequence(proj1, 'test seq 1')
seq1.save()
shot1 = Shot(seq1, 1)
shot1.save()
shot2 = Shot(seq1, 2)
shot2.save()
# check if they are in the session
self.assertIn(proj1, db.session)
self.assertIn(seq1, db.session)
self.assertIn(shot1, db.session)
self.assertIn(shot2, db.session)
# delete the shot
db.session.delete(shot1)
db.session.commit()
self.assertNotIn(shot1, db.session)
self.assertIn(shot2, db.session)
def test_deleting_an_asset_will_not_delete_the_other_assets_in_the_related_project(
self):
"""testing if deleting an asset will not delete the other assets in the
related project
"""
proj1 = Project('test project 1')
proj1.save()
asset1 = Asset(proj1, 'test asset 1')
asset1.save()
asset2 = Asset(proj1, 'test asset 2')
asset2.save()
asset3 = Asset(proj1, 'test asset 3')
asset3.save()
# check if they are properly in the db.session
self.assertIn(proj1, db.session)
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(asset3, db.session)
# delete asset1
db.session.delete(asset1)
db.session.commit()
# check if the asset1 is deleted
self.assertNotIn(asset1, db.session)
# and the others are in place
self.assertIn(proj1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(asset3, db.session)
def test_deleting_a_project_deletes_the_related_sequences(self):
"""testing if deleting a project will also delete the related sequences
"""
proj1 = Project("Test Project 1")
proj1.save()
proj2 = Project("Test Project 2")
proj2.save()
seq1 = Sequence(proj1, "Test Sequence 1")
seq1.save()
seq2 = Sequence(proj1, "Test Sequence 2")
seq2.save()
seq3 = Sequence(proj2, "Test Sequence 3")
seq3.save()
self.assertIn(proj1, db.session)
self.assertIn(seq1, db.session)
self.assertIn(seq2, db.session)
db.session.delete(proj1)
db.session.commit()
self.assertNotIn(proj1, db.session)
self.assertNotIn(seq1, db.session)
self.assertNotIn(seq2, db.session)
self.assertIn(proj2, db.session)
self.assertIn(seq3, db.session)
def test_deleting_an_asset_will_not_delete_the_other_assets_in_the_related_project(self):
"""testing if deleting an asset will not delete the other assets in the
related project
"""
proj1 = Project('test project 1')
proj1.save()
asset1 = Asset(proj1, 'test asset 1')
asset1.save()
asset2 = Asset(proj1, 'test asset 2')
asset2.save()
asset3 = Asset(proj1, 'test asset 3')
asset3.save()
# check if they are properly in the db.session
self.assertIn(proj1, db.session)
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(asset3, db.session)
# delete asset1
db.session.delete(asset1)
db.session.commit()
# check if the asset1 is deleted
self.assertNotIn(asset1, db.session)
# and the others are in place
self.assertIn(proj1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(asset3, db.session)
def test_deleting_a_project_deletes_the_related_assets(self):
"""testing if deleting a project also deletes all Assets related to it
"""
proj1 = Project("Test Project1")
proj1.save()
proj2 = Project("Test Project2")
proj2.save()
asset1 = Asset(proj1, "Test Asset 1")
asset1.save()
asset2 = Asset(proj1, "Test Asset 2")
asset2.save()
asset3 = Asset(proj2, "Test Asset 3")
asset3.save()
# confirm assets are in session
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
db.session.delete(proj1)
db.session.commit()
# now check if asset1 and asset2 are also deleted
assets = db.session.query(Asset).all()
self.assertNotIn(asset1, assets)
self.assertNotIn(asset2, assets)
self.assertNotIn(asset1, db.session)
self.assertNotIn(asset2, db.session)
# check if proj2 and asset3 are still there
self.assertIn(proj2, db.session)
self.assertIn(asset3, db.session)
def test_calling_commit_multiple_times(self):
"""testing if there is no problem of calling Project.save() multiple
times
"""
new_proj = Project("TEST_PROJECT")
new_proj.create()
new_proj.save()
new_proj.save()
def test_calling_commit_multiple_times(self):
"""testing if there is no problem of calling Project.save() multiple
times
"""
new_proj = Project("TEST_PROJECT")
new_proj.create()
new_proj.save()
new_proj.save()
def test_shot_number_prefix_attribute_initialization_from_DB(self):
"""testing if the shot_number_prefix attribute is initialized correctly
for a Project which is already in the database
"""
new_proj = Project("TEST_PROJECT")
new_proj.shot_number_prefix = "PL"
new_proj.create()
new_proj.save()
# now get it back from db
new_proj = Project("TEST_PROJECT")
self.assertEqual(new_proj.shot_number_prefix, "PL")
def test_shot_number_prefix_attribute_initialization_from_DB(self):
"""testing if the shot_number_prefix attribute is initialized correctly
for a Project which is already in the database
"""
new_proj = Project("TEST_PROJECT")
new_proj.shot_number_prefix = "PL"
new_proj.create()
new_proj.save()
# now get it back from db
new_proj = Project("TEST_PROJECT")
self.assertEqual(new_proj.shot_number_prefix, "PL")
def test_deleting_a_project_will_delete_the_related_shots(self):
"""testing if deleting a project will also delete the related shots
"""
proj1 = Project("Test Project 1")
proj1.save()
proj2 = Project("Test Project 2")
proj2.save()
seq1 = Sequence(proj1, "Sequence 1")
seq1.save()
seq2 = Sequence(proj2, "Sequence 2")
seq2.save()
shot1 = Shot(seq1, 1)
shot1.save()
shot2 = Shot(seq1, 2)
shot2.save()
shot3 = Shot(seq2, 1)
shot3.save()
shot4 = Shot(seq2, 2)
shot4.save()
# check all are in session
self.assertIn(proj1, db.session)
self.assertIn(proj2, db.session)
self.assertIn(seq1, db.session)
self.assertIn(seq2, db.session)
self.assertIn(shot1, db.session)
self.assertIn(shot2, db.session)
self.assertIn(shot3, db.session)
self.assertIn(shot4, db.session)
# delete the project
db.session.delete(proj1)
db.session.commit()
self.assertNotIn(proj1, db.session)
self.assertNotIn(seq1, db.session)
self.assertNotIn(shot1, db.session)
self.assertNotIn(shot2, db.session)
self.assertIn(proj2, db.session)
self.assertIn(seq2, db.session)
self.assertIn(shot3, db.session)
self.assertIn(shot4, db.session)
def test_deleting_a_project_will_delete_the_related_shots(self):
"""testing if deleting a project will also delete the related shots
"""
proj1 = Project("Test Project 1")
proj1.save()
proj2 = Project("Test Project 2")
proj2.save()
seq1 = Sequence(proj1, "Sequence 1")
seq1.save()
seq2 = Sequence(proj2, "Sequence 2")
seq2.save()
shot1 = Shot(seq1, 1)
shot1.save()
shot2 = Shot(seq1, 2)
shot2.save()
shot3 = Shot(seq2, 1)
shot3.save()
shot4 = Shot(seq2, 2)
shot4.save()
# check all are in session
self.assertIn(proj1, db.session)
self.assertIn(proj2, db.session)
self.assertIn(seq1, db.session)
self.assertIn(seq2, db.session)
self.assertIn(shot1, db.session)
self.assertIn(shot2, db.session)
self.assertIn(shot3, db.session)
self.assertIn(shot4, db.session)
# delete the project
db.session.delete(proj1)
db.session.commit()
self.assertNotIn(proj1, db.session)
self.assertNotIn(seq1, db.session)
self.assertNotIn(shot1, db.session)
self.assertNotIn(shot2, db.session)
self.assertIn(proj2, db.session)
self.assertIn(seq2, db.session)
self.assertIn(shot3, db.session)
self.assertIn(shot4, db.session)
def test_project_restores_from_database_1(self):
"""testing if a project restores it self from the database with all its
connections
"""
# we need to create a new project and a sequence
new_proj = Project("TEST_PROJECT")
new_proj.create()
test_description = "test description"
new_proj.description = test_description
new_proj.save()
del new_proj
# now retrieve the project by recreating it
new_proj2 = Project("TEST_PROJECT")
self.assertEqual(new_proj2.description, test_description)
def test_project_restores_from_database_1(self):
"""testing if a project restores it self from the database with all its
connections
"""
# we need to create a new project and a sequence
new_proj = Project("TEST_PROJECT")
new_proj.create()
test_description = "test description"
new_proj.description = test_description
new_proj.save()
del new_proj
# now retrieve the project by recreating it
new_proj2 = Project("TEST_PROJECT")
self.assertEqual(new_proj2.description, test_description)
def test_deleting_an_asset_will_not_delete_the_related_project(self):
"""testing if deleting an asset will not delete the related project
"""
proj1 = Project('test project 1')
proj1.save()
asset = Asset(proj1, 'Test asset')
asset.save()
# check if they are in the session
self.assertIn(proj1, db.session)
self.assertIn(asset, db.session)
# delete the asset
db.session.delete(asset)
db.session.commit()
# check if it is removed from the session
self.assertNotIn(asset, db.session)
# and the project is there
self.assertIn(proj1, db.session)
def test_deleting_an_asset_will_not_delete_the_related_project(self):
"""testing if deleting an asset will not delete the related project
"""
proj1 = Project('test project 1')
proj1.save()
asset = Asset(proj1, 'Test asset')
asset.save()
# check if they are in the session
self.assertIn(proj1, db.session)
self.assertIn(asset, db.session)
# delete the asset
db.session.delete(asset)
db.session.commit()
# check if it is removed from the session
self.assertNotIn(asset, db.session)
# and the project is there
self.assertIn(proj1, db.session)
def test_deleting_an_asset_will_delete_all_the_related_versions_but_keep_references(
self):
"""testing if deleting an asset will only delete the version of that
asset and will keep the referenced versions.
"""
proj1 = Project('test project 1')
proj1.save()
asset1 = Asset(proj1, 'test asset 1')
asset1.save()
asset2 = Asset(proj1, 'test asset 2')
asset2.save()
asset_vtypes = VersionType.query().filter_by(type_for="Asset").all()
user = User.query().first()
vers1 = Version(version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user)
vers1.save()
vers2 = Version(version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user)
vers2.save()
vers3 = Version(version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user)
vers3.save()
vers4 = Version(version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user)
vers4.save()
vers5 = Version(version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user)
vers5.save()
vers6 = Version(version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user)
vers6.save()
# reference vers4, vers5 and vers6 to vers1, vers2 and vers3
vers1.references.append(vers4)
vers1.references.append(vers5)
vers1.references.append(vers6)
vers2.references.append(vers4)
vers2.references.append(vers5)
vers2.references.append(vers6)
vers3.references.append(vers4)
vers3.references.append(vers5)
vers3.references.append(vers6)
# check if all are in the session
self.assertIn(proj1, db.session)
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers1, db.session)
self.assertIn(vers2, db.session)
self.assertIn(vers3, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
# there should be 9 entries in the secondary table
result = db.session\
.query('referencer_id', 'reference_id')\
.from_statement("SELECT referencer_id, reference_id "
"FROM Version_References").all()
self.assertEqual(len(result), 9)
# delete the asset
db.session.delete(asset1)
db.session.commit()
# check if it is not in the session anymore
self.assertNotIn(asset1, db.session)
# check if the versions are also deleted
self.assertNotIn(vers1, db.session)
self.assertNotIn(vers2, db.session)
self.assertNotIn(vers3, db.session)
# check if the others are still there
self.assertIn(proj1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
# to be sure check the secondary table
result = db.session\
.query('referencer_id', 'reference_id')\
.from_statement("SELECT referencer_id, reference_id "
"FROM Version_References").all()
self.assertEqual(len(result), 0)
def test_deleting_an_asset_will_delete_all_the_related_versions(self):
"""testing if deleting an asset will also delete the related versions
"""
proj1 = Project('test project 1')
proj1.save()
asset1 = Asset(proj1, 'test asset 1')
asset1.save()
asset2 = Asset(proj1, 'test asset 2')
asset2.save()
asset_vtypes = VersionType.query().filter_by(type_for="Asset").all()
user = User.query().first()
vers1 = Version(version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user)
vers1.save()
vers2 = Version(version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user)
vers2.save()
vers3 = Version(version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user)
vers3.save()
vers4 = Version(version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user)
vers4.save()
vers5 = Version(version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user)
vers5.save()
vers6 = Version(version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user)
vers6.save()
# check if all are in the session
self.assertIn(proj1, db.session)
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers1, db.session)
self.assertIn(vers2, db.session)
self.assertIn(vers3, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
# delete the asset
db.session.delete(asset1)
db.session.commit()
# check if it is not in the session anymore
self.assertNotIn(asset1, db.session)
# check if the versions are also deleted
self.assertNotIn(vers1, db.session)
self.assertNotIn(vers2, db.session)
self.assertNotIn(vers3, db.session)
# check if the others are still there
self.assertIn(proj1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
def test_deleting_a_shot_will_delete_the_related_versions(self):
"""testing if deleting a shot will delete the related versions
"""
proj1 = Project('test project 1')
proj1.save()
seq1 = Sequence(proj1, 'test sequence 1')
seq1.save()
shot1 = Shot(seq1, 1)
shot1.save()
shot2 = Shot(seq1, 2)
shot2.save()
user = User.query().first()
shot_vtypes = VersionType.query().filter_by(type_for="Shot").all()
# versions for shot1
vers1 = Version(
shot1,
base_name=shot1.code,
type=shot_vtypes[0],
created_by=user
)
vers1.save()
vers2 = Version(
shot1,
base_name=shot1.code,
type=shot_vtypes[0],
created_by=user
)
vers2.save()
vers3 = Version(
shot1,
base_name=shot1.code,
type=shot_vtypes[0],
created_by=user
)
vers3.save()
# versions for shot2
vers4 = Version(
shot2,
base_name=shot2.code,
type=shot_vtypes[0],
created_by=user
)
vers4.save()
vers5 = Version(
shot2,
base_name=shot2.code,
type=shot_vtypes[0],
created_by=user
)
vers5.save()
vers6 = Version(
shot2,
base_name=shot2.code,
type=shot_vtypes[0],
created_by=user
)
vers6.save()
# test all are in the session
self.assertIn(proj1, db.session)
self.assertIn(seq1, db.session)
self.assertIn(shot1, db.session)
self.assertIn(shot2, db.session)
self.assertIn(vers1, db.session)
self.assertIn(vers2, db.session)
self.assertIn(vers3, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
# delete shot1
db.session.delete(shot1)
db.session.commit()
# check if versions are deleted
self.assertNotIn(shot1, db.session)
self.assertNotIn(vers1, db.session)
self.assertNotIn(vers2, db.session)
self.assertNotIn(vers3, db.session)
# check if all the others are still there
self.assertIn(proj1, db.session)
self.assertIn(seq1, db.session)
self.assertIn(shot2, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
def test_deleting_an_asset_will_delete_all_the_related_versions_but_keep_references(self):
"""testing if deleting an asset will only delete the version of that
asset and will keep the referenced versions.
"""
proj1 = Project('test project 1')
proj1.save()
asset1 = Asset(proj1, 'test asset 1')
asset1.save()
asset2 = Asset(proj1, 'test asset 2')
asset2.save()
asset_vtypes = VersionType.query().filter_by(type_for="Asset").all()
user = User.query().first()
vers1 = Version(
version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user
)
vers1.save()
vers2 = Version(
version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user
)
vers2.save()
vers3 = Version(
version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user
)
vers3.save()
vers4 = Version(
version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user
)
vers4.save()
vers5 = Version(
version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user
)
vers5.save()
vers6 = Version(
version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user
)
vers6.save()
# reference vers4, vers5 and vers6 to vers1, vers2 and vers3
vers1.references.append(vers4)
vers1.references.append(vers5)
vers1.references.append(vers6)
vers2.references.append(vers4)
vers2.references.append(vers5)
vers2.references.append(vers6)
vers3.references.append(vers4)
vers3.references.append(vers5)
vers3.references.append(vers6)
# check if all are in the session
self.assertIn(proj1, db.session)
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers1, db.session)
self.assertIn(vers2, db.session)
self.assertIn(vers3, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
# there should be 9 entries in the secondary table
result = db.session\
.query('referencer_id', 'reference_id')\
.from_statement("SELECT referencer_id, reference_id "
"FROM Version_References").all()
self.assertEqual(len(result), 9)
# delete the asset
db.session.delete(asset1)
db.session.commit()
# check if it is not in the session anymore
self.assertNotIn(asset1, db.session)
# check if the versions are also deleted
self.assertNotIn(vers1, db.session)
self.assertNotIn(vers2, db.session)
self.assertNotIn(vers3, db.session)
# check if the others are still there
self.assertIn(proj1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
# to be sure check the secondary table
result = db.session\
.query('referencer_id', 'reference_id')\
.from_statement("SELECT referencer_id, reference_id "
"FROM Version_References").all()
self.assertEqual(len(result), 0)
def test_deleting_an_asset_will_delete_all_the_related_versions(self):
"""testing if deleting an asset will also delete the related versions
"""
proj1 = Project('test project 1')
proj1.save()
asset1 = Asset(proj1, 'test asset 1')
asset1.save()
asset2 = Asset(proj1, 'test asset 2')
asset2.save()
asset_vtypes = VersionType.query().filter_by(type_for="Asset").all()
user = User.query().first()
vers1 = Version(
version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user
)
vers1.save()
vers2 = Version(
version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user
)
vers2.save()
vers3 = Version(
version_of=asset1,
base_name=asset1.code,
type=asset_vtypes[0],
created_by=user
)
vers3.save()
vers4 = Version(
version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user
)
vers4.save()
vers5 = Version(
version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user
)
vers5.save()
vers6 = Version(
version_of=asset2,
base_name=asset2.code,
type=asset_vtypes[0],
created_by=user
)
vers6.save()
# check if all are in the session
self.assertIn(proj1, db.session)
self.assertIn(asset1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers1, db.session)
self.assertIn(vers2, db.session)
self.assertIn(vers3, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
# delete the asset
db.session.delete(asset1)
db.session.commit()
# check if it is not in the session anymore
self.assertNotIn(asset1, db.session)
# check if the versions are also deleted
self.assertNotIn(vers1, db.session)
self.assertNotIn(vers2, db.session)
self.assertNotIn(vers3, db.session)
# check if the others are still there
self.assertIn(proj1, db.session)
self.assertIn(asset2, db.session)
self.assertIn(vers4, db.session)
self.assertIn(vers5, db.session)
self.assertIn(vers6, db.session)
