def test_update_users_is_working_properly_with_post(self):
"""testing if update_users() method is working properly with POST
"""
from stalker import db
# add some users first to see if patching works
self.test_department1.users = [self.test_user1]
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_department1.id
request.params = DummyMultiDict()
request.method = 'POST'
request.params['user_id'] = [self.test_user2.id, self.test_user3.id]
department_view = department.DepartmentViews(request)
response = department_view.update_users()
from stalker import Department
test_dep_db = Department.query\
.filter(Department.id == self.test_department1.id)\
.first()
self.assertEqual(sorted(test_dep_db.users),
sorted([self.test_user2, self.test_user3]))
def test_remove_tags_is_working_properly_with_non_existing_tags(self):
"""testing if the remove_tags() method is working properly
"""
# create some tags
from stalker import db, Tag
t1 = Tag(name='tag1')
t2 = Tag(name='tag2')
t3 = Tag(name='tag3')
from stalker import Entity
test_entity = Entity(name='Test Entity', tags=[t1, t2])
db.DBSession.add_all([t1, t2, t3, test_entity])
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.method = 'DELETE'
request.matchdict['id'] = test_entity.id
request.params = DummyMultiDict()
request.params['tag'] = ['tag3']
request.POST = request.params
entity_view = entity.EntityViews(request)
entity_view.remove_tags()
# now query entity tags
test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
response = [t.name for t in test_entity.tags]
expected = ['tag1', 'tag2']
self.assertEqual(sorted(response), sorted(expected))
def test_update_entity_is_working_properly(self):
"""testing if update_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_structure1.id
request.method = 'POST'
request.params = DummyMultiDict()
request.params['name'] = 'New Structure Name'
request.params['description'] = 'New description'
request.params['custom_template'] = 'New custom template code'
request.params['template_id'] = [
self.test_filename_template2.id, self.test_filename_template3.id
]
structure_view = structure.StructureViews(request)
self.patch_logged_in_user(request)
response = structure_view.update_entity()
from stalker import Structure
structure_db = Structure.query.get(self.test_structure1.id)
self.assertEqual(structure_db.name, 'New Structure Name')
self.assertEqual(structure_db.description, 'New description')
self.assertEqual(structure_db.custom_template,
'New custom template code')
self.assertEqual(
sorted(structure_db.templates),
sorted(
[self.test_filename_template2, self.test_filename_template3]))
def test_update_tags_is_working_properly_with_post(self):
"""testing if the update_tags() view is working properly when the
request.method is POST
"""
# create some tags
from stalker import db, Tag
t1 = Tag(name='tag1')
t2 = Tag(name='tag2')
t3 = Tag(name='tag3')
db.DBSession.add_all([t1, t2, t3])
from stalker import Entity
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_entity.id
request.method = 'POST'
request.params = DummyMultiDict()
request.params['tag'] = ['tag1', 'tag2']
request.POST = request.params
entity_view = entity.EntityViews(request)
entity_view.update_tags()
# now query entity tags
test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
self.assertEqual(sorted([t.name for t in test_entity.tags]),
sorted(['tag1', 'tag2']))
def test_update_entity_is_working_properly_with_patch(self):
"""testing if update_entity() method is working properly with PATCH
"""
from stalker import db, Tag
new_tag = Tag(name='Test Tag 1')
db.DBSession.add(new_tag)
db.DBSession.flush()
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = new_tag.id
self.patch_logged_in_user(request)
request.params = DummyMultiDict()
request.params['name'] = 'New Tag Name'
request.params['description'] = 'This also should be updated'
request.method = 'PATCH'
tag_view = tag.TagViews(request)
tag_view.update_entity()
new_tag_db = Tag.query.get(new_tag.id)
self.assertEqual(new_tag_db.name, 'New Tag Name')
self.assertEqual(new_tag_db.description, 'This also should be updated')
self.assertEqual(new_tag_db.updated_by, self.admin)
def test_entity_notes_is_working_properly(self):
"""testing if get_notes is working properly
"""
from stalker import db, Entity, Note
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
# Note 1
test_note1 = Note(content='Note 1')
db.DBSession.add(test_note1)
# Note 2
test_note2 = Note(content='Note 2')
db.DBSession.add(test_note2)
# Note 3
test_note3 = Note(content='Note 3')
db.DBSession.add(test_note3)
# dummy Note 4
test_note4 = Note(content='Note 4')
db.DBSession.add(test_note4)
test_entity.notes = [test_note1, test_note2, test_note3]
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_entity.id
request.method = 'GET'
entity_view = entity.EntityViews(request)
response = entity_view.get_notes()
self.assertEqual(
sorted(response.json_body),
sorted([
{
'id': test_note1.id,
'$ref': '/api/notes/%s' % test_note1.id,
'name': test_note1.name,
'entity_type': 'Note'
},
{
'id': test_note2.id,
'$ref': '/api/notes/%s' % test_note2.id,
'name': test_note2.name,
'entity_type': 'Note'
},
{
'id': test_note3.id,
'$ref': '/api/notes/%s' % test_note3.id,
'name': test_note3.name,
'entity_type': 'Note'
},
]))
def test_update_notes_is_working_properly_with_patch(self):
"""testing if update_notes is working properly when the request method
is PATCH
"""
from stalker import db, Entity, Note
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
# Note 1
test_note1 = Note(content='Note 1')
db.DBSession.add(test_note1)
# Note 2
test_note2 = Note(content='Note 2')
db.DBSession.add(test_note2)
# Note 3
test_note3 = Note(content='Note 3')
db.DBSession.add(test_note3)
# Note 4
test_note4 = Note(content='Note 4')
db.DBSession.add(test_note4)
# Note 5
test_note5 = Note(content='Note 5')
db.DBSession.add(test_note5)
test_entity.notes = [test_note1, test_note2, test_note3]
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_entity.id
request.method = 'PATCH'
# add the 4th and 5th notes
request.params = DummyMultiDict()
request.params['note_id'] = [test_note4.id, test_note5.id]
request.POST = request.params
entity_view = entity.EntityViews(request)
entity_view.update_notes()
test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
self.assertEqual(
sorted(test_entity.notes),
sorted(
[test_note1, test_note2, test_note3, test_note4, test_note5]))
def test_update_user_roles_is_working_properly_with_non_related_user(self):
"""testing if update_user_roles() method is working properly with non
related user
"""
from stalker import db, DepartmentUser
# create a role for the user
du1 = DepartmentUser(department=self.test_department1,
user=self.test_user1,
role=self.test_role1)
db.DBSession.add(du1)
db.DBSession.commit()
du2 = DepartmentUser(department=self.test_department1,
user=self.test_user2,
role=self.test_role1)
db.DBSession.add(du2)
db.DBSession.commit()
# now update the user role to something new
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_department1.id
request.method = 'POST'
request.params = DummyMultiDict()
request.params['user_role'] = [
'%s,%s' % (self.test_user1.id, self.test_role2.id),
'%s,%s' % (self.test_user2.id, self.test_role3.id),
'%s,%s' % (self.test_user3.id, self.test_role1.id)
]
department_view = department.DepartmentViews(request)
department_view.update_user_role()
du1_db = DepartmentUser.query\
.filter(DepartmentUser.department == self.test_department1)\
.filter(DepartmentUser.user == self.test_user1)\
.first()
du2_db = DepartmentUser.query\
.filter(DepartmentUser.department == self.test_department1)\
.filter(DepartmentUser.user == self.test_user2)\
.first()
self.assertEqual(du1_db.role, self.test_role2)
self.assertEqual(du2_db.role, self.test_role3)
def test_update_templates_is_working_properly_with_post(self):
"""testing if update_templates() method is working properly with post
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_structure1.id
request.params = DummyMultiDict()
request.params['template_id'] = \
[self.test_filename_template3.id]
request.method = 'POST'
structure_view = structure.StructureViews(request)
response = structure_view.update_templates()
from stalker import Structure
structure_db = Structure.query.get(self.test_structure1.id)
self.assertEqual(sorted(structure_db.templates),
sorted([self.test_filename_template3]))
def test_remove_user_roles_is_working_properly(self):
"""testing if remove_user_roles() method is working properly
"""
from stalker import db, DepartmentUser
# create a role for the user
du1 = DepartmentUser(department=self.test_department1,
user=self.test_user1,
role=self.test_role1)
db.DBSession.add(du1)
db.DBSession.commit()
du2 = DepartmentUser(department=self.test_department1,
user=self.test_user2,
role=self.test_role1)
db.DBSession.add(du2)
db.DBSession.commit()
# now update the user role to something new
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_department1.id
request.method = 'POST'
request.params = DummyMultiDict()
request.params['user_id'] = [self.test_user1.id, self.test_user2.id]
department_view = department.DepartmentViews(request)
department_view.remove_user_role()
du1_db = DepartmentUser.query\
.filter(DepartmentUser.department == self.test_department1)\
.filter(DepartmentUser.user == self.test_user1)\
.first()
du2_db = DepartmentUser.query\
.filter(DepartmentUser.department == self.test_department1)\
.filter(DepartmentUser.user == self.test_user2)\
.first()
self.assertIsNone(du1_db.role)
self.assertIsNone(du2_db.role)
def test_update_statuses_is_working_properly_with_patch(self):
"""testing if update_statuses() method is working properly when the
request method is PATCH
"""
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='Test Status List',
target_entity_type='Project',
statuses=[test_status1, test_status2, test_status3, test_status4])
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, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_status_list.id
self.patch_logged_in_user(request)
request.params = DummyMultiDict()
request.params['status_id'] = [test_status5.id]
request.method = 'PATCH'
status_list_view = status.StatusListViews(request)
response = status_list_view.update_statuses()
self.maxDiff = None
self.assertEqual(
sorted(test_status_list.statuses),
sorted([
test_status1, test_status2, test_status3, test_status4,
test_status5
]))
def test_update_users_is_working_properly_with_post(self):
"""testing if update_users() method is working properly with request
method is post
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_group1.id
request.params = DummyMultiDict()
request.params['user_id'] = [self.test_user2.id, self.test_user3.id]
request.method = 'POST'
group_view = group.GroupViews(request)
response = group_view.update_users()
from stalker import Group
test_group1_db = Group.query.get(self.test_group1.id)
self.assertEqual(
sorted(test_group1_db.users),
sorted([self.test_user2, self.test_user3])
)
def test_update_entity_is_working_properly_with_post(self):
"""testing if the update_entity() method is working properly when the
request method is POST
"""
from stalker import db, Entity, User
test_user_1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(test_user_1)
test_user_2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(test_user_2)
test_entity = Entity(name='Test Entity', created_by=test_user_1)
db.DBSession.add(test_entity)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.method = 'POST'
request.matchdict['id'] = test_entity.id
request.params = DummyMultiDict()
request.params['name'] = 'New Entity Name'
request.params['description'] = 'New Description'
request.params['updated_by_id'] = test_user_2.id
self.patch_logged_in_user(request)
entity_view = entity.EntityViews(request)
entity_view.update_entity()
test_entity_db = Entity.query.get(test_entity.id)
self.assertEqual(test_entity_db.name, 'New Entity Name')
self.assertEqual(test_entity_db.description, 'New Description')
self.assertEqual(test_entity_db.updated_by, test_user_2)
def test_create_entity_is_working_properly(self):
"""testing if the create_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.params = DummyMultiDict()
request.params['name'] = 'Test Tag 1'
request.method = 'PUT'
# patch get_logged_in_user
self.patch_logged_in_user(request)
tag_view = tag.TagViews(request)
response = tag_view.create_entity()
from stalker_pyramid.views import EntityViewBase
from stalker import Tag
new_tag = Tag.query.filter(Tag.name == 'Test Tag 1').first()
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(new_tag.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(new_tag.date_updated),
'description':
'',
'entity_type':
'Tag',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % new_tag.id,
'length': 0
},
'generic_text':
'',
'id':
new_tag.id,
'name':
'Test Tag 1',
'stalker_version':
stalker.__version__,
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': 3,
'$ref': '/api/users/3',
'name': 'admin',
'entity_type': 'User'
}
})
