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
"""
new_simple_entity = SimpleEntity(**self.kwargs)
from stalker import User
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
])
from stalker import db
db.DBSession.add(new_simple_entity)
db.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)
db.DBSession.remove()
def setUp(self):
"""setup the test
"""
super(ProjectMixinTester, self).setUp()
# create a repository
from stalker import db, Type
self.repository_type = Type(
name="Test Repository Type",
code='testproj',
target_entity_type='Repository'
)
db.DBSession.add(self.repository_type)
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
db.DBSession.add(self.test_repository)
# statuses
from stalker import Status
self.status1 = Status(name="Status1", code="STS1")
self.status2 = Status(name="Status2", code="STS2")
self.status3 = Status(name="Status3", code="STS3")
db.DBSession.add_all([self.status1, self.status2, self.status3])
# project status list
from stalker import StatusList
self.project_status_list = StatusList(
name="Project Status List",
statuses=[
self.status1,
self.status2,
self.status3,
],
target_entity_type='Project'
)
db.DBSession.add(self.project_status_list)
# project type
self.test_project_type = Type(
name="Test Project Type",
code='testproj',
target_entity_type='Project',
)
db.DBSession.add(self.test_project_type)
# create projects
from stalker import Project
self.test_project1 = Project(
name="Test Project 1",
code='tp1',
type=self.test_project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
db.DBSession.add(self.test_project1)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.test_project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
db.DBSession.add(self.test_project2)
self.kwargs = {
"name": "Test Class",
"project": self.test_project1,
}
self.test_foo_obj = ProjMixClass(**self.kwargs)
db.DBSession.add(self.test_foo_obj)
def setUp(self):
"""lets setup the tests
"""
super(ClientTestCase, self).setUp()
# create a couple of test users
from stalker import User
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.users_list = [
self.test_user1, self.test_user2, self.test_user3, self.test_user4
]
self.test_admin = User(name='admin',
login='******',
email='*****@*****.**',
password='******')
from stalker import Status
self.status_new = Status(name='New', code='NEW')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_cmpl = Status(name='Completed', code='CMPL')
from stalker import StatusList
self.project_statuses = StatusList(
name="Project Status List",
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type='Project')
from stalker import Repository
self.test_repo = Repository(name="Test Repository")
from stalker import Project
self.test_project1 = Project(
name="Test Project 1",
code='proj1',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.test_project2 = Project(
name="Test Project 1",
code='proj2',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.test_project3 = Project(
name="Test Project 1",
code='proj3',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.projects_list = [
self.test_project1, self.test_project2, self.test_project3
]
import pytz
import datetime
self.date_created = self.date_updated = datetime.datetime.now(pytz.utc)
self.kwargs = {
"name": "Test Client",
"description": "This is a client for testing purposes",
"created_by": self.test_admin,
"updated_by": self.test_admin,
"date_created": self.date_created,
"date_updated": self.date_updated,
"users": self.users_list,
"projects": self.projects_list
}
# create a default client object
self.test_client = Client(**self.kwargs)
def setUp(self):
"""set up the test
"""
# we need a database
db.setup(self.config)
db.init()
# replace datetime now function
# create departments
self.test_dep1 = Department(name='Dep1')
self.test_dep2 = Department(name='Dep2')
# create resources
self.test_user1 = User(login='******',
name='User1',
email='*****@*****.**',
password='******',
departments=[self.test_dep1])
DBSession.add(self.test_user1)
self.test_user2 = User(login='******',
name='User2',
email='*****@*****.**',
password='******',
departments=[self.test_dep1])
DBSession.add(self.test_user2)
self.test_user3 = User(login='******',
name='User3',
email='*****@*****.**',
password='******',
departments=[self.test_dep2])
DBSession.add(self.test_user3)
self.test_user4 = User(login='******',
name='User4',
email='*****@*****.**',
password='******',
departments=[self.test_dep2])
DBSession.add(self.test_user4)
# user with two departments
self.test_user5 = User(login='******',
name='User5',
email='*****@*****.**',
password='******',
departments=[self.test_dep1, self.test_dep2])
DBSession.add(self.test_user5)
# user with no departments
self.test_user6 = User(login='******',
name='User6',
email='*****@*****.**',
password='******')
DBSession.add(self.test_user6)
# repository
self.test_repo = Repository(name='Test Repository',
linux_path='/mnt/T/',
windows_path='T:/',
osx_path='/Volumes/T/')
DBSession.add(self.test_repo)
# statuses
self.test_status1 = Status(name='Status 1', code='STS1')
self.test_status2 = Status(name='Status 2', code='STS2')
self.test_status3 = Status(name='Status 3', code='STS3')
self.test_status4 = Status(name='Status 4', code='STS4')
self.test_status5 = Status(name='Status 5', code='STS5')
DBSession.add_all([
self.test_status1, self.test_status2, self.test_status3,
self.test_status4, self.test_status5
])
# status lists
self.test_proj_status_list = StatusList(
name='Project Status List',
statuses=[self.test_status1, self.test_status2, self.test_status3],
target_entity_type='Project')
DBSession.add(self.test_proj_status_list)
# create one project
self.test_proj1 = Project(name='Test Project 1',
code='TP1',
repository=self.test_repo,
status_list=self.test_proj_status_list,
start=datetime.datetime(2013, 4, 4),
end=datetime.datetime(2013, 5, 4))
DBSession.add(self.test_proj1)
self.test_proj1.now = datetime.datetime(2013, 4, 4)
# create task status list
with DBSession.no_autoflush:
self.test_task_status_list = StatusList.query\
.filter_by(target_entity_type='Task').first()
# create two tasks with the same resources
self.test_task1 = Task(name='Task1',
project=self.test_proj1,
resources=[self.test_user1, self.test_user2],
alternative_resources=[
self.test_user3, self.test_user4,
self.test_user5
],
schedule_model=0,
schedule_timing=50,
schedule_unit='h',
status_list=self.test_task_status_list)
DBSession.add(self.test_task1)
self.test_task2 = Task(name='Task2',
project=self.test_proj1,
resources=[self.test_user1, self.test_user2],
alternative_resources=[
self.test_user3, self.test_user4,
self.test_user5
],
depends=[self.test_task1],
schedule_model=0,
schedule_timing=60,
schedule_unit='h',
status_list=self.test_task_status_list)
DBSession.add(self.test_task2)
DBSession.commit()
def setUp(self):
"""set up the test
"""
super(self.__class__, self).setUp()
# create departments
from stalker import Department
self.test_dep1 = Department(name='Dep1')
self.test_dep2 = Department(name='Dep2')
# create resources
from stalker import User
self.test_user1 = User(
login='******',
name='User1',
email='*****@*****.**',
password='******',
departments=[self.test_dep1]
)
from stalker.db.session import DBSession
DBSession.add(self.test_user1)
self.test_user2 = User(
login='******',
name='User2',
email='*****@*****.**',
password='******',
departments=[self.test_dep1]
)
DBSession.add(self.test_user2)
self.test_user3 = User(
login='******',
name='User3',
email='*****@*****.**',
password='******',
departments=[self.test_dep2]
)
DBSession.add(self.test_user3)
self.test_user4 = User(
login='******',
name='User4',
email='*****@*****.**',
password='******',
departments=[self.test_dep2]
)
DBSession.add(self.test_user4)
# user with two departments
self.test_user5 = User(
login='******',
name='User5',
email='*****@*****.**',
password='******',
departments=[self.test_dep1, self.test_dep2]
)
DBSession.add(self.test_user5)
# user with no departments
self.test_user6 = User(
login='******',
name='User6',
email='*****@*****.**',
password='******'
)
DBSession.add(self.test_user6)
# repository
from stalker import Repository
self.test_repo = Repository(
name='Test Repository',
linux_path='/mnt/T/',
windows_path='T:/',
osx_path='/Volumes/T/'
)
DBSession.add(self.test_repo)
# statuses
from stalker import Status
self.test_status1 = Status(name='Status 1', code='STS1')
self.test_status2 = Status(name='Status 2', code='STS2')
self.test_status3 = Status(name='Status 3', code='STS3')
self.test_status4 = Status(name='Status 4', code='STS4')
self.test_status5 = Status(name='Status 5', code='STS5')
DBSession.add_all([
self.test_status1, self.test_status2, self.test_status3,
self.test_status4, self.test_status5
])
# create one project
from stalker import Project
self.test_proj1 = Project(
name='Test Project 1',
code='TP1',
repository=self.test_repo,
start=datetime.datetime(2013, 4, 4, tzinfo=pytz.utc),
end=datetime.datetime(2013, 5, 4, tzinfo=pytz.utc)
)
DBSession.add(self.test_proj1)
self.test_proj1.now = datetime.datetime(2013, 4, 4, tzinfo=pytz.utc)
# create two tasks with the same resources
from stalker import Task
self.test_task1 = Task(
name='Task1',
project=self.test_proj1,
resources=[self.test_user1, self.test_user2],
alternative_resources=[
self.test_user3, self.test_user4, self.test_user5
],
schedule_model=0,
schedule_timing=50,
schedule_unit='h',
)
DBSession.add(self.test_task1)
self.test_task2 = Task(
name='Task2',
project=self.test_proj1,
resources=[self.test_user1, self.test_user2],
alternative_resources=[
self.test_user3, self.test_user4, self.test_user5
],
depends=[self.test_task1],
schedule_model=0,
schedule_timing=60,
schedule_unit='h',
priority=800
)
DBSession.save(self.test_task2)
def setUp(self):
"""run once
"""
super(PaymentTestCase, self).setUp()
from stalker import Status
self.status_new = Status(name='Mew', code='NEW')
self.status_wfd = Status(name='Waiting For Dependency', code='WFD')
self.status_rts = Status(name='Ready To Start', code='RTS')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_prev = Status(name='Pending Review', code='PREV')
self.status_hrev = Status(name='Has Revision', code='HREV')
self.status_drev = Status(name='Dependency Has Revision', code='DREV')
self.status_oh = Status(name='On Hold', code='OH')
self.status_stop = Status(name='Stopped', code='STOP')
self.status_cmpl = Status(name='Completed', code='CMPL')
self.status_new = Status(name='New', code='NEW')
self.status_app = Status(name='Approved', code='APP')
from stalker import StatusList
self.budget_status_list = StatusList(
name='Budget Statuses',
target_entity_type='Budget',
statuses=[self.status_new, self.status_prev, self.status_app])
self.task_status_list = StatusList(
name='Task Statses',
statuses=[
self.status_wfd, self.status_rts, self.status_wip,
self.status_prev, self.status_hrev, self.status_drev,
self.status_oh, self.status_stop, self.status_cmpl
],
target_entity_type='Task')
from stalker import Project
self.test_project_status_list = StatusList(
name="Project Statuses",
statuses=[self.status_wip, self.status_prev, self.status_cmpl],
target_entity_type=Project,
)
from stalker import Type
self.test_movie_project_type = Type(
name="Movie Project",
code='movie',
target_entity_type=Project,
)
from stalker import Repository
self.test_repository_type = Type(
name="Test Repository Type",
code='test',
target_entity_type=Repository,
)
self.test_repository = Repository(
name="Test Repository",
code='TR',
type=self.test_repository_type,
)
from stalker import User
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="******")
from stalker import Client
self.test_client = Client(name='Test Client', )
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,
clients=[self.test_client])
from stalker import Budget
self.test_budget = Budget(project=self.test_project,
name='Test Budget 1',
status_list=self.budget_status_list)
from stalker import Invoice
self.test_invoice = Invoice(budget=self.test_budget,
client=self.test_client,
amount=1500,
unit='TRY')
def setUp(self):
"""lets setup the tests
"""
# create a couple of test users
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.users_list = [
self.test_user1, self.test_user2, self.test_user3, self.test_user4
]
self.test_admin = User(
name="admin",
login="******",
email="*****@*****.**",
password="******",
)
self.status_new = Status(name="Test status 1", code="Status1")
self.status_wip = Status(name="Test status 2", code="Status2")
self.status_cmpl = Status(name="Test status 3", code="Status3")
self.project_statuses = StatusList(
name="Project Status List",
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type='Project')
self.test_repo = Repository(name="Test Repository")
self.test_project1 = Project(
name="Test Project 1",
code='proj1',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.test_project2 = Project(
name="Test Project 1",
code='proj2',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.test_project3 = Project(
name="Test Project 1",
code='proj3',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.projects_list = [
self.test_project1, self.test_project2, self.test_project3
]
self.date_created = self.date_updated = datetime.datetime.now()
self.kwargs = {
"name": "Test Client",
"description": "This is a client for testing purposes",
"created_by": self.test_admin,
"updated_by": self.test_admin,
"date_created": self.date_created,
"date_updated": self.date_updated,
"users": self.users_list,
"projects": self.projects_list
}
# create a default client object
self.test_client = Client(**self.kwargs)
def test_get_entity_is_working_properly(self):
"""testing if the get_entity() method is working properly
"""
from stalker import db, Status, StatusList
test_status1 = Status(name='Test Status 1', code='TST1')
test_status2 = Status(name='Test Status 2', code='TST2')
test_status3 = Status(name='Test Status 3', code='TST3')
test_status4 = Status(name='Test Status 4', code='TST4')
test_status5 = Status(name='Test Status 5', code='TST5')
test_status_list = StatusList(
name='Status List',
statuses=[test_status1, test_status2, test_status3, test_status4],
target_entity_type='Project',
created_by=self.admin)
db.DBSession.add_all([
test_status1, test_status2, test_status3, test_status4,
test_status5, test_status_list
])
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_status_list.id
status_list_view = status.StatusListViews(request)
response = status_list_view.get_entity()
from stalker_pyramid.views import EntityViewBase
import stalker
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': 3,
'$ref': '/api/users/3',
'name': 'admin',
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
test_status_list.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
test_status_list.date_updated),
'description':
'',
'entity_type':
'StatusList',
'id':
test_status_list.id,
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' %
test_status_list.id,
'length':
0
},
'generic_text':
'',
'name':
test_status_list.name,
'notes': {
'$ref': '/api/entities/%s/notes' % test_status_list.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'statuses': {
'$ref':
'/api/status_lists/%s/statuses' % test_status_list.id,
'length': 4
},
'tags': {
'$ref': '/api/entities/%s/tags' % test_status_list.id,
'length': 0
},
'target_entity_type':
'Project',
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': 3,
'$ref': '/api/users/3',
'name': 'admin',
'entity_type': 'User'
}
})
def test_create_entity_is_working_properly(self):
"""testing if PUT: /api/status_lists view is working properly
"""
from stalker import db, Status
test_status1 = Status(name='Test Status 1', code='TST1')
test_status2 = Status(name='Test Status 2', code='TST2')
test_status3 = Status(name='Test Status 3', code='TST3')
test_status4 = Status(name='Test Status 4', code='TST4')
test_status5 = Status(name='Test Status 5', code='TST5')
db.DBSession.add_all([
test_status1, test_status2, test_status3, test_status4,
test_status5
])
db.DBSession.commit()
response = self.test_app.put(
'/api/status_lists',
params={
'name': 'Project Status List',
'description': 'Test description',
'status_id':
[test_status1.id, test_status2.id, test_status3.id],
'target_entity_type': 'Project',
'created_by_id': 3
},
status=201)
from stalker import StatusList
test_status_list = StatusList.query\
.filter(StatusList.name == 'Project Status List')\
.first()
from stalker_pyramid.views import EntityViewBase
import stalker
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': 3,
'$ref': '/api/users/3',
'name': 'admin',
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
test_status_list.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
test_status_list.date_updated),
'description':
'Test description',
'entity_type':
'StatusList',
'id':
test_status_list.id,
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' %
test_status_list.id,
'length':
0
},
'generic_text':
'',
'name':
test_status_list.name,
'notes': {
'$ref': '/api/entities/%s/notes' % test_status_list.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'statuses': {
'$ref':
'/api/status_lists/%s/statuses' % test_status_list.id,
'length': 3
},
'tags': {
'$ref': '/api/entities/%s/tags' % test_status_list.id,
'length': 0
},
'target_entity_type':
'Project',
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': 3,
'$ref': '/api/users/3',
'name': 'admin',
'entity_type': 'User'
}
})
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
"""
super(TicketTester, self).setUp()
# create statuses
from stalker import Status
self.test_status1 = Status(name='N', code='N')
self.test_status2 = Status(name='R', code='R')
# get the ticket types
from stalker import Type
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
from stalker import User
self.test_user = User(
name='Test User',
login='******',
email='*****@*****.**',
password='******'
)
# create a Repository
from stalker import 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')
# create a Project
from stalker import Project
self.test_project = Project(
name="Test Project 1",
code="TEST_PROJECT_1",
type=self.test_project_type,
repository=self.test_repo,
)
from stalker.db.session import DBSession
DBSession.add(self.test_project)
DBSession.commit()
self.test_asset_type = Type(
name='Character Asset',
code='char',
target_entity_type='Asset'
)
from stalker import Asset
self.test_asset = Asset(
name="Test Asset",
code='ta',
project=self.test_project,
type=self.test_asset_type
)
DBSession.add(self.test_asset)
DBSession.commit()
# create a Task
from stalker import Task
self.test_task = Task(
name="Modeling of Asset 1",
resources=[self.test_user],
parent=self.test_asset
)
DBSession.add(self.test_task)
DBSession.commit()
from stalker import Version
self.test_version = Version(
name='Test Version',
task=self.test_task,
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,
}
from stalker import Ticket
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):
"""setup the test
"""
super(SceneTester, self).setUp()
# create statuses
from stalker import db, Status, StatusList
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_status4 = Status(name="Status4", code="STS4")
self.test_status5 = Status(name="Status5", code="STS5")
# create a test project, user and a couple of shots
from stalker import Type
self.project_type = Type(
name="Test Project Type",
code='test',
target_entity_type='Project',
)
# create a status list for project
self.project_status_list = StatusList(
name="Project Statuses",
statuses=[
self.test_status1,
self.test_status2,
self.test_status3,
self.test_status4,
self.test_status5,
],
target_entity_type='Project',
)
# create a repository
self.repository_type = Type(name="Test Type",
code='test',
target_entity_type='Repository')
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
# create projects
from stalker import Project
self.test_project = Project(
name="Test Project 1",
code='tp1',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
# the parameters
self.kwargs = {
"name": "Test Scene",
'code': 'tsce',
"description": "A test scene",
"project": self.test_project,
}
# the test sequence
self.test_scene = Scene(**self.kwargs)
db.DBSession.add(self.test_scene)
db.DBSession.commit()
def setUp(self):
"""setting the test up
"""
super(TimeLogViewsFunctionalTestCase, self).setUp()
# get the admin
import datetime
from stalker import User
self.admin = User.query.filter(User.login == 'admin').first()
# update the date_created to a known value
self.admin.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.admin.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
# create test users
self.test_user1 = User(
name='Test User 1',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin,
)
# update the date_created to a known value
self.test_user1.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user1.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user2 = User(
name='Test User 2',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin,
)
# update the date_created to a known value
self.test_user2.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user2.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user3 = User(
name='Test User 3',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin,
)
# update the date_created to a known value
self.test_user3.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user3.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
# create Projects
from stalker import Status, StatusList, Project, Repository
self.test_status1 = Status(name='Work In Progress', code='WIP')
self.test_status2 = Status(name='Completed', code='CMPL')
self.test_status_list = StatusList(
name='Project Status List',
target_entity_type='Project',
statuses=[self.test_status1, self.test_status2])
self.test_repo = Repository(name='Test Repository', )
self.test_project1 = Project(name='Test Project 1',
code='TP1',
status_list=self.test_status_list,
repositories=[self.test_repo])
self.test_project2 = Project(name='Test Project 2',
code='TP2',
status_list=self.test_status_list,
repositories=[self.test_repo])
# set user projects
self.test_user1.projects = [self.test_project1]
self.test_user2.projects = [self.test_project2]
self.test_user3.projects = [self.test_project1, self.test_project2]
from stalker import db
db.DBSession.add_all([
self.test_user1, self.test_user2, self.test_user3,
self.test_status1, self.test_status2, self.test_status_list,
self.test_repo, self.test_project1, self.test_project2
])
db.DBSession.flush()
db.DBSession.commit()
# create tasks
# tasks
# as resource
from stalker import Task
self.test_task1 = Task(name='T1',
project=self.test_project1,
resources=[self.test_user1],
responsible=[self.test_user2],
schedule_timing=10,
schedule_unit='h',
schedule_model='effort')
db.DBSession.add(self.test_task1)
self.test_task2 = Task(name='T2',
project=self.test_project1,
resources=[self.test_user1],
responsible=[self.test_user2])
db.DBSession.add(self.test_task2)
self.test_task3 = Task(name='T3',
project=self.test_project1,
resources=[self.test_user1],
responsible=[self.test_user2])
db.DBSession.add(self.test_task3)
# as responsible
self.test_task4 = Task(name='T4',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user1])
db.DBSession.add(self.test_task4)
self.test_task5 = Task(name='T5',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user1])
db.DBSession.add(self.test_task5)
self.test_task6 = Task(name='T6',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user1])
db.DBSession.add(self.test_task6)
# non related
self.test_task7 = Task(name='T7',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task7)
self.test_task8 = Task(name='T8',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task8)
self.test_task9 = Task(name='T9',
project=self.test_project2,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task9)
self.test_task10 = Task(name='T10',
project=self.test_project2,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task10)
db.DBSession.flush()
db.DBSession.commit()
def setUp(self):
"""set the test up
"""
super(EntityGroupTestCase, self).setUp()
from stalker import (Status, User, StatusList, Repository, Project,
Type, Asset, Task)
# create a couple of task
self.status_new = Status(name='Mew', code='NEW')
self.status_wfd = Status(name='Waiting For Dependency', code='WFD')
self.status_rts = Status(name='Ready To Start', code='RTS')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_prev = Status(name='Pending Review', code='PREV')
self.status_hrev = Status(name='Has Revision', code='HREV')
self.status_drev = Status(name='Dependency Has Revision', code='DREV')
self.status_cmpl = Status(name='Completed', code='CMPL')
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.project_status_list = StatusList(
name="Project Status List",
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type="Project",
)
self.repo = Repository(
name='Test Repo',
code='TR',
linux_path='/mnt/M/JOBs',
windows_path='M:/JOBs',
osx_path='/Users/Shared/Servers/M',
)
self.project1 = Project(
name='Tests Project',
code='tp',
status_list=self.project_status_list,
repository=self.repo,
)
self.char_asset_type = Type(
name='Character Asset',
code='char',
target_entity_type="Asset"
)
self.task_status_list = StatusList(
name='Task Statuses',
statuses=[
self.status_wfd, self.status_rts, self.status_wip,
self.status_prev, self.status_hrev, self.status_drev,
self.status_cmpl
],
target_entity_type='Task'
)
self.asset_status_list = StatusList(
name='Asset Statuses',
statuses=[
self.status_wfd, self.status_rts, self.status_wip,
self.status_prev, self.status_hrev, self.status_drev,
self.status_cmpl
],
target_entity_type='Asset'
)
self.asset1 = Asset(
name='Char1',
code='char1',
type=self.char_asset_type,
project=self.project1,
responsible=[self.test_user1],
status_list=self.asset_status_list
)
self.task1 = Task(
name="Test Task",
watchers=[self.test_user3],
parent=self.asset1,
schedule_timing=5,
schedule_unit='h',
bid_timing=52,
bid_unit='h',
status_list=self.task_status_list
)
self.child_task1 = Task(
name='Child Task 1',
resources=[self.test_user1, self.test_user2],
parent=self.task1,
status_list=self.task_status_list
)
self.child_task2 = Task(
name='Child Task 2',
resources=[self.test_user1, self.test_user2],
parent=self.task1,
status_list=self.task_status_list
)
self.task2 = Task(
name='Another Task',
project=self.project1,
resources=[self.test_user1],
responsible=[self.test_user2],
status_list=self.task_status_list
)
self.entity_group1 = EntityGroup(
name='My Tasks',
entities=[
self.task1, self.child_task2, self.task2
]
)
def create_entity_statuses(entity_type='',
status_names=None,
status_codes=None,
user=None):
"""creates the default task statuses
"""
if not entity_type:
raise ValueError('Please supply entity_type')
if not status_names:
raise ValueError('Please supply status names')
if not status_codes:
raise ValueError('Please supply status codes')
# create statuses for entity
from stalker import Status, StatusList
logger.debug("Creating %s Statuses" % entity_type)
statuses = Status.query.filter(Status.name.in_(status_names)).all()
logger.debug('status_names: %s' % status_names)
logger.debug('statuses: %s' % statuses)
status_names_in_db = list(map(lambda x: x.name, statuses))
logger.debug('statuses_names_in_db: %s' % status_names_in_db)
from stalker.db.session import DBSession
for name, code in zip(status_names, status_codes):
if name not in status_names_in_db:
logger.debug('Creating Status: %s (%s)' % (name, code))
new_status = Status(name=name,
code=code,
created_by=user,
updated_by=user)
statuses.append(new_status)
DBSession.add(new_status)
else:
logger.debug('Status %s (%s) is already created skipping!' %
(name, code))
# create the Status List
status_list = StatusList.query\
.filter(StatusList.target_entity_type == entity_type)\
.first()
if status_list is None:
logger.debug('No %s Status List found, creating new!' % entity_type)
status_list = StatusList(name='%s Statuses' % entity_type,
target_entity_type=entity_type,
created_by=user,
updated_by=user)
else:
logger.debug("%s Status List already created, updating statuses" %
entity_type)
status_list.statuses = statuses
DBSession.add(status_list)
from sqlalchemy.exc import IntegrityError
try:
DBSession.commit()
except IntegrityError as e:
logger.debug("error in DBSession.commit, rolling back: %s" % e)
DBSession.rollback()
else:
logger.debug("Created %s Statuses successfully" % entity_type)
DBSession.flush()
def setUp(self):
super(DailyTestBase, self).setUp()
from stalker import Status, StatusList
self.status_new = Status(name='Mew', code='NEW')
self.status_wfd = Status(name='Waiting For Dependency', code='WFD')
self.status_rts = Status(name='Ready To Start', code='RTS')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_prev = Status(name='Pending Review', code='PREV')
self.status_hrev = Status(name='Has Revision', code='HREV')
self.status_drev = Status(name='Dependency Has Revision', code='DREV')
self.status_cmpl = Status(name='Completed', code='CMPL')
self.status_open = Status(name='Open', code='OPEN')
self.status_cls = Status(name='Closed', code='CLS')
self.daily_status_list = StatusList(
name='Daily Statuses',
statuses=[self.status_open, self.status_cls],
target_entity_type='Daily')
self.task_status_list = StatusList(
name='Task Statuses',
statuses=[
self.status_wfd, self.status_rts, self.status_wip,
self.status_prev, self.status_hrev, self.status_drev,
self.status_cmpl
],
target_entity_type='Task')
self.test_project_status_list = StatusList(
name='Project Statuses',
target_entity_type='Project',
statuses=[self.status_new, self.status_wip, self.status_cmpl])
from stalker import Repository, Project
self.test_repo = Repository(name='Test Repository')
self.test_project = Project(name='Test Project',
code='TP',
repository=self.test_repo,
status_list=self.test_project_status_list)
from stalker import Task
self.test_task1 = Task(name='Test Task 1',
project=self.test_project,
status_list=self.task_status_list)
self.test_task2 = Task(name='Test Task 2',
project=self.test_project,
status_list=self.task_status_list)
self.test_task3 = Task(name='Test Task 3',
project=self.test_project,
status_list=self.task_status_list)
from stalker import Version
self.test_version1 = Version(task=self.test_task1)
self.test_version2 = Version(task=self.test_task1)
self.test_version3 = Version(task=self.test_task1)
self.test_version4 = Version(task=self.test_task2)
from stalker import Link
self.test_link1 = Link(original_filename='test_render1.jpg')
self.test_link2 = Link(original_filename='test_render2.jpg')
self.test_link3 = Link(original_filename='test_render3.jpg')
self.test_link4 = Link(original_filename='test_render4.jpg')
self.test_version1.outputs = [
self.test_link1, self.test_link2, self.test_link3
]
self.test_version4.outputs = [self.test_link4]
