def setUp(self): """setup the test """ super(SequenceTester, self).setUp() # create a test project, user and a couple of shots from stalker import Type self.project_type = Type( name="Test Project Type", code='test', target_entity_type='Project', ) from stalker.db.session import DBSession DBSession.add(self.project_type) # create a repository self.repository_type = Type( name="Test Type", code='test', target_entity_type='Repository' ) DBSession.add(self.repository_type) from stalker import Repository self.test_repository = Repository( name="Test Repository", type=self.repository_type, ) DBSession.add(self.test_repository) # create projects from stalker import Project self.test_project = Project( name="Test Project 1", code='tp1', type=self.project_type, repository=self.test_repository, ) DBSession.add(self.test_project) self.test_project2 = Project( name="Test Project 2", code='tp2', type=self.project_type, repository=self.test_repository, ) DBSession.add(self.test_project2) # the parameters self.kwargs = { "name": "Test Sequence", 'code': 'tseq', "description": "A test sequence", "project": self.test_project, } # the test sequence from stalker import Sequence self.test_sequence = Sequence(**self.kwargs) DBSession.commit()
def setUp(self): """setup the test """ super(LinkTester, self).setUp() # create a mock LinkType object from stalker import db, Type self.test_link_type1 = Type( name='Test Type 1', code='test type1', target_entity_type=Link, ) db.DBSession.add(self.test_link_type1) self.test_link_type2 = Type( name='Test Type 2', code='test type2', target_entity_type=Link, ) db.DBSession.add(self.test_link_type2) self.kwargs = { 'name': 'An Image Link', 'full_path': 'C:/A_NEW_PROJECT/td/dsdf/' '22-fdfffsd-32342-dsf2332-dsfd-3.exr', 'original_filename': 'this_is_an_image.jpg', 'type': self.test_link_type1 } self.test_link = Link(**self.kwargs) db.DBSession.add(self.test_link) db.DBSession.commit()
def setUp(self): """setup the test """ # create a user self.test_user = User( name='Test User', login='******', email='*****@*****.**', password='******', ) # vacation type self.personal_vacation = Type( name='Personal', code='PERS', target_entity_type='Vacation' ) self.studio_vacation = Type( name='Studio Wide', code='STD', target_entity_type='Vacation' ) self.kwargs = { 'user': self.test_user, 'type': self.personal_vacation, 'start': datetime.datetime(2013, 6, 6, 10, 0), 'end': datetime.datetime(2013, 6, 10, 19, 0) } self.test_vacation = Vacation(**self.kwargs)
def setUp(self): """setup the test """ super(VacationTestCase, self).setUp() # create a user from stalker import User self.test_user = User( name='Test User', login='******', email='*****@*****.**', password='******', ) # vacation type from stalker import Type self.personal_vacation = Type(name='Personal', code='PERS', target_entity_type='Vacation') self.studio_vacation = Type(name='Studio Wide', code='STD', target_entity_type='Vacation') import datetime import pytz self.kwargs = { 'user': self.test_user, 'type': self.personal_vacation, 'start': datetime.datetime(2013, 6, 6, 10, 0, tzinfo=pytz.utc), 'end': datetime.datetime(2013, 6, 10, 19, 0, tzinfo=pytz.utc) } self.test_vacation = Vacation(**self.kwargs)
def setUp(self): """setting up the test """ super(PageTester, self).setUp() # create a repository from stalker import Type self.repository_type = Type(name="Test Repository Type", code='test_repo', target_entity_type='Repository') from stalker import Repository self.test_repository = Repository( name="Test Repository", code="TR", type=self.repository_type, ) # statuses from stalker import Status self.status1 = Status(name="Status1", code="STS1") self.status2 = Status(name="Status2", code="STS2") self.status3 = Status(name="Status3", code="STS3") # project status list from stalker import StatusList self.project_status_list = StatusList(name="Project Status List", statuses=[ self.status1, self.status2, self.status3, ], target_entity_type='Project') # project type self.test_project_type = Type( name="Test Project Type", code='testproj', target_entity_type='Project', ) # create projects from stalker import Project self.test_project1 = Project( name="Test Project 1", code='tp1', type=self.test_project_type, status_list=self.project_status_list, repository=self.test_repository, ) self.kwargs = { 'title': 'Test Page Title', 'content': 'Test content', 'project': self.test_project1 } self.test_page = Page(**self.kwargs)
def setUp(self): """setup the test """ # create a repository self.repository_type = Type(name="Test Repository Type", code='testproj', target_entity_type=Repository) self.test_repository = Repository( name="Test Repository", type=self.repository_type, ) # statuses self.status1 = Status(name="Status1", code="STS1") self.status2 = Status(name="Status2", code="STS2") self.status3 = Status(name="Status3", code="STS3") # project status list self.project_status_list = StatusList(name="Project Status List", statuses=[ self.status1, self.status2, self.status3, ], target_entity_type=Project) # project type self.test_project_type = Type( name="Test Project Type", code='testproj', target_entity_type=Project, ) # create projects self.test_project1 = Project( name="Test Project 1", code='tp1', type=self.test_project_type, status_list=self.project_status_list, repository=self.test_repository, ) self.test_project2 = Project( name="Test Project 2", code='tp2', type=self.test_project_type, status_list=self.project_status_list, repository=self.test_repository, ) self.kwargs = { "name": "Test Class", "project": self.test_project1, } self.test_foo_obj = ProjMixClass(**self.kwargs)
def setUp(self): """setting up the tests """ super(StructureTester, self).setUp() from stalker import db, Type vers_type = Type(name="Version", code='vers', target_entity_type="FilenameTemplate") db.DBSession.add(vers_type) ref_type = Type(name="Reference", code='ref', target_entity_type="FilenameTemplate") db.DBSession.add(ref_type) db.DBSession.commit() # type templates from stalker import FilenameTemplate self.asset_template = FilenameTemplate(name="Test Asset Template", target_entity_type="Asset", type=vers_type) self.shot_template = FilenameTemplate(name="Test Shot Template", target_entity_type="Shot", type=vers_type) self.reference_template = FilenameTemplate( name="Test Reference Template", target_entity_type="Link", type=ref_type) self.test_templates = [ self.asset_template, self.shot_template, self.reference_template ] self.test_templates2 = [self.asset_template] self.custom_template = "a custom template" self.test_type = Type( name="Commercial Structure", code='comm', target_entity_type='Structure', ) # keyword arguments self.kwargs = { "name": "Test Structure", "description": "This is a test structure", "templates": self.test_templates, "custom_template": self.custom_template, "type": self.test_type, } self.test_structure = Structure(**self.kwargs) db.DBSession.add(self.test_structure) db.DBSession.commit()
def create_ticket_statuses(): """creates the default ticket statuses """ from stalker import defaults, User # create as admin admin = User.query.filter(User.login == defaults.admin_name).first() # create statuses for Tickets ticket_names = defaults.ticket_status_names ticket_codes = defaults.ticket_status_codes create_entity_statuses('Ticket', ticket_names, ticket_codes, admin) # Again I hate doing this in this way from stalker import Type types = Type.query \ .filter_by(target_entity_type="Ticket") \ .all() t_names = [t.name for t in types] # create Ticket Types logger.debug("Creating Ticket Types") from stalker.db.session import DBSession if 'Defect' not in t_names: ticket_type_1 = Type( name='Defect', code='Defect', target_entity_type='Ticket', created_by=admin, updated_by=admin ) DBSession.add(ticket_type_1) if 'Enhancement' not in t_names: ticket_type_2 = Type( name='Enhancement', code='Enhancement', target_entity_type='Ticket', created_by=admin, updated_by=admin ) DBSession.add(ticket_type_2) from sqlalchemy.exc import IntegrityError try: DBSession.commit() except IntegrityError: DBSession.rollback() logger.debug("Ticket Types are already in the database!") else: # DBSession.flush() logger.debug("Ticket Types are created successfully")
def setUp(self): """setting up the tests """ vers_type = Type(name="Version", code='vers', target_entity_type="FilenameTemplate") ref_type = Type(name="Reference", code='ref', target_entity_type="FilenameTemplate") # type templates self.asset_template = FilenameTemplate(name="Test Asset Template", target_entity_type="Asset", type=vers_type) self.shot_template = FilenameTemplate(name="Test Shot Template", target_entity_type="Shot", type=vers_type) self.reference_template = FilenameTemplate( name="Test Reference Template", target_entity_type="Link", type=ref_type) self.test_templates = [ self.asset_template, self.shot_template, self.reference_template ] self.test_templates2 = [self.asset_template] self.custom_template = "a custom template" self.test_type = Type( name="Commercial Structure", code='comm', target_entity_type=Structure, ) # keyword arguments self.kwargs = { "name": "Test Structure", "description": "This is a test structure", "templates": self.test_templates, "custom_template": self.custom_template, "type": self.test_type, } self.test_structure = Structure(**self.kwargs)
def test_TaskMixin_initialization(self): """testing if the TaskMixin part is initialized correctly """ commercial_project_type = Type( name="Commercial", code='comm', target_entity_type=Project, ) new_project = Project( name="Commercial", code='COM', type=commercial_project_type, status_list=self.project_status_list, repository=self.repository, ) character_asset_type = Type( name="Character", code='char', target_entity_type=Asset ) new_asset = Asset( name="test asset", type=character_asset_type, code="tstasset", project=new_project, responsible=[self.test_user1] ) task1 = Task( name="Modeling", parent=new_asset ) task2 = Task( name="Lighting", parent=new_asset ) tasks = [task1, task2] self.assertEqual( sorted(new_asset.tasks, key=lambda x: x.name), sorted(tasks, key=lambda x: x.name) )
def loads(self, data): """Decodes Stalker data :param data: :return: """ from stalker.db.session import DBSession from stalker import Asset, Task, Shot, Sequence, Version, Type if isinstance(data, str): data = json.loads(data) # get the entity_type entity_type = data['entity_type'] # set default entity class to Task entity_class = Task if entity_type == 'Asset': entity_class = Asset elif entity_type == 'Shot': entity_class = Shot # this is a bug data['sequences'] = [] elif entity_type == 'Sequence': entity_class = Sequence version_data = data['versions'] data['versions'] = [] # get the type if 'type' in data: type_data = data['type'] if type_data: type_name = type_data['name'] type_ = Type.query.filter(Type.name == type_name).first() if not type_: # create a Type type_ = Type(**type_data) data['type'] = type_ data['project'] = self.project entity = entity_class(**data) DBSession.add(entity) DBSession.commit() # create Versions if version_data: for v_data in version_data: # get Version info v_data['task'] = entity v = Version(**v_data) # update version_number v.version_number = v_data['version_number'] v.is_published = v_data['is_published'] # for each child task call a new StalkerEntityDecoder for t in data['tasks']: child_task = self.loads(t) entity.tasks.append(child_task) return entity
def test_update_entity_method_is_working_properly_with_post(self): """testing if the POST: /api/types/{id} view is working properly """ from stalker import db, Type test_type = Type(name='Test Type', code='TT', description='A test type', target_entity_type='Project', created_by=self.admin) db.DBSession.add(test_type) db.DBSession.commit() self.admin_login() response = self.test_app.post('/api/types/%s' % test_type.id, params={ 'description': 'New description', 'name': 'New Name', 'code': 'New Code' }, status=200) test_type_db = Type.query.get(test_type.id) self.assertEqual(test_type_db.name, 'New Name') self.assertEqual(test_type_db.code, 'New Code') self.assertEqual(test_type_db.description, 'New description')
def test_equality(self): """testing the equality operator """ new_type2 = Type(**self.kwargs) self.kwargs["target_entity_type"] = "Asset" new_type3 = Type(**self.kwargs) self.kwargs["name"] = "a different type" self.kwargs["description"] = "this is a different type" new_type4 = Type(**self.kwargs) self.assertTrue(self.test_type == new_type2) self.assertFalse(self.test_type == new_type3) self.assertFalse(self.test_type == new_type4) self.assertFalse(self.test_type == self.entity1)
def test_ReferenceMixin_initialization(self): """testing if the ReferenceMixin part is initialized correctly """ from stalker import Link, Type link_type_1 = Type( name="Image", code='image', target_entity_type="Link" ) link1 = Link( name="Artwork 1", full_path="/mnt/M/JOBs/TEST_PROJECT", filename="a.jpg", type=link_type_1 ) link2 = Link( name="Artwork 2", full_path="/mnt/M/JOBs/TEST_PROJECT", filename="b.jbg", type=link_type_1 ) references = [link1, link2] self.kwargs["code"] = "SH12314" self.kwargs["references"] = references from stalker import Asset new_asset = Asset(**self.kwargs) assert new_asset.references == references
def test_ProjectMixin_initialization(self): """testing if the ProjectMixin part is initialized correctly """ from stalker import Status, StatusList status1 = Status(name="On Hold", code="OH") project_status_list = StatusList( name="Project Statuses", statuses=[status1], target_entity_type='Project' ) from stalker import Type project_type = Type( name="Commercial", code='comm', target_entity_type='Project' ) from stalker import Project new_project = Project( name="Test Project", code='tp', status=project_status_list[0], status_list=project_status_list, type=project_type, repository=self.test_repository ) from stalker import Sequence self.kwargs["project"] = new_project new_sequence = Sequence(**self.kwargs) self.assertEqual(new_sequence.project, new_project)
def test_ReferenceMixin_initialization(self): """testing if the ReferenceMixin part is initialized correctly """ from stalker import Type, Link, Sequence link_type_1 = Type( name="Image", code='image', target_entity_type="Link" ) link1 = Link( name="Artwork 1", full_path="/mnt/M/JOBs/TEST_PROJECT", filename="a.jpg", type=link_type_1 ) link2 = Link( name="Artwork 2", full_path="/mnt/M/JOBs/TEST_PROJECT", filename="b.jbg", type=link_type_1 ) references = [link1, link2] self.kwargs["references"] = references new_sequence = Sequence(**self.kwargs) self.assertEqual(new_sequence.references, references)
def test_update_entity_method_is_working_properly(self): """testing if the update_entity() method is working properly """ from stalker import db, Type test_type = Type(name='Test Type', code='TT', description='A test type', target_entity_type='Project', created_by=self.admin) db.DBSession.add(test_type) db.DBSession.commit() from stalker_pyramid.testing import DummyRequest, DummyMultiDict request = DummyRequest() request.matchdict['id'] = test_type.id request.params = DummyMultiDict() request.params['description'] = 'New description' request.params['name'] = 'New Name' request.params['code'] = 'New Code' self.patch_logged_in_user(request) type_view = type.TypeViews(request) response = type_view.update_entity() test_type_db = Type.query.get(test_type.id) self.assertEqual(test_type_db.name, 'New Name') self.assertEqual(test_type_db.code, 'New Code') self.assertEqual(test_type_db.description, 'New description')
def test_inequality(self): """testing the inequality operator """ new_type2 = Type(**self.kwargs) self.kwargs["target_entity_type"] = "Asset" new_type3 = Type(**self.kwargs) self.kwargs["name"] = "a different type" self.kwargs["description"] = "this is a different type" new_type4 = Type(**self.kwargs) assert not self.test_type != new_type2 assert self.test_type != new_type3 assert self.test_type != new_type4 assert self.test_type != self.entity1
def test_TaskMixin_initialization(self): """testing if the TaskMixin part is initialized correctly """ from stalker import Type, Project, Asset, Task commercial_project_type = Type( name="Commercial", code='comm', target_entity_type='Project', ) new_project = Project( name="Commercial", code='COM', type=commercial_project_type, repository=self.repository, ) character_asset_type = Type( name="Character", code='char', target_entity_type='Asset' ) new_asset = Asset( name="test asset", type=character_asset_type, code="tstasset", project=new_project, responsible=[self.test_user1] ) task1 = Task( name="Modeling", parent=new_asset ) task2 = Task( name="Lighting", parent=new_asset ) tasks = [task1, task2] assert \ sorted(new_asset.tasks, key=lambda x: x.name) == \ sorted(tasks, key=lambda x: x.name)
def test_target_entity_type_argument_accepts_Python_classes(self): """testing if target_entity_type argument is given as a Python class will be converted to a string """ from stalker.models.asset import Asset self.kwargs["target_entity_type"] = Asset new_type = Type(**self.kwargs) assert new_type.target_entity_type == "Asset"
def test_target_entity_type_argument_can_not_be_empty_string(self): """testing if a ValueError will be raised when the target_entity_type argument is an empty string """ self.kwargs["target_entity_type"] = "" with pytest.raises(ValueError) as cm: Type(**self.kwargs) assert str(cm.value) == 'Type.target_entity_type can not be empty'
def test_target_entity_type_argument_can_not_be_None(self): """testing if a TypeError will be raised when the target_entity_type argument is None """ self.kwargs["target_entity_type"] = None with pytest.raises(TypeError) as cm: Type(**self.kwargs) assert str(cm.value) == 'Type.target_entity_type can not be None'
def test_target_entity_type_argument_can_not_be_skipped(self): """testing if a TypeError will be raised when the created Type doesn't have any target_entity_type """ self.kwargs.pop("target_entity_type") with pytest.raises(TypeError) as cm: Type(**self.kwargs) assert str(cm.value) == 'Type.target_entity_type can not be None'
def test_target_entity_type_argument_can_not_be_empty_string(self): """testing if a ValueError will be raised when the target_entity_type argument is an empty string """ self.kwargs["target_entity_type"] = "" with self.assertRaises(ValueError) as cm: Type(**self.kwargs) self.assertEqual(str(cm.exception), 'Type.target_entity_type can not be empty')
def test_target_entity_type_argument_can_not_be_skipped(self): """testing if a TypeError will be raised when the created Type doesn't have any target_entity_type """ self.kwargs.pop("target_entity_type") with self.assertRaises(TypeError) as cm: Type(**self.kwargs) self.assertEqual(str(cm.exception), 'Type.target_entity_type can not be None')
def test_target_entity_type_argument_can_not_be_None(self): """testing if a TypeError will be raised when the target_entity_type argument is None """ self.kwargs["target_entity_type"] = None with self.assertRaises(TypeError) as cm: Type(**self.kwargs) self.assertEqual(str(cm.exception), 'Type.target_entity_type can not be None')
def test_TaskMixin_initialization(self): """testing if the TaskMixin part is initialized correctly """ from stalker import StatusList project_status_list = \ StatusList.query\ .filter(StatusList.target_entity_type=='Project').first() from stalker import Type project_type = Type( name="Commercial", code='comm', target_entity_type='Project' ) from stalker import Project new_project = Project( name="Commercial1", code='comm1', status_list=project_status_list, type=project_type, repository=self.test_repository, ) from stalker.db.session import DBSession DBSession.add(new_project) DBSession.commit() self.kwargs['project'] = new_project self.kwargs['code'] = "SH12314" from stalker import Task new_shot = Shot(**self.kwargs) task1 = Task( name="Modeling", status=0, project=new_project, parent=new_shot, ) task2 = Task( name="Lighting", status=0, project=new_project, parent=new_shot, ) tasks = [task1, task2] assert \ sorted(new_shot.tasks, key=lambda x: x.name) == \ sorted(tasks, key=lambda x: x.name)
def create_ticket_types(): """Creates the extra ticket types """ # create Review ticket type review = Type.query.filter_by(name='Review').first() if not review: # create the review type for Tickets review = Type(target_entity_type='Ticket', name='Review', code='Review') # Warning! Not using scoped_session here, it is the plain old session DBSession.add(review) DBSession.commit()
def test_TaskableEntity_initialization(self): """testing if the TaskableEntity part is initialized correctly """ from stalker import Status, StatusList status1 = Status(name="On Hold", code="OH") project_status_list = StatusList( name="Project Statuses", statuses=[status1], target_entity_type='Project', ) from stalker import Type, Project, Sequence, Task project_type = Type( name="Commercial", code='comm', target_entity_type='Project' ) new_project = Project( name="Commercial", code='comm', status_list=project_status_list, type=project_type, repository=self.test_repository, ) self.kwargs["new_project"] = new_project new_sequence = Sequence(**self.kwargs) task1 = Task( name="Modeling", status=0, project=new_project, parent=new_sequence, ) task2 = Task( name="Lighting", status=0, project=new_project, parent=new_sequence, ) tasks = [task1, task2] self.assertEqual( sorted(new_sequence.tasks, key=lambda x: x.name), sorted(tasks, key=lambda x: x.name) )
def setUp(self): """set up the test """ self.kwargs = { "name": "test type", 'code': 'test', "description": "this is a test type", "target_entity_type": "SimpleEntity" } self.test_type = Type(**self.kwargs) # create another Entity with the same name of the # test_type for __eq__ and __ne__ tests self.entity1 = Entity(**self.kwargs)