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 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 the test up
"""
db.setup({'sqlalchemy.url': 'sqlite:///:memory:'})
self.kwargs = {
'name': 'Test DAG Mixin'
}
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 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 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 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 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 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 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 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 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()
