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_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_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_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_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)