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_asset_attribute_returns_a_list_of_assets_related_to_this_project(
self):
"""testing if the asset attribute returns a list of assets which are
related to this project
"""
new_proj1 = Project("Test Project 1")
new_proj1.create()
new_proj2 = Project("Test Project 2")
new_proj2.create()
new_proj3 = Project("Test Project 3")
new_proj3.create()
asset1 = Asset(new_proj1, "Asset 1")
asset1.save()
asset2 = Asset(new_proj1, "Asset 2")
asset2.save()
asset3 = Asset(new_proj2, "Asset 3")
asset3.save()
asset4 = Asset(new_proj2, "Asset 4")
asset4.save()
self.assertItemsEqual(new_proj1.assets, [asset1, asset2])
self.assertItemsEqual(new_proj2.assets, [asset3, asset4])
self.assertItemsEqual(new_proj3.assets, [])
def test___eq__operator(self):
"""testing the __eq__ (equal) operator
"""
# create two projects
proj1 = Project(name="TEST_PROJ1")
proj2 = Project(name="TEST_PROJ1")
self.assertEqual(proj1, proj2)
def test_creating_two_different_projects_and_calling_create_in_mixed_order(
self):
"""testing no error will be raised when creating two Project instances
and calling their create method in mixed order
"""
new_proj1 = Project("TEST_PROJECT1")
new_proj2 = Project("TEST_PROJECT2")
new_proj1.create()
new_proj2.create()
def test_calling_create_on_a_project_which_is_retrieved_from_db(self):
"""testing if there will be no error messages generated when the new
project is retrieved from the database and the create method of this
project is called
"""
project_name = "TEST_PROJECT1"
new_proj1 = Project(project_name)
new_proj1.create()
new_proj2 = Project(project_name)
new_proj2.create()
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_initialization_with_database(self):
"""testing the project initialization occurs without any problem
"""
test_value = "TEST_PROJECT"
new_proj = Project(test_value)
self.assertEqual(new_proj.name, test_value)
def test_full_path_attribute_is_calculated_from_the_project_code(self):
"""testing if the full_path attribute is calculated from the project
code
"""
new_proj = Project(name="Test Project 1", code="TEST_PROJECT_1")
self.assertEqual(new_proj.full_path,
os.path.join(os.environ["REPO"], new_proj.code))
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_client_attribute_is_not_a_Client_instance(self):
"""testing if a TypeError will be raised when the client attribute is
not set to a Client instance
"""
new_client = Client(name='Test Client')
new_proj = Project(name='Test Project', client=new_client)
self.assertRaises(TypeError, setattr, new_proj, 'client', 'a client')
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_shot_number_prefix_attribute_initialization(self):
"""testing the shot_number_prefix attribute is initialized correctly
for a newly created Project instance
"""
new_proj = Project("TEST_PROJECT")
new_proj.create()
self.assertEqual(new_proj.shot_number_prefix, conf.shot_number_prefix)
def test_client_attribute_is_None(self):
"""testing if the client attribute is set to None will not cause any
error
"""
new_client = Client(name="Test Client")
new_proj = Project(name="Test Project", client=new_client)
new_proj.client = None
self.assertEqual(None, new_proj.client)
def test_project_creation_for_new_project(self):
"""testing if the project creation occurs without any problem
"""
new_proj = Project("TEST_PROJECT")
new_proj.create()
# now check if the folder is created
self.assertTrue(os.path.exists(new_proj.full_path))
def test_client_attribute_is_working_properly(self):
"""testing if the client attribute is working properly
"""
new_client1 = Client(name='Test Client 1')
new_client2 = Client(name='Test Client 2')
new_proj = Project(name='Test Project', client=new_client1)
self.assertNotEqual(new_client2, new_proj.client)
new_proj.client = new_client2
self.assertEqual(new_client2, new_proj.client)
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 _updateProjectObject(self):
"""updates the project object if it is changed
it is introduced to take advantage of the cache system
"""
currentProjectName = self.getCurrentProjectName()
if self._project is None or \
self._project.name != currentProjectName or \
(currentProjectName != "" or currentProjectName is not None):
self._project = Project(currentProjectName)
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_name_attribute_formatting(self):
"""testing if the name property will be formatted correctly.
"""
new_project = Project("TEST_NAME")
for test_value in self._name_test_values:
new_project.name = test_value[0]
expected_project_name = test_value[1]
self.assertEqual(new_project.name, expected_project_name)
def test_equality_of_assets(self):
"""testing if two assets are equal if their names and projects are also
equal
"""
proj1 = Project("EQUALITY_TEST_PROJECT_1")
proj1.create()
proj2 = Project("EQUALITY_TEST_PROJECT_2")
proj2.create()
asset1 = Asset(proj1, "TEST_ASSET1")
asset2 = Asset(proj1, "TEST_ASSET1")
asset3 = Asset(proj1, "TEST_ASSET3")
asset4 = Asset(proj2, "TEST_ASSET3")
self.assertTrue(asset1 == asset2)
self.assertFalse(asset1 == asset3)
self.assertFalse(asset3 == asset4)
def test_inequality_of_assets(self):
"""testing if two assets are inequal if their names are different and
or their projects are different
"""
proj1 = Project("EQUALITY_TEST_PROJECT_1")
proj1.create()
proj2 = Project("EQUALITY_TEST_PROJECT_2")
proj2.create()
asset1 = Asset(proj1, "TEST_ASSET1")
asset2 = Asset(proj1, "TEST_ASSET1")
asset3 = Asset(proj1, "TEST_ASSET3")
asset4 = Asset(proj2, "TEST_ASSET3")
self.assertFalse(asset1 != asset2)
self.assertTrue(asset1 != asset3)
self.assertTrue(asset3 != asset4)
def test_code_argument_is_formatted_correctly(self):
"""testing if the code attribute is formatted correctly on Project
instance creation
"""
for test_value in self._name_test_values:
project_code = test_value[0]
expected_project_code = test_value[2]
new_project = Project(name="TEST_PROJ1", code=project_code)
self.assertEqual(new_project.code, expected_project_code)
def test_name_argument_formatting(self):
"""testing if the name will be formatted correctly when creating a
new project.
"""
for test_value in self._name_test_values:
project_name = test_value[0]
expected_project_name = test_value[1]
new_project = Project(project_name)
self.assertEqual(new_project.name, expected_project_name)
def setUp(self):
"""setup the test settings with environment variables
"""
# -----------------------------------------------------------------
# start of the setUp
# create the environment variable and point it to a temp directory
conf.database_url = "sqlite://"
self.temp_config_folder = tempfile.mkdtemp()
self.temp_projects_folder = tempfile.mkdtemp()
os.environ["OYPROJECTMANAGER_PATH"] = self.temp_config_folder
os.environ[conf.repository_env_key] = self.temp_projects_folder
self.test_proj = Project("TEST_PROJ1")
self.test_proj.create()
self.kwargs = {
"project": self.test_proj,
"name": "Test Asset",
"code": "TEST_ASSET",
'type': 'Prop',
}
self.test_asset = Asset(**self.kwargs)
self.test_asset.save()
self._name_test_values = [
("Test Asset", "Test Asset"),
("23Test_Asset", "23Test_Asset"),
("TEST_ASSET", "TEST_ASSET"),
("£#$£#$AB", "AB"),
("'^+'^%^+%&&AB3£#$£½'^+'3'^+'4", "AB334"),
("afasfas fasf asdf67", "Afasfas fasf asdf67"),
("45a", "45a"),
("45acafs", "45acafs"),
("45'^+'^+a 234", "45a 234"),
("45asf78wr", "45asf78wr"),
("'^+'afsd2342'^+'asdFGH", "Afsd2342asdFGH"),
]
self._code_test_values = [
("Test Asset", "Test_Asset"),
("23Test_Asset", "23Test_Asset"),
("TEST_ASSET", "TEST_ASSET"),
("£#$£#$AB", "AB"),
("'^+'^%^+%&&AB3£#$£½'^+'3'^+'4", "AB334"),
("afasfas fasf asdf67", "Afasfas_fasf_asdf67"),
("45a", "45a"),
("45acafs", "45acafs"),
("45'^+'^+a 234", "45a_234"),
("45asf78wr", "45asf78wr"),
("'^+'afsd2342'^+'asdFGH", "Afsd2342asdFGH"),
]
def test_path_attribute_does_not_change_when_the_name_of_the_project_is_changed(
self):
"""testing if the path attribute will be the same even the name of
the proejct is changed
"""
new_proj = Project(name="TEST_PROJ1")
path = new_proj.path
# change the name
new_proj.name = "TEST_PROJ1_NEW_NAME"
# now check if the path is still the same
self.assertEqual(new_proj.path, path)
def setUp(self):
"""setup the test settings with environment variables
"""
# -----------------------------------------------------------------
# start of the setUp
conf.database_url = "sqlite://"
# create the environment variable and point it to a temp directory
self.temp_config_folder = tempfile.mkdtemp()
self.temp_projects_folder = tempfile.mkdtemp()
os.environ["OYPROJECTMANAGER_PATH"] = self.temp_config_folder
os.environ[conf.repository_env_key] = self.temp_projects_folder
self.test_proj = Project("TEST_PROJ1")
self.test_proj.create()
self.test_seq = Sequence(self.test_proj, "TEST_SEQ")
self.test_seq.save()
self.test_seq.create()
self.kwargs = {
"sequence": self.test_seq,
"number": 1,
"start_frame": 1,
"end_frame": 100,
"description": "Test shot"
}
self.test_shot = Shot(**self.kwargs)
self._number_test_values = [
(23, "23"),
("24", "24"),
("324ASF", "324ASF"),
("AD43", "AD43"),
("AS43A", "AS43A"),
("afasfas fasf asdf67", "AFASFAS_FASF_ASDF67"),
("45a", "45A"),
("45acafs","45ACAFS"),
("45'^+'^+b", "45B"),
("45asf78wr", "45ASF78WR"),
("'^+'afsd2342'^+'asdFGH", "AFSD2342ASDFGH"),
("46B-3-B", "46B-3-B"),
("XB58P-4-C", "XB58P-4-C"),
("A143AN-04-D", "A143AN-04-D"),
("xb58q-2-d", "XB58Q-2-D"),
("underscores_are_allowed", "UNDERSCORES_ARE_ALLOWED"),
("304_sb_0403_0040", "304_SB_0403_0040"),
#("0001", "1"),
]
def test_calling_create_over_and_over_again_will_not_cause_any_problem(
self):
"""testing if calling the create over and over again will not create a
problem
"""
# we need to create a new project and a sequence
new_proj = Project("TEST_PROJECT")
new_proj.create()
new_proj.create()
new_proj.create()
new_proj.create()
new_proj.create()
new_proj.create()
def test_project_restores_from_database_2(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()
new_seq = Sequence(new_proj, "TEST_SEQ")
new_seq.save()
new_seq.create()
db.session.add(new_proj)
db.session.commit()
del new_proj
del new_seq
# now retrieve the project by recreating it
new_proj2 = Project(name="TEST_PROJECT")
self.assertEqual(new_proj2.sequences[0].name, "TEST_SEQ")
