def test_create_entity_missing_user_id(self):
"""testing if PUT: /api/vacations view with missing user_id parameter
"""
from stalker import db, User
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
db.DBSession.commit()
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
from stalker_pyramid.views import EntityViewBase
response = self.test_app.put(
'/api/vacations',
params={
'start': EntityViewBase.milliseconds_since_epoch(start),
'end': EntityViewBase.milliseconds_since_epoch(end),
},
status=500)
self.assertEqual(response.body,
'Server Error: Missing "user_id" parameter')
def test_create_entity_with_missing_user_id(self):
"""testing if create_entity() method is working properly with missing
user_id parameter
"""
from stalker import db, User
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
db.DBSession.commit()
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
from stalker_pyramid.views import EntityViewBase
request = DummyRequest()
request.params = DummyMultiDict()
request.params['start'] = \
EntityViewBase.milliseconds_since_epoch(start)
request.params['end'] = EntityViewBase.milliseconds_since_epoch(end)
vacation_views = vacation.VacationViews(request)
from pyramid.httpexceptions import HTTPServerError
with self.assertRaises(HTTPServerError) as cm:
vacation_views.create_entity()
self.assertEqual(str(cm.exception), 'Missing "user_id" parameter')
def test_get_entity_is_working_properly(self):
"""testing if GET /api/notes/{id} view is working properly
"""
from stalker import db, Note
test_note1 = Note(content='This is a test note', created_by=self.admin)
db.DBSession.add(test_note1)
db.DBSession.commit()
response = self.test_app.get('/api/notes/%s' % test_note1.id,
status=200)
import stalker
from stalker_pyramid.views import EntityViewBase
self.assertEqual(
response.json_body, {
'created_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': self.admin.entity_type
},
'content':
'This is a test note',
'date_created':
EntityViewBase.milliseconds_since_epoch(
test_note1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
test_note1.date_updated),
'description':
'This is a test note',
'entity_type':
'Note',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % test_note1.id,
'length': 0
},
'id':
test_note1.id,
'name':
test_note1.name,
'stalker_version':
stalker.__version__,
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': self.admin.entity_type
}
})
def test_create_entity_is_working_properly(self):
"""testing if PUT: /api/tags view is working properly
"""
self.admin_login()
response = self.test_app.put('/api/tags',
params={'name': 'Test Tag 1'},
status=201)
from stalker_pyramid.views import EntityViewBase
from stalker import Tag
new_tag = Tag.query.filter(Tag.name == 'Test Tag 1').first()
import stalker
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'
}
})
def test_get_entity(self):
"""testing if get_entity() method is working properly
"""
from stalker import db, Tag
tag1 = Tag(name='Test Tag 1')
db.DBSession.add(tag1)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = tag1.id
tag_view = tag.TagViews(request)
response = tag_view.get_entity()
from stalker_pyramid.views import EntityViewBase
import stalker
self.assertEqual(
response.json_body, {
'created_by':
None,
'date_created':
EntityViewBase.milliseconds_since_epoch(tag1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(tag1.date_updated),
'description':
'',
'entity_type':
'Tag',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' % tag1.id,
'length': 0
},
'generic_text':
'',
'id':
tag1.id,
'name':
'Test Tag 1',
'stalker_version':
stalker.__version__,
'thumbnail':
None,
'type':
None,
'updated_by':
None
})
def test_create_entity_missing_end(self):
"""testing if PUT: /api/vacations view with missing end parameter
"""
from stalker import db, User
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
db.DBSession.commit()
import datetime
start = datetime.datetime(2016, 4, 22, 10)
user1 = User.query.filter(User.login == user1.login).first()
from stalker_pyramid.views import EntityViewBase
self.admin_login()
response = self.test_app.put(
'/api/vacations',
params={
'user_id': user1.id,
'start': EntityViewBase.milliseconds_since_epoch(start)
},
status=500)
self.assertEqual(str(response.body),
'Server Error: Missing "end" parameter')
def test_update_entity_is_working_properly_with_post(self):
"""testing if POST: /api/time_logs/{id} view is working properly
"""
# create a time log
import datetime
start = datetime.datetime(2016, 7, 26, 16)
end = datetime.datetime(2016, 7, 26, 17)
new_end = datetime.datetime(2016, 7, 26, 18)
from stalker import db, TimeLog
db.DBSession.flush()
db.DBSession.commit()
t1 = TimeLog(task=self.test_task1,
resource=self.test_user1,
start=start,
end=end,
created_by=self.test_user2)
db.DBSession.add(t1)
db.DBSession.commit()
from stalker_pyramid.views import EntityViewBase
self.admin_login()
response = self.test_app.post(
'/api/time_logs/%s' % t1.id,
params={'end': EntityViewBase.milliseconds_since_epoch(new_end)},
status=200)
t1_db = TimeLog.query.filter(TimeLog.name == t1.name).first()
self.assertEqual(t1_db.end, new_end)
def test_update_entity_change_end_with_post(self):
"""testing POST: /api/vacations/{id}?end={value} is working properly
"""
from stalker import db, User, Vacation
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
new_end = datetime.datetime(2016, 4, 22, 17)
vac1 = Vacation(user=user1, start=start, end=end)
db.DBSession.commit()
user1 = User.query.filter(User.login == user1.login).first()
vac1 = Vacation.query.filter(Vacation.name == vac1.name).first()
from stalker_pyramid.views import EntityViewBase
self.admin_login()
self.test_app.patch(
'/api/vacations/%s' % vac1.id,
params={'end': EntityViewBase.milliseconds_since_epoch(new_end)},
status=200)
vac = Vacation.query.filter(Vacation.name == vac1.name).first()
self.assertEqual(vac.start, start)
self.assertEqual(vac.end, new_end)
self.assertEqual(vac.user, user1)
def test_create_entity_invalid_user_id(self):
"""testing if PUT: /api/vacations view with invalid user_id parameter
"""
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
from stalker_pyramid.views import EntityViewBase
response = self.test_app.put(
'/api/vacations',
params={
'user_id': -1,
'start': EntityViewBase.milliseconds_since_epoch(start),
'end': EntityViewBase.milliseconds_since_epoch(end)
},
status=500)
self.assertEqual(response.body,
'Server Error: Missing "user_id" parameter')
def test_get_entity(self):
"""testing if GET: /api/tags/{id} view is working properly
"""
from stalker import db, Tag
tag1 = Tag(name='Test Tag 1')
db.DBSession.add(tag1)
db.DBSession.commit()
response = self.test_app.get('/api/tags/%s' % tag1.id, status=200)
from stalker_pyramid.views import EntityViewBase
import stalker
self.assertEqual(
response.json_body, {
'created_by':
None,
'date_created':
EntityViewBase.milliseconds_since_epoch(tag1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(tag1.date_updated),
'description':
'',
'entity_type':
'Tag',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' % tag1.id,
'length': 0
},
'generic_text':
'',
'id':
tag1.id,
'name':
'Test Tag 1',
'stalker_version':
stalker.__version__,
'thumbnail':
None,
'type':
None,
'updated_by':
None
})
def test_create_entity_with_invalid_user_id(self):
"""testing if create_entity() method is working properly with invalid
user_id parameter
"""
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
from stalker_pyramid.views import EntityViewBase
request = DummyRequest()
request.params = DummyMultiDict()
request.params['user_id'] = -1
request.params['start'] = \
EntityViewBase.milliseconds_since_epoch(start)
request.params['end'] = EntityViewBase.milliseconds_since_epoch(end)
vacation_views = vacation.VacationViews(request)
from pyramid.httpexceptions import HTTPServerError
with self.assertRaises(HTTPServerError) as cm:
vacation_views.create_entity()
self.assertEqual(str(cm.exception), 'Missing "user_id" parameter')
def test_update_entity_change_end(self):
"""testing if update_entity() method is working properly for changing
end attribute
"""
from stalker import db, User, Vacation
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
new_end = datetime.datetime(2016, 4, 22, 17)
vac1 = Vacation(user=user1, start=start, end=end)
db.DBSession.commit()
user1 = User.query.filter(User.login == user1.login).first()
vac1 = Vacation.query.filter(Vacation.name == vac1.name).first()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = vac1.id
request.params = DummyMultiDict()
# change start
from stalker_pyramid.views import EntityViewBase
request.params['end'] = \
EntityViewBase.milliseconds_since_epoch(new_end)
self.patch_logged_in_user(request)
vacation_views = vacation.VacationViews(request)
vacation_views.update_entity()
vac = Vacation.query.filter(Vacation.name == vac1.name).first()
self.assertEqual(vac.start, start)
self.assertEqual(vac.end, new_end)
self.assertEqual(vac.user, user1)
def append_entities_to_entity(request):
"""Appends entities to entity for example appends Projects to user.projects
etc.
"""
logger.debug('append_class_to_entity is running')
entity_id = request.matchdict.get('id', -1)
from stalker import Entity
entity = Entity.query.filter_by(id=entity_id).first()
# selected_list = get_multi_integer(request, 'selected_items[]')
from stalker_pyramid.views import EntityViewBase
selected_list = EntityViewBase.get_multi_integer(request, 'selected_ids')
logger.debug('selected_list: %s' % selected_list)
if entity and selected_list:
appended_entities = Entity.query\
.filter(Entity.id.in_(selected_list)).all()
if appended_entities:
attr_name = appended_entities[0].plural_class_name.lower()
eval('entity.%(attr_name)s.extend(appended_entities)' %
{'attr_name': attr_name})
from stalker.db.session import DBSession
DBSession.add(entity)
logger.debug('entity is updated successfully')
request.session.flash(
'success:User <strong>%s</strong> is updated successfully' %
entity.name)
logger.debug('***append_entities_to_entity method ends ***')
else:
logger.debug('not all parameters are in request.params')
from pyramid.httpexceptions import HTTPServerError
HTTPServerError()
from pyramid.httpexceptions import HTTPOk
return HTTPOk()
def test_update_entity_is_working_properly(self):
"""testing if update_entity() method is working properly
"""
# create a time log
import datetime
start = datetime.datetime(2016, 7, 26, 16)
end = datetime.datetime(2016, 7, 26, 17)
new_end = datetime.datetime(2016, 7, 26, 18)
from stalker import db, TimeLog
db.DBSession.flush()
db.DBSession.commit()
t1 = TimeLog(task=self.test_task1,
resource=self.test_user1,
start=start,
end=end,
created_by=self.test_user2)
db.DBSession.add(t1)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = t1.id
request.params = DummyMultiDict()
from stalker_pyramid.views import EntityViewBase
request.params['end'] = \
EntityViewBase.milliseconds_since_epoch(new_end)
self.patch_logged_in_user(request)
time_log_view = time_log.TimeLogViews(request)
response = time_log_view.update_entity()
t1_db = TimeLog.query.filter(TimeLog.name == t1.name).first()
self.assertEqual(t1_db.end, new_end)
def test_get_entity_is_working_properly(self):
"""testing if GET: /api/groups/{id} view is working properly
"""
response = self.test_app.get(
'/api/groups/%s' % self.test_group1.id,
status=200
)
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body,
{
'created_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
self.test_group1.date_created
),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
self.test_group1.date_updated
),
'description': '',
'entity_type': 'Group',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' %
self.test_group1.id,
'length': 0
},
'generic_text': '',
'id': self.test_group1.id,
'name': 'Test Group',
'notes': {
'$ref': '/api/entities/%s/notes' % self.test_group1.id,
'length': 0
},
'permissions': [
'Allow_Create_User',
'Allow_Read_User',
'Allow_Update_User',
'Deny_Delete_User'
],
'stalker_version': stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % self.test_group1.id,
'length': 0
},
'thumbnail': None,
'type': None,
'updated_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'users': {
'$ref': '/api/groups/%s/users' % self.test_group1.id,
'length': 2
}
}
)
def test_get_entity_is_working_properly(self):
"""testing if get_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = self.test_repo1.id
repo_view = repository.RepositoryViews(request)
response = repo_view.get_entity()
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'name': 'admin',
'id': 3,
'entity_type': 'User',
'$ref': '/api/users/3'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
self.test_repo1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
self.test_repo1.date_updated),
'description':
'',
'entity_type':
'Repository',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' %
self.test_repo1.id,
'length':
0
},
'id':
self.test_repo1.id,
'linux_path':
self.test_repo1.linux_path,
'name':
'Test Repo 1',
'notes': {
'$ref': '/api/entities/%s/notes' % self.test_repo1.id,
'length': 0
},
'osx_path':
self.test_repo1.osx_path,
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % self.test_repo1.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'name': 'admin',
'id': 3,
'entity_type': 'User',
'$ref': '/api/users/3'
},
'windows_path':
self.test_repo1.windows_path,
})
def test_create_entity_is_working_properly(self):
"""testing if PUT: /api/repositories view is working properly
"""
self.admin_login()
response = self.test_app.put('/api/repositories',
params={
'name': 'New Repository',
'windows_path': 'T:/new/repo/',
'linux_path': '/mnt/T/new/repo/',
'osx_path': '/Volumes/T/new/repo/',
'description':
'this is a new test repo',
'created_by_id': 3,
},
status=201)
from stalker import Repository
repo_db = Repository.query\
.filter(Repository.name == 'New Repository')\
.first()
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'name': 'admin',
'id': 3,
'entity_type': 'User',
'$ref': '/api/users/3'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(repo_db.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(repo_db.date_updated),
'description':
'this is a new test repo',
'entity_type':
'Repository',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % repo_db.id,
'length': 0
},
'id':
repo_db.id,
'linux_path':
'/mnt/T/new/repo/',
'name':
'New Repository',
'notes': {
'$ref': '/api/entities/%s/notes' % repo_db.id,
'length': 0
},
'osx_path':
'/Volumes/T/new/repo/',
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % repo_db.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'name': 'admin',
'id': 3,
'entity_type': 'User',
'$ref': '/api/users/3'
},
'windows_path':
'T:/new/repo/',
})
def test_create_entity_is_working_properly(self):
"""testing if PUT: /api/vacations view is working properly
"""
from stalker import db, User, Vacation
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
db.DBSession.commit()
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
user1 = User.query.filter(User.login == user1.login).first()
from stalker_pyramid.views import EntityViewBase
self.admin_login()
response = self.test_app.put(
'/api/vacations',
params={
'user_id': user1.id,
'start': EntityViewBase.milliseconds_since_epoch(start),
'end': EntityViewBase.milliseconds_since_epoch(end),
},
status=201)
vac = Vacation.query.filter(Vacation.user == user1).first()
self.assertEqual(vac.start, start)
self.assertEqual(vac.end, end)
self.assertEqual(vac.user, user1)
import stalker
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(vac.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(vac.date_created),
'description':
'',
'end':
EntityViewBase.milliseconds_since_epoch(vac.end),
'entity_type':
'Vacation',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' % vac.id,
'length': 0
},
'generic_text':
'',
'id':
vac.id,
'name':
vac.name,
'stalker_version':
stalker.__version__,
'start':
EntityViewBase.milliseconds_since_epoch(vac.start),
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'user': {
'id': vac.user_id,
'$ref': '/api/users/%s' % vac.user_id,
'name': vac.user.name,
'entity_type': 'User'
}
})
def test_create_entity_method_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 Type'
request.params['code'] = 'TT'
request.params['target_entity_type'] = 'Project'
request.params['description'] = 'A test type'
request.params['created_by_id'] = self.admin.id
type_view = type.TypeViews(request)
response = type_view.create_entity()
from stalker import Type
test_type = Type.query.filter(Type.name == 'Test Type').first()
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body, {
'code':
'TT',
'created_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
test_type.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
test_type.date_updated),
'description':
'A test type',
'entity_type':
'Type',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % test_type.id,
'length': 0
},
'id':
test_type.id,
'name':
'Test Type',
'notes': {
'$ref': '/api/entities/%s/notes' % test_type.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % test_type.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
})
def test_get_entity_method_is_working_properly(self):
"""testing if the get_entity() method is working properly
"""
from stalker import db, Type
test_type = Type(name='Test Type',
code='TT',
description='A test type',
target_entity_type='Project',
created_by=self.admin)
db.DBSession.add(test_type)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_type.id
type_view = type.TypeViews(request)
response = type_view.get_entity()
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body, {
'code':
'TT',
'created_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
test_type.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
test_type.date_updated),
'description':
'A test type',
'entity_type':
'Type',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % test_type.id,
'length': 0
},
'id':
test_type.id,
'name':
'Test Type',
'notes': {
'$ref': '/api/entities/%s/notes' % test_type.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % test_type.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': self.admin.entity_type
},
})
def test_get_entity_is_working_properly(self):
"""test if GET: /api/vacation/{id} view is working properly
"""
# login as admin
self.admin_login()
# create a vacation instance
from stalker import db, User, Vacation
user = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user)
admin = User.query.filter(User.login == 'admin').first()
import datetime
vac = Vacation(user=user,
start=datetime.datetime(2016, 4, 22, 10, 0),
end=datetime.datetime(2016, 4, 24, 10, 0),
created_by=admin)
db.DBSession.add(vac)
db.DBSession.commit()
response = self.test_app.get('/api/vacations/%s' % vac.id)
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
import stalker
self.assertEqual(
response.json, {
'created_by': {
'id': admin.id,
'$ref': '/api/users/%s' % admin.id,
'name': admin.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(vac.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(vac.date_created),
'description':
'',
'end':
EntityViewBase.milliseconds_since_epoch(vac.end),
'entity_type':
'Vacation',
'id':
vac.id,
'generic_text':
'',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' % vac.id,
'length': 0
},
'name':
vac.name,
'stalker_version':
stalker.__version__,
'start':
EntityViewBase.milliseconds_since_epoch(vac.start),
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': admin.id,
'$ref': '/api/users/%s' % admin.id,
'name': admin.name,
'entity_type': 'User'
},
'user': {
'id': vac.user_id,
'$ref': '/api/users/%s' % vac.user_id,
'name': vac.user.name,
'entity_type': 'User'
}
})
def test_create_entity_method_is_working_properly(self):
"""testing if the PUT: /api/types is working properly
"""
self.admin_login()
response = self.test_app.put(
'/api/types',
params={
'name': 'Test Type',
'code': 'TT',
'target_entity_type': 'Project',
'description': 'A test type',
},
status=201,
)
from stalker import Type
test_type = Type.query.filter(Type.name == 'Test Type').first()
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body, {
'code':
'TT',
'created_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
test_type.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
test_type.date_updated),
'description':
'A test type',
'entity_type':
'Type',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % test_type.id,
'length': 0
},
'id':
test_type.id,
'name':
'Test Type',
'notes': {
'$ref': '/api/entities/%s/notes' % test_type.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % test_type.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
})
def test_create_entity_is_working_properly(self):
"""testing if create_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.params = DummyMultiDict()
request.params['name'] = 'New Group'
request.params['description'] = 'This is a new test group'
request.params['user_id'] = [self.test_user1.id, self.test_user3.id]
request.params['permission'] = \
['%s_%s_%s' % (p.access, p.action, p.class_name)
for p in self.all_permissions[4:10]]
request.params['created_by_id'] = self.test_user2.id
group_view = group.GroupViews(request)
response = group_view.create_entity()
# get the new group from db
import stalker
from stalker import Group
from stalker_pyramid.views import EntityViewBase
new_group = Group.query.filter(Group.name == 'New Group').first()
self.maxDiff = None
self.assertEqual(
response.json_body,
{
'created_by': {
'id': self.test_user2.id,
'$ref': '/api/users/%s' % self.test_user2.id,
'name': self.test_user2.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(new_group.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(new_group.date_updated),
'description': 'This is a new test group',
'entity_type': 'Group',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' %
new_group.id,
'length': 0
},
'generic_text': '',
'id': new_group.id,
'name': 'New Group',
'notes': {
'$ref': '/api/entities/%s/notes' % new_group.id,
'length': 0
},
'permissions': [
'%s_%s_%s' % (p.access, p.action, p.class_name)
for p in self.all_permissions[4:10]
],
'stalker_version': stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % new_group.id,
'length': 0
},
'thumbnail': None,
'type': None,
'updated_by': {
'id': self.test_user2.id,
'$ref': '/api/users/%s' % self.test_user2.id,
'name': self.test_user2.name,
'entity_type': 'User'
},
'users': {
'$ref': '/api/groups/%s/users' % new_group.id,
'length': 2
}
}
)
def test_get_entity_is_working_properly(self):
"""testing if get_entity() method is working properly
"""
from stalker import db, User, Vacation
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
import datetime
start = datetime.datetime(2016, 4, 22)
end = datetime.datetime(2016, 4, 23)
# get admin
admin = User.query.filter(User.login == 'admin').first()
vac1 = Vacation(
user=user1,
start=start,
end=end,
created_by=admin,
)
db.DBSession.add(vac1)
db.DBSession.commit()
# get the id
vac1 = Vacation.query.filter(Vacation.name == vac1.name).first()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = vac1.id
vacation_views = vacation.VacationViews(request)
response = vacation_views.get_entity()
from stalker_pyramid.views import EntityViewBase
import stalker
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': vac1.created_by.id,
'$ref': '/api/users/%s' % vac1.created_by.id,
'name': vac1.created_by.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(vac1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(vac1.date_updated),
'description':
'',
'end':
EntityViewBase.milliseconds_since_epoch(vac1.end),
'entity_type':
'Vacation',
'generic_text':
'',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' % vac1.id,
'length': 0
},
'id':
vac1.id,
'name':
vac1.name,
'stalker_version':
stalker.__version__,
'start':
EntityViewBase.milliseconds_since_epoch(vac1.start),
'thumbnail':
None,
'type':
None,
'user': {
'id': vac1.user.id,
'$ref': '/api/users/%s' % vac1.user.id,
'name': vac1.user.name,
'entity_type': 'User'
},
'updated_by': {
'id': vac1.updated_by.id,
'$ref': '/api/users/%s' % vac1.updated_by.id,
'name': vac1.updated_by.name,
'entity_type': 'User'
},
})
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'] = 'New Department'
request.params['description'] = 'New department description'
request.params['user_id'] = [self.test_user1.id, self.test_user2.id]
department_view = department.DepartmentViews(request)
print('code is here 1')
self.patch_logged_in_user(request)
print('code is here 2')
response = department_view.create_entity()
print('code is here 3')
from stalker import Department
new_dep = Department.query\
.filter(Department.name == 'New Department')\
.first()
from stalker_pyramid.views import EntityViewBase
import stalker
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(new_dep.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(new_dep.date_updated),
'description':
'New department description',
'entity_type':
'Department',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % new_dep.id,
'length': 0
},
'id':
new_dep.id,
'name':
'New Department',
'notes': {
'$ref': '/api/entities/%s/notes' % new_dep.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % new_dep.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'user_roles': {
'$ref': '/api/departments/%s/user_roles' % new_dep.id,
'length': 2
},
'users': {
'$ref': '/api/departments/%s/users' % new_dep.id,
'length': 2
},
})
def test_get_entity_is_working_properly(self):
"""testing if the GET: /api/departments/{id} view is working properly
"""
response = self.test_app.get('/api/departments/%s' %
self.test_department1.id,
status=200)
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
self.test_department1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
self.test_department1.date_updated),
'description':
'',
'entity_type':
'Department',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' %
self.test_department1.id,
'length':
0
},
'id':
self.test_department1.id,
'name':
'Test Department 1',
'notes': {
'$ref':
'/api/entities/%s/notes' % self.test_department1.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % self.test_department1.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'user_roles': {
'$ref':
'/api/departments/%s/user_roles' %
self.test_department1.id,
'length':
0
},
'users': {
'$ref':
'/api/departments/%s/users' % self.test_department1.id,
'length': 0
},
})
def test_get_entity_is_working_properly(self):
"""testing if the get_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = self.test_department1.id
department_view = department.DepartmentViews(request)
response = department_view.get_entity()
import stalker
from stalker_pyramid.views import EntityViewBase
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
self.test_department1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
self.test_department1.date_updated),
'description':
'',
'entity_type':
'Department',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' %
self.test_department1.id,
'length':
0
},
'id':
self.test_department1.id,
'name':
'Test Department 1',
'notes': {
'$ref':
'/api/entities/%s/notes' % self.test_department1.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % self.test_department1.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'user_roles': {
'$ref':
'/api/departments/%s/user_roles' %
self.test_department1.id,
'length':
0
},
'users': {
'$ref':
'/api/departments/%s/users' % self.test_department1.id,
'length': 0
},
})
def test_create_entity_is_working_properly(self):
"""testing if PUT: /api/groups view is working properly
"""
self.admin_login()
response = self.test_app.put(
'/api/groups',
params={
'name': 'New Group',
'description': 'This is a new test group',
'user_id': [self.test_user1.id, self.test_user3.id],
'permission':[
'%s_%s_%s' % (p.access, p.action, p.class_name)
for p in self.all_permissions[4:10]
],
'created_by_id': self.test_user2.id
},
status=201
)
# get the new group from db
import stalker
from stalker import Group
from stalker_pyramid.views import EntityViewBase
new_group = Group.query.filter(Group.name == 'New Group').first()
self.maxDiff = None
self.assertEqual(
response.json_body,
{
'created_by': {
'id': self.test_user2.id,
'$ref': '/api/users/%s' % self.test_user2.id,
'name': self.test_user2.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(
new_group.date_created
),
'date_updated':
EntityViewBase.milliseconds_since_epoch(
new_group.date_updated
),
'description': 'This is a new test group',
'entity_type': 'Group',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' %
new_group.id,
'length': 0
},
'generic_text': '',
'id': new_group.id,
'name': 'New Group',
'notes': {
'$ref': '/api/entities/%s/notes' % new_group.id,
'length': 0
},
'permissions': [
'%s_%s_%s' % (p.access, p.action, p.class_name)
for p in self.all_permissions[4:10]
],
'stalker_version': stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % new_group.id,
'length': 0
},
'thumbnail': None,
'type': None,
'updated_by': {
'id': self.test_user2.id,
'$ref': '/api/users/%s' % self.test_user2.id,
'name': self.test_user2.name,
'entity_type': 'User'
},
'users': {
'$ref': '/api/groups/%s/users' % new_group.id,
'length': 2
}
}
)
def test_create_entity_is_working_properly(self):
"""testing if the PUT: /api/departments view is working properly
"""
self.admin_login()
response = self.test_app.put(
'/api/departments',
params={
'name': 'New Department',
'description': 'New department description',
'user_id': [self.test_user1.id, self.test_user2.id],
},
status=201)
from stalker import Department
new_dep = Department.query\
.filter(Department.name == 'New Department')\
.first()
from stalker_pyramid.views import EntityViewBase
import stalker
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(new_dep.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(new_dep.date_updated),
'description':
'New department description',
'entity_type':
'Department',
'generic_text':
'',
'generic_data': {
'$ref':
'/api/simple_entities/%s/generic_data' % new_dep.id,
'length': 0
},
'id':
new_dep.id,
'name':
'New Department',
'notes': {
'$ref': '/api/entities/%s/notes' % new_dep.id,
'length': 0
},
'stalker_version':
stalker.__version__,
'tags': {
'$ref': '/api/entities/%s/tags' % new_dep.id,
'length': 0
},
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'name': 'admin',
'$ref': '/api/users/%s' % self.admin.id,
'entity_type': 'User'
},
'user_roles': {
'$ref': '/api/departments/%s/user_roles' % new_dep.id,
'length': 2
},
'users': {
'$ref': '/api/departments/%s/users' % new_dep.id,
'length': 2
},
})
def test_create_entity_is_working_properly(self):
"""testing if create_entity() method is working properly
"""
from stalker import db, User, Vacation
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
db.DBSession.flush()
import transaction
transaction.commit()
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
user1 = User.query.filter(User.login == user1.login).first()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
from stalker_pyramid.views import EntityViewBase
request = DummyRequest()
request.params = DummyMultiDict()
request.params['user_id'] = user1.id
request.params['start'] = \
EntityViewBase.milliseconds_since_epoch(start)
request.params['end'] = EntityViewBase.milliseconds_since_epoch(end)
self.patch_logged_in_user(request)
vacation_views = vacation.VacationViews(request)
response = vacation_views.create_entity()
vac = Vacation.query.filter(Vacation.user == user1).first()
self.assertEqual(vac.start, start)
self.assertEqual(vac.end, end)
self.assertEqual(vac.user, user1)
import stalker
self.maxDiff = None
self.assertEqual(
response.json_body, {
'created_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'date_created':
EntityViewBase.milliseconds_since_epoch(vac.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(vac.date_created),
'description':
'',
'end':
EntityViewBase.milliseconds_since_epoch(vac.end),
'entity_type':
'Vacation',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' % vac.id,
'length': 0
},
'generic_text':
'',
'id':
vac.id,
'name':
vac.name,
'stalker_version':
stalker.__version__,
'start':
EntityViewBase.milliseconds_since_epoch(vac.start),
'thumbnail':
None,
'type':
None,
'updated_by': {
'id': self.admin.id,
'$ref': '/api/users/%s' % self.admin.id,
'name': self.admin.name,
'entity_type': 'User'
},
'user': {
'id': vac.user_id,
'$ref': '/api/users/%s' % vac.user_id,
'name': vac.user.name,
'entity_type': 'User'
}
})
