def test_add_alternative_shot_is_working_properly(self): """testing if the add_alternative_shot method is working properly """ new_proj = Project("Test Project") new_proj.create() new_seq = Sequence(new_proj, "Test Sequence", "TEST_SEQ1") new_seq.save() new_shot = Shot(new_seq, 1) new_shot.save() # check if the sequence has only one shot self.assertEqual(len(new_seq.shots), 1) # now create an alternative to this shot new_seq.add_alternative_shot(1) # now check if the sequence has two shots self.assertEqual(len(new_seq.shots), 2) # and the second shots number is 1A self.assertEqual(new_seq.shots[1].number, "1A") # add a new alternative new_seq.add_alternative_shot("1") # check if there is three shots self.assertEqual(len(new_seq.shots), 3) # and the third shots number is 1B self.assertEqual(new_seq.shots[2].number, "1B")
def test_database_simple_data(self): """testing if the database file has the necessary information related to the Sequence """ new_proj = Project(name="TEST_PROJECT") new_proj.create() test_seq_name = "TEST_SEQ1" new_seq = Sequence(new_proj, test_seq_name) new_seq.save() new_seq.create() # fill it with some non default values description = new_seq.description = "Test description" new_seq.save() # now check if the database is created correctly del new_seq # create the seq from scratch and let it read the database new_seq = db.session.query(Sequence).first() # now check if it was able to get these data self.assertEqual(description, new_seq.description)
def test_UI_will_edit_the_given_Project_instance(self): """testing if a Project instance is passed the interface will allow the given Project instance to be edited """ new_client = Client(name='Test Client 1') new_client.save() new_project = Project("Test Project") new_project.create() dialog = project_properties.MainDialog(project=new_project) # now edit the project from the UI new_name = "Test Project New Name" new_fps = 50 dialog.name_lineEdit.setText(new_name) new_client_2_name = 'Test Client 2' dialog.clients_comboBox.lineEdit().setText(new_client_2_name) dialog.fps_spinBox.setValue(new_fps) dialog.resolution_comboBox.setCurrentIndex(3) preset_name = dialog.resolution_comboBox.currentText() resolution_data = conf.resolution_presets[preset_name] dialog.active_checkBox.setChecked(False) dialog.shot_number_prefix_lineEdit.setText("PL") dialog.shot_number_padding_spinBox.setValue(5) dialog.revision_number_prefix_lineEdit.setText("rev") dialog.revision_number_padding_spinBox.setValue(3) dialog.version_number_prefix_lineEdit.setText("ver") dialog.version_number_padding_spinBox.setValue(5) new_structure = "This is the new structure\nwith three lines\n" + \ "and this is the third line" dialog.structure_textEdit.setText(new_structure) # hit ok QTest.mouseClick(dialog.buttonBox.buttons()[0], Qt.LeftButton) # now check the data self.assertEqual(new_project.name, new_name) self.assertEqual(new_project.client.name, new_client_2_name) # check if a client is created with that name new_client_2 = Client.query().filter( Client.name == new_client_2_name).first() self.assertIsInstance(new_client_2, Client) self.assertEqual(new_project.fps, new_fps) self.assertEqual(new_project.width, resolution_data[0]) self.assertEqual(new_project.height, resolution_data[1]) self.assertEqual(new_project.pixel_aspect, resolution_data[2]) self.assertEqual(new_project.active, False) self.assertEqual(new_project.shot_number_padding, 5) self.assertEqual(new_project.shot_number_prefix, "PL") self.assertEqual(new_project.rev_number_padding, 3) self.assertEqual(new_project.rev_number_prefix, "rev") self.assertEqual(new_project.ver_number_padding, 5) self.assertEqual(new_project.ver_number_prefix, "ver") self.assertEqual(new_project.structure, new_structure)
def test_add_shots_method_creates_shots_based_on_the_given_range_formulat(self): """testing if the add_shots will create shots based on the shot_range_formula argument """ new_proj = Project(name="Test Project") new_proj.create() new_seq1 = Sequence(new_proj, "Test Sequence 1", "TEST_SEQ1") new_seq1.save() expected_shot_numbers = [ "1", "2", "3", "4", "5", "6", "7", "8", "10", "12", "13", "14", "15", "304_SB_0403_0040", ] # assert there is no shots in the sequence self.assertTrue(len(new_seq1.shots) == 0) # add a new shot new_seq1.add_shots("1") self.assertTrue(len(new_seq1.shots) == 1) self.assertTrue(new_seq1.shots[0].number in expected_shot_numbers) # add a couple of shots new_seq1.add_shots("2,3,4") self.assertTrue(len(new_seq1.shots) == 4) self.assertTrue(new_seq1.shots[1].number in expected_shot_numbers) self.assertTrue(new_seq1.shots[2].number in expected_shot_numbers) self.assertTrue(new_seq1.shots[3].number in expected_shot_numbers) # add a couple of more # new_seq1.add_shots("5-8,10,12-15") new_seq1.add_shots("5,6,7,8,10,12,13,14,15,304_sb_0403_0040") self.assertTrue(len(new_seq1.shots) == 14) self.assertIn(new_seq1.shots[4].number, expected_shot_numbers) self.assertIn(new_seq1.shots[5].number, expected_shot_numbers) self.assertIn(new_seq1.shots[6].number, expected_shot_numbers) self.assertIn(new_seq1.shots[7].number, expected_shot_numbers) self.assertIn(new_seq1.shots[8].number, expected_shot_numbers) self.assertIn(new_seq1.shots[9].number, expected_shot_numbers) self.assertIn(new_seq1.shots[10].number, expected_shot_numbers) self.assertIn(new_seq1.shots[11].number, expected_shot_numbers) self.assertIn(new_seq1.shots[12].number, expected_shot_numbers) self.assertIn(new_seq1.shots[13].number, expected_shot_numbers)
def test_UI_will_edit_the_given_Project_instance(self): """testing if a Project instance is passed the interface will allow the given Project instance to be edited """ new_client = Client(name='Test Client 1') new_client.save() new_project = Project("Test Project") new_project.create() dialog = project_properties.MainDialog(project=new_project) # now edit the project from the UI new_name = "Test Project New Name" new_fps = 50 dialog.name_lineEdit.setText(new_name) new_client_2_name = 'Test Client 2' dialog.clients_comboBox.lineEdit().setText(new_client_2_name) dialog.fps_spinBox.setValue(new_fps) dialog.resolution_comboBox.setCurrentIndex(3) preset_name = dialog.resolution_comboBox.currentText() resolution_data = conf.resolution_presets[preset_name] dialog.active_checkBox.setChecked(False) dialog.shot_number_prefix_lineEdit.setText("PL") dialog.shot_number_padding_spinBox.setValue(5) dialog.revision_number_prefix_lineEdit.setText("rev") dialog.revision_number_padding_spinBox.setValue(3) dialog.version_number_prefix_lineEdit.setText("ver") dialog.version_number_padding_spinBox.setValue(5) new_structure = "This is the new structure\nwith three lines\n" + \ "and this is the third line" dialog.structure_textEdit.setText(new_structure) # hit ok QTest.mouseClick(dialog.buttonBox.buttons()[0], Qt.LeftButton) # now check the data self.assertEqual(new_project.name, new_name) self.assertEqual(new_project.client.name, new_client_2_name) # check if a client is created with that name new_client_2 = Client.query().filter(Client.name==new_client_2_name).first() self.assertIsInstance(new_client_2, Client) self.assertEqual(new_project.fps, new_fps) self.assertEqual(new_project.width, resolution_data[0]) self.assertEqual(new_project.height, resolution_data[1]) self.assertEqual(new_project.pixel_aspect, resolution_data[2]) self.assertEqual(new_project.active, False) self.assertEqual(new_project.shot_number_padding, 5) self.assertEqual(new_project.shot_number_prefix, "PL") self.assertEqual(new_project.rev_number_padding, 3) self.assertEqual(new_project.rev_number_prefix, "rev") self.assertEqual(new_project.ver_number_padding, 5) self.assertEqual(new_project.ver_number_prefix, "ver") self.assertEqual(new_project.structure, new_structure)
def test_save_as_sets_the_fps(self): """testing if the save_as method sets the fps value correctly """ # create two projects with different fps values # first create a new scene and save it under the first project # and then save it under the other project # and check if the fps follows the project values project1 = Project("FPS_TEST_PROJECT_1") project1.fps = 24 project1.create() project2 = Project("FPS_TEST_PROJECT_2") project2.fps = 30 project2.save() # create assets asset1 = Asset(project1, "Test Asset 1") asset1.save() asset2 = Asset(project2, "Test Asset 2") asset2.save() # create versions version1 = Version( version_of=asset1, base_name=asset1.code, type=self.asset_vtypes[0], created_by=self.user1 ) version2 = Version( version_of=asset2, base_name=asset2.code, type=self.asset_vtypes[0], created_by=self.user1 ) # save the current scene for asset1 self.mEnv.save_as(version1) # check the fps value self.assertEqual( self.mEnv.get_fps(), 24 ) # now save it for asset2 self.mEnv.save_as(version2) # check the fps value self.assertEqual( self.mEnv.get_fps(), 30 )
def test_sequences_comboBox_is_filled_with_sequences_from_the_current_project( self): """testing if the sequences_comboBox is filled with the correct sequences from the currently chosen Project instance """ project1 = Project("Test Project 1") project2 = Project("Test Project 2") project1.create() project2.create() project1.save() project2.save() seq1 = Sequence(project1, "Test Sequence 1") seq1.save() seq2 = Sequence(project1, "Test Sequence 2") seq2.save() seq3 = Sequence(project2, "Test Sequence 3") seq3.save() seq4 = Sequence(project2, "Test Sequence 4") seq4.save() # create dialog dialog = project_manager.MainDialog() # self.show_dialog(dialog) # set the project to project2 index = dialog.projects_comboBox.findText(project2.name) dialog.projects_comboBox.setCurrentIndex(index) # check if the sequences_comboBox is filled with correct data self.assertEqual(dialog.sequences_comboBox.count(), 2) item_texts = [] for i in range(2): dialog.sequences_comboBox.setCurrentIndex(i) item_texts.append(dialog.sequences_comboBox.currentText()) self.assertTrue(seq3.name in item_texts) self.assertTrue(seq4.name in item_texts) # set the project to project1 index = dialog.projects_comboBox.findText(project1.name) dialog.projects_comboBox.setCurrentIndex(index) # check if the sequences_comboBox is filled with correct data self.assertEqual(dialog.sequences_comboBox.count(), 2) item_texts = [] for i in range(2): dialog.sequences_comboBox.setCurrentIndex(i) item_texts.append(dialog.sequences_comboBox.currentText()) self.assertTrue(seq1.name in item_texts) self.assertTrue(seq2.name in item_texts)
def test_code_lineEdit_is_disabled_when_an_existing_Project_is_passed(self): """testing if the code_lineEdit is disabled when an existing Project instance is passed to the UI """ new_project = Project("Test Project 1") new_project.create() dialog = project_properties.MainDialog(project=new_project) self.assertFalse(dialog.code_lineEdit.isEnabled())
def test_sequences_comboBox_is_filled_with_sequences_from_the_current_project(self): """testing if the sequences_comboBox is filled with the correct sequences from the currently chosen Project instance """ project1 = Project("Test Project 1") project2 = Project("Test Project 2") project1.create() project2.create() project1.save() project2.save() seq1 = Sequence(project1, "Test Sequence 1") seq1.save() seq2 = Sequence(project1, "Test Sequence 2") seq2.save() seq3 = Sequence(project2, "Test Sequence 3") seq3.save() seq4 = Sequence(project2, "Test Sequence 4") seq4.save() # create dialog dialog = project_manager.MainDialog() # self.show_dialog(dialog) # set the project to project2 index = dialog.projects_comboBox.findText(project2.name) dialog.projects_comboBox.setCurrentIndex(index) # check if the sequences_comboBox is filled with correct data self.assertEqual(dialog.sequences_comboBox.count(), 2) item_texts = [] for i in range(2): dialog.sequences_comboBox.setCurrentIndex(i) item_texts.append(dialog.sequences_comboBox.currentText()) self.assertTrue(seq3.name in item_texts) self.assertTrue(seq4.name in item_texts) # set the project to project1 index = dialog.projects_comboBox.findText(project1.name) dialog.projects_comboBox.setCurrentIndex(index) # check if the sequences_comboBox is filled with correct data self.assertEqual(dialog.sequences_comboBox.count(), 2) item_texts = [] for i in range(2): dialog.sequences_comboBox.setCurrentIndex(i) item_texts.append(dialog.sequences_comboBox.currentText()) self.assertTrue(seq1.name in item_texts) self.assertTrue(seq2.name in item_texts)
def test_code_lineEdit_is_disabled_when_an_existing_Project_is_passed( self): """testing if the code_lineEdit is disabled when an existing Project instance is passed to the UI """ new_project = Project("Test Project 1") new_project.create() dialog = project_properties.MainDialog(project=new_project) self.assertFalse(dialog.code_lineEdit.isEnabled())
def test_sequences_comboBox_caches_Sequence_instances_in_sequences_attribute( self): """testing if the sequence_comboBox caches the Sequence instances in an attribute called Sequence """ project1 = Project("Test Project 1") project1.create() project2 = Project("Test Project 2") project2.create() seq1 = Sequence(project1, "Test Sequence 1") seq1.save() seq2 = Sequence(project1, "Test Sequence 2") seq2.save() seq3 = Sequence(project2, "Test Sequence 3") seq3.save() seq4 = Sequence(project2, "Test Sequence 4") seq4.save() seq5 = Sequence(project2, "Test Sequence 5") seq5.save() dialog = project_manager.MainDialog() self.assertTrue(hasattr(dialog.sequences_comboBox, "sequences")) # set it to project1 index = dialog.projects_comboBox.findText(project1.name) dialog.projects_comboBox.setCurrentIndex(index) # check if sequences_comboBox.sequences has 3 elements self.assertEqual(len(dialog.sequences_comboBox.sequences), 2) # check if all the sequences are there self.assertTrue(seq1 in dialog.sequences_comboBox.sequences) self.assertTrue(seq2 in dialog.sequences_comboBox.sequences) # set it to project2 index = dialog.projects_comboBox.findText(project2.name) dialog.projects_comboBox.setCurrentIndex(index) # check if sequences_comboBox.sequences has 3 elements self.assertEqual(len(dialog.sequences_comboBox.sequences), 3) # check if all the sequences are there self.assertTrue(seq3 in dialog.sequences_comboBox.sequences) self.assertTrue(seq4 in dialog.sequences_comboBox.sequences) self.assertTrue(seq5 in dialog.sequences_comboBox.sequences)
def test_sequences_comboBox_caches_Sequence_instances_in_sequences_attribute(self): """testing if the sequence_comboBox caches the Sequence instances in an attribute called Sequence """ project1 = Project("Test Project 1") project1.create() project2 = Project("Test Project 2") project2.create() seq1 = Sequence(project1, "Test Sequence 1") seq1.save() seq2 = Sequence(project1, "Test Sequence 2") seq2.save() seq3 = Sequence(project2, "Test Sequence 3") seq3.save() seq4 = Sequence(project2, "Test Sequence 4") seq4.save() seq5 = Sequence(project2, "Test Sequence 5") seq5.save() dialog = project_manager.MainDialog() self.assertTrue(hasattr(dialog.sequences_comboBox, "sequences")) # set it to project1 index = dialog.projects_comboBox.findText(project1.name) dialog.projects_comboBox.setCurrentIndex(index) # check if sequences_comboBox.sequences has 3 elements self.assertEqual(len(dialog.sequences_comboBox.sequences), 2) # check if all the sequences are there self.assertTrue(seq1 in dialog.sequences_comboBox.sequences) self.assertTrue(seq2 in dialog.sequences_comboBox.sequences) # set it to project2 index = dialog.projects_comboBox.findText(project2.name) dialog.projects_comboBox.setCurrentIndex(index) # check if sequences_comboBox.sequences has 3 elements self.assertEqual(len(dialog.sequences_comboBox.sequences), 3) # check if all the sequences are there self.assertTrue(seq3 in dialog.sequences_comboBox.sequences) self.assertTrue(seq4 in dialog.sequences_comboBox.sequences) self.assertTrue(seq5 in dialog.sequences_comboBox.sequences)
def test_add_shots_method_creates_shots_based_on_the_given_range_formulat( self): """testing if the add_shots will create shots based on the shot_range_formula argument """ new_proj = Project(name="Test Project") new_proj.create() new_seq1 = Sequence(new_proj, "Test Sequence 1", "TEST_SEQ1") new_seq1.save() expected_shot_numbers = [ '1', '2', '3', '4', '5', '6', '7', '8', '10', '12', '13', '14', '15', '304_SB_0403_0040' ] # assert there is no shots in the sequence self.assertTrue(len(new_seq1.shots) == 0) # add a new shot new_seq1.add_shots("1") self.assertTrue(len(new_seq1.shots) == 1) self.assertTrue(new_seq1.shots[0].number in expected_shot_numbers) # add a couple of shots new_seq1.add_shots("2,3,4") self.assertTrue(len(new_seq1.shots) == 4) self.assertTrue(new_seq1.shots[1].number in expected_shot_numbers) self.assertTrue(new_seq1.shots[2].number in expected_shot_numbers) self.assertTrue(new_seq1.shots[3].number in expected_shot_numbers) # add a couple of more #new_seq1.add_shots("5-8,10,12-15") new_seq1.add_shots("5,6,7,8,10,12,13,14,15,304_sb_0403_0040") self.assertTrue(len(new_seq1.shots) == 14) self.assertIn(new_seq1.shots[4].number, expected_shot_numbers) self.assertIn(new_seq1.shots[5].number, expected_shot_numbers) self.assertIn(new_seq1.shots[6].number, expected_shot_numbers) self.assertIn(new_seq1.shots[7].number, expected_shot_numbers) self.assertIn(new_seq1.shots[8].number, expected_shot_numbers) self.assertIn(new_seq1.shots[9].number, expected_shot_numbers) self.assertIn(new_seq1.shots[10].number, expected_shot_numbers) self.assertIn(new_seq1.shots[11].number, expected_shot_numbers) self.assertIn(new_seq1.shots[12].number, expected_shot_numbers) self.assertIn(new_seq1.shots[13].number, expected_shot_numbers)
def test_save_as_sets_the_fps(self): """testing if the save_as method sets the fps value correctly """ # create two projects with different fps values # first create a new scene and save it under the first project # and then save it under the other project # and check if the fps follows the project values project1 = Project("FPS_TEST_PROJECT_1") project1.fps = 24 project1.create() project2 = Project("FPS_TEST_PROJECT_2") project2.fps = 30 project2.save() # create assets asset1 = Asset(project1, "Test Asset 1") asset1.save() asset2 = Asset(project2, "Test Asset 2") asset2.save() # create versions version1 = Version(version_of=asset1, base_name=asset1.code, type=self.asset_vtypes[0], created_by=self.user1) version2 = Version(version_of=asset2, base_name=asset2.code, type=self.asset_vtypes[0], created_by=self.user1) # save the current scene for asset1 self.mEnv.save_as(version1) # check the fps value self.assertEqual(self.mEnv.get_fps(), 24) # now save it for asset2 self.mEnv.save_as(version2) # check the fps value self.assertEqual(self.mEnv.get_fps(), 30)
def test_calling_create_multiple_times(self): """testing if no error will be raised when calling Sequence.create multiple times """ new_proj = Project(name="TEST_PROJECT") new_proj.create() new_seq = Sequence(new_proj, "TEST_SEQ") new_seq.save() # now call create multiple times new_seq.create() new_seq.create() new_seq.create() new_seq.create() new_seq.create()
def test_save_as_references_to_a_version_in_same_workspace_are_replaced_with_abs_path_with_env_variable( self): """testing if the save_as method updates the references paths with an absolute path starting with conf.repository_env_key for references to a version in the same project thus the referenced path is relative """ # create project proj1 = Project("Proj1") proj1.save() proj1.create() # create assets asset1 = Asset(proj1, "Asset 1") asset1.save() # create a version of asset vtype vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() # save it self.mEnv.save_as(vers1) # new scene pm.newFile(force=True) # create another version with different type vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() # reference the other version self.mEnv.reference(vers1) # save it self.mEnv.save_as(vers2) # now check if the referenced vers1 starts with $REPO refs = pm.listReferences() # there should be only one ref self.assertTrue(len(refs) == 1) # and the path should start with conf.repository_env_key self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key))
def test_save_as_references_to_a_version_in_same_workspace_are_replaced_with_abs_path_with_env_variable(self): """testing if the save_as method updates the references paths with an absolute path starting with conf.repository_env_key for references to a version in the same project thus the referenced path is relative """ # create project proj1 = Project("Proj1") proj1.save() proj1.create() # create assets asset1 = Asset(proj1, "Asset 1") asset1.save() # create a version of asset vtype vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() # save it self.mEnv.save_as(vers1) # new scene pm.newFile(force=True) # create another version with different type vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() # reference the other version self.mEnv.reference(vers1) # save it self.mEnv.save_as(vers2) # now check if the referenced vers1 starts with $REPO refs = pm.listReferences() # there should be only one ref self.assertTrue(len(refs)==1) # and the path should start with conf.repository_env_key self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key) )
def test_creating_two_different_sequences_and_calling_create(self): """testing if no error will be raised when creating two different Sequences for the same Project and calling the Sequences.create() in mixed order """ new_proj = Project(name="TEST_PROJECT") new_proj.create() new_seq1 = Sequence(new_proj, "TEST_SEQ1") new_seq2 = Sequence(new_proj, "TEST_SEQ2") new_seq1.save() new_seq2.save() # print "calling new_seq1.create" new_seq1.create() # print "calling new_seq2.create" new_seq2.create()
def test_reference_creates_references_to_Versions_in_other_workspaces_loaded( self): """testing if reference method creates references to Versions with different VersionType and the reference state will be loaded """ proj1 = Project("Test Project 1") proj1.create() proj1.save() asset1 = Asset(proj1, "Test Asset 1") asset1.save() vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() self.mEnv.save_as(vers1) pm.newFile(force=True) self.mEnv.save_as(vers2) # refence vers1 to vers2 self.mEnv.reference(vers1) # now check if the referenced files unresolved path is already starting # with conf.repository_env_key refs = pm.listReferences() # there should be only one reference self.assertEqual(len(refs), 1) # the unresolved path should start with $REPO self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key)) self.assertTrue(refs[0].isLoaded())
def test_save_as_of_a_scene_with_two_references_to_the_same_version(self): """testing if the case where the current maya scene has two references to the same file is gracefully handled by assigning the version only once """ # create project proj1 = Project("Proj1") proj1.save() proj1.create() # create assets asset1 = Asset(proj1, "Asset 1") asset1.save() # create a version of asset vtype vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() # save it self.mEnv.save_as(vers1) # new scene pm.newFile(force=True) # create another version with different type vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() # reference the other version twice self.mEnv.reference(vers1) self.mEnv.reference(vers1) # save it and expect no InvalidRequestError self.mEnv.save_as(vers2) self.mEnv.reference(vers1) vers3 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers3.save() self.mEnv.save_as(vers3)
def test_reference_creates_references_to_Versions_in_other_workspaces_loaded(self): """testing if reference method creates references to Versions with different VersionType and the reference state will be loaded """ proj1 = Project("Test Project 1") proj1.create() proj1.save() asset1 = Asset(proj1, "Test Asset 1") asset1.save() vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() self.mEnv.save_as(vers1) pm.newFile(force=True) self.mEnv.save_as(vers2) # refence vers1 to vers2 self.mEnv.reference(vers1) # now check if the referenced files unresolved path is already starting # with conf.repository_env_key refs = pm.listReferences() # there should be only one reference self.assertEqual(len(refs), 1) # the unresolved path should start with $REPO self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key) ) self.assertTrue(refs[0].isLoaded())
def test_database_recreation_of_sequence_object(self): """testing if the database file has the necessary information related to the Sequence """ new_proj = Project(name="TEST_PROJECT") new_proj.create() test_seq_name = "TEST_SEQ1" new_seq = Sequence(new_proj, test_seq_name) new_seq.save() description = new_seq.description # now check if the database is created correctly del new_seq # create the seq from scratch and let it read the database new_seq = Sequence(new_proj, test_seq_name) # now check if it was able to get these data self.assertEqual(new_seq.description, description)
def test___ne___operator(self): """testing the __ne__ (not equal) operator """ # create a new project and two sequence # then create three new sequence objects to compare each of them # with the other new_proj = Project("TEST_PROJECT_FOR_NE_TEST") new_proj.create() seq1 = Sequence(new_proj, "SEQ1") seq2 = Sequence(new_proj, "SEQ1") seq3 = Sequence(new_proj, "SEQ2") new_proj2 = Project("TEST_PROJECT2") new_proj2.create() seq4 = Sequence(new_proj2, "SEQ3") self.assertFalse(seq1 != seq2) self.assertTrue(seq1 != seq3) self.assertTrue(seq1 != seq4) self.assertTrue(seq3 != seq4)
class MayaTester(unittest.TestCase): """Tests the oyProjectManager.environments.mayaEnv.Maya class """ def setUp(self): """setup the tests """ # ----------------------------------------------------------------- # 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 # create a test project self.project = Project("Test Project") self.project.create() # create a test asset self.asset1 = Asset(self.project, "Test Asset 1") # version type self.asset_vtypes = VersionType.query()\ .filter(VersionType.type_for == "Asset").all() self.shot_vtypes = VersionType.query()\ .filter(VersionType.type_for == "Shot").all() self.user1 = User(name="Test User 1", email="*****@*****.**") # create a test version self.kwargs = { "version_of": self.asset1, "base_name": self.asset1.code, "type": self.asset_vtypes[0], "created_by": self.user1, "extension": "ma" } self.version1 = Version(**self.kwargs) self.version1.save() # create the environment instance self.mEnv = mayaEnv.Maya() # just renew the scene pm.newFile(force=True) def tearDown(self): """cleanup the test """ # set the db.session to None db.session = None # delete the temp folder shutil.rmtree(self.temp_config_folder) shutil.rmtree(self.temp_projects_folder) # quit maya pm.runtime.Quit() def test_save_as_creates_a_maya_file_at_version_full_path(self): """testing if the save_as creates a maya file at the Version.full_path """ # check the version file doesn't exists self.assertFalse(os.path.exists(self.version1.full_path)) # save the version self.mEnv.save_as(self.version1) # check the file exists self.assertTrue(os.path.exists(self.version1.full_path)) def test_save_as_sets_the_version_extension_to_ma(self): """testing if the save_as method sets the version extension to ma """ self.version1.extension = "" self.mEnv.save_as(self.version1) self.assertEqual(self.version1.extension, ".ma") def test_save_as_sets_the_render_version_string(self): """testing if the save_as method sets the version string in the render settings """ self.mEnv.save_as(self.version1) # now check if the render settings version is the same with the # version.version_number render_version = pm.getAttr("defaultRenderGlobals.renderVersion") self.assertEqual(render_version, "v%03d" % self.version1.version_number) def test_save_as_sets_the_render_format_to_exr_for_mentalray(self): """testing if the save_as method sets the render format to exr """ # load mayatomr plugin pm.loadPlugin("Mayatomr") # set the current renderer to mentalray dRG = pm.PyNode("defaultRenderGlobals") dRG.setAttr('currentRenderer', 'mentalRay') # dirty little maya tricks pm.mel.miCreateDefaultNodes() mrG = pm.PyNode("mentalrayGlobals") self.mEnv.save_as(self.version1) # now check if the render format is correctly set to exr with zip # compression self.assertEqual(dRG.getAttr("imageFormat"), 51) self.assertEqual(dRG.getAttr("imfkey"), "exr") self.assertEqual(mrG.getAttr("imageCompression"), 4) def test_save_as_sets_the_render_file_name_for_Assets(self): """testing if the save_as sets the render file name correctly """ self.mEnv.save_as(self.version1) # check if the path equals to expected_path = self.version1.output_path +\ "/<Layer>/"+ self.version1.project.code + "_" +\ self.version1.base_name +"_" +\ self.version1.take_name +\ "_<Layer>_<RenderPass>_<Version>" image_path = os.path.join(pm.workspace.path, pm.workspace.fileRules['image']).replace( "\\", "/") expected_path = utils.relpath( image_path, expected_path, ) dRG = pm.PyNode("defaultRenderGlobals") self.assertEqual(expected_path, dRG.getAttr("imageFilePrefix")) def test_save_as_sets_the_render_file_name_for_Shots(self): """testing if the save_as sets the render file name correctly """ test_seq = Sequence(self.project, "Test Sequence 1") test_seq.save() test_shot = Shot(test_seq, 1) test_shot.save() self.kwargs["type"] = self.shot_vtypes[0] self.kwargs["version_of"] = test_shot self.version1 = Version(**self.kwargs) self.mEnv.save_as(self.version1) # check if the path equals to expected_path = self.version1.output_path + \ "/<Layer>/"+ self.version1.project.code + "_" + \ self.version1.version_of.sequence.code + "_" + \ self.version1.base_name +"_" + \ self.version1.take_name + \ "_<Layer>_<RenderPass>_<Version>" image_path = os.path.join(pm.workspace.path, pm.workspace.fileRules['image']).replace( "\\", "/") expected_path = utils.relpath( image_path, expected_path, ) dRG = pm.PyNode("defaultRenderGlobals") self.assertEqual(expected_path, dRG.getAttr("imageFilePrefix")) def test_save_as_replaces_file_image_paths(self): """testing if save_as method replaces image paths with REPO relative path """ self.mEnv.save_as(self.version1) # create file node file_node = pm.createNode("file") # set it to a path in the workspace texture_path = os.path.join(pm.workspace.path, ".maya_files/textures/test.jpg") file_node.fileTextureName.set(texture_path) # save a newer version version2 = Version(**self.kwargs) version2.save() self.mEnv.save_as(version2) # now check if the file nodes fileTextureName is converted to a # relative path to the current workspace expected_path = texture_path.replace(os.environ["REPO"], "$REPO") self.assertEqual(file_node.getAttr("fileTextureName"), expected_path) def test_save_as_sets_the_resolution(self): """testing if save_as sets the render resolution for the current scene """ project = self.version1.project width = 1920 height = 1080 pixel_aspect = 1.0 project.width = width project.height = height project.pixel_aspect = pixel_aspect project.save() # save the scene self.mEnv.save_as(self.version1) # check the resolutions dRes = pm.PyNode("defaultResolution") self.assertEqual(dRes.width.get(), width) self.assertEqual(dRes.height.get(), height) self.assertEqual(dRes.pixelAspect.get(), pixel_aspect) def test_save_as_sets_the_resolution_only_for_first_version(self): """testing if save_as sets the render resolution for the current scene but only for the first version of the asset """ project = self.version1.project width = 1920 height = 1080 pixel_aspect = 1.0 project.width = width project.height = height project.pixel_aspect = pixel_aspect project.save() # save the scene self.mEnv.save_as(self.version1) # check the resolutions dRes = pm.PyNode("defaultResolution") self.assertEqual(dRes.width.get(), width) self.assertEqual(dRes.height.get(), height) self.assertEqual(dRes.pixelAspect.get(), pixel_aspect) # now change the resolution of the maya file new_width = 1280 new_height = 720 new_pixel_aspect = 1.0 dRes.width.set(new_width) dRes.height.set(new_height) dRes.pixelAspect.set(new_pixel_aspect) # save the version again new_version = Version(**self.kwargs) new_version.save() self.mEnv.save_as(new_version) # test if the resolution is not changed self.assertEqual(dRes.width.get(), new_width) self.assertEqual(dRes.height.get(), new_height) self.assertEqual(dRes.pixelAspect.get(), new_pixel_aspect) def test_save_as_fills_the_referenced_versions_list(self): """testing if the save_as method updates the Version.references list with the current references list from the Maya """ # create a couple of versions and reference them to each other # and reference them to the the scene and check if maya updates the # Version.references list versionBase = Version(**self.kwargs) versionBase.save() # change the take name self.kwargs["take_name"] = "Take1" version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "Take2" version2 = Version(**self.kwargs) version2.save() self.kwargs["take_name"] = "Take3" version3 = Version(**self.kwargs) version3.save() # now create scenes with these files self.mEnv.save_as(version1) self.mEnv.save_as(version2) self.mEnv.save_as(version3) # this is the dummy version # create a new scene pm.newFile(force=True) # check if the versionBase.references is an empty list self.assertTrue(versionBase.references == []) # reference the given versions self.mEnv.reference(version1) self.mEnv.reference(version2) # save it as versionBase self.mEnv.save_as(versionBase) # now check if versionBase.references is updated self.assertTrue(len(versionBase.references) == 2) self.assertTrue(version1 in versionBase.references) self.assertTrue(version2 in versionBase.references) def test_save_as_references_to_a_version_in_same_workspace_are_replaced_with_abs_path_with_env_variable( self): """testing if the save_as method updates the references paths with an absolute path starting with conf.repository_env_key for references to a version in the same project thus the referenced path is relative """ # create project proj1 = Project("Proj1") proj1.save() proj1.create() # create assets asset1 = Asset(proj1, "Asset 1") asset1.save() # create a version of asset vtype vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() # save it self.mEnv.save_as(vers1) # new scene pm.newFile(force=True) # create another version with different type vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() # reference the other version self.mEnv.reference(vers1) # save it self.mEnv.save_as(vers2) # now check if the referenced vers1 starts with $REPO refs = pm.listReferences() # there should be only one ref self.assertTrue(len(refs) == 1) # and the path should start with conf.repository_env_key self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key)) def test_save_as_of_a_scene_with_two_references_to_the_same_version(self): """testing if the case where the current maya scene has two references to the same file is gracefully handled by assigning the version only once """ # create project proj1 = Project("Proj1") proj1.save() proj1.create() # create assets asset1 = Asset(proj1, "Asset 1") asset1.save() # create a version of asset vtype vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() # save it self.mEnv.save_as(vers1) # new scene pm.newFile(force=True) # create another version with different type vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() # reference the other version twice self.mEnv.reference(vers1) self.mEnv.reference(vers1) # save it and expect no InvalidRequestError self.mEnv.save_as(vers2) self.mEnv.reference(vers1) vers3 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers3.save() self.mEnv.save_as(vers3) def test_save_as_will_not_save_the_file_if_there_are_file_textures_with_local_path( self): """testing if save_as will raise a RuntimeError if there are file textures with local path """ # create a texture file with local path new_texture_file = pm.nt.File() # generate a local path local_file_full_path = os.path.join(tempfile.gettempdir(), "temp.png") new_texture_file.fileTextureName.set(local_file_full_path) # now try to save it as a new version and expect a RuntimeError self.assertRaises(RuntimeError, self.mEnv.save_as, self.version1) def test_open_updates_the_referenced_versions_list(self): """testing if the open method updates the Version.references list with the current references list from the Maya """ # create a couple of versions and reference them to each other # and reference them to the the scene and check if maya updates the # Version.references list versionBase = Version(**self.kwargs) versionBase.save() # change the take naem self.kwargs["take_name"] = "Take1" version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "Take2" version2 = Version(**self.kwargs) version2.save() self.kwargs["take_name"] = "Take3" version3 = Version(**self.kwargs) version3.save() # now create scenes with these files self.mEnv.save_as(version1) self.mEnv.save_as(version2) self.mEnv.save_as(version3) # this is the dummy version # create a new scene pm.newFile(force=True) # check if the versionBase.references is an empty list self.assertTrue(versionBase.references == []) # reference the given versions self.mEnv.reference(version1) self.mEnv.reference(version2) # save it as versionBase self.mEnv.save_as(versionBase) # now check if versionBase.references is updated # this part is already tested in save_as self.assertTrue(len(versionBase.references) == 2) self.assertTrue(version1 in versionBase.references) self.assertTrue(version2 in versionBase.references) # now remove references ref_data = self.mEnv.get_referenced_versions() for data in ref_data: ref_node = data[1] ref_node.remove() # do a save (not save_as) pm.saveFile() # clean scene pm.newFile(force=True) # open the same asset self.mEnv.open_(versionBase, force=True) # and check the references is updated self.assertEqual(len(versionBase.references), 0) self.assertEqual(versionBase.references, []) def test_open_loads_the_references(self): """testing if the open method loads the references """ # create a couple of versions and reference them to each other # and reference them to the the scene and check if maya updates the # Version.references list versionBase = Version(**self.kwargs) versionBase.save() # change the take naem self.kwargs["take_name"] = "Take1" version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "Take2" version2 = Version(**self.kwargs) version2.save() self.kwargs["take_name"] = "Take3" version3 = Version(**self.kwargs) version3.save() # now create scenes with these files self.mEnv.save_as(version1) self.mEnv.save_as(version2) self.mEnv.save_as(version3) # this is the dummy version # create a new scene pm.newFile(force=True) # check if the versionBase.references is an empty list self.assertTrue(versionBase.references == []) # reference the given versions self.mEnv.reference(version1) self.mEnv.reference(version2) # save it as versionBase self.mEnv.save_as(versionBase) # clean scene pm.newFile(force=True) # re-open the file self.mEnv.open_(versionBase, force=True) self.mEnv.post_open(versionBase) # check if the references are loaded ref_data = self.mEnv.get_referenced_versions() for data in ref_data: ref_node = data[1] self.assertTrue(ref_node.isLoaded()) def test_save_as_in_another_project_updates_paths_correctly(self): """testing if the external paths are updated correctly if the document is created in one maya project but it is saved under another one. """ # create a new scene # save it under one Asset Version with name Asset1 asset1 = Asset(self.project, "Asset 1") asset1.save() self.kwargs["version_of"] = asset1 self.kwargs["base_name"] = asset1.code version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "References1" version_ref1 = Version(**self.kwargs) version_ref1.save() self.kwargs["take_name"] = "References2" version_ref2 = Version(**self.kwargs) version_ref2.save() # save a maya file with this references self.mEnv.save_as(version_ref1) self.mEnv.save_as(version_ref2) # save the original version self.mEnv.save_as(version1) # create a couple of file textures file_texture1 = pm.createNode("file") file_texture2 = pm.createNode("file") path1 = os.path.dirname(version1.path) + "/.maya_files/TEXTURES/a.jpg" path2 = os.path.dirname(version1.path) + "/.maya_files/TEXTURES/b.jpg" # set them to some relative paths file_texture1.fileTextureName.set(path1) file_texture2.fileTextureName.set(path2) # create a couple of references in the same project self.mEnv.reference(version_ref1) self.mEnv.reference(version_ref2) # save again self.mEnv.save_as(version1) # then save it under another Asset with name Asset2 # because with this new system all the Assets folders are a maya # project, the references should be updated correctly asset2 = Asset(self.project, "Asset 2") asset2.save() # create a new Version for Asset 2 self.kwargs["version_of"] = asset2 self.kwargs["base_name"] = asset2.code version2 = Version(**self.kwargs) # now save it under that asset self.mEnv.save_as(version2) # check if the paths are updated self.assertEqual( file_texture1.fileTextureName.get(), "$REPO/TEST_PROJECT/Assets/Asset_1/.maya_files/TEXTURES/a.jpg") self.assertEqual( file_texture2.fileTextureName.get(), "$REPO/TEST_PROJECT/Assets/Asset_1/.maya_files/TEXTURES/b.jpg") def test_save_as_sets_the_fps(self): """testing if the save_as method sets the fps value correctly """ # create two projects with different fps values # first create a new scene and save it under the first project # and then save it under the other project # and check if the fps follows the project values project1 = Project("FPS_TEST_PROJECT_1") project1.fps = 24 project1.create() project2 = Project("FPS_TEST_PROJECT_2") project2.fps = 30 project2.save() # create assets asset1 = Asset(project1, "Test Asset 1") asset1.save() asset2 = Asset(project2, "Test Asset 2") asset2.save() # create versions version1 = Version(version_of=asset1, base_name=asset1.code, type=self.asset_vtypes[0], created_by=self.user1) version2 = Version(version_of=asset2, base_name=asset2.code, type=self.asset_vtypes[0], created_by=self.user1) # save the current scene for asset1 self.mEnv.save_as(version1) # check the fps value self.assertEqual(self.mEnv.get_fps(), 24) # now save it for asset2 self.mEnv.save_as(version2) # check the fps value self.assertEqual(self.mEnv.get_fps(), 30) def test_reference_creates_references_with_paths_starting_with_repository_env_key( self): """testing if reference method creates references with unresolved paths starting with conf.repository_env_key """ proj1 = Project("Test Project 1") proj1.create() proj1.save() asset1 = Asset(proj1, "Test Asset 1") asset1.save() vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() vers2 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers2.save() self.mEnv.save_as(vers1) pm.newFile(force=True) self.mEnv.save_as(vers2) # refence vers1 to vers2 self.mEnv.reference(vers1) # now check if the referenced files unresolved path is already starting # with conf.repository_env_key refs = pm.listReferences() # there should be only one reference self.assertEqual(len(refs), 1) # the unresolved path should start with $REPO self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key)) self.assertTrue(refs[0].isLoaded()) def test_reference_creates_references_to_Versions_in_other_workspaces_loaded( self): """testing if reference method creates references to Versions with different VersionType and the reference state will be loaded """ proj1 = Project("Test Project 1") proj1.create() proj1.save() asset1 = Asset(proj1, "Test Asset 1") asset1.save() vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() self.mEnv.save_as(vers1) pm.newFile(force=True) self.mEnv.save_as(vers2) # refence vers1 to vers2 self.mEnv.reference(vers1) # now check if the referenced files unresolved path is already starting # with conf.repository_env_key refs = pm.listReferences() # there should be only one reference self.assertEqual(len(refs), 1) # the unresolved path should start with $REPO self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key)) self.assertTrue(refs[0].isLoaded()) def test_save_as_replaces_imagePlane_filename_with_env_variable(self): """testing if save_as replaces the imagePlane filename with repository environment variable """ # create a camera # create an image plane # set it to something # save the scene # check if the path is replaced with repository environment variable self.fail("test is not implemented yet") def test_save_as_creates_the_workspace_mel_file_in_the_given_path(self): """testing if save_as creates the workspace.mel file in the Asset or Shot root """ # check if the workspace.mel file does not exist yet workspace_mel_full_path = os.path.join( os.path.dirname(self.version1.path), 'workspace.mel') self.assertFalse(os.path.exists(workspace_mel_full_path)) self.mEnv.save_as(self.version1) self.assertTrue(os.path.exists(workspace_mel_full_path)) def test_save_as_creates_the_workspace_fileRule_folders(self): """testing if save_as creates the fileRule folders """ # first prove that the folders doesn't exist for key in pm.workspace.fileRules.keys(): file_rule_partial_path = pm.workspace.fileRules[key] file_rule_full_path = os.path.join( os.path.dirname(self.version1.path), file_rule_partial_path) self.assertFalse(os.path.exists(file_rule_full_path)) self.mEnv.save_as(self.version1) # save_as and now expect the folders to be created for key in pm.workspace.fileRules.keys(): file_rule_partial_path = pm.workspace.fileRules[key] file_rule_full_path = os.path.join( os.path.dirname(self.version1.path), file_rule_partial_path) self.assertTrue(os.path.exists(file_rule_full_path))
def test_shots_comboBox_is_filled_with_the_shots_from_the_current_sequence( self): """testing if the shots_comboBox is filled with the shots from the currently selected Sequence instance """ # projects project1 = Project("Test Project 1") project1.create() project2 = Project("Test Project 2") project2.create() # sequences seq1 = Sequence(project1, "Test Sequence 1") seq1.save() seq2 = Sequence(project1, "Test Sequence 2") seq2.save() seq3 = Sequence(project2, "Test Sequence 3") seq3.save() seq4 = Sequence(project2, "Test Sequence 4") seq4.save() # shots shot1 = Shot(seq1, 1) shot2 = Shot(seq1, 2) shot3 = Shot(seq1, 3) shot4 = Shot(seq2, 4) shot5 = Shot(seq2, 5) shot6 = Shot(seq2, 6) shot7 = Shot(seq3, 7) shot8 = Shot(seq3, 8) shot9 = Shot(seq3, 9) shot10 = Shot(seq4, 10) shot11 = Shot(seq4, 11) shot12 = Shot(seq4, 12) db.session.add_all([ shot1, shot2, shot3, shot4, shot5, shot6, shot7, shot8, shot9, shot10, shot11, shot12 ]) db.session.commit() dialog = project_manager.MainDialog() # self.show_dialog(dialog) # set to project1 index = dialog.projects_comboBox.findText(project1.name) dialog.projects_comboBox.setCurrentIndex(index) # set to seq1 index = dialog.sequences_comboBox.findText(seq1.name) dialog.sequences_comboBox.setCurrentIndex(index) # check if shots_comboBox has 3 entries self.assertEqual(dialog.shots_comboBox.count(), 3) # check if shot1, shot2, shot3 are in the comboBox item_texts = [] for i in range(3): dialog.shots_comboBox.setCurrentIndex(i) item_texts.append(dialog.shots_comboBox.currentText()) self.assertTrue(shot1.code in item_texts) self.assertTrue(shot2.code in item_texts) self.assertTrue(shot3.code in item_texts) # set to project2 index = dialog.projects_comboBox.findText(project2.name) dialog.projects_comboBox.setCurrentIndex(index) # set to seq4 index = dialog.sequences_comboBox.findText(seq4.name) dialog.sequences_comboBox.setCurrentIndex(index) # check if shots_comboBox has 3 entries self.assertEqual(dialog.shots_comboBox.count(), 3) # check if shot10, shot11, shot12 are in the comboBox item_texts = [] for i in range(3): dialog.shots_comboBox.setCurrentIndex(i) item_texts.append(dialog.shots_comboBox.currentText()) self.assertTrue(shot10.code in item_texts) self.assertTrue(shot11.code in item_texts) self.assertTrue(shot12.code in item_texts)
class VersionTypeTester(unittest.TestCase): """tests the VersionType class """ 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_project = Project("TEST_PROJ1") self.test_project.create() self.test_project.save() self.kwargs = { # "project": self.test_project, "name": "Test VType", "code": "TVT", "path": "{{project.full_path}}/Sequences/{{sequence.code}}/SHOTS/{{version.base_name}}/{{type.code}}", "filename": "{{version.base_name}}_{{version.take_name}}_{{type.code}}_v{{'%03d'|format(version.version_number)}}_{{version.created_by.initials}}", "environments": ["MAYA", "HOUDINI"], "output_path": "SHOTS/{{version.base_name}}/{{type.code}}/OUTPUT/{{version.take_name}}", "extra_folders": """{{version.path}}/exports {{version.path}}/cache """, "type_for": "Shot", } self.test_versionType = VersionType(**self.kwargs) self.test_versionType.save() self._name_test_values = [ ("base name", "Base_Name"), ("123123 base_name", "Base_Name"), ("123432!+!'^+Base_NAme323^+'^%&+%&324", "Base_NAme323324"), (" ---base 9s_name", "Base_9s_Name"), (" ---base 9s-name", "Base_9s_Name"), ( " multiple spaces are converted to under scores", "Multiple_Spaces_Are_Converted_To_Under_Scores", ), ("camelCase", "CamelCase"), ("CamelCase", "CamelCase"), ("_Project_Setup_", "Project_Setup"), ("_PROJECT_SETUP_", "PROJECT_SETUP"), ("FUL_3D", "FUL_3D"), ("BaseName", "BaseName"), ("baseName", "BaseName"), (" baseName", "BaseName"), (" base name", "Base_Name"), (" 12base name", "Base_Name"), (" 12 base name", "Base_Name"), (" 12 base name 13", "Base_Name_13"), (">£#>$#£½$ 12 base £#$£#$£½¾{½{ name 13", "Base_Name_13"), ("_base_name_", "Base_Name"), ] def tearDown(self): """cleanup the test """ # set the db.session to None db.session = None # delete the temp folder shutil.rmtree(self.temp_config_folder) shutil.rmtree(self.temp_projects_folder) def test_name_argument_is_None(self): """testing if a TypeError will be raised when the name argument is None """ self.kwargs["name"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_name_attribute_is_None(self): """testing if a TypeError will be raised when the name attribute is set to None """ self.assertRaises(TypeError, setattr, self.test_versionType, "name", None) def test_name_argument_is_not_a_string(self): """testing if a TypeError will be raised when the name argument is not a string or unicode instance """ self.kwargs["name"] = 123 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_name_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the name argument is not a string or unicode instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "name", 8) def test_name_argument_is_working_properly(self): """testing if the name argument is working properly and sets the name attribute correctly """ self.assertEqual(self.kwargs["name"], self.test_versionType.name) def test_name_attribute_is_working_properly(self): """testing if the name attribute is working properly """ test_value = "New Name" self.test_versionType.name = test_value self.assertEqual(test_value, self.test_versionType.name) def test_name_attribute_is_not_unique(self): """testing if an IntegrityError error will be raised when the name argument is not unique """ # creating a new VersionType should raise the ?? error new_vtype = VersionType(**self.kwargs) self.assertRaises(IntegrityError, new_vtype.save) def test_code_argument_is_skipped(self): """testing if a TypeError will be raised when the code argument is skipped """ self.kwargs.pop("code") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_code_argument_is_None(self): """testing if a TypeError will be raised when the code argument is None """ self.kwargs["code"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_code_attribute_is_None(self): """testing if a TypeError will be raised when the code attribute is set to None """ self.assertRaises(TypeError, setattr, self.test_versionType, "code", None) def test_code_argument_is_not_a_string(self): """testing if a TypeError will be raised when the code argument is not a string or unicode instance """ self.kwargs["code"] = 123 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_code_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the code argument is not a string or unicode instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "code", 8) def test_code_argument_is_working_properly(self): """testing if the code argument is working properly and sets the code attribute correctly """ self.assertEqual(self.kwargs["code"], self.test_versionType.code) def test_code_attribute_is_working_properly(self): """testing if the code attribute is working properly """ test_value = "New Name" self.test_versionType.code = test_value self.assertEqual(test_value, self.test_versionType.code) def test_code_attribute_is_not_unique(self): """testing if an IntegrityError error will be raised when the code argument is not unique """ # creating a new VersionType should raise the IntegrityError self.kwargs["name"] = "A Different Name" new_vtype = VersionType(**self.kwargs) self.assertRaises(IntegrityError, new_vtype.save) def test_filename_argument_is_skipped(self): """testing if a TypeError will be raised when the filename argument is skipped """ self.kwargs.pop("filename") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_filename_argument_is_empty_string(self): """testing if a ValueError will be raised when the filename argument is an empty string """ self.kwargs["filename"] = "" self.assertRaises(ValueError, VersionType, **self.kwargs) def test_filename_attribute_is_empty_string(self): """testing if a ValueError will be raised when the filename attribute is set to an empty string """ self.assertRaises(ValueError, setattr, self.test_versionType, "filename", "") def test_filename_argument_is_not_a_string(self): """testing if a TypeError will be raised when the filename argument is not a string instance """ self.kwargs["filename"] = 13245 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_filename_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the filename attribute is not a string instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "filename", 23412) def test_filename_argument_is_working_properly(self): """testing if the filename attribute is initialized correctly with the same value of the filename argument """ self.assertEqual(self.test_versionType.filename, self.kwargs["filename"]) def test_filename_attribute_is_working_properly(self): """testing if the filename attribute is working properly """ test_value = "test_filename" self.test_versionType.filename = test_value self.assertEqual(self.test_versionType.filename, test_value) def test_path_argument_is_skipped(self): """testing if a TypeError will be raised when the path argument is skipped """ self.kwargs.pop("path") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_path_argument_is_empty_string(self): """testing if a ValueError will be raised when the path argument is an empty string """ self.kwargs["path"] = "" self.assertRaises(ValueError, VersionType, **self.kwargs) def test_path_attribute_is_empty_string(self): """testing if a ValueError will be raised when the path attribute is set to an empty string """ self.assertRaises(ValueError, setattr, self.test_versionType, "path", "") def test_path_argument_is_not_a_string(self): """testing if a TypeError will be raised when the path argument is not a string instance """ self.kwargs["path"] = 13245 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_path_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the path attribute is not a string instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "path", 23412) def test_path_argument_is_working_properly(self): """testing if the path attribute is initialized correctly with the same value of the path argument """ self.assertEqual(self.test_versionType.path, self.kwargs["path"]) def test_path_attribute_is_working_properly(self): """testing if the path attribute is working properly """ test_value = "test_path" self.test_versionType.path = test_value self.assertEqual(self.test_versionType.path, test_value) def test_output_path_argument_is_skipped(self): """testing if a TypeError will be raised when the output_path argument is skipped """ self.kwargs.pop("output_path") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_output_path_argument_is_empty_string(self): """testing if a ValueError will be raised when the output_path argument is an empty string """ self.kwargs["output_path"] = "" self.assertRaises(ValueError, VersionType, **self.kwargs) def test_output_path_attribute_is_empty_string(self): """testing if a ValueError will be raised when the output_path attribute is set to an empty string """ self.assertRaises(ValueError, setattr, self.test_versionType, "output_path", "") def test_output_path_argument_is_not_a_string(self): """testing if a TypeError will be raised when the output_path argument is not a string instance """ self.kwargs["output_path"] = 13245 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_output_path_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the output_path attribute is not a string instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "output_path", 23412) def test_output_path_argument_is_working_properly(self): """testing if the output_path attribute is initialized correctly with the same value of the output_path argument """ self.assertEqual(self.test_versionType.output_path, self.kwargs["output_path"]) def test_output_path_attribute_is_working_properly(self): """testing if the output_path attribute is working properly """ test_value = "test_output_path" self.test_versionType.output_path = test_value self.assertEqual(self.test_versionType.output_path, test_value) def test_extra_folders_argument_is_skipped(self): """testing if the extra_folders argument is skipped the extra_folders attribute will be an empty string """ self.kwargs.pop("extra_folders") new_version_type = VersionType(**self.kwargs) self.assertEqual(new_version_type.extra_folders, "") def test_extra_folders_argument_is_None(self): """testing if the extra_folders attribute is going to be an empty string when the extra folders argument is given as None """ self.kwargs["extra_folders"] = None new_version_type = VersionType(**self.kwargs) self.assertEqual(new_version_type.extra_folders, "") def test_extra_folders_attribute_is_None(self): """testing if the extra_folders attribute will be an empty list when it is set to None """ self.test_versionType.extra_folders = None self.assertEqual(self.test_versionType.extra_folders, "") def test_extra_folders_argument_is_not_a_string_instance(self): """testing if a TypeError will be raised when the extra_folders argument is not a string or unicode instance """ self.kwargs["extra_folders"] = 123 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_extra_folders_attribute_is_not_a_string_instance(self): """testing if a TypeError will be raised when the extra_folders attribute is set to something other than a string or unicode instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "extra_folders", 23423) def test_extra_folders_argument_is_working_properly(self): """testing if the extra_folders attribute will be set to the same value with the extra_folders argument while initialization """ self.assertEqual(self.test_versionType.extra_folders, self.kwargs["extra_folders"]) def test_extra_folders_attribute_is_working_properly(self): """testing if the extra_folders attribute is working properly """ test_value = "extra_folders" self.test_versionType.extra_folders = test_value self.assertEqual(self.test_versionType.extra_folders, test_value) def test_environments_argument_is_skipped(self): """testing if a TypeError will be raised when the environments argument is skipped """ self.kwargs.pop("environments") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_argument_is_None(self): """testing if a TypeError will be raised when the environments argument is None """ self.kwargs["environments"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_attribute_is_None(self): """testing if a TypeError will be raised when the environments attribute is set to None """ self.assertRaises(TypeError, setattr, self.test_versionType, "environments", None) def test_environments_argument_is_not_a_list(self): """testing if a TypeError will be raised when the environments argument is not a list instance """ self.kwargs["environments"] = 12354 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_attribute_is_not_a_list(self): """testing if a TypeError will be raised when the environments attribute is set to something other than a list """ self.assertRaises(TypeError, setattr, self.test_versionType, "environments", 123) def test_environments_argument_is_not_a_list_of_strings(self): """testing if a TypeError will be raised when the environments argument is not a list of strings """ self.kwargs["environments"] = [123, "MAYA"] self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_attribute_is_not_a_list_of_strings(self): """testing if a TypeError will be raised when the environments attribute is not a list of strings """ self.assertRaises(TypeError, setattr, self.test_versionType, "environments", [123, "MAYA"]) def test_environments_argument_works_properly(self): """testing if the environments attribute will be initialized correctly with the environments argument """ test_value = ["MAYA", "HOUDINI"] self.kwargs["environments"] = test_value new_vtype = VersionType(**self.kwargs) for env in test_value: self.assertTrue(env in new_vtype.environments) def test_environments_attribute_works_properly(self): """testing if the environments attribute is working properly """ test_value = ["MAYA", "HOUDINI", "NUKE", "3DEQUALIZER"] self.test_versionType.environments = test_value for env in test_value: self.assertTrue(env in self.test_versionType.environments) def test_type_for_argument_is_skipped(self): """testing if a TypeError will be raised when the type_for argument is skipped """ self.kwargs.pop("type_for") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_type_for_argument_is_None(self): """testing if a TypeError will be raised when the type_for argument is None """ self.kwargs["type_for"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_type_for_argument_is_not_a_string_or_integer(self): """testing if a TypeError will be raised when the type_for argument is not a string or unicode or an integer """ self.kwargs["type_for"] = [12] self.assertRaises(TypeError, VersionType, **self.kwargs) def test_type_for_argument_is_working_properly(self): """testing if the type_for argument is working properly """ self.kwargs["name"] = "Test Animation" self.kwargs["code"] = "TA" self.kwargs["type_for"] = "Asset" new_vtype = VersionType(**self.kwargs) new_vtype.save() self.assertEqual(new_vtype.type_for, "Asset") def test_type_for_attribute_is_read_only(self): """testing if type_for attribute is read-only """ self.assertRaises(AttributeError, setattr, self.test_versionType, "type_for", "Asset") def test_save_method_saves_the_version_type_to_the_database(self): """testing if the save method saves the current VersionType to the database """ self.kwargs["name"] = "Test Animation" self.kwargs["code"] = "TA" new_vtype = VersionType(**self.kwargs) new_vtype.save() code = new_vtype.code environments = new_vtype.environments filename = new_vtype.filename name = new_vtype.name output_path = new_vtype.output_path path = new_vtype.path type_for = new_vtype.type_for # del new_vtype new_vtypeDB = VersionType.query().filter_by(name=self.kwargs["name"]).first() self.assertEqual(code, new_vtypeDB.code) self.assertEqual(filename, new_vtypeDB.filename) self.assertEqual(name, new_vtypeDB.name) self.assertEqual(output_path, new_vtypeDB.output_path) self.assertEqual(path, new_vtypeDB.path) self.assertEqual(type_for, new_vtypeDB.type_for) self.assertEqual(environments, new_vtypeDB.environments) def test__eq__(self): """testing the equality operator """ verst1 = VersionType( name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) verst2 = VersionType( name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) verst3 = VersionType( name="Test Type 2", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) verst4 = VersionType( name="Test Type 3", code="TT3", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) self.assertTrue(verst1 == verst2) self.assertFalse(verst1 == verst3) self.assertFalse(verst3 == verst4) def test__ne__(self): """testing the equality operator """ verst1 = VersionType( name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) verst2 = VersionType( name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) verst3 = VersionType( name="Test Type 2", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) verst4 = VersionType( name="Test Type 3", code="TT3", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset", ) self.assertFalse(verst1 != verst2) self.assertTrue(verst1 != verst3) self.assertTrue(verst3 != verst4)
class MainDialog(QtGui.QDialog, project_properties_UI.Ui_Dialog): """Dialog to edit project properties If a :class:`~oyProjectManager.models.project.Project` instance is also passed it will edit the given project. If no Project is passed then it will create and return a new one. """ def __init__(self, parent=None, project=None): super(MainDialog, self).__init__(parent) self.setupUi(self) if db.session is None: db.setup() self.resolution_presets = conf.resolution_presets self.project = project self._setup_signals() self._setup_defaults() self.update_UI_from_project(self.project) def _setup_signals(self): """sets up signals """ # cancel button QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL("rejected()"), self.close ) # ok button QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL("accepted()"), self.button_box_ok_clicked ) # changing the name of the project should also update the code # if the code field is empty QtCore.QObject.connect( self.name_lineEdit, QtCore.SIGNAL("textChanged(QString)"), self.name_edited ) def set_resolution_to_default(self): # set the resolution to the default preset index = self.resolution_comboBox.findText( conf.default_resolution_preset ) self.resolution_comboBox.setCurrentIndex(index) def _setup_defaults(self): """sets up the default values """ self.resolution_comboBox.addItems( sorted(conf.resolution_presets.keys()) ) self.set_resolution_to_default() # clients clients = map( lambda x: x.name, Client.query().order_by(Client.name.asc()).all() ) self.clients_comboBox.clear() self.clients_comboBox.addItems(clients) # set the fps to conf.default_fps self.fps_spinBox.setValue(conf.default_fps) # set active_checkBox to true self.active_checkBox.setChecked(True) # if a project is given don't let the user to try to change the code # attribute if self.project is not None: self.code_lineEdit.setEnabled(False) # advanced properties self.shot_number_padding_spinBox.setValue(conf.shot_number_padding) self.shot_number_prefix_lineEdit.setText(conf.shot_number_prefix) self.revision_number_padding_spinBox.setValue(conf.rev_number_padding) self.revision_number_prefix_lineEdit.setText(conf.rev_number_prefix) self.version_number_padding_spinBox.setValue(conf.ver_number_padding) self.version_number_prefix_lineEdit.setText(conf.ver_number_prefix) self.structure_textEdit.setText(conf.project_structure) def update_UI_from_project(self, project): """Updates the UI with the info from the given project instance :param project: The :class:`~oyProjectManager.models.project.Project` instance which the UI data will be read from. """ # if a project is given update the UI with the given project info if project is None: return self.name_lineEdit.setText(project.name) self.code_lineEdit.setText(project.code) if project.client: index = self.clients_comboBox.findText(project.client.name) if index != -1: self.clients_comboBox.setCurrentIndex(index) self.fps_spinBox.setValue(project.fps) self.active_checkBox.setChecked(project.active) # advanced properties self.shot_number_prefix_lineEdit.setText(project.shot_number_prefix) self.shot_number_padding_spinBox.setValue(project.shot_number_padding) self.revision_number_prefix_lineEdit.setText(project.rev_number_prefix) self.revision_number_padding_spinBox.setValue( project.rev_number_padding ) self.version_number_prefix_lineEdit.setText(project.ver_number_prefix) self.version_number_padding_spinBox.setValue(project.ver_number_padding) self.structure_textEdit.setText(project.structure) # set the resolution preset_key = None for key in conf.resolution_presets.keys(): if conf.resolution_presets[key] == [project.width, project.height, project.pixel_aspect]: preset_key = key break if preset_key is not None: index = self.resolution_comboBox.findText(preset_key) self.resolution_comboBox.setCurrentIndex(index) else: # set it to custom self.resolution_comboBox.setCurrentIndex( self.resolution_comboBox.count()-1 ) def button_box_ok_clicked(self): """runs when the ok button clicked """ # if there is no project given create a new one and return it # create_project # get the data from the input fields name = self.name_lineEdit.text() code = self.code_lineEdit.text() # check if the code is empty if code=="": # raise an error please QtGui.QMessageBox.critical( self, "Error", "Code field can not be empty,\n" "Please enter a proper Code!!!" ) return client_name = self.clients_comboBox.currentText() client = Client.query().filter(Client.name==client_name).first() if not client: # just create the client client = Client(name=client_name) client.save() resolution_name = self.resolution_comboBox.currentText() resolution_data = conf.resolution_presets[resolution_name] fps = self.fps_spinBox.value() active = self.active_checkBox.isChecked() # advanced properties shot_number_padding = self.shot_number_padding_spinBox.value() shot_number_prefix = self.shot_number_prefix_lineEdit.text() rev_number_padding = self.revision_number_padding_spinBox.value() rev_number_prefix = self.revision_number_prefix_lineEdit.text() ver_number_padding = self.version_number_padding_spinBox.value() ver_number_prefix = self.version_number_prefix_lineEdit.text() structure_code = self.structure_textEdit.toPlainText() is_new_project = False if self.project is None: logger.debug("no project is given creating new one") # create the project self.project = Project(name=name, code=code) is_new_project = True else: logger.debug("updating the given project") # update the project self.project.name = name self.project.client = client self.project.fps = fps self.project.width = resolution_data[0] self.project.height = resolution_data[1] self.project.pixel_aspect = resolution_data[2] self.project.active = active self.project.shot_number_padding = shot_number_padding self.project.shot_number_prefix = shot_number_prefix self.project.rev_number_padding = rev_number_padding self.project.rev_number_prefix = rev_number_prefix self.project.ver_number_padding = ver_number_padding self.project.ver_number_prefix = ver_number_prefix self.project.structure = structure_code if is_new_project: self.project.create() else: self.project.save() # and close the dialog self.close() def name_edited(self, new_name): """called by the ui event when the text in project name lineEdit changed, it updates the code field if the code field is empty :param new_name: the changed name """ # update only if the code field is empty import re new_code = re.sub(r'([^A-Z0-9]+)([\-\s]*)', '_', new_name.upper()) self.code_lineEdit.setText(new_code)
class MayaTester(unittest.TestCase): """Tests the oyProjectManager.environments.mayaEnv.Maya class """ def setUp(self): """setup the tests """ # ----------------------------------------------------------------- # 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 # create a test project self.project = Project("Test Project") self.project.create() # create a test asset self.asset1 = Asset(self.project, "Test Asset 1") # version type self.asset_vtypes = VersionType.query()\ .filter(VersionType.type_for == "Asset").all() self.shot_vtypes = VersionType.query()\ .filter(VersionType.type_for == "Shot").all() self.user1 = User(name="Test User 1", email="*****@*****.**") # create a test version self.kwargs = { "version_of":self.asset1, "base_name":self.asset1.code, "type":self.asset_vtypes[0], "created_by":self.user1, "extension":"ma" } self.version1 = Version(**self.kwargs) self.version1.save() # create the environment instance self.mEnv = mayaEnv.Maya() # just renew the scene pm.newFile(force=True) def tearDown(self): """cleanup the test """ # set the db.session to None db.session = None # delete the temp folder shutil.rmtree(self.temp_config_folder) shutil.rmtree(self.temp_projects_folder) # quit maya pm.runtime.Quit() def test_save_as_creates_a_maya_file_at_version_full_path(self): """testing if the save_as creates a maya file at the Version.full_path """ # check the version file doesn't exists self.assertFalse(os.path.exists(self.version1.full_path)) # save the version self.mEnv.save_as(self.version1) # check the file exists self.assertTrue(os.path.exists(self.version1.full_path)) def test_save_as_sets_the_version_extension_to_ma(self): """testing if the save_as method sets the version extension to ma """ self.version1.extension = "" self.mEnv.save_as(self.version1) self.assertEqual(self.version1.extension, ".ma") def test_save_as_sets_the_render_version_string(self): """testing if the save_as method sets the version string in the render settings """ self.mEnv.save_as(self.version1) # now check if the render settings version is the same with the # version.version_number render_version = pm.getAttr("defaultRenderGlobals.renderVersion") self.assertEqual(render_version, "v%03d" % self.version1.version_number) def test_save_as_sets_the_render_format_to_exr_for_mentalray(self): """testing if the save_as method sets the render format to exr """ # load mayatomr plugin pm.loadPlugin("Mayatomr") # set the current renderer to mentalray dRG = pm.PyNode("defaultRenderGlobals") dRG.setAttr('currentRenderer', 'mentalRay') # dirty little maya tricks pm.mel.miCreateDefaultNodes() mrG = pm.PyNode("mentalrayGlobals") self.mEnv.save_as(self.version1) # now check if the render format is correctly set to exr with zip # compression self.assertEqual(dRG.getAttr("imageFormat"), 51) self.assertEqual(dRG.getAttr("imfkey"), "exr") self.assertEqual(mrG.getAttr("imageCompression"), 4) def test_save_as_sets_the_render_file_name_for_Assets(self): """testing if the save_as sets the render file name correctly """ self.mEnv.save_as(self.version1) # check if the path equals to expected_path = self.version1.output_path +\ "/<Layer>/"+ self.version1.project.code + "_" +\ self.version1.base_name +"_" +\ self.version1.take_name +\ "_<Layer>_<RenderPass>_<Version>" image_path = os.path.join( pm.workspace.path, pm.workspace.fileRules['image'] ).replace("\\", "/") expected_path = utils.relpath( image_path, expected_path, ) dRG = pm.PyNode("defaultRenderGlobals") self.assertEqual( expected_path, dRG.getAttr("imageFilePrefix") ) def test_save_as_sets_the_render_file_name_for_Shots(self): """testing if the save_as sets the render file name correctly """ test_seq = Sequence(self.project, "Test Sequence 1") test_seq.save() test_shot = Shot(test_seq, 1) test_shot.save() self.kwargs["type"] = self.shot_vtypes[0] self.kwargs["version_of"] = test_shot self.version1 = Version(**self.kwargs) self.mEnv.save_as(self.version1) # check if the path equals to expected_path = self.version1.output_path + \ "/<Layer>/"+ self.version1.project.code + "_" + \ self.version1.version_of.sequence.code + "_" + \ self.version1.base_name +"_" + \ self.version1.take_name + \ "_<Layer>_<RenderPass>_<Version>" image_path = os.path.join( pm.workspace.path, pm.workspace.fileRules['image'] ).replace("\\", "/") expected_path = utils.relpath( image_path, expected_path, ) dRG = pm.PyNode("defaultRenderGlobals") self.assertEqual( expected_path, dRG.getAttr("imageFilePrefix") ) def test_save_as_replaces_file_image_paths(self): """testing if save_as method replaces image paths with REPO relative path """ self.mEnv.save_as(self.version1) # create file node file_node = pm.createNode("file") # set it to a path in the workspace texture_path = os.path.join( pm.workspace.path, ".maya_files/textures/test.jpg" ) file_node.fileTextureName.set(texture_path) # save a newer version version2 = Version(**self.kwargs) version2.save() self.mEnv.save_as(version2) # now check if the file nodes fileTextureName is converted to a # relative path to the current workspace expected_path = texture_path.replace(os.environ["REPO"], "$REPO") self.assertEqual( file_node.getAttr("fileTextureName"), expected_path ) def test_save_as_sets_the_resolution(self): """testing if save_as sets the render resolution for the current scene """ project = self.version1.project width = 1920 height = 1080 pixel_aspect = 1.0 project.width = width project.height = height project.pixel_aspect = pixel_aspect project.save() # save the scene self.mEnv.save_as(self.version1) # check the resolutions dRes = pm.PyNode("defaultResolution") self.assertEqual(dRes.width.get(), width) self.assertEqual(dRes.height.get(), height) self.assertEqual(dRes.pixelAspect.get(), pixel_aspect) def test_save_as_sets_the_resolution_only_for_first_version(self): """testing if save_as sets the render resolution for the current scene but only for the first version of the asset """ project = self.version1.project width = 1920 height = 1080 pixel_aspect = 1.0 project.width = width project.height = height project.pixel_aspect = pixel_aspect project.save() # save the scene self.mEnv.save_as(self.version1) # check the resolutions dRes = pm.PyNode("defaultResolution") self.assertEqual(dRes.width.get(), width) self.assertEqual(dRes.height.get(), height) self.assertEqual(dRes.pixelAspect.get(), pixel_aspect) # now change the resolution of the maya file new_width = 1280 new_height = 720 new_pixel_aspect = 1.0 dRes.width.set(new_width) dRes.height.set(new_height) dRes.pixelAspect.set(new_pixel_aspect) # save the version again new_version = Version(**self.kwargs) new_version.save() self.mEnv.save_as(new_version) # test if the resolution is not changed self.assertEqual(dRes.width.get(), new_width) self.assertEqual(dRes.height.get(), new_height) self.assertEqual(dRes.pixelAspect.get(), new_pixel_aspect) def test_save_as_fills_the_referenced_versions_list(self): """testing if the save_as method updates the Version.references list with the current references list from the Maya """ # create a couple of versions and reference them to each other # and reference them to the the scene and check if maya updates the # Version.references list versionBase = Version(**self.kwargs) versionBase.save() # change the take name self.kwargs["take_name"] = "Take1" version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "Take2" version2 = Version(**self.kwargs) version2.save() self.kwargs["take_name"] = "Take3" version3 = Version(**self.kwargs) version3.save() # now create scenes with these files self.mEnv.save_as(version1) self.mEnv.save_as(version2) self.mEnv.save_as(version3) # this is the dummy version # create a new scene pm.newFile(force=True) # check if the versionBase.references is an empty list self.assertTrue(versionBase.references==[]) # reference the given versions self.mEnv.reference(version1) self.mEnv.reference(version2) # save it as versionBase self.mEnv.save_as(versionBase) # now check if versionBase.references is updated self.assertTrue(len(versionBase.references)==2) self.assertTrue(version1 in versionBase.references) self.assertTrue(version2 in versionBase.references) def test_save_as_references_to_a_version_in_same_workspace_are_replaced_with_abs_path_with_env_variable(self): """testing if the save_as method updates the references paths with an absolute path starting with conf.repository_env_key for references to a version in the same project thus the referenced path is relative """ # create project proj1 = Project("Proj1") proj1.save() proj1.create() # create assets asset1 = Asset(proj1, "Asset 1") asset1.save() # create a version of asset vtype vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() # save it self.mEnv.save_as(vers1) # new scene pm.newFile(force=True) # create another version with different type vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() # reference the other version self.mEnv.reference(vers1) # save it self.mEnv.save_as(vers2) # now check if the referenced vers1 starts with $REPO refs = pm.listReferences() # there should be only one ref self.assertTrue(len(refs)==1) # and the path should start with conf.repository_env_key self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key) ) def test_save_as_of_a_scene_with_two_references_to_the_same_version(self): """testing if the case where the current maya scene has two references to the same file is gracefully handled by assigning the version only once """ # create project proj1 = Project("Proj1") proj1.save() proj1.create() # create assets asset1 = Asset(proj1, "Asset 1") asset1.save() # create a version of asset vtype vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() # save it self.mEnv.save_as(vers1) # new scene pm.newFile(force=True) # create another version with different type vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() # reference the other version twice self.mEnv.reference(vers1) self.mEnv.reference(vers1) # save it and expect no InvalidRequestError self.mEnv.save_as(vers2) self.mEnv.reference(vers1) vers3 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers3.save() self.mEnv.save_as(vers3) def test_save_as_will_not_save_the_file_if_there_are_file_textures_with_local_path(self): """testing if save_as will raise a RuntimeError if there are file textures with local path """ # create a texture file with local path new_texture_file = pm.nt.File() # generate a local path local_file_full_path = os.path.join( tempfile.gettempdir(), "temp.png" ) new_texture_file.fileTextureName.set(local_file_full_path) # now try to save it as a new version and expect a RuntimeError self.assertRaises( RuntimeError, self.mEnv.save_as, self.version1 ) def test_open_updates_the_referenced_versions_list(self): """testing if the open method updates the Version.references list with the current references list from the Maya """ # create a couple of versions and reference them to each other # and reference them to the the scene and check if maya updates the # Version.references list versionBase = Version(**self.kwargs) versionBase.save() # change the take naem self.kwargs["take_name"] = "Take1" version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "Take2" version2 = Version(**self.kwargs) version2.save() self.kwargs["take_name"] = "Take3" version3 = Version(**self.kwargs) version3.save() # now create scenes with these files self.mEnv.save_as(version1) self.mEnv.save_as(version2) self.mEnv.save_as(version3) # this is the dummy version # create a new scene pm.newFile(force=True) # check if the versionBase.references is an empty list self.assertTrue(versionBase.references==[]) # reference the given versions self.mEnv.reference(version1) self.mEnv.reference(version2) # save it as versionBase self.mEnv.save_as(versionBase) # now check if versionBase.references is updated # this part is already tested in save_as self.assertTrue(len(versionBase.references)==2) self.assertTrue(version1 in versionBase.references) self.assertTrue(version2 in versionBase.references) # now remove references ref_data = self.mEnv.get_referenced_versions() for data in ref_data: ref_node = data[1] ref_node.remove() # do a save (not save_as) pm.saveFile() # clean scene pm.newFile(force=True) # open the same asset self.mEnv.open_(versionBase, force=True) # and check the references is updated self.assertEqual(len(versionBase.references), 0) self.assertEqual(versionBase.references, []) def test_open_loads_the_references(self): """testing if the open method loads the references """ # create a couple of versions and reference them to each other # and reference them to the the scene and check if maya updates the # Version.references list versionBase = Version(**self.kwargs) versionBase.save() # change the take naem self.kwargs["take_name"] = "Take1" version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "Take2" version2 = Version(**self.kwargs) version2.save() self.kwargs["take_name"] = "Take3" version3 = Version(**self.kwargs) version3.save() # now create scenes with these files self.mEnv.save_as(version1) self.mEnv.save_as(version2) self.mEnv.save_as(version3) # this is the dummy version # create a new scene pm.newFile(force=True) # check if the versionBase.references is an empty list self.assertTrue(versionBase.references==[]) # reference the given versions self.mEnv.reference(version1) self.mEnv.reference(version2) # save it as versionBase self.mEnv.save_as(versionBase) # clean scene pm.newFile(force=True) # re-open the file self.mEnv.open_(versionBase, force=True) self.mEnv.post_open(versionBase) # check if the references are loaded ref_data = self.mEnv.get_referenced_versions() for data in ref_data: ref_node = data[1] self.assertTrue(ref_node.isLoaded()) def test_save_as_in_another_project_updates_paths_correctly(self): """testing if the external paths are updated correctly if the document is created in one maya project but it is saved under another one. """ # create a new scene # save it under one Asset Version with name Asset1 asset1 = Asset(self.project, "Asset 1") asset1.save() self.kwargs["version_of"] = asset1 self.kwargs["base_name"] = asset1.code version1 = Version(**self.kwargs) version1.save() self.kwargs["take_name"] = "References1" version_ref1 = Version(**self.kwargs) version_ref1.save() self.kwargs["take_name"] = "References2" version_ref2 = Version(**self.kwargs) version_ref2.save() # save a maya file with this references self.mEnv.save_as(version_ref1) self.mEnv.save_as(version_ref2) # save the original version self.mEnv.save_as(version1) # create a couple of file textures file_texture1 = pm.createNode("file") file_texture2 = pm.createNode("file") path1 = os.path.dirname(version1.path) + "/.maya_files/TEXTURES/a.jpg" path2 = os.path.dirname(version1.path) + "/.maya_files/TEXTURES/b.jpg" # set them to some relative paths file_texture1.fileTextureName.set(path1) file_texture2.fileTextureName.set(path2) # create a couple of references in the same project self.mEnv.reference(version_ref1) self.mEnv.reference(version_ref2) # save again self.mEnv.save_as(version1) # then save it under another Asset with name Asset2 # because with this new system all the Assets folders are a maya # project, the references should be updated correctly asset2 = Asset(self.project, "Asset 2") asset2.save() # create a new Version for Asset 2 self.kwargs["version_of"] = asset2 self.kwargs["base_name"] = asset2.code version2 = Version(**self.kwargs) # now save it under that asset self.mEnv.save_as(version2) # check if the paths are updated self.assertEqual( file_texture1.fileTextureName.get(), "$REPO/TEST_PROJECT/Assets/Asset_1/.maya_files/TEXTURES/a.jpg" ) self.assertEqual( file_texture2.fileTextureName.get(), "$REPO/TEST_PROJECT/Assets/Asset_1/.maya_files/TEXTURES/b.jpg" ) def test_save_as_sets_the_fps(self): """testing if the save_as method sets the fps value correctly """ # create two projects with different fps values # first create a new scene and save it under the first project # and then save it under the other project # and check if the fps follows the project values project1 = Project("FPS_TEST_PROJECT_1") project1.fps = 24 project1.create() project2 = Project("FPS_TEST_PROJECT_2") project2.fps = 30 project2.save() # create assets asset1 = Asset(project1, "Test Asset 1") asset1.save() asset2 = Asset(project2, "Test Asset 2") asset2.save() # create versions version1 = Version( version_of=asset1, base_name=asset1.code, type=self.asset_vtypes[0], created_by=self.user1 ) version2 = Version( version_of=asset2, base_name=asset2.code, type=self.asset_vtypes[0], created_by=self.user1 ) # save the current scene for asset1 self.mEnv.save_as(version1) # check the fps value self.assertEqual( self.mEnv.get_fps(), 24 ) # now save it for asset2 self.mEnv.save_as(version2) # check the fps value self.assertEqual( self.mEnv.get_fps(), 30 ) def test_reference_creates_references_with_paths_starting_with_repository_env_key(self): """testing if reference method creates references with unresolved paths starting with conf.repository_env_key """ proj1 = Project("Test Project 1") proj1.create() proj1.save() asset1 = Asset(proj1, "Test Asset 1") asset1.save() vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() vers2 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers2.save() self.mEnv.save_as(vers1) pm.newFile(force=True) self.mEnv.save_as(vers2) # refence vers1 to vers2 self.mEnv.reference(vers1) # now check if the referenced files unresolved path is already starting # with conf.repository_env_key refs = pm.listReferences() # there should be only one reference self.assertEqual(len(refs), 1) # the unresolved path should start with $REPO self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key) ) self.assertTrue(refs[0].isLoaded()) def test_reference_creates_references_to_Versions_in_other_workspaces_loaded(self): """testing if reference method creates references to Versions with different VersionType and the reference state will be loaded """ proj1 = Project("Test Project 1") proj1.create() proj1.save() asset1 = Asset(proj1, "Test Asset 1") asset1.save() vers1 = Version(asset1, asset1.code, self.asset_vtypes[0], self.user1) vers1.save() vers2 = Version(asset1, asset1.code, self.asset_vtypes[1], self.user1) vers2.save() self.mEnv.save_as(vers1) pm.newFile(force=True) self.mEnv.save_as(vers2) # refence vers1 to vers2 self.mEnv.reference(vers1) # now check if the referenced files unresolved path is already starting # with conf.repository_env_key refs = pm.listReferences() # there should be only one reference self.assertEqual(len(refs), 1) # the unresolved path should start with $REPO self.assertTrue( refs[0].unresolvedPath().startswith("$" + conf.repository_env_key) ) self.assertTrue(refs[0].isLoaded()) def test_save_as_replaces_imagePlane_filename_with_env_variable(self): """testing if save_as replaces the imagePlane filename with repository environment variable """ # create a camera # create an image plane # set it to something # save the scene # check if the path is replaced with repository environment variable self.fail("test is not implemented yet") def test_save_as_creates_the_workspace_mel_file_in_the_given_path(self): """testing if save_as creates the workspace.mel file in the Asset or Shot root """ # check if the workspace.mel file does not exist yet workspace_mel_full_path = os.path.join( os.path.dirname(self.version1.path), 'workspace.mel' ) self.assertFalse(os.path.exists(workspace_mel_full_path)) self.mEnv.save_as(self.version1) self.assertTrue(os.path.exists(workspace_mel_full_path)) def test_save_as_creates_the_workspace_fileRule_folders(self): """testing if save_as creates the fileRule folders """ # first prove that the folders doesn't exist for key in pm.workspace.fileRules.keys(): file_rule_partial_path = pm.workspace.fileRules[key] file_rule_full_path = os.path.join( os.path.dirname(self.version1.path), file_rule_partial_path ) self.assertFalse(os.path.exists(file_rule_full_path)) self.mEnv.save_as(self.version1) # save_as and now expect the folders to be created for key in pm.workspace.fileRules.keys(): file_rule_partial_path = pm.workspace.fileRules[key] file_rule_full_path = os.path.join( os.path.dirname(self.version1.path), file_rule_partial_path ) self.assertTrue(os.path.exists(file_rule_full_path))
class MainDialog(QtGui.QDialog, project_properties_UI.Ui_Dialog): """Dialog to edit project properties If a :class:`~oyProjectManager.models.project.Project` instance is also passed it will edit the given project. If no Project is passed then it will create and return a new one. """ def __init__(self, parent=None, project=None): super(MainDialog, self).__init__(parent) self.setupUi(self) if db.session is None: db.setup() self.resolution_presets = conf.resolution_presets self.project = project self._setup_signals() self._setup_defaults() self.update_UI_from_project(self.project) def _setup_signals(self): """sets up signals """ # cancel button QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("rejected()"), self.close) # ok button QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("accepted()"), self.button_box_ok_clicked) # changing the name of the project should also update the code # if the code field is empty QtCore.QObject.connect(self.name_lineEdit, QtCore.SIGNAL("textChanged(QString)"), self.name_edited) def set_resolution_to_default(self): # set the resolution to the default preset index = self.resolution_comboBox.findText( conf.default_resolution_preset) self.resolution_comboBox.setCurrentIndex(index) def _setup_defaults(self): """sets up the default values """ self.resolution_comboBox.addItems( sorted(conf.resolution_presets.keys())) self.set_resolution_to_default() # clients clients = map(lambda x: x.name, Client.query().order_by(Client.name.asc()).all()) self.clients_comboBox.clear() self.clients_comboBox.addItems(clients) # set the fps to conf.default_fps self.fps_spinBox.setValue(conf.default_fps) # set active_checkBox to true self.active_checkBox.setChecked(True) # if a project is given don't let the user to try to change the code # attribute if self.project is not None: self.code_lineEdit.setEnabled(False) # advanced properties self.shot_number_padding_spinBox.setValue(conf.shot_number_padding) self.shot_number_prefix_lineEdit.setText(conf.shot_number_prefix) self.revision_number_padding_spinBox.setValue(conf.rev_number_padding) self.revision_number_prefix_lineEdit.setText(conf.rev_number_prefix) self.version_number_padding_spinBox.setValue(conf.ver_number_padding) self.version_number_prefix_lineEdit.setText(conf.ver_number_prefix) self.structure_textEdit.setText(conf.project_structure) def update_UI_from_project(self, project): """Updates the UI with the info from the given project instance :param project: The :class:`~oyProjectManager.models.project.Project` instance which the UI data will be read from. """ # if a project is given update the UI with the given project info if project is None: return self.name_lineEdit.setText(project.name) self.code_lineEdit.setText(project.code) if project.client: index = self.clients_comboBox.findText(project.client.name) if index != -1: self.clients_comboBox.setCurrentIndex(index) self.fps_spinBox.setValue(project.fps) self.active_checkBox.setChecked(project.active) # advanced properties self.shot_number_prefix_lineEdit.setText(project.shot_number_prefix) self.shot_number_padding_spinBox.setValue(project.shot_number_padding) self.revision_number_prefix_lineEdit.setText(project.rev_number_prefix) self.revision_number_padding_spinBox.setValue( project.rev_number_padding) self.version_number_prefix_lineEdit.setText(project.ver_number_prefix) self.version_number_padding_spinBox.setValue( project.ver_number_padding) self.structure_textEdit.setText(project.structure) # set the resolution preset_key = None for key in conf.resolution_presets.keys(): if conf.resolution_presets[key] == [ project.width, project.height, project.pixel_aspect ]: preset_key = key break if preset_key is not None: index = self.resolution_comboBox.findText(preset_key) self.resolution_comboBox.setCurrentIndex(index) else: # set it to custom self.resolution_comboBox.setCurrentIndex( self.resolution_comboBox.count() - 1) def button_box_ok_clicked(self): """runs when the ok button clicked """ # if there is no project given create a new one and return it # create_project # get the data from the input fields name = self.name_lineEdit.text() code = self.code_lineEdit.text() # check if the code is empty if code == "": # raise an error please QtGui.QMessageBox.critical( self, "Error", "Code field can not be empty,\n" "Please enter a proper Code!!!") return client_name = self.clients_comboBox.currentText() client = Client.query().filter(Client.name == client_name).first() if not client: # just create the client client = Client(name=client_name) client.save() resolution_name = self.resolution_comboBox.currentText() resolution_data = conf.resolution_presets[resolution_name] fps = self.fps_spinBox.value() active = self.active_checkBox.isChecked() # advanced properties shot_number_padding = self.shot_number_padding_spinBox.value() shot_number_prefix = self.shot_number_prefix_lineEdit.text() rev_number_padding = self.revision_number_padding_spinBox.value() rev_number_prefix = self.revision_number_prefix_lineEdit.text() ver_number_padding = self.version_number_padding_spinBox.value() ver_number_prefix = self.version_number_prefix_lineEdit.text() structure_code = self.structure_textEdit.toPlainText() is_new_project = False if self.project is None: logger.debug("no project is given creating new one") # create the project self.project = Project(name=name, code=code) is_new_project = True else: logger.debug("updating the given project") # update the project self.project.name = name self.project.client = client self.project.fps = fps self.project.width = resolution_data[0] self.project.height = resolution_data[1] self.project.pixel_aspect = resolution_data[2] self.project.active = active self.project.shot_number_padding = shot_number_padding self.project.shot_number_prefix = shot_number_prefix self.project.rev_number_padding = rev_number_padding self.project.rev_number_prefix = rev_number_prefix self.project.ver_number_padding = ver_number_padding self.project.ver_number_prefix = ver_number_prefix self.project.structure = structure_code if is_new_project: self.project.create() else: self.project.save() # and close the dialog self.close() def name_edited(self, new_name): """called by the ui event when the text in project name lineEdit changed, it updates the code field if the code field is empty :param new_name: the changed name """ # update only if the code field is empty import re new_code = re.sub(r'([^A-Z0-9]+)([\-\s]*)', '_', new_name.upper()) self.code_lineEdit.setText(new_code)
def test_shots_comboBox_is_filled_with_the_shots_from_the_current_sequence(self): """testing if the shots_comboBox is filled with the shots from the currently selected Sequence instance """ # projects project1 = Project("Test Project 1") project1.create() project2 = Project("Test Project 2") project2.create() # sequences seq1 = Sequence(project1, "Test Sequence 1") seq1.save() seq2 = Sequence(project1, "Test Sequence 2") seq2.save() seq3 = Sequence(project2, "Test Sequence 3") seq3.save() seq4 = Sequence(project2, "Test Sequence 4") seq4.save() # shots shot1 = Shot(seq1, 1) shot2 = Shot(seq1, 2) shot3 = Shot(seq1, 3) shot4 = Shot(seq2, 4) shot5 = Shot(seq2, 5) shot6 = Shot(seq2, 6) shot7 = Shot(seq3, 7) shot8 = Shot(seq3, 8) shot9 = Shot(seq3, 9) shot10 = Shot(seq4, 10) shot11 = Shot(seq4, 11) shot12 = Shot(seq4, 12) db.session.add_all( [shot1, shot2, shot3, shot4, shot5, shot6, shot7, shot8, shot9, shot10, shot11, shot12] ) db.session.commit() dialog = project_manager.MainDialog() # self.show_dialog(dialog) # set to project1 index = dialog.projects_comboBox.findText(project1.name) dialog.projects_comboBox.setCurrentIndex(index) # set to seq1 index = dialog.sequences_comboBox.findText(seq1.name) dialog.sequences_comboBox.setCurrentIndex(index) # check if shots_comboBox has 3 entries self.assertEqual(dialog.shots_comboBox.count(), 3) # check if shot1, shot2, shot3 are in the comboBox item_texts = [] for i in range(3): dialog.shots_comboBox.setCurrentIndex(i) item_texts.append(dialog.shots_comboBox.currentText()) self.assertTrue(shot1.code in item_texts) self.assertTrue(shot2.code in item_texts) self.assertTrue(shot3.code in item_texts) # set to project2 index = dialog.projects_comboBox.findText(project2.name) dialog.projects_comboBox.setCurrentIndex(index) # set to seq4 index = dialog.sequences_comboBox.findText(seq4.name) dialog.sequences_comboBox.setCurrentIndex(index) # check if shots_comboBox has 3 entries self.assertEqual(dialog.shots_comboBox.count(), 3) # check if shot10, shot11, shot12 are in the comboBox item_texts = [] for i in range(3): dialog.shots_comboBox.setCurrentIndex(i) item_texts.append(dialog.shots_comboBox.currentText()) self.assertTrue(shot10.code in item_texts) self.assertTrue(shot11.code in item_texts) self.assertTrue(shot12.code in item_texts)
class VersionTypeTester(unittest.TestCase): """tests the VersionType class """ 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_project = Project("TEST_PROJ1") self.test_project.create() self.test_project.save() self.kwargs = { # "project": self.test_project, "name": "Test VType", "code": "TVT", "path": "{{project.full_path}}/Sequences/{{sequence.code}}/SHOTS/{{version.base_name}}/{{type.code}}", "filename": "{{version.base_name}}_{{version.take_name}}_{{type.code}}_v{{'%03d'|format(version.version_number)}}_{{version.created_by.initials}}", "environments": ["MAYA", "HOUDINI"], "output_path": "SHOTS/{{version.base_name}}/{{type.code}}/OUTPUT/{{version.take_name}}", "extra_folders": """{{version.path}}/exports {{version.path}}/cache """, "type_for": "Shot" } self.test_versionType = VersionType(**self.kwargs) self.test_versionType.save() self._name_test_values = [ ("base name", "Base_Name"), ("123123 base_name", "Base_Name"), ("123432!+!'^+Base_NAme323^+'^%&+%&324", "Base_NAme323324"), (" ---base 9s_name", "Base_9s_Name"), (" ---base 9s-name", "Base_9s_Name"), (" multiple spaces are converted to under scores", "Multiple_Spaces_Are_Converted_To_Under_Scores"), ("camelCase", "CamelCase"), ("CamelCase", "CamelCase"), ("_Project_Setup_", "Project_Setup"), ("_PROJECT_SETUP_", "PROJECT_SETUP"), ("FUL_3D", "FUL_3D"), ("BaseName", "BaseName"), ("baseName", "BaseName"), (" baseName", "BaseName"), (" base name", "Base_Name"), (" 12base name", "Base_Name"), (" 12 base name", "Base_Name"), (" 12 base name 13", "Base_Name_13"), (">£#>$#£½$ 12 base £#$£#$£½¾{½{ name 13", "Base_Name_13"), ("_base_name_", "Base_Name"), ] def tearDown(self): """cleanup the test """ # set the db.session to None db.session = None # delete the temp folder shutil.rmtree(self.temp_config_folder) shutil.rmtree(self.temp_projects_folder) def test_name_argument_is_None(self): """testing if a TypeError will be raised when the name argument is None """ self.kwargs["name"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_name_attribute_is_None(self): """testing if a TypeError will be raised when the name attribute is set to None """ self.assertRaises(TypeError, setattr, self.test_versionType, "name", None) def test_name_argument_is_not_a_string(self): """testing if a TypeError will be raised when the name argument is not a string or unicode instance """ self.kwargs["name"] = 123 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_name_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the name argument is not a string or unicode instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "name", 8) def test_name_argument_is_working_properly(self): """testing if the name argument is working properly and sets the name attribute correctly """ self.assertEqual(self.kwargs["name"], self.test_versionType.name) def test_name_attribute_is_working_properly(self): """testing if the name attribute is working properly """ test_value = "New Name" self.test_versionType.name = test_value self.assertEqual(test_value, self.test_versionType.name) def test_name_attribute_is_not_unique(self): """testing if an IntegrityError error will be raised when the name argument is not unique """ # creating a new VersionType should raise the ?? error new_vtype = VersionType(**self.kwargs) self.assertRaises(IntegrityError, new_vtype.save) def test_code_argument_is_skipped(self): """testing if a TypeError will be raised when the code argument is skipped """ self.kwargs.pop("code") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_code_argument_is_None(self): """testing if a TypeError will be raised when the code argument is None """ self.kwargs["code"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_code_attribute_is_None(self): """testing if a TypeError will be raised when the code attribute is set to None """ self.assertRaises(TypeError, setattr, self.test_versionType, "code", None) def test_code_argument_is_not_a_string(self): """testing if a TypeError will be raised when the code argument is not a string or unicode instance """ self.kwargs["code"] = 123 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_code_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the code argument is not a string or unicode instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "code", 8) def test_code_argument_is_working_properly(self): """testing if the code argument is working properly and sets the code attribute correctly """ self.assertEqual(self.kwargs["code"], self.test_versionType.code) def test_code_attribute_is_working_properly(self): """testing if the code attribute is working properly """ test_value = "New Name" self.test_versionType.code = test_value self.assertEqual(test_value, self.test_versionType.code) def test_code_attribute_is_not_unique(self): """testing if an IntegrityError error will be raised when the code argument is not unique """ # creating a new VersionType should raise the IntegrityError self.kwargs["name"] = "A Different Name" new_vtype = VersionType(**self.kwargs) self.assertRaises(IntegrityError, new_vtype.save) def test_filename_argument_is_skipped(self): """testing if a TypeError will be raised when the filename argument is skipped """ self.kwargs.pop("filename") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_filename_argument_is_empty_string(self): """testing if a ValueError will be raised when the filename argument is an empty string """ self.kwargs["filename"] = "" self.assertRaises(ValueError, VersionType, **self.kwargs) def test_filename_attribute_is_empty_string(self): """testing if a ValueError will be raised when the filename attribute is set to an empty string """ self.assertRaises(ValueError, setattr, self.test_versionType, "filename", "") def test_filename_argument_is_not_a_string(self): """testing if a TypeError will be raised when the filename argument is not a string instance """ self.kwargs["filename"] = 13245 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_filename_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the filename attribute is not a string instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "filename", 23412) def test_filename_argument_is_working_properly(self): """testing if the filename attribute is initialized correctly with the same value of the filename argument """ self.assertEqual(self.test_versionType.filename, self.kwargs["filename"]) def test_filename_attribute_is_working_properly(self): """testing if the filename attribute is working properly """ test_value = "test_filename" self.test_versionType.filename = test_value self.assertEqual(self.test_versionType.filename, test_value) def test_path_argument_is_skipped(self): """testing if a TypeError will be raised when the path argument is skipped """ self.kwargs.pop("path") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_path_argument_is_empty_string(self): """testing if a ValueError will be raised when the path argument is an empty string """ self.kwargs["path"] = "" self.assertRaises(ValueError, VersionType, **self.kwargs) def test_path_attribute_is_empty_string(self): """testing if a ValueError will be raised when the path attribute is set to an empty string """ self.assertRaises(ValueError, setattr, self.test_versionType, "path", "") def test_path_argument_is_not_a_string(self): """testing if a TypeError will be raised when the path argument is not a string instance """ self.kwargs["path"] = 13245 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_path_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the path attribute is not a string instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "path", 23412) def test_path_argument_is_working_properly(self): """testing if the path attribute is initialized correctly with the same value of the path argument """ self.assertEqual(self.test_versionType.path, self.kwargs["path"]) def test_path_attribute_is_working_properly(self): """testing if the path attribute is working properly """ test_value = "test_path" self.test_versionType.path = test_value self.assertEqual(self.test_versionType.path, test_value) def test_output_path_argument_is_skipped(self): """testing if a TypeError will be raised when the output_path argument is skipped """ self.kwargs.pop("output_path") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_output_path_argument_is_empty_string(self): """testing if a ValueError will be raised when the output_path argument is an empty string """ self.kwargs["output_path"] = "" self.assertRaises(ValueError, VersionType, **self.kwargs) def test_output_path_attribute_is_empty_string(self): """testing if a ValueError will be raised when the output_path attribute is set to an empty string """ self.assertRaises(ValueError, setattr, self.test_versionType, "output_path", "") def test_output_path_argument_is_not_a_string(self): """testing if a TypeError will be raised when the output_path argument is not a string instance """ self.kwargs["output_path"] = 13245 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_output_path_attribute_is_not_a_string(self): """testing if a TypeError will be raised when the output_path attribute is not a string instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "output_path", 23412) def test_output_path_argument_is_working_properly(self): """testing if the output_path attribute is initialized correctly with the same value of the output_path argument """ self.assertEqual(self.test_versionType.output_path, self.kwargs["output_path"]) def test_output_path_attribute_is_working_properly(self): """testing if the output_path attribute is working properly """ test_value = "test_output_path" self.test_versionType.output_path = test_value self.assertEqual(self.test_versionType.output_path, test_value) def test_extra_folders_argument_is_skipped(self): """testing if the extra_folders argument is skipped the extra_folders attribute will be an empty string """ self.kwargs.pop("extra_folders") new_version_type = VersionType(**self.kwargs) self.assertEqual(new_version_type.extra_folders, "") def test_extra_folders_argument_is_None(self): """testing if the extra_folders attribute is going to be an empty string when the extra folders argument is given as None """ self.kwargs["extra_folders"] = None new_version_type = VersionType(**self.kwargs) self.assertEqual(new_version_type.extra_folders, "") def test_extra_folders_attribute_is_None(self): """testing if the extra_folders attribute will be an empty list when it is set to None """ self.test_versionType.extra_folders = None self.assertEqual(self.test_versionType.extra_folders, "") def test_extra_folders_argument_is_not_a_string_instance(self): """testing if a TypeError will be raised when the extra_folders argument is not a string or unicode instance """ self.kwargs["extra_folders"] = 123 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_extra_folders_attribute_is_not_a_string_instance(self): """testing if a TypeError will be raised when the extra_folders attribute is set to something other than a string or unicode instance """ self.assertRaises(TypeError, setattr, self.test_versionType, "extra_folders", 23423) def test_extra_folders_argument_is_working_properly(self): """testing if the extra_folders attribute will be set to the same value with the extra_folders argument while initialization """ self.assertEqual(self.test_versionType.extra_folders, self.kwargs["extra_folders"]) def test_extra_folders_attribute_is_working_properly(self): """testing if the extra_folders attribute is working properly """ test_value = "extra_folders" self.test_versionType.extra_folders = test_value self.assertEqual(self.test_versionType.extra_folders, test_value) def test_environments_argument_is_skipped(self): """testing if a TypeError will be raised when the environments argument is skipped """ self.kwargs.pop("environments") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_argument_is_None(self): """testing if a TypeError will be raised when the environments argument is None """ self.kwargs["environments"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_attribute_is_None(self): """testing if a TypeError will be raised when the environments attribute is set to None """ self.assertRaises(TypeError, setattr, self.test_versionType, "environments", None) def test_environments_argument_is_not_a_list(self): """testing if a TypeError will be raised when the environments argument is not a list instance """ self.kwargs["environments"] = 12354 self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_attribute_is_not_a_list(self): """testing if a TypeError will be raised when the environments attribute is set to something other than a list """ self.assertRaises(TypeError, setattr, self.test_versionType, "environments", 123) def test_environments_argument_is_not_a_list_of_strings(self): """testing if a TypeError will be raised when the environments argument is not a list of strings """ self.kwargs["environments"] = [123, "MAYA"] self.assertRaises(TypeError, VersionType, **self.kwargs) def test_environments_attribute_is_not_a_list_of_strings(self): """testing if a TypeError will be raised when the environments attribute is not a list of strings """ self.assertRaises(TypeError, setattr, self.test_versionType, "environments", [123, "MAYA"]) def test_environments_argument_works_properly(self): """testing if the environments attribute will be initialized correctly with the environments argument """ test_value = ["MAYA", "HOUDINI"] self.kwargs["environments"] = test_value new_vtype = VersionType(**self.kwargs) for env in test_value: self.assertTrue(env in new_vtype.environments) def test_environments_attribute_works_properly(self): """testing if the environments attribute is working properly """ test_value = ["MAYA", "HOUDINI", "NUKE", "3DEQUALIZER"] self.test_versionType.environments = test_value for env in test_value: self.assertTrue(env in self.test_versionType.environments) def test_type_for_argument_is_skipped(self): """testing if a TypeError will be raised when the type_for argument is skipped """ self.kwargs.pop("type_for") self.assertRaises(TypeError, VersionType, **self.kwargs) def test_type_for_argument_is_None(self): """testing if a TypeError will be raised when the type_for argument is None """ self.kwargs["type_for"] = None self.assertRaises(TypeError, VersionType, **self.kwargs) def test_type_for_argument_is_not_a_string_or_integer(self): """testing if a TypeError will be raised when the type_for argument is not a string or unicode or an integer """ self.kwargs["type_for"] = [12] self.assertRaises(TypeError, VersionType, **self.kwargs) def test_type_for_argument_is_working_properly(self): """testing if the type_for argument is working properly """ self.kwargs["name"] = "Test Animation" self.kwargs["code"] = "TA" self.kwargs["type_for"] = "Asset" new_vtype = VersionType(**self.kwargs) new_vtype.save() self.assertEqual(new_vtype.type_for, "Asset") def test_type_for_attribute_is_read_only(self): """testing if type_for attribute is read-only """ self.assertRaises(AttributeError, setattr, self.test_versionType, "type_for", "Asset") def test_save_method_saves_the_version_type_to_the_database(self): """testing if the save method saves the current VersionType to the database """ self.kwargs["name"] = "Test Animation" self.kwargs["code"] = "TA" new_vtype = VersionType(**self.kwargs) new_vtype.save() code = new_vtype.code environments = new_vtype.environments filename = new_vtype.filename name = new_vtype.name output_path = new_vtype.output_path path = new_vtype.path type_for = new_vtype.type_for # del new_vtype new_vtypeDB = VersionType.query().\ filter_by(name=self.kwargs["name"]).first() self.assertEqual(code, new_vtypeDB.code) self.assertEqual(filename, new_vtypeDB.filename) self.assertEqual(name, new_vtypeDB.name) self.assertEqual(output_path, new_vtypeDB.output_path) self.assertEqual(path, new_vtypeDB.path) self.assertEqual(type_for, new_vtypeDB.type_for) self.assertEqual(environments, new_vtypeDB.environments) def test__eq__(self): """testing the equality operator """ verst1 = VersionType(name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") verst2 = VersionType(name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") verst3 = VersionType(name="Test Type 2", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") verst4 = VersionType(name="Test Type 3", code="TT3", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") self.assertTrue(verst1 == verst2) self.assertFalse(verst1 == verst3) self.assertFalse(verst3 == verst4) def test__ne__(self): """testing the equality operator """ verst1 = VersionType(name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") verst2 = VersionType(name="Test Type", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") verst3 = VersionType(name="Test Type 2", code="TT", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") verst4 = VersionType(name="Test Type 3", code="TT3", path="path", filename="filename", output_path="output_path", environments=["MAYA", "NUKE"], type_for="Asset") self.assertFalse(verst1 != verst2) self.assertTrue(verst1 != verst3) self.assertTrue(verst3 != verst4)