def test_inequality(self):
"""testing inequality of two Department objects
"""
dep1 = Department(**self.kwargs)
dep2 = Department(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Animation"
dep3 = Department(**self.kwargs)
self.assertFalse(dep1 != dep2)
self.assertTrue(dep1 != dep3)
self.assertTrue(dep1 != entity1)
def test_users_attribute_defaults_to_empty_list(self):
"""testing if the users attribute defaults to an empty list if the
users argument is skipped
"""
self.kwargs.pop("users")
new_department = Department(**self.kwargs)
assert new_department.users == []
def test_users_argument_accepts_an_empty_list(self):
"""testing if users argument accepts an empty list
"""
# this should work without raising any error
self.kwargs["users"] = []
new_dep = Department(**self.kwargs)
assert isinstance(new_dep, Department)
def test_inequality(self):
"""testing inequality of two Department objects
"""
from stalker import Entity
dep1 = Department(**self.kwargs)
dep2 = Department(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Animation"
dep3 = Department(**self.kwargs)
assert not dep1 != dep2
assert dep1 != dep3
assert dep1 != entity1
def setUp(self):
"""create the test data
"""
super(DepartmentViewsFunctionalTestCase, self).setUp()
from stalker import db, User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin)
db.DBSession.add(self.test_user1)
self.test_user2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin)
db.DBSession.add(self.test_user2)
self.test_user3 = User(name='Test User 3',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin)
db.DBSession.add(self.test_user3)
from stalker import Department
self.test_department1 = Department(name='Test Department 1',
created_by=self.admin)
db.DBSession.add(self.test_department1)
self.test_department2 = Department(name='Test Department 2',
created_by=self.admin)
db.DBSession.add(self.test_department2)
# create a couple of roles
from stalker import Role
self.test_role1 = Role(name='Test Role 1', created_by=self.admin)
self.test_role2 = Role(name='Test Role 2', created_by=self.admin)
self.test_role3 = Role(name='Test Role 3', created_by=self.admin)
db.DBSession.add_all(
[self.test_role1, self.test_role2, self.test_role3])
db.DBSession.commit()
def test_users_argument_is_not_iterable(self):
"""testing if a TypeError will be raised when the given users
argument is not an instance of list
"""
self.kwargs["users"] = "a user"
with pytest.raises(TypeError) as cm:
Department(**self.kwargs)
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not str'
def test_users_argument_accepts_only_a_list_of_user_objects(self):
"""testing if users argument accepts only a list of user objects
"""
test_value = [1, 2.3, [], {}]
self.kwargs["users"] = test_value
# this should raise a TypeError
with pytest.raises(TypeError) as cm:
Department(**self.kwargs)
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not int'
def test_users_argument_is_not_iterable(self):
"""testing if a TypeError will be raised when the given users
argument is not an instance of list
"""
self.kwargs["users"] = "a user"
with self.assertRaises(TypeError) as cm:
Department(**self.kwargs)
self.assertEqual(
str(cm.exception),
'DepartmentUser.user should be a stalker.models.auth.User '
'instance, not str')
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',
code='TR',
)
from stalker import Structure
test_struct = Structure(name='Test Project Structure')
from stalker import Project
test_proj = Project(
name='Test Project 1',
code='tp1',
repository=test_repo,
structure=test_struct,
)
new_simple_entity.generic_data.extend(
[test_proj, test_struct, test_repo, test_department, test_user])
# 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()
assert test_proj in new_simple_entity_db.generic_data
assert test_struct in new_simple_entity_db.generic_data
assert test_repo in new_simple_entity_db.generic_data
assert test_department in new_simple_entity_db.generic_data
assert test_user in new_simple_entity_db.generic_data
def test_role_argument_is_not_a_role_instance(self):
"""testing if a TypeError will be raised when the role argument is not
a Role instance
"""
from stalker import Department, User
with self.assertRaises(TypeError) as cm:
DepartmentUser(department=Department(name='Test Department'),
user=User(name='Test User',
login='******',
email='*****@*****.**',
password='******'),
role='not a role instance')
self.assertEqual(
str(cm.exception),
'DepartmentUser.role should be a stalker.models.auth.Role '
'instance, not str')
def test_role_argument_is_not_a_role_instance():
"""testing if a TypeError will be raised when the role argument is not
a Role instance
"""
from stalker import DepartmentUser
from stalker import Department, User
with pytest.raises(TypeError) as cm:
DepartmentUser(department=Department(name='Test Department'),
user=User(name='Test User',
login='******',
email='*****@*****.**',
password='******'),
role='not a role instance')
assert str(cm.value) == \
'DepartmentUser.role should be a stalker.models.auth.Role ' \
'instance, not str'
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()
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):
"""lets setup the tests
"""
super(DepartmentTester, self).setUp()
from stalker import User
self.test_admin = User(
name='admin',
login='******',
email='*****@*****.**',
password='******',
)
# 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.test_user5 = User(
name="User5",
login="******",
email="*****@*****.**",
password="******",
)
self.users_list = [
self.test_user1, self.test_user2, self.test_user3, self.test_user4
]
import datetime
import pytz
self.date_created = self.date_updated = datetime.datetime.now(pytz.utc)
self.kwargs = {
"name": "Test Department",
"description": "This is a department 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
}
# create a default department object
self.test_department = Department(**self.kwargs)
def setUp(self):
"""lets setup the tests
"""
super(DepartmentDBTester, self).setUp()
from stalker import User
self.test_admin = User.query.filter_by(login="******").first()
# create a couple of test users
self.test_user1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
from stalker.db.session import DBSession
DBSession.add(self.test_user1)
self.test_user2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******",
)
DBSession.add(self.test_user2)
self.test_user3 = User(
name="User3",
login="******",
email="*****@*****.**",
password="******",
)
DBSession.add(self.test_user3)
self.test_user4 = User(
name="User4",
login="******",
email="*****@*****.**",
password="******",
)
DBSession.add(self.test_user4)
self.test_user5 = User(
name="User5",
login="******",
email="*****@*****.**",
password="******",
)
DBSession.add(self.test_user5)
self.users_list = [
self.test_user1, self.test_user2, self.test_user3, self.test_user4
]
import datetime
import pytz
self.date_created = self.date_updated = datetime.datetime.now(pytz.utc)
self.kwargs = {
"name": "Test Department",
"description": "This is a department 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
}
# create a default department object
self.test_department = Department(**self.kwargs)
DBSession.add(self.test_department)
DBSession.commit()
class DepartmentTester(unittest.TestCase):
"""tests the Department class
"""
def setUp(self):
"""lets setup the tests
"""
super(DepartmentTester, self).setUp()
from stalker import User
self.test_admin = User(
name='admin',
login='******',
email='*****@*****.**',
password='******',
)
# 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.test_user5 = User(
name="User5",
login="******",
email="*****@*****.**",
password="******",
)
self.users_list = [
self.test_user1, self.test_user2, self.test_user3, self.test_user4
]
import datetime
import pytz
self.date_created = self.date_updated = datetime.datetime.now(pytz.utc)
self.kwargs = {
"name": "Test Department",
"description": "This is a department 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
}
# create a default department object
self.test_department = Department(**self.kwargs)
def test___auto_name__class_attribute_is_set_to_false(self):
"""testing if the __auto_name__ class attribute is set to False for
Department class
"""
assert Department.__auto_name__ is False
def test___hash___value_is_correctly_calculated(self):
"""testing if the __hash__ value is correctly calculated
"""
assert self.test_department.__hash__() == \
hash(self.test_department.id) + \
2 * hash(self.test_department.name) + \
3 * hash(self.test_department.entity_type)
def test_users_argument_accepts_an_empty_list(self):
"""testing if users argument accepts an empty list
"""
# this should work without raising any error
self.kwargs["users"] = []
new_dep = Department(**self.kwargs)
assert isinstance(new_dep, Department)
def test_users_attribute_accepts_an_empty_list(self):
"""testing if users attribute accepts an empty list
"""
# this should work without raising any error
self.test_department.users = []
def test_users_argument_accepts_only_a_list_of_user_objects(self):
"""testing if users argument accepts only a list of user objects
"""
test_value = [1, 2.3, [], {}]
self.kwargs["users"] = test_value
# this should raise a TypeError
with pytest.raises(TypeError) as cm:
Department(**self.kwargs)
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not int'
def test_users_attribute_accepts_only_a_list_of_user_objects(self):
"""testing if users attribute accepts only a list of user objects
"""
test_value = [1, 2.3, [], {}]
# this should raise a TypeError
with pytest.raises(TypeError) as cm:
self.test_department.users = test_value
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not int'
def test_users_attribute_elements_accepts_User_only_1(self):
"""testing if a TypeError will be raised when trying to assign
something other than a User object to the users list
"""
# append
with pytest.raises(TypeError) as cm:
self.test_department.users.append(0)
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not int'
def test_users_attribute_elements_accepts_User_only_2(self):
"""testing if a TypeError will be raised when trying to assign
something other than a User object to the users list
"""
# __setitem__
with pytest.raises(TypeError) as cm:
self.test_department.users[0] = 0
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not int'
def test_users_argument_is_not_iterable(self):
"""testing if a TypeError will be raised when the given users
argument is not an instance of list
"""
self.kwargs["users"] = "a user"
with pytest.raises(TypeError) as cm:
Department(**self.kwargs)
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not str'
def test_users_attribute_is_not_iterable(self):
"""testing if a TypeError will be raised when the users attribute
is tried to be set to a non-iterable value
"""
with pytest.raises(TypeError) as cm:
self.test_department.users = "a user"
assert str(cm.value) == \
'DepartmentUser.user should be a stalker.models.auth.User ' \
'instance, not str'
def test_users_attribute_defaults_to_empty_list(self):
"""testing if the users attribute defaults to an empty list if the
users argument is skipped
"""
self.kwargs.pop("users")
new_department = Department(**self.kwargs)
assert new_department.users == []
def test_users_attribute_set_to_None(self):
"""testing if a TypeError will be raised when the users attribute is
set to None
"""
with pytest.raises(TypeError) as cm:
self.test_department.users = None
assert str(cm.value) == "'NoneType' object is not iterable"
def test_equality(self):
"""testing equality of two Department objects
"""
from stalker import Entity
dep1 = Department(**self.kwargs)
dep2 = Department(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Animation"
dep3 = Department(**self.kwargs)
assert dep1 == dep2
assert not dep1 == dep3
assert not dep1 == entity1
def test_inequality(self):
"""testing inequality of two Department objects
"""
from stalker import Entity
dep1 = Department(**self.kwargs)
dep2 = Department(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Animation"
dep3 = Department(**self.kwargs)
assert not dep1 != dep2
assert dep1 != dep3
assert dep1 != entity1
def setUp(self):
"""lets setup the tests
"""
db.setup() # uses in memory sqlite db
db.init()
self.test_admin = User.query.filter_by(login="******").first()
# create a couple of test users
self.test_user1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
db.DBSession.add(self.test_user1)
self.test_user2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******",
)
db.DBSession.add(self.test_user2)
self.test_user3 = User(
name="User3",
login="******",
email="*****@*****.**",
password="******",
)
db.DBSession.add(self.test_user3)
self.test_user4 = User(
name="User4",
login="******",
email="*****@*****.**",
password="******",
)
db.DBSession.add(self.test_user4)
self.test_user5 = User(
name="User5",
login="******",
email="*****@*****.**",
password="******",
)
db.DBSession.add(self.test_user5)
self.users_list = [
self.test_user1,
self.test_user2,
self.test_user3,
self.test_user4
]
self.date_created = self.date_updated = datetime.datetime.now()
self.kwargs = {
"name": "Test Department",
"description": "This is a department 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
}
# create a default department object
self.test_department = Department(**self.kwargs)
db.DBSession.add(self.test_department)
db.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',
code='TR',
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)
from stalker import db
db.setup({"sqlalchemy.url": "sqlite:///"})
db.init()
from stalker import Studio
my_studio = Studio(name='My Great Studio')
from stalker import User
me = User(name="Erkan Ozgur Yilmaz",
login="******",
email="*****@*****.**",
password="******",
description="This is me")
from stalker import Department
tds_department = Department(name="TDs",
description="This is the TDs department")
tds_department.users.append(me)
print(me.departments)
# you should get something like
# [<TDs (Department)>]
from stalker.db.session import DBSession
DBSession.add(my_studio)
DBSession.add(me)
DBSession.add(tds_department)
DBSession.commit()
all_departments = Department.query.all()
print(all_departments)
