def setUp(self): """set up the test """ import transaction from pyramid import paster, testing from webtest import TestApp from stalker import db from stalker.db.session import DBSession testing.setUp() import os import stalker_pyramid app = paster.get_app( os.path.join( os.path.dirname( stalker_pyramid.__path__[0], ), 'testing.ini' ).replace('\\', '/') ) self.test_app = TestApp(app) # patch DBSession commit, to let the db.init() work # with its calls to DBSession.commit() _orig_commit = DBSession.commit DBSession.commit = transaction.commit db.setup(app.registry.settings) db.init() # restore DBSession.commit DBSession.commit = _orig_commit from stalker import User self.admin = User.query.filter(User.name == 'admin').first()
def test_updating_a_repository_will_update_repo_path(self): """testing if the environment variable will be updated when the repository path is updated """ from stalker import db, defaults db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) repo = Repository(name='Test Repo', linux_path='/mnt/T', osx_path='/Volumes/T', windows_path='T:/') db.DBSession.add(repo) db.DBSession.commit() import os self.assertTrue(defaults.repo_env_var_template % {'id': repo.id} in os.environ) # now update the repository test_value = '/mnt/S/' repo.path = test_value # expect the environment variable is also updated self.assertEqual( os.environ[defaults.repo_env_var_template % { 'id': repo.id }], test_value)
def test_update_with_studio_is_working_properly(self): """testing if the default values are updated with the Studio instance if there is a database connection and there is a Studio in there """ import datetime from stalker import db, defaults from stalker.db.session import DBSession from stalker.models.studio import Studio db.setup() db.init() # check the defaults are still using them self self.assertEqual( defaults.timing_resolution, datetime.timedelta(hours=1) ) studio = Studio( name='Test Studio', timing_resolution=datetime.timedelta(minutes=15) ) DBSession.add(studio) DBSession.commit() # now check it again self.assertEqual( defaults.timing_resolution, studio.timing_resolution )
def create_db(): """creates a test database """ import os os.environ.pop('STALKER_PATH') from stalker import db db.setup({'sqlalchemy.url': 'sqlite://'}) db.init()
def setUp(self): """set the test up """ db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) self.kwargs = { 'name': 'Test DAG Mixin' }
def create_db(): """creates a test database """ from stalker import db print("setting up test database") db.setup({'sqlalchemy.url': 'sqlite://'}) print("initializing test database") db.init()
def setUp(self): """set up the test """ db.setup() db.init() self.temp_path = tempfile.mkdtemp() self.repo = Repository( name='Test Repository', linux_path=self.temp_path, windows_path=self.temp_path, osx_path=self.temp_path ) self.status_new = Status.query.filter_by(code='NEW').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() self.project_status_list = \ StatusList.query.filter_by(target_entity_type='Project').first() self.task_filename_template = FilenameTemplate( name='Task Filename Template', target_entity_type='Task', path='{{project.code}}/{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}{{extension}}' ) self.project_structure = Structure( name='Project Structure', templates=[self.task_filename_template] ) self.project = Project( name='Test Project', code='TP', status_list=self.project_status_list, repository=self.repo, structure=self.project_structure ) self.task = Task( name='Test Task', project=self.project ) from stalker.db.session import DBSession DBSession.add(self.task) DBSession.commit() self.version = Version( task=self.task ) self.kwargs = { 'name': 'Photoshop', 'extensions': ['psd'], 'structure': ['Outputs'] } self.external_env = ExternalEnv(**self.kwargs)
def setUpClass(cls): """setup once """ db.setup() db.init() cls.status_new = Status.query.filter_by(code='NEW').first() cls.status_wip = Status.query.filter_by(code='WIP').first() cls.status_cmpl = Status.query.filter_by(code='CMPL').first() cls.test_project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[cls.status_new, cls.status_wip, cls.status_cmpl]) cls.test_repo = Repository(name='Test Repository') cls.test_project = Project(name='Test Project', code='TP', repository=cls.test_repo, status_list=cls.test_project_status_list) cls.test_task1 = Task(name='Test Task 1', project=cls.test_project) cls.test_task2 = Task(name='Test Task 2', project=cls.test_project) cls.test_task3 = Task(name='Test Task 3', project=cls.test_project) cls.test_version1 = Version(task=cls.test_task1) db.DBSession.add(cls.test_version1) db.DBSession.commit() cls.test_version2 = Version(task=cls.test_task1) db.DBSession.add(cls.test_version2) db.DBSession.commit() cls.test_version3 = Version(task=cls.test_task1) db.DBSession.add(cls.test_version3) db.DBSession.commit() cls.test_version4 = Version(task=cls.test_task2) db.DBSession.add(cls.test_version4) db.DBSession.commit() cls.test_link1 = Link(original_filename='test_render1.jpg') cls.test_link2 = Link(original_filename='test_render2.jpg') cls.test_link3 = Link(original_filename='test_render3.jpg') cls.test_link4 = Link(original_filename='test_render4.jpg') cls.test_version1.outputs = [ cls.test_link1, cls.test_link2, cls.test_link3 ] cls.test_version4.outputs = [cls.test_link4] db.DBSession.add_all([ cls.test_task1, cls.test_task2, cls.test_task3, cls.test_version1, cls.test_version2, cls.test_version3, cls.test_version4, cls.test_link1, cls.test_link2, cls.test_link3, cls.test_link4 ]) db.DBSession.commit()
def test_env_var_property_is_working_properly(self): """testing if the env_var property is working properly """ from stalker import db db.setup() db.DBSession.add(self.test_repo) db.DBSession.commit() self.assertEqual(self.test_repo.env_var, 'REPO1')
def setUp(self): """setup test """ import datetime from stalker import defaults defaults.timing_resolution = datetime.timedelta(hours=1) # init database from stalker import db db.setup(self.config) db.init()
def setUp(self): """setup the test """ db.setup() # create permissions self.test_perm1 = Permission(access='Allow', action='Create', class_name='Something') self.test_instance = TestClassForACL() self.test_instance.name = 'Test' self.test_instance.permissions.append(self.test_perm1)
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) db.setup(settings) # db.init() # no init needed remove_unused_files()
def test_get_last_version_is_working_properly(self): """testing if hte get_last_version() method will return Version instance properly """ # need a database for this test from stalker import db db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) db.DBSession.add(self.version) db.DBSession.commit() self.assertTrue(self.version.id is not None) self.external_env.append_to_recent_files(self.version) last_version = self.external_env.get_last_version() self.assertEqual(last_version, self.version)
def setUpClass(cls): """setup tests in class level """ cls.config = { 'sqlalchemy.url': 'postgresql://*****:*****@localhost/stalker_test', 'sqlalchemy.echo': False } # clean up test database db.setup(cls.config) from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) DBSession.commit()
def test_to_os_independent_path_is_working_properly(self): """testing if to_os_independent_path class method is working properly """ from stalker import db db.setup() db.DBSession.add(self.test_repo) db.DBSession.commit() relative_part = 'some/path/to/a/file.ma' test_path = '%s/%s' % (self.test_repo.path, relative_part) self.assertEqual(Repository.to_os_independent_path(test_path), '$REPO%s/%s' % (self.test_repo.id, relative_part))
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) db.setup(settings) db.init() # create statuses create_statuses_and_status_lists() create_ticket_types()
def test_get_last_version_is_working_properly(self): """testing if hte get_last_version() method will return Version instance properly """ # need a database for this test from stalker import db db.setup({"sqlalchemy.url": "sqlite:///:memory:"}) db.DBSession.add(self.version) db.DBSession.commit() self.assertTrue(self.version.id is not None) self.external_env.append_to_recent_files(self.version) last_version = self.external_env.get_last_version() self.assertEqual(last_version, self.version)
def test_cut_duration_initialization_bug_with_cut_out(self): """testing if the _cut_duration attribute is initialized correctly for a Shot restored from DB """ # re connect to the database db.setup({'sqlalchemy.url': 'sqlite:///%s' % self.db_path}) # retrieve the shot back from DB test_shot_db = Shot.query.filter_by(name=self.kwargs['name']).first() # trying to change the cut_in and cut_out values should not raise any # errors test_shot_db.cut_out = 100 db.DBSession.add(test_shot_db) db.DBSession.commit()
def test_updating_linux_path_only_update_repo_path_if_on_linux(self): """testing if updating the linux path will only update the path if the system is linux """ self.patcher.patch('Darwin') from stalker import db, defaults db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) repo = Repository(name='Test Repo', linux_path='/mnt/T', osx_path='/Volumes/T', windows_path='T:/') db.DBSession.add(repo) db.DBSession.commit() import os self.assertTrue(defaults.repo_env_var_template % {'id': repo.id} in os.environ) # now update the repository test_value = '/mnt/S/' repo.linux_path = test_value # expect the environment variable not updated self.assertNotEqual( os.environ[defaults.repo_env_var_template % { 'id': repo.id }], test_value) self.assertEqual( os.environ[defaults.repo_env_var_template % { 'id': repo.id }], repo.osx_path) # make it linux self.patcher.patch('Linux') # now update the repository test_value = '/mnt/S/' repo.linux_path = test_value # expect the environment variable not updated self.assertEqual( os.environ[defaults.repo_env_var_template % { 'id': repo.id }], test_value) self.assertEqual( os.environ[defaults.repo_env_var_template % { 'id': repo.id }], repo.linux_path)
def setUp(self): """setup the test """ db.setup() # create permissions self.test_perm1 = Permission( access='Allow', action='Create', class_name='Something' ) self.test_instance = TestClassForACL() self.test_instance.name = 'Test' self.test_instance.permissions.append(self.test_perm1)
def process(self, context): # First check if the file is saved if not bpy.data.is_saved or bpy.data.is_dirty: raise Warning("Please save the file before publishing") try: task_id = bpy.context.scene.piecekeeper.stalker.task except AttributeError: self.log.error("Task ID could not be found in the scene") raise if not task_id or task_id == "-1": self.log.warning( "The task is not set. Is this a valid production file?") return db.setup() task = Task.query.filter_by(id=task_id).first() if not task: self.log.warning("There is no task with ID %s" % task_id) return if not task.name.lower() == 'rig': self.log.info("This is not a rigging task, but %s" % task.name) return self.log.info( "Found rigging task for character '%s' in project '%s'..." % (task.parent.name, task.project.name)) for obj in bpy.data.objects: if not obj.type == 'ARMATURE' or obj.name == 'metarig': continue modifier_children = { c for c in bpy.data.objects if c.find_armature() == obj } object_children = get_children(obj) children = modifier_children.union(object_children) all_children = get_all_children(children) widgets = { pb.custom_shape for pb in obj.pose.bones if pb.custom_shape is not None } members = {obj}.union(all_children).union(widgets) instance = context.create_instance(obj.name, family='Rig') instance[:] = list(members) instance.set_data('armature', obj) instance.set_data('children', all_children) instance.set_data('widgets', widgets)
def setUpClass(cls): """setup once """ # create a test database db.setup() db.init() # create test repositories cls.repo1 = Repository( name='Test Repo 1', linux_path='/test/repo/1/linux/path', windows_path='T:/test/repo/1/windows/path', osx_path='/test/repo/1/osx/path', ) cls.repo2 = Repository( name='Test Repo 2', linux_path='/test/repo/2/linux/path', windows_path='T:/test/repo/2/windows/path', osx_path='/test/repo/2/osx/path', ) cls.repo3 = Repository( name='Test Repo 3', linux_path='/test/repo/3/linux/path', windows_path='T:/test/repo/3/windows/path', osx_path='/test/repo/3/osx/path', ) cls.repo4 = Repository( name='Test Repo 4', linux_path='/test/repo/4/linux/path', windows_path='T:/test/repo/4/windows/path', osx_path='/test/repo/4/osx/path', ) cls.repo5 = Repository( name='Test Repo 5', linux_path='/test/repo/5/linux/path', windows_path='T:/test/repo/5/windows/path', osx_path='/test/repo/5/osx/path', ) cls.all_repos = [cls.repo1, cls.repo2, cls.repo3, cls.repo4, cls.repo5] db.DBSession.add_all(cls.all_repos) db.DBSession.commit()
def main(argv=sys.argv): if len(argv) != 2: usage(argv) from pyramid.paster import get_appsettings, setup_logging from stalker import db config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) db.setup(settings) db.init() # create statuses create_statuses_and_status_lists() create_ticket_types()
def setUp(self): self.config = testing.setUp() db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) self.test_status1 = Status(name='Test Status 1', code='TS1') self.test_status2 = Status(name='Test Status 2', code='TS2') self.test_status3 = Status(name='Test Status 3', code='TS3') self.test_project_status_list = StatusList( target_entity_type='Project', statuses=[ self.test_status1, self.test_status2, self.test_status3 ] ) self.test_repo = Repository( name='Test Repository', windows_path='T:/', linux_path='/mnt/T', osx_path='/Volumes/T' ) self.test_project = Project( name='Test Project 1', code='TP1', status_list=self.test_project_status_list, repository=self.test_repo ) DBSession.add(self.test_project) transaction.commit() DBSession.add(self.test_project) self.params = { 'mode': 'CREATE' } self.matchdict = { 'project_id': self.test_project.id } self.request = testing.DummyRequest(params=self.params) self.request.matchdict = self.matchdict
def setUp(self): """setup the test """ # create mock objects self.start = datetime.datetime(2013, 3, 22, 15, 15) self.end = self.start + datetime.timedelta(days=20) self.duration = datetime.timedelta(days=10) self.kwargs = { 'name': 'Test Daterange Mixin', 'description': 'This is a simple entity object for testing ' 'DateRangeMixin', 'start': self.start, 'end': self.end, 'duration': self.duration } db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) self.test_foo_obj = DateRangeMixFooMixedInClass(**self.kwargs)
def test_cut_values_are_set_correctly(self): """testing if the cut_in attribute is set correctly in db """ self.test_shot.cut_in = 100 self.assertEqual(self.test_shot.cut_in, 100) self.test_shot.cut_out = 153 self.assertEqual(self.test_shot.cut_in, 100) self.assertEqual(self.test_shot.cut_out, 153) db.DBSession.add(self.test_shot) db.DBSession.commit() # re connect to the database db.setup({'sqlalchemy.url': 'sqlite:///%s' % self.db_path}) # retrieve the shot back from DB test_shot_db = Shot.query.filter_by(name=self.kwargs['name']).first() self.assertEqual(test_shot_db.cut_in, 100) self.assertEqual(test_shot_db.cut_out, 153)
def setUp(self): """set up the test """ db.setup() db.init() self.temp_path = tempfile.mkdtemp() self.repo = Repository( name="Test Repository", linux_path=self.temp_path, windows_path=self.temp_path, osx_path=self.temp_path ) self.status_new = Status.query.filter_by(code="NEW").first() self.status_wip = Status.query.filter_by(code="WIP").first() self.status_cmpl = Status.query.filter_by(code="CMPL").first() self.project_status_list = StatusList( target_entity_type="Project", name="Project Statuses", statuses=[self.status_new, self.status_wip, self.status_cmpl], ) self.task_filename_template = FilenameTemplate( name="Task Filename Template", target_entity_type="Task", path="{{project.code}}/{%- for parent_task in parent_tasks -%}" "{{parent_task.nice_name}}/{%- endfor -%}", filename="{{version.nice_name}}" '_v{{"%03d"|format(version.version_number)}}{{extension}}', ) self.project_structure = Structure(name="Project Structure", templates=[self.task_filename_template]) self.project = Project( name="Test Project", code="TP", status_list=self.project_status_list, repository=self.repo, structure=self.project_structure, ) self.task = Task(name="Test Task", project=self.project) self.version = Version(task=self.task) self.kwargs = {"name": "Photoshop", "extensions": ["psd"], "structure": ["Outputs"]} self.external_env = ExternalEnv(**self.kwargs)
def test_creating_and_committing_a_new_repository_instance_will_create_env_var( self): """testing if an environment variable will be created when a new repository is created """ from stalker import db, defaults db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) repo = Repository(name='Test Repo', linux_path='/mnt/T', osx_path='/Volumes/T', windows_path='T:/') db.DBSession.add(repo) db.DBSession.commit() import os self.assertTrue(defaults.repo_env_var_template % {'id': repo.id} in os.environ) self.assertEqual( os.environ[defaults.repo_env_var_template % { 'id': repo.id }], repo.path)
def main(argv=sys.argv): """main function """ if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) # global here global stalker_server_external_url global mailer global resource_mail_html_template global responsible_mail_html_template global resource_mail_html_template_content global responsible_mail_html_template_content # here = os.path.dirname(os.path.realpath(sys.argv[0])) stalker_server_external_url = settings.get('stalker.external_url') mailer = Mailer.from_settings(settings) with open(resource_mail_html_template_path) as f: resource_mail_html_template_content = f.read() with open(responsible_mail_html_template_path) as f: responsible_mail_html_template_content = f.read() resource_mail_html_template = Template(resource_mail_html_template_content) responsible_mail_html_template = Template( responsible_mail_html_template_content) db.setup(settings) for user in User.query.all(): send_resource_remainder(user) send_responsible_remainder(user) transaction.commit()
def do_db_setup(): """the common routing for setting up the database """ from sqlalchemy.exc import UnboundExecutionError from stalker import db from stalker.db import DBSession DBSession.remove() DBSession.close() try: DBSession.connection() logger.debug('already connected, not creating any new connections') except UnboundExecutionError: # no connection do setup logger.debug('doing a new connection with NullPool') from stalker import defaults from sqlalchemy.pool import NullPool settings = defaults.database_engine_settings settings['sqlalchemy.poolclass'] = NullPool db.setup(settings)
def test_find_repo_is_working_properly(self): """testing if the find_repo class method is working properly """ from stalker import db db.setup() db.DBSession.add(self.test_repo) db.DBSession.commit() # add some other repositories new_repo1 = Repository(name='New Repository', linux_path='/mnt/T/Projects', osx_path='/Volumes/T/Projects', windows_path='T:/Projects') db.DBSession.add(new_repo1) db.DBSession.commit() test_path = '%s/some/path/to/a/file.ma' % self.test_repo.path self.assertEqual(Repository.find_repo(test_path), self.test_repo) test_path = '%s/some/path/to/a/file.ma' % new_repo1.windows_path self.assertEqual(Repository.find_repo(test_path), new_repo1)
def setUp(self): """setup test """ import os from stalker.config import Config try: os.environ.pop(Config.env_key) except KeyError: # already removed pass # regenerate the defaults import stalker stalker.defaults = Config() import datetime stalker.defaults.timing_resolution = datetime.timedelta(hours=1) # init database from stalker import db # remove anything beforehand db.setup(self.config) db.init()
def setUp(self): """sets up the test """ db.setup() db.init() self.test_repo_path = tempfile.mkdtemp() # create test data self.test_repo = Repository( name='Test Repository', linux_path=self.test_repo_path, windows_path=self.test_repo_path, osx_path=self.test_repo_path ) self.test_task_template = FilenameTemplate( name='Task Template', target_entity_type='Task', path='{{project.code}}/{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.test_structure = Structure( name='Test Project Structure', templates=[self.test_task_template] ) self.status_new = Status.query.filter_by(code='NEW').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() self.test_project_status_list = StatusList( name='Project Statuses', statuses=[self.status_new, self.status_wip, self.status_cmpl], target_entity_type='Project' ) self.test_project1 = Project( name='Test Project 1', code='TP1', repository=self.test_repo, structure=self.test_structure, status_list=self.test_project_status_list ) db.DBSession.add(self.test_project1) db.DBSession.commit() # now create tasks # root tasks self.test_task1 = Task( name='Task1', project=self.test_project1 ) self.test_task2 = Task( name='Task2', project=self.test_project1 ) self.test_task3 = Task( name='Task3', project=self.test_project1 ) # child of Task1 self.test_task4 = Task( name='Task4', parent=self.test_task1 ) self.test_task5 = Task( name='Task5', parent=self.test_task1 ) self.test_task6 = Task( name='Task6', parent=self.test_task1 ) # child of Task2 self.test_task7 = Task( name='Task7', parent=self.test_task2 ) self.test_task8 = Task( name='Task8', parent=self.test_task2 ) self.test_task9 = Task( name='Task9', parent=self.test_task2 ) # child of Task10 self.test_task10 = Task( name='Task10', parent=self.test_task3 ) self.test_task11 = Task( name='Task11', parent=self.test_task3 ) self.test_task12 = Task( name='Task12', parent=self.test_task3 ) db.DBSession.add_all([ self.test_task1, self.test_task2, self.test_task3, self.test_task4, self.test_task5, self.test_task6, self.test_task7, self.test_task8, self.test_task9, self.test_task10, self.test_task11, self.test_task12 ]) # now create versions for each of leaf tasks # Task4 # Main self.test_version1 = self.create_version(self.test_task4, take_name='Main') self.test_version2 = self.create_version(self.test_task4, take_name='Main') self.test_version3 = self.create_version(self.test_task4, take_name='Main') # Take1 self.test_version4 = self.create_version(self.test_task4, take_name='Take1') self.test_version5 = self.create_version(self.test_task4, take_name='Take1') self.test_version6 = self.create_version(self.test_task4, take_name='Take1') # Take2 self.test_version7 = self.create_version(self.test_task4, take_name='Take2') self.test_version8 = self.create_version(self.test_task4, take_name='Take2') self.test_version9 = self.create_version(self.test_task4, take_name='Take2') # Task5 # Main self.test_version10 = self.create_version(self.test_task5, take_name='Main') self.test_version11 = self.create_version(self.test_task5, take_name='Main') self.test_version12 = self.create_version(self.test_task5, take_name='Main') # Take1 self.test_version13 = self.create_version(self.test_task5, take_name='Take1') self.test_version14 = self.create_version(self.test_task5, take_name='Take1') self.test_version15 = self.create_version(self.test_task5, take_name='Take1') # Take2 self.test_version16 = self.create_version(self.test_task5, take_name='Take2') self.test_version17 = self.create_version(self.test_task5, take_name='Take2') self.test_version18 = self.create_version(self.test_task5, take_name='Take2') # Task6 # Main self.test_version19 = self.create_version(self.test_task6, take_name='Main') self.test_version20 = self.create_version(self.test_task6, take_name='Main') self.test_version21 = self.create_version(self.test_task6, take_name='Main') # Take1 self.test_version22 = self.create_version(self.test_task6, take_name='Take1') self.test_version23 = self.create_version(self.test_task6, take_name='Take1') self.test_version24 = self.create_version(self.test_task6, take_name='Take1') # Take2 self.test_version25 = self.create_version(self.test_task6, take_name='Take2') self.test_version26 = self.create_version(self.test_task6, take_name='Take2') self.test_version27 = self.create_version(self.test_task6, take_name='Take2') # Task7 # Main self.test_version28 = self.create_version(self.test_task7, take_name='Main') self.test_version29 = self.create_version(self.test_task7, take_name='Main') self.test_version30 = self.create_version(self.test_task7, take_name='Main') # Take1 self.test_version31 = self.create_version(self.test_task7, take_name='Take1') self.test_version32 = self.create_version(self.test_task7, take_name='Take1') self.test_version33 = self.create_version(self.test_task7, take_name='Take1') # Take2 self.test_version34 = self.create_version(self.test_task7, take_name='Take2') self.test_version35 = self.create_version(self.test_task7, take_name='Take2') self.test_version36 = self.create_version(self.test_task7, take_name='Take2') # Task8 - will have no versions # Task9 - it is a destination task with versions # Main self.test_version37 = self.create_version(self.test_task9, take_name='Main') self.test_version38 = self.create_version(self.test_task9, take_name='Main') self.test_version39 = self.create_version(self.test_task9, take_name='Main') # Take1 - an existing take self.test_version40 = self.create_version(self.test_task9, take_name='Take1') self.test_version41 = self.create_version(self.test_task9, take_name='Take1') self.test_version42 = self.create_version(self.test_task9, take_name='Take1') # Take3 - a non existing take self.test_version43 = self.create_version(self.test_task9, take_name='Take1') self.test_version44 = self.create_version(self.test_task9, take_name='Take1') self.test_version45 = self.create_version(self.test_task9, take_name='Take1') if not QtGui.QApplication.instance(): self.app = QtGui.QApplication(sys.argv) else: # self.app = QtGui.qApp self.app = QtGui.QApplication.instance() self.dialog = VersionMover()
def setUpClass(cls): """setup test """ # ----------------------------------------------------------------- # start of the setUp # create the environment variable and point it to a temp directory database_url = "sqlite:///:memory:" db.setup({'sqlalchemy.url': database_url}) db.init() cls.temp_repo_path = tempfile.mkdtemp() cls.user1 = User( name='User 1', login='******', email='*****@*****.**', password='******' ) cls.repo1 = Repository( name='Test Project Repository', linux_path=cls.temp_repo_path, windows_path=cls.temp_repo_path, osx_path=cls.temp_repo_path ) cls.status_new = Status.query.filter_by(code='NEW').first() cls.status_wip = Status.query.filter_by(code='WIP').first() cls.status_comp = Status.query.filter_by(code='CMPL').first() cls.task_template = FilenameTemplate( name='Task Template', target_entity_type='Task', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) cls.structure = Structure( name='Project Struture', templates=[cls.task_template] ) cls.project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[cls.status_new, cls.status_wip, cls.status_comp] ) cls.image_format = ImageFormat( name='HD 1080', width=1920, height=1080, pixel_aspect=1.0 ) # create a test project cls.project = Project( name='Test Project', code='TP', repository=cls.repo1, status_list=cls.project_status_list, structure=cls.structure, image_format=cls.image_format ) cls.task_status_list =\ StatusList.query.filter_by(target_entity_type='Task').first() cls.character_type = Type( name='Character', code='CHAR', target_entity_type='Asset' ) # create a test series of root task cls.task1 = Task( name='Test Task 1', project=cls.project ) cls.task2 = Task( name='Test Task 2', project=cls.project ) # commit everything db.DBSession.add_all([ cls.repo1, cls.status_new, cls.status_wip, cls.status_comp, cls.project_status_list, cls.project, cls.task_status_list, cls.task1, cls.task2, cls.task_template ]) db.DBSession.commit() cls.version1 = cls.create_version(cls.task1, 'Main') cls.version2 = cls.create_version(cls.task1, 'Main') cls.version3 = cls.create_version(cls.task1, 'Main') # create other reprs # BBOX cls.version4 = cls.create_version(cls.task1, 'Main@BBox') cls.version5 = cls.create_version(cls.task1, 'Main@BBox') cls.version5.is_published = True db.DBSession.commit() # ASS cls.version6 = cls.create_version(cls.task1, 'Main@ASS') cls.version7 = cls.create_version(cls.task1, 'Main@ASS') cls.version7.is_published = True db.DBSession.commit() # GPU cls.version8 = cls.create_version(cls.task1, 'Main@GPU') cls.version9 = cls.create_version(cls.task1, 'Main@GPU') # Non default take name cls.version10 = cls.create_version(cls.task1, 'alt1') cls.version11 = cls.create_version(cls.task1, 'alt1') # Hires cls.version12 = cls.create_version(cls.task1, 'alt1@Hires') cls.version13 = cls.create_version(cls.task1, 'alt1@Hires') # Midres cls.version14 = cls.create_version(cls.task1, 'alt1@Midres') cls.version15 = cls.create_version(cls.task1, 'alt1@Midres') # Lores cls.version16 = cls.create_version(cls.task1, 'alt1@Lores') cls.version17 = cls.create_version(cls.task1, 'alt1@Lores') cls.version17.is_published = True # No Repr cls.version18 = cls.create_version(cls.task1, 'NoRepr') cls.version19 = cls.create_version(cls.task1, 'NoRepr') db.DBSession.commit() # create a buffer for extra created files, which are to be removed cls.remove_these_files_buffer = []
def setUp(self): """setup the test """ # setup a test database self.TEST_DATABASE_URI = "sqlite:///:memory:" db.setup() db.init() # need to have some test object for # a department self.test_department1 = Department(name="Test Department 1") self.test_department2 = Department(name="Test Department 2") self.test_department3 = Department(name="Test Department 3") DBSession.add_all([self.test_department1, self.test_department2, self.test_department3]) # a couple of groups self.test_group1 = Group(name="Test Group 1") self.test_group2 = Group(name="Test Group 2") self.test_group3 = Group(name="Test Group 3") DBSession.add_all([self.test_group1, self.test_group2, self.test_group3]) # a couple of statuses self.test_status1 = Status(name="Completed", code="CMPLT") self.test_status2 = Status(name="Work In Progress", code="WIP") self.test_status3 = Status(name="Waiting To Start", code="WTS") self.test_status4 = Status(name="Pending Review", code="PRev") DBSession.add_all([self.test_status1, self.test_status2, self.test_status3, self.test_status4]) # a project status list self.project_status_list = StatusList( name="Project Status List", statuses=[self.test_status1, self.test_status2, self.test_status3, self.test_status4], target_entity_type=Project, ) # a repository type self.test_repository_type = Type(name="Test", code="test", target_entity_type=Repository) # a repository self.test_repository = Repository(name="Test Repository", type=self.test_repository_type) # a project type self.commercial_project_type = Type(name="Commercial Project", code="comm", target_entity_type=Project) # a couple of projects self.test_project1 = Project( name="Test Project 1", code="tp1", status_list=self.project_status_list, type=self.commercial_project_type, repository=self.test_repository, ) self.test_project2 = Project( name="Test Project 2", code="tp2", status_list=self.project_status_list, type=self.commercial_project_type, repository=self.test_repository, ) self.test_project3 = Project( name="Test Project 3", code="tp3", status_list=self.project_status_list, type=self.commercial_project_type, repository=self.test_repository, ) DBSession.add_all([self.test_project1, self.test_project2, self.test_project3]) # a task status list self.task_status_list = StatusList.query.filter_by(target_entity_type="Task").first() # a couple of tasks self.test_task1 = Task(name="Test Task 1", status_list=self.task_status_list, project=self.test_project1) self.test_task2 = Task(name="Test Task 2", status_list=self.task_status_list, project=self.test_project1) self.test_task3 = Task(name="Test Task 3", status_list=self.task_status_list, project=self.test_project2) self.test_task4 = Task(name="Test Task 4", status_list=self.task_status_list, project=self.test_project3) DBSession.add_all([self.test_task1, self.test_task2, self.test_task3, self.test_task4]) # for task1 self.test_version1 = Version(task=self.test_task1, full_path="some/path") DBSession.add(self.test_version1) self.test_version2 = Version(task=self.test_task1, full_path="some/path") DBSession.add(self.test_version2) self.test_version3 = Version(task=self.test_task1, full_path="some/path") DBSession.add(self.test_version3) # for task2 self.test_version4 = Version(task=self.test_task2, full_path="some/path") DBSession.add(self.test_version4) self.test_version5 = Version(task=self.test_task2, full_path="some/path") DBSession.add(self.test_version5) self.test_version6 = Version(task=self.test_task2, full_path="some/path") DBSession.add(self.test_version6) # for task3 self.test_version7 = Version(task=self.test_task3, full_path="some/path") DBSession.add(self.test_version7) self.test_version8 = Version(task=self.test_task3, full_path="some/path") DBSession.add(self.test_version8) self.test_version9 = Version(task=self.test_task3, full_path="some/path") DBSession.add(self.test_version9) # for task4 self.test_version10 = Version(task=self.test_task4, full_path="some/path") DBSession.add(self.test_version10) self.test_version11 = Version(task=self.test_task4, full_path="some/path") DBSession.add(self.test_version11) self.test_version12 = Version(task=self.test_task4, full_path="some/path") DBSession.add(self.test_version12) # ********************************************************************* # Tickets # ********************************************************************* # no need to create status list for tickets cause we have a database # set up an running so it will be automatically linked # tickets for version1 self.test_ticket1 = Ticket(project=self.test_project1, links=[self.test_version1]) DBSession.add(self.test_ticket1) # set it to closed self.test_ticket1.resolve() # create a new ticket and leave it open self.test_ticket2 = Ticket(project=self.test_project1, links=[self.test_version1]) DBSession.add(self.test_ticket2) # create a new ticket and close and then reopen it self.test_ticket3 = Ticket(project=self.test_project1, links=[self.test_version1]) DBSession.add(self.test_ticket3) self.test_ticket3.resolve() self.test_ticket3.reopen() # ********************************************************************* # tickets for version2 # create a new ticket and leave it open self.test_ticket4 = Ticket(project=self.test_project1, links=[self.test_version2]) DBSession.add(self.test_ticket4) # create a new Ticket and close it self.test_ticket5 = Ticket(project=self.test_project1, links=[self.test_version2]) DBSession.add(self.test_ticket5) self.test_ticket5.resolve() # create a new Ticket and close it self.test_ticket6 = Ticket(project=self.test_project1, links=[self.test_version3]) DBSession.add(self.test_ticket6) self.test_ticket6.resolve() # ********************************************************************* # tickets for version3 # create a new ticket and close it self.test_ticket7 = Ticket(project=self.test_project1, links=[self.test_version3]) DBSession.add(self.test_ticket7) self.test_ticket7.resolve() # create a new ticket and close it self.test_ticket8 = Ticket(project=self.test_project1, links=[self.test_version3]) DBSession.add(self.test_ticket8) self.test_ticket8.resolve() # ********************************************************************* # tickets for version4 # create a new ticket and close it self.test_ticket9 = Ticket(project=self.test_project1, links=[self.test_version4]) DBSession.add(self.test_ticket9) self.test_ticket9.resolve() # no tickets for any other version # ********************************************************************* # a status list for sequence self.sequence_status_list = StatusList.query.filter_by(target_entity_type="Sequence").first() # a couple of sequences self.test_sequence1 = Sequence( name="Test Seq 1", code="ts1", project=self.test_project1, status_list=self.sequence_status_list ) self.test_sequence2 = Sequence( name="Test Seq 2", code="ts2", project=self.test_project1, status_list=self.sequence_status_list ) self.test_sequence3 = Sequence( name="Test Seq 3", code="ts3", project=self.test_project1, status_list=self.sequence_status_list ) self.test_sequence4 = Sequence( name="Test Seq 4", code="ts4", project=self.test_project1, status_list=self.sequence_status_list ) DBSession.add_all([self.test_sequence1, self.test_sequence2, self.test_sequence3, self.test_sequence4]) # a test admin # self.test_admin = User( # name='Admin', # login='******', # email='*****@*****.**', # password='******' # ) self.test_admin = User.query.filter_by(name=defaults.admin_name).first() self.assertIsNotNone(self.test_admin) # create the default values for parameters self.kwargs = { "name": "Erkan Ozgur Yilmaz", "login": "******", "description": "this is a test user", "password": "******", "email": "*****@*****.**", "departments": [self.test_department1], "groups": [self.test_group1, self.test_group2], "created_by": self.test_admin, "updated_by": self.test_admin, } # create a proper user object self.test_user = User(**self.kwargs) DBSession.add(self.test_user) DBSession.commit() # just change the kwargs for other tests self.kwargs["name"] = "some other name" self.kwargs["email"] = "*****@*****.**"
def setUp(self): """setup the test """ # create a database db.setup()
def setUp(self): """setup the test """ self.config = testing.setUp() db.setup({'sqlalchemy.url': 'sqlite:///:memory:'}) DBSession.configure(extension=ZopeTransactionExtension()) with transaction.manager: self.test_repo = Repository( name='Test Repository', linux_path=tempfile.mkdtemp(), windows_path=tempfile.mkdtemp(), osx_path=tempfile.mkdtemp() ) DBSession.add(self.test_repo) self.status1 = Status(name='Status1', code='STS1') self.status2 = Status(name='Status2', code='STS2') self.status3 = Status(name='Status3', code='STS3') self.status4 = Status(name='Status4', code='STS4') self.status5 = Status(name='Status5', code='STS5') DBSession.add_all([self.status1, self.status2, self.status3, self.status4, self.status5]) self.test_project_status_list = StatusList( name='Project Statuses', statuses=[self.status1, self.status2, self.status3, self.status4, self.status5], target_entity_type='Project' ) DBSession.add(self.test_project_status_list) self.test_task_status_list = StatusList( name='Task Statuses', statuses=[self.status1, self.status2, self.status3, self.status4, self.status5], target_entity_type='Task' ) DBSession.add(self.test_task_status_list) self.test_version_status_list = StatusList( name='Version Statuses', statuses=[self.status1, self.status2, self.status3, self.status4, self.status5], target_entity_type='Version' ) DBSession.add(self.test_task_status_list) # create a project self.test_project = Project( name='Test Project', code='TP', repository=self.test_repo, status_list=self.test_project_status_list ) DBSession.add(self.test_project) # create a task self.test_task = Task( project=self.test_project, name='Test Task', status_list=self.test_task_status_list ) DBSession.add(self.test_task) # create a test version self.test_version = Version( task=self.test_task, status_list=self.test_version_status_list ) DBSession.add(self.test_version) DBSession.add_all([ self.test_project, self.test_project_status_list, self.test_repo, self.test_task, self.test_task_status_list, self.test_version ])
def setUp(self): """set up the test """ db.setup({"sqlalchemy.url": "sqlite:///:memory:"})
def setUp(self): """run once """ defaults.timing_resolution = datetime.timedelta(hours=1) # create a new session db.setup({ 'sqlalchemy.url': 'sqlite://', 'sqlalchemy.echo': False }) db.init() self.status_wfd = Status.query.filter_by(code="WFD").first() self.status_rts = Status.query.filter_by(code="RTS").first() self.status_wip = Status.query.filter_by(code="WIP").first() self.status_prev = Status.query.filter_by(code="PREV").first() self.status_hrev = Status.query.filter_by(code="HREV").first() self.status_drev = Status.query.filter_by(code="DREV").first() self.status_oh = Status.query.filter_by(code="OH").first() self.status_stop = Status.query.filter_by(code="STOP").first() self.status_cmpl = Status.query.filter_by(code="CMPL").first() self.task_status_list = StatusList.query\ .filter_by(target_entity_type='Task').first() self.test_project_status_list = StatusList( name="Project Statuses", statuses=[self.status_wip, self.status_prev, self.status_cmpl], target_entity_type=Project, ) self.test_movie_project_type = Type( name="Movie Project", code='movie', target_entity_type=Project, ) self.test_repository_type = Type( name="Test Repository Type", code='test', target_entity_type=Repository, ) self.test_repository = Repository( name="Test Repository", type=self.test_repository_type, linux_path=tempfile.mkdtemp(), windows_path=tempfile.mkdtemp(), osx_path=tempfile.mkdtemp() ) self.test_user1 = User( name="User1", login="******", email="*****@*****.**", password="******" ) self.test_user2 = User( name="User2", login="******", email="*****@*****.**", password="******" ) self.test_user3 = User( name="User3", login="******", email="*****@*****.**", password="******" ) self.test_user4 = User( name="User4", login="******", email="*****@*****.**", password="******" ) self.test_user5 = User( name="User5", login="******", email="*****@*****.**", password="******" ) self.test_project = Project( name="Test Project1", code='tp1', type=self.test_movie_project_type, status_list=self.test_project_status_list, repository=self.test_repository ) self.kwargs = { 'project': self.test_project, 'name': 'Test Budget 1' } self.test_budget = Budget(**self.kwargs) self.test_good = Good( name='Some Good', cost=100, msrp=120, unit='$' )
def setUp(self): """setup the test """ db.setup() db.init() # statuses self.status_new = Status.query.filter_by(code='NEW').first() self.status_wfd = Status.query.filter_by(code='WFD').first() self.status_rts = Status.query.filter_by(code='RTS').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_prev = Status.query.filter_by(code='PREV').first() self.status_hrev = Status.query.filter_by(code='HREV').first() self.status_drev = Status.query.filter_by(code='DREV').first() self.status_oh = Status.query.filter_by(code='OH').first() self.status_stop = Status.query.filter_by(code='STOP').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() # status lists self.test_project_status_list = StatusList( name="Project Status List", statuses=[ self.status_new, self.status_wip, self.status_cmpl ], target_entity_type=Project, ) self.test_sequence_status_list = \ StatusList.query.filter_by(target_entity_type='Sequence').first() self.test_shot_status_list = \ StatusList.query.filter_by(target_entity_type='Shot').first() self.test_asset_status_list = \ StatusList.query.filter_by(target_entity_type='Asset').first() # types self.test_commercial_project_type = Type( name="Commercial Project", code='comm', target_entity_type=Project, ) self.test_character_asset_type = Type( name="Character", code='char', target_entity_type=Asset, ) self.test_repository_type = Type( name="Test Repository Type", code='test', target_entity_type=Repository ) # repository self.test_repository = Repository( name="Test Repository", type=self.test_repository_type, ) # image format self.test_image_format1 = ImageFormat( name='Test Image Format 1', width=1920, height=1080, pixel_aspect=1.0 ) self.test_image_format2 = ImageFormat( name='Test Image Format 2', width=1280, height=720, pixel_aspect=1.0 ) # project and sequences self.test_project1 = Project( name='Test Project1', code='tp1', type=self.test_commercial_project_type, status_list=self.test_project_status_list, repository=self.test_repository, image_format=self.test_image_format1 ) self.test_project2 = Project( name='Test Project2', code='tp2', type=self.test_commercial_project_type, status_list=self.test_project_status_list, repository=self.test_repository, image_format=self.test_image_format1 ) self.test_sequence1 = Sequence( name="Test Seq1", code='ts1', project=self.test_project1, status_list=self.test_sequence_status_list, ) self.test_sequence2 = Sequence( name="Test Seq2", code='ts2', project=self.test_project1, status_list=self.test_sequence_status_list, ) self.test_sequence3 = Sequence( name="Test Seq3", code='ts3', project=self.test_project1, status_list=self.test_sequence_status_list, ) self.test_scene1 = Scene( name='Test Sce1', code='tsc1', project=self.test_project1, ) self.test_scene2 = Scene( name='Test Sce2', code='tsc2', project=self.test_project1, ) self.test_scene3 = Scene( name='Test Sce3', code='tsc3', project=self.test_project1 ) self.test_asset1 = Asset( name="Test Asset1", code='ta1', project=self.test_project1, status_list=self.test_asset_status_list, type=self.test_character_asset_type, ) self.test_asset2 = Asset( name="Test Asset2", code='ta2', project=self.test_project1, status_list=self.test_asset_status_list, type=self.test_character_asset_type, ) self.test_asset3 = Asset( name="Test Asset3", code='ta3', project=self.test_project1, status_list=self.test_asset_status_list, type=self.test_character_asset_type, ) self.test_cut_in_default = 1 self.test_cut_duration_default = 1 self.test_cut_out_default = 1 self.kwargs = dict( name='SH123', code='SH123', description='This is a test Shot', project=self.test_project1, sequences=[self.test_sequence1, self.test_sequence2], scenes=[self.test_scene1, self.test_scene2], cut_in=112, cut_out=149, cut_duration=123, status=0, status_list=self.test_shot_status_list, image_format=self.test_image_format2 ) # create a mock shot object self.test_shot = Shot(**self.kwargs)
# update the config config = {'sqlalchemy.url': database_url, 'sqlalchemy.poolclass': NullPool} try: os.environ.pop(Config.env_key) except KeyError: # already removed pass # regenerate the defaults stalker.defaults = Config() stalker.defaults.timing_resolution = datetime.timedelta(minutes=10) # init database db.setup(config) db.init() status_wfd = Status.query.filter_by(code="WFD").first() status_rts = Status.query.filter_by(code="RTS").first() status_wip = Status.query.filter_by(code="WIP").first() status_prev = Status.query.filter_by(code="PREV").first() status_hrev = Status.query.filter_by(code="HREV").first() status_drev = Status.query.filter_by(code="DREV").first() status_oh = Status.query.filter_by(code="OH").first() status_stop = Status.query.filter_by(code="STOP").first() status_cmpl = Status.query.filter_by(code="CMPL").first() task_status_list = StatusList.query \ .filter_by(target_entity_type='Task').first()
def setUpClass(cls): """set up once """ db.setup() db.init()
def setUp(self): """set up the test """ # create the db DBSession.remove() db.setup() # db.init() # we just need statuses so create them instead of initializing the db db.create_ticket_statuses() db.create_entity_statuses(entity_type='Task', status_names=defaults.task_status_names, status_codes=defaults.task_status_codes) db.create_entity_statuses(entity_type='Asset', status_names=defaults.task_status_names, status_codes=defaults.task_status_codes) db.create_entity_statuses(entity_type='Shot', status_names=defaults.task_status_names, status_codes=defaults.task_status_codes) db.create_entity_statuses(entity_type='Sequence', status_names=defaults.task_status_names, status_codes=defaults.task_status_codes) db.create_entity_statuses(entity_type='Review', status_names=defaults.review_status_names, status_codes=defaults.review_status_codes) # create statuses self.test_status1 = Status(name='N', code='N') self.test_status2 = Status(name='R', code='R') # get the ticket types ticket_types = Type.query \ .filter(Type.target_entity_type == 'Ticket').all() self.ticket_type_1 = ticket_types[0] self.ticket_type_2 = ticket_types[1] # create a User self.test_user = User( name='Test User', login='******', email='*****@*****.**', password='******' ) # create a Repository self.test_repo = Repository(name="Test Repo") # create a Project Type self.test_project_type = Type( name='Commercial Project', code='comm', target_entity_type=Project, ) # create a Project StatusList self.test_project_status1 = Status(name='PrjStat1', code='PrjStat1') self.test_project_status2 = Status(name='PrjStat2', code='PrjStat2') self.test_project_status_list = StatusList( name="Project Status List", target_entity_type=Project, statuses=[ self.test_project_status1, self.test_project_status2, ] ) self.test_task_status_list = StatusList.query\ .filter_by(target_entity_type='Task').first() # create a Project self.test_project = Project( name="Test Project 1", code="TEST_PROJECT_1", type=self.test_project_type, repository=self.test_repo, status_list=self.test_project_status_list ) # create an Asset self.test_asset_status_list = StatusList.query\ .filter_by(target_entity_type='Asset').first() self.test_asset_type = Type( name='Character Asset', code='char', target_entity_type=Asset ) self.test_asset = Asset( name="Test Asset", code='ta', project=self.test_project, status_list=self.test_asset_status_list, type=self.test_asset_type ) # create a Task self.test_task = Task( name="Modeling of Asset 1", resources=[self.test_user], status_list=self.test_task_status_list, parent=self.test_asset ) # create a Version self.test_version_status_list = StatusList( name='Version Statuses', target_entity_type=Version, statuses=[self.test_status1, self.test_status2] ) self.test_version = Version( name='Test Version', task=self.test_task, status_list=self.test_version_status_list, version=1, full_path='some/path' ) # create the Ticket self.kwargs = { 'project': self.test_project, 'links': [self.test_version], 'summary': 'This is a test ticket', 'description': 'This is the long description', 'priority': 'TRIVIAL', 'reported_by': self.test_user, } self.test_ticket = Ticket(**self.kwargs) DBSession.add(self.test_ticket) DBSession.commit() # get the Ticket Statuses self.status_new = Status.query.filter_by(name='New').first() self.status_accepted = Status.query.filter_by(name='Accepted').first() self.status_assigned = Status.query.filter_by(name='Assigned').first() self.status_reopened = Status.query.filter_by(name='Reopened').first() self.status_closed = Status.query.filter_by(name='Closed').first()
def setUp(self): """set up the test """ db.setup() db.init() # get statuses self.status_new = Status.query.filter_by(code="NEW").first() self.status_wfd = Status.query.filter_by(code="WFD").first() self.status_rts = Status.query.filter_by(code="RTS").first() self.status_wip = Status.query.filter_by(code="WIP").first() self.status_prev = Status.query.filter_by(code="PREV").first() self.status_hrev = Status.query.filter_by(code="HREV").first() self.status_drev = Status.query.filter_by(code="DREV").first() self.status_oh = Status.query.filter_by(code="OH").first() self.status_stop = Status.query.filter_by(code="STOP").first() self.status_cmpl = Status.query.filter_by(code="CMPL").first() self.test_user1 = User( name='Test User 1', login='******', email='*****@*****.**', password='******' ) self.test_user2 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) self.test_user3 = User( name='Test User 1', login='******', email='*****@*****.**', password='******' ) self.test_repo = Repository( name='Test Repository' ) self.test_structure = Structure( name='test structure' ) # project status list self.test_project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[ self.status_new, self.status_wip, self.status_oh, self.status_stop, self.status_cmpl ] ) self.test_project1 = Project( name='Test Project 1', code='TP1', lead=self.test_user1, repository=self.test_repo, structure=self.test_structure, status_list=self.test_project_status_list ) # create three Tasks self.test_task1 = Task( name='Test Task 1', project=self.test_project1 ) self.test_task2 = Task( name='Test Task 2', project=self.test_project1 ) self.test_task3 = Task( name='Test Task 3', project=self.test_project1 ) # add everything to db DBSession.add_all([ self.test_project1, self.test_project_status_list, self.test_repo, self.test_structure, self.test_task1, self.test_task2, self.test_task3, self.test_user1, self.test_user2 ]) DBSession.commit() self.kwargs = { 'task': self.test_task1, 'depends_to': self.test_task2, 'dependency_target': 'onend', 'gap_timing': 0, 'gap_unit': 'h', 'gap_model': 'length' }
"""This is an example which uses two different folder structure in two different projects. The first one prefers to use a flat one, in which all the files are in the same folder. The second project uses a more traditional folder structure where every Task/Asset/Shot/Sequence has its own folder and the Task hierarchy is directly reflected to folder hierarchy. """ from stalker import (db, Project, Repository, Structure, FilenameTemplate, Task, Status, StatusList, Version, Sequence, Shot) # initialize an in memory sqlite3 database db.setup() # fill in default data db.init() # create a new repository repo = Repository( name='Test Repository', linux_path='/mnt/T/stalker_tests/', osx_path='/Volumes/T/stalker_tests/', windows_path='T:/stalker_tests/' ) # create a Structure for our flat project flat_task_template = FilenameTemplate( name='Flat Task Template',
def setUp(self): """set up the test """ db.setup() db.init() self.user1 = User( name='Test User 1', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user1) self.user2 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user2) self.user3 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user3) # Review Statuses self.status_new = Status.query.filter_by(code='NEW').first() self.status_rrev = Status.query.filter_by(code='RREV').first() self.status_app = Status.query.filter_by(code='APP').first() # Task Statuses self.status_wfd = Status.query.filter_by(code='WFD').first() self.status_rts = Status.query.filter_by(code='RTS').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_prev = Status.query.filter_by(code='PREV').first() self.status_hrev = Status.query.filter_by(code='HREV').first() self.status_drev = Status.query.filter_by(code='DREV').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() self.project_status_list = StatusList( target_entity_type='Project', statuses=[ self.status_new, self.status_wip, self.status_cmpl ] ) DBSession.add(self.project_status_list) self.temp_path = tempfile.mkdtemp() self.repo = Repository( name='Test Repository', linux_path=self.temp_path, windows_path=self.temp_path, osx_path=self.temp_path ) DBSession.add(self.repo) self.structure = Structure( name='Test Project Structure' ) DBSession.add(self.structure) self.project = Project( name='Test Project', code='TP', lead=self.user1, status_list=self.project_status_list, repository=self.repo ) DBSession.add(self.project) self.task1 = Task( name='Test Task 1', project=self.project, resources=[self.user1] ) DBSession.add(self.task1) self.task2 = Task( name='Test Task 2', project=self.project ) DBSession.add(self.task2) self.task3 = Task( name='Test Task 3', parent=self.task2, resources=[self.user1] ) DBSession.add(self.task3) self.kwargs = { 'task': self.task1, 'reviewer': self.user1 } #self.review = Review(**self.kwargs) #DBSession.add(self.review) # add everything to the db DBSession.commit()
def setUp(self): """setup the test """ DBSession.remove() db.setup() defaults.local_storage_path = tempfile.mktemp()
from datetime import datetime from stalker import db, User, Department, Project, ImageFormat from stalker.db.session import session db.setup("sqlite:////tmp/studio.db") myUser = User( name="Erkan Ozgur Yilmaz", login_name="eoyilmaz", email="*****@*****.**", password="******", description="This is me" ) tds_department = Department( name="TDs", description="This is the TDs department" ) tds_department.users.append(myUser) all_departments = Department.query.all() all_members_of_dep = all_departments[0].members print all_members_of_dep[0].first_name session.add(myUser) session.add(tds_department) new_project = Project(name="Fancy Commercial")
def setUp(self): """setup the tests """ # ----------------------------------------------------------------- # start of the setUp # create the environment variable and point it to a temp directory db.setup() db.init() self.temp_repo_path = tempfile.mkdtemp() self.user1 = User( name='User 1', login='******', email='*****@*****.**', password='******' ) db.DBSession.add(self.user1) db.DBSession.commit() # login as self.user1 from stalker import LocalSession local_session = LocalSession() local_session.store_user(self.user1) local_session.save() self.repo1 = Repository( name='Test Project Repository', linux_path=self.temp_repo_path, windows_path=self.temp_repo_path, osx_path=self.temp_repo_path ) self.status_new = Status.query.filter_by(code='NEW').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_comp = Status.query.filter_by(code='CMPL').first() self.task_template = FilenameTemplate( name='Task Template', target_entity_type='Task', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.asset_template = FilenameTemplate( name='Asset Template', target_entity_type='Asset', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.shot_template = FilenameTemplate( name='Shot Template', target_entity_type='Shot', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.sequence_template = FilenameTemplate( name='Sequence Template', target_entity_type='Sequence', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.structure = Structure( name='Project Struture', templates=[self.task_template, self.asset_template, self.shot_template, self.sequence_template] ) self.project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[self.status_new, self.status_wip, self.status_comp] ) self.image_format = ImageFormat( name='HD 1080', width=1920, height=1080, pixel_aspect=1.0 ) # create a test project self.project = Project( name='Test Project', code='TP', repository=self.repo1, status_list=self.project_status_list, structure=self.structure, image_format=self.image_format ) self.task_status_list =\ StatusList.query.filter_by(target_entity_type='Task').first() self.asset_status_list =\ StatusList.query.filter_by(target_entity_type='Asset').first() self.shot_status_list =\ StatusList.query.filter_by(target_entity_type='Shot').first() self.sequence_status_list =\ StatusList.query.filter_by(target_entity_type='Sequence').first() self.character_type = Type( name='Character', code='CHAR', target_entity_type='Asset' ) # create a test series of root task self.task1 = Task( name='Test Task 1', project=self.project ) self.task2 = Task( name='Test Task 2', project=self.project ) self.task3 = Task( name='Test Task 3', project=self.project ) # then a couple of child tasks self.task4 = Task( name='Test Task 4', parent=self.task1 ) self.task5 = Task( name='Test Task 5', parent=self.task1 ) self.task6 = Task( name='Test Task 6', parent=self.task1 ) # create a root asset self.asset1 = Asset( name='Asset 1', code='asset1', type=self.character_type, project=self.project ) # create a child asset self.asset2 = Asset( name='Asset 2', code='asset2', type=self.character_type, parent=self.task4 ) # create a root Sequence self.sequence1 = Sequence( name='Sequence1', code='SEQ1', project=self.project ) # create a child Sequence self.sequence2 = Sequence( name='Sequence2', code='SEQ2', parent=self.task2 ) # create a root Shot self.shot1 = Shot( name='SH001', code='SH001', project=self.project ) # create a child Shot (child of a Sequence) self.shot2 = Shot( name='SH002', code='SH002', parent=self.sequence1 ) # create a child Shot (child of a child Sequence) self.shot3 = Shot( name='SH003', code='SH003', parent=self.sequence2 ) # commit everything db.DBSession.add_all([ self.repo1, self.status_new, self.status_wip, self.status_comp, self.project_status_list, self.project, self.task_status_list, self.asset_status_list, self.shot_status_list, self.sequence_status_list, self.task1, self.task2, self.task3, self.task4, self.task5, self.task6, self.asset1, self.asset2, self.shot1, self.shot2, self.shot3, self.sequence1, self.sequence2, self.task_template, self.asset_template, self.shot_template, self.sequence_template ]) db.DBSession.commit() # now create versions def create_version(task, take_name): """Creates a new version :param task: the task :param take_name: the take_name name :return: the version """ # just renew the scene #pymel.core.newFile(force=True) v = Version(task=task, take_name=take_name) v.update_paths() db.DBSession.add(v) db.DBSession.commit() #self.maya_env.save_as(v) return v # asset2 self.version1 = create_version(self.asset2, 'Main') self.version2 = create_version(self.asset2, 'Main') self.version3 = create_version(self.asset2, 'Main') self.version3.description = 'Test Description' self.version4 = create_version(self.asset2, 'Take1') self.version5 = create_version(self.asset2, 'Take1') self.version6 = create_version(self.asset2, 'Take1') # task5 self.version7 = create_version(self.task5, 'Main') self.version8 = create_version(self.task5, 'Main') self.version9 = create_version(self.task5, 'Main') self.version10 = create_version(self.task5, 'Take1') self.version11 = create_version(self.task5, 'Take1') self.version12 = create_version(self.task5, 'Take1') # task6 self.version13 = create_version(self.task6, 'Main') self.version14 = create_version(self.task6, 'Main') self.version15 = create_version(self.task6, 'Main') self.version16 = create_version(self.task6, 'Take1') self.version17 = create_version(self.task6, 'Take1') self.version18 = create_version(self.task6, 'Take1') # shot3 self.version19 = create_version(self.shot3, 'Main') self.version20 = create_version(self.shot3, 'Main') self.version21 = create_version(self.shot3, 'Main') self.version22 = create_version(self.shot3, 'Take1') self.version23 = create_version(self.shot3, 'Take1') self.version24 = create_version(self.shot3, 'Take1') # task3 self.version25 = create_version(self.task3, 'Main') self.version26 = create_version(self.task3, 'Main') self.version27 = create_version(self.task3, 'Main') self.version28 = create_version(self.task3, 'Take1') self.version29 = create_version(self.task3, 'Take1') self.version30 = create_version(self.task3, 'Take1') # asset1 self.version31 = create_version(self.asset1, 'Main') self.version32 = create_version(self.asset1, 'Main') self.version33 = create_version(self.asset1, 'Main') self.version34 = create_version(self.asset1, 'Take1') self.version35 = create_version(self.asset1, 'Take1') self.version36 = create_version(self.asset1, 'Take1') # shot2 self.version37 = create_version(self.shot2, 'Main') self.version38 = create_version(self.shot2, 'Main') self.version39 = create_version(self.shot2, 'Main') self.version40 = create_version(self.shot2, 'Take1') self.version41 = create_version(self.shot2, 'Take1') self.version42 = create_version(self.shot2, 'Take1') # shot1 self.version43 = create_version(self.shot1, 'Main') self.version44 = create_version(self.shot1, 'Main') self.version45 = create_version(self.shot1, 'Main') self.version46 = create_version(self.shot1, 'Take1') self.version47 = create_version(self.shot1, 'Take1') self.version48 = create_version(self.shot1, 'Take1') # +- task1 # | | # | +- task4 # | | | # | | +- asset2 # | | +- Main # | | | +- version1 # | | | +- version2 (P) # | | | +- version3 (P) # | | +- Take1 # | | +- version4 (P) # | | +- version5 # | | +- version6 (P) # | | # | +- task5 # | | +- Main # | | | +- version7 # | | | +- version8 # | | | +- version9 # | | +- Take1 # | | +- version10 # | | +- version11 # | | +- version12 (P) # | | # | +- task6 # | +- Main # | | +- version13 # | | +- version14 # | | +- version15 # | +- Take1 # | +- version16 (P) # | +- version17 # | +- version18 (P) # | # +- task2 # | | # | +- sequence2 # | | # | +- shot3 # | +- Main # | | +- version19 # | | +- version20 # | | +- version21 # | +- Take1 # | +- version22 # | +- version23 # | +- version24 # | # +- task3 # | +- Main # | | +- version25 # | | +- version26 # | | +- version27 # | +- Take1 # | +- version28 # | +- version29 # | +- version30 # | # +- asset1 # | +- Main # | | +- version31 # | | +- version32 # | | +- version33 # | +- Take1 # | +- version34 # | +- version35 # | +- version36 # | # +- sequence1 # | | # | +- shot2 # | +- Main # | | +- version37 # | | +- version38 # | | +- version39 # | +- Take1 # | +- version40 # | +- version41 # | +- version42 # | # +- shot1 # +- Main # | +- version43 # | +- version44 # | +- version45 # +- Take1 # +- version46 # +- version47 # +- version48 # Start Condition: # # version15 # version12 # version5 # version2 -> has new published version (version3) # version5 -> Referenced a second time # version2 -> has new published version (version3) # version12 -> Referenced a second time # version5 # version2 -> has new published version (version3) # version5 # version2 -> has new published version (version3) # version45 -> no change # version48 -> no change # # Expected Final Result # version15A -> Derived from version15 # version12A -> Derived from version12 # version5A -> Derived from version5 # version3 -> has new published version (version3) # version5A -> Derived from version5 # version3 -> has new published version (version3) # version12A -> Derived from version12 - The second reference # version5A -> Derived from version5 # version3 -> has new published version (version3) # version5A -> Derived from version5 # version3 -> has new published version (version3) # version45 -> no change # version48 -> no change # create a deep relation self.version2.is_published = True self.version3.is_published = True # new scene # version5 references version2 self.version5.inputs.append(self.version2) self.version5.is_published = True # version12 references version5 self.version12.inputs.append(self.version5) self.version12.is_published = True # version45 references version48 self.version45.is_published = True self.version48.is_published = True self.version45.inputs.append(self.version48) # version15 references version12 and version48 self.version15.inputs.append(self.version12) self.version15.inputs.append(self.version45) # reference_resolution self.reference_resolution = { 'root': [self.version12, self.version45], 'leave': [self.version48, self.version45], 'update': [self.version2], 'create': [self.version5, self.version12] } # create a buffer for extra created files, which are to be removed self.remove_these_files_buffer = [] self.test_environment = TestEnvironment(name='Test Environment') self.test_environment._version = self.version15 if not QtGui.QApplication.instance(): logger.debug('creating a new QApplication') self.app = QtGui.QApplication(sys.argv) else: logger.debug('using the present QApplication: %s' % QtGui.qApp) # self.app = QtGui.qApp self.app = QtGui.QApplication.instance() self.dialog = version_updater.MainDialog( environment=self.test_environment, reference_resolution=self.reference_resolution )
def setUp(self): """set up the test """ # create an in memory database from stalker import db db.setup() db.init() self.status_wfd = Status.query.filter_by(code='WFD').first() self.status_rts = Status.query.filter_by(code='RTS').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_prev = Status.query.filter_by(code='PREV').first() self.status_hrev = Status.query.filter_by(code='HREV').first() self.status_drev = Status.query.filter_by(code='DREV').first() self.status_oh = Status.query.filter_by(code='OH').first() self.status_stop = Status.query.filter_by(code='STOP').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() # create a resource self.test_resource1 = User( name="User1", login="******", email="*****@*****.**", password="******", ) self.test_resource2 = User( name="User2", login="******", email="*****@*****.**", password="******" ) self.test_repo = Repository(name="test repository") # create a Project self.test_status1 = Status(name="Status1", code="STS1") self.test_status2 = Status(name="Status2", code="STS2") self.test_status3 = Status(name="Status3", code="STS3") self.test_project_status_list = StatusList( name="Project Statuses", statuses=[self.test_status1], target_entity_type=Project ) self.test_task_status_list = StatusList.query\ .filter_by(target_entity_type='Task').first() self.test_project = Project( name="test project", code='tp', repository=self.test_repo, status_list=self.test_project_status_list ) # create a Task self.test_task = Task( name="test task", project=self.test_project, status_list=self.test_task_status_list, schedule_timing=10, schedule_unit='d', resources=[self.test_resource1] ) self.kwargs = { "name": "test time_log", "task": self.test_task, "resource": self.test_resource1, "start": datetime.datetime(2013, 3, 22, 1, 0), "duration": datetime.timedelta(10) }
def test_generic_data_attribute_can_hold_a_wide_variety_of_object_types(self): """testing if the generic_data attribute can hold any kind of object as a list """ from stalker import db db.setup() new_simple_entity = SimpleEntity(**self.kwargs) test_user = User( name='email', login='******', email='*****@*****.**', password='******', ) from stalker import Department test_department = Department( name='department1' ) from stalker import Repository test_repo = Repository( name='Test Repository' ) from stalker import Structure test_struct = Structure( name='Test Project Structure' ) from stalker import Status, StatusList test_project_status_list = StatusList( name='Project Status List', target_entity_type='Project', statuses=[ Status(name='Active', code='ACT') ] ) from stalker import Project test_proj = Project( name='Test Project 1', code='tp1', repository=test_repo, structure=test_struct, status_list=test_project_status_list ) new_simple_entity.generic_data.extend( [test_proj, test_project_status_list, test_struct, test_repo, test_department, test_user] ) DBSession.add(new_simple_entity) DBSession.commit() # now check if it is added to the database correctly del new_simple_entity new_simple_entity_db = SimpleEntity.query \ .filter_by(name=self.kwargs['name']) \ .first() self.assertTrue(test_proj in new_simple_entity_db.generic_data) self.assertTrue( test_project_status_list in new_simple_entity_db.generic_data) self.assertTrue(test_struct in new_simple_entity_db.generic_data) self.assertTrue(test_repo in new_simple_entity_db.generic_data) self.assertTrue(test_department in new_simple_entity_db.generic_data) self.assertTrue(test_user in new_simple_entity_db.generic_data) DBSession.remove()