def test_update_entity_is_working_properly_with_post(self):
"""testing if POST: /api/entities/{id} is working properly
"""
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()
self.test_app.post('/api/entities/%s' % test_entity.id,
params={
'name': 'New Entity Name',
'description': 'New Description',
'updated_by_id': test_user_2.id
},
status=200)
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 setUp(self):
"""setup the test
"""
# create a resource
self.test_resource1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
self.test_resource2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******"
)
self.test_repo = Repository(name="test repository")
# create a Project
self.test_status1 = Status(name="Status1", code="STS1")
self.test_status2 = Status(name="Status2", code="STS2")
self.test_status3 = Status(name="Status3", code="STS3")
self.test_project_status_list = StatusList(
name="Project Statuses",
statuses=[self.test_status1],
target_entity_type=Project
)
self.test_task_status_list = StatusList.query\
.filter_by(target_entity_type='Task').first()
self.test_project = Project(
name="test project",
code='tp',
repository=self.test_repo,
status_list=self.test_project_status_list
)
# create a Task
self.test_task = Task(
name="test task",
project=self.test_project,
status_list=self.test_task_status_list
)
self.kwargs = {
"task": self.test_task,
"resource": self.test_resource1,
"start": datetime.datetime(2013, 3, 22, 1, 0),
"duration": datetime.timedelta(10)
}
# create a TimeLog
# and test it
self.test_time_log = TimeLog(**self.kwargs)
def setUp(self):
"""set the test up
"""
super(AuthenticationLogTestCase, self).setUp()
from stalker import User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
self.test_user2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
def test_authenticate_updates_user_password_if_stalker_fails_but_ldap_successes(ldap_server, create_db, monkeypatch):
"""testing if the anima.utils.authenticate() will update the user password
if stalker fails but ldap doesn't fail and the user exists
"""
from ldap3.extend import StandardExtendedOperations
def mock_return(*arg, **kwargs):
return "pipeline"
monkeypatch.setattr(StandardExtendedOperations, "who_am_i", mock_return)
# This is not working with mock server
login = '******'
ldap_password = '******'
stalker_password = '******'
# create a user in Stalker with a different password
from stalker import User
from stalker.db.session import DBSession
new_user = User(login=login, password=stalker_password, email='*****@*****.**', name='Pipeline')
DBSession.add(new_user)
DBSession.commit()
assert new_user.check_password(ldap_password) is False
assert new_user.check_password(stalker_password) is True
# now authenticate with the new password
from anima.utils import authenticate
result = authenticate(login, ldap_password)
# result should be True
assert result is True
# and the password should be updated
pipeline_user = User.query.filter(User.login==login).first()
assert pipeline_user is not None
assert new_user.check_password(ldap_password) is True
assert new_user.check_password(stalker_password) is False
def setUp(self):
"""setup the test
"""
super(VacationTestCase, self).setUp()
# create a user
from stalker import User
self.test_user = User(
name='Test User',
login='******',
email='*****@*****.**',
password='******',
)
# vacation type
from stalker import Type
self.personal_vacation = Type(name='Personal',
code='PERS',
target_entity_type='Vacation')
self.studio_vacation = Type(name='Studio Wide',
code='STD',
target_entity_type='Vacation')
import datetime
import pytz
self.kwargs = {
'user': self.test_user,
'type': self.personal_vacation,
'start': datetime.datetime(2013, 6, 6, 10, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2013, 6, 10, 19, 0, tzinfo=pytz.utc)
}
self.test_vacation = Vacation(**self.kwargs)
def setUp(self):
"""set the test up
"""
super(ProjectClientTestDBCase, self).setUp()
from stalker import Status, Repository
self.test_repo = Repository(name='Test Repo')
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 User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
from stalker import Client
self.test_client = Client(name='Test Client')
from stalker import Project
self.test_project = Project(
name='Test Project 1',
code='TP1',
repositories=[self.test_repo],
)
from stalker import Role
self.test_role = Role(name='Test Client')
def test_update_entity_is_working_properly(self):
"""testing if update_note is working properly
"""
from stalker import db, Note, User
test_user = User(name='Test User',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(test_user)
note1 = Note(content='This is a test note')
db.DBSession.add(note1)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = note1.id
request.params = DummyMultiDict()
request.params['content'] = 'this is the new content'
request.params['updated_by_id'] = test_user.id
note_view = note.NoteViews(request)
note_view.update_entity()
note1 = Note.query.first()
self.assertEqual(note1.content, 'this is the new content')
self.assertEqual(note1.updated_by, test_user)
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 setUp(self):
"""setup the test
"""
# create a user
self.test_user = User(
name='Test User',
login='******',
email='*****@*****.**',
password='******',
)
# vacation type
self.personal_vacation = Type(
name='Personal',
code='PERS',
target_entity_type='Vacation'
)
self.studio_vacation = Type(
name='Studio Wide',
code='STD',
target_entity_type='Vacation'
)
self.kwargs = {
'user': self.test_user,
'type': self.personal_vacation,
'start': datetime.datetime(2013, 6, 6, 10, 0),
'end': datetime.datetime(2013, 6, 10, 19, 0)
}
self.test_vacation = Vacation(**self.kwargs)
def test_create_entity_with_missing_end(self):
"""testing if create_entity() method is working properly 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.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)
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 "end" parameter')
def setUp(self):
"""setting up some proper values
"""
# create a user
self.test_user = User(name="Test User",
login="******",
email="*****@*****.**",
password="******")
# create some test Tag objects, not necessarily needed but create them
self.test_tag1 = Tag(name="Test Tag 1")
self.test_tag2 = Tag(name="Test Tag 1") # make it equal to tag1
self.test_tag3 = Tag(name="Test Tag 3")
self.tags = [self.test_tag1, self.test_tag2]
# create a couple of test Note objects
self.test_note1 = Note(name="test note1", content="test note1")
self.test_note2 = Note(name="test note2", content="test note2")
self.test_note3 = Note(name="test note3", content="test note3")
self.notes = [self.test_note1, self.test_note2]
self.kwargs = {
"name": "Test Entity",
"description": "This is a test entity, and this is a proper \
description for it",
"created_by": self.test_user,
"updated_by": self.test_user,
"tags": self.tags,
"notes": self.notes,
}
# create a proper SimpleEntity to use it later in the tests
self.test_entity = Entity(**self.kwargs)
def setUp(self):
"""set the test up
"""
super(ProjectUserTestDBCase, self).setUp()
from stalker import Repository
self.test_repo = Repository(name='Test Repo')
from stalker.db.session import DBSession
DBSession.add(self.test_repo)
DBSession.commit()
from stalker import User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.test_user1)
from stalker import Project
self.test_project = Project(
name='Test Project 1',
code='TP1',
repositories=[self.test_repo],
)
DBSession.add(self.test_project)
from stalker import Role
self.test_role = Role(name='Test User')
DBSession.add(self.test_role)
DBSession.commit()
def test_put_tags_view_will_raise_404(self):
"""testing if the PUT /api/entities/{id}/tags view will return 404
"""
from stalker import db, User, Tag
test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(test_user1)
tag1 = Tag(name='Tag1')
tag2 = Tag(name='Tag2')
tag3 = Tag(name='Tag3')
tag4 = Tag(name='Tag4')
tag5 = Tag(name='Tag5')
db.DBSession.add_all([tag1, tag2, tag3, tag4, tag5])
test_user1.tags = [tag1, tag2, tag3]
import transaction
transaction.commit()
test_user1 = User.query.filter(User.login == test_user1.login).first()
self.test_app.put('/api/entities/%s/tags?tag=%s' %
(test_user1.id, tag4.name),
status=404)
def setUp(self):
"""set the test up
"""
from stalker import Status, StatusList, Repository
self.test_repo = Repository(name='Test Repo')
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')
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 User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
from stalker import Project
self.test_project = Project(name='Test Project 1',
code='TP1',
repositories=[self.test_repo],
status_list=self.project_statuses)
from stalker import Role
self.test_role = Role(name='Test User')
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_logged_in_user_returns_the_stored_User_instance_from_last_time(
self):
"""testing if logged_in_user returns the logged in user
"""
# create a new user
new_user = User(name='Test User',
login='******',
email='*****@*****.**',
password='******')
# save it to the Database
DBSession.add(new_user)
DBSession.commit()
self.assertTrue(new_user.id is not None)
# save it to the local storage
local_session = LocalSession()
local_session.store_user(new_user)
# save the session
local_session.save()
# now get it back with a new local_session
local_session2 = LocalSession()
self.assertEqual(local_session2.logged_in_user_id, new_user.id)
self.assertEqual(local_session2.logged_in_user, new_user)
def test_delete_entity(self):
"""testing if delete_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, 10)
end = datetime.datetime(2016, 4, 22, 16)
vac1 = Vacation(user=user1, start=start, end=end)
db.DBSession.commit()
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)
vacation_views.delete_entity()
vac = Vacation.query.filter(Vacation.name == vac1.name).all()
self.assertEqual(vac, [])
def test_logged_in_user_returns_the_stored_User_instance_from_last_time(
self):
"""testing if logged_in_user returns the logged in user
"""
# create a new user
from stalker import User
new_user = User(name='Test User',
login='******',
email='*****@*****.**',
password='******')
# save it to the Database
from stalker.db.session import DBSession
DBSession.add(new_user)
DBSession.commit()
assert new_user.id is not None
# save it to the local storage
from stalker import LocalSession
local_session = LocalSession()
local_session.store_user(new_user)
# save the session
local_session.save()
# now get it back with a new local_session
local_session2 = LocalSession()
assert local_session2.logged_in_user_id == new_user.id
assert local_session2.logged_in_user == new_user
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_delete_tags_view_is_working_properly(self):
"""testing if the DELETE /api/entities/{id}/tags view is working
properly
"""
from stalker import db, User, Tag
test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(test_user1)
tag1 = Tag(name='Tag1')
tag2 = Tag(name='Tag2')
tag3 = Tag(name='Tag3')
tag4 = Tag(name='Tag4')
tag5 = Tag(name='Tag5')
db.DBSession.add_all([tag1, tag2, tag3, tag4, tag5])
test_user1.tags = [tag1, tag2, tag3]
import transaction
transaction.commit()
test_user1 = User.query.filter(User.login == test_user1.login).first()
self.test_app.delete('/api/entities/%s/tags?tag=%s' %
(test_user1.id, tag3.name),
status=200)
test_user1 = User.query.filter(User.login == test_user1.login).first()
self.assertEqual(sorted([tag.name for tag in test_user1.tags]),
['Tag1', 'Tag2'])
def setUp(self):
"""set the test
"""
super(SimpleEntityDBTester, self).setUp()
from stalker import User
import json
self.test_user = User(
name="Test User",
login="******",
email="*****@*****.**",
password="******",
generic_text=json.dumps({'Phone number': '123'}, sort_keys=True),
)
from stalker.db.session import DBSession
DBSession.add(self.test_user)
DBSession.commit()
import datetime
import pytz
self.date_created = \
datetime.datetime(2010, 10, 21, 3, 8, 0, tzinfo=pytz.utc)
self.date_updated = self.date_created
self.kwargs = {
"name": "Test Entity",
"code": "TstEnt",
"description": "This is a test entity, and this is a proper \
description for it",
"created_by": self.test_user,
"updated_by": self.test_user,
"date_created": self.date_created,
"date_updated": self.date_updated,
'generic_text': json.dumps({'Phone number': '123'},
sort_keys=True),
}
def test_update_entity_change_user(self):
"""testing if update_entity() method is working properly for changing
user attribute
"""
from stalker import db, User, Vacation
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
user2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user2)
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
vac1 = Vacation(user=user1, start=start, end=end)
db.DBSession.commit()
user2 = User.query.filter(User.login == user2.login).first()
vac1 = Vacation.query.filter(Vacation.name == vac1.name).first()
# also update updated_by_id attribute
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = vac1.id
request.params = DummyMultiDict()
# change user
request.params['user_id'] = user2.id
request.params['updated_by_id'] = user2.id
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, end)
self.assertEqual(vac.user, user2)
self.assertEqual(vac.updated_by, user2)
def test_delete_will_delete_the_session_cache(self):
"""testing if the LocalSession.delete() will delete the current cache
file
"""
# create a new user
from stalker import db, User
new_user = User(
name='Test User',
login='******',
email='*****@*****.**',
password='******'
)
# save it to the Database
db.DBSession.add(new_user)
db.DBSession.commit()
self.assertTrue(new_user.id is not None)
# save it to the local storage
from stalker import LocalSession
local_session = LocalSession()
local_session.store_user(new_user)
# save the session
local_session.save()
# check if the file is created
# check if a file is created in the users local storage
import os
from stalker import defaults
self.assertTrue(
os.path.exists(
os.path.join(
defaults.local_storage_path,
defaults.local_session_data_file_name
)
)
)
# now delete the session by calling delete()
local_session.delete()
# check if the file is gone
# check if a file is created in the users local storage
self.assertFalse(
os.path.exists(
os.path.join(
defaults.local_storage_path,
defaults.local_session_data_file_name
)
)
)
# delete a second time
# this should not raise an OSError
local_session.delete()
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 create_user(self):
"""
Creates new user
"""
from stalker.db.session import DBSession
from stalker import User
new_user = User(
name="{0}".format(self.user_name),
login="******".format(self.user_login),
email="{0}".format(self.user_email),
password="******".format(self.user_password)
)
#Checks if the user's name and e-mail address are registered in the database.
#Sends a warning message to the user if registered.
if not User.query.filter_by(email=self.user_email).scalar() == None:
QtWidgets.QMessageBox.warning(
self,
"Warning",
"The email address you entered already belongs to an existing user , Please re-enter your e-mail address!"
)
elif not User.query.filter_by(login=self.user_login).scalar() == None:
QtWidgets.QMessageBox.warning(
self,
"Warning",
"The user '{0}' already exists, Please enter new username!".format(self.user_login)
)
else:
try:
# Save the user to database
DBSession.save(new_user)
#Gets the string representation of an exception
except BaseException as e:
DBSession.rollback()
QtWidgets.QMessageBox.critical(
self,
"Error",
str(e)
)
# now we can give the information message
QtWidgets.QMessageBox.information(
self,
"Success",
"User '{0}' successfully created!".format(self.user_login)
)
# then we can close this dialog
self.close()
def test_user_attribute_back_populates_vacations_attribute(self):
"""testing if the user attribute back populates vacations attribute of
the User instance
"""
new_user = User(name='test user 2',
login='******',
email='*****@*****.**',
password='******')
self.test_vacation.user = new_user
self.assertTrue(self.test_vacation in new_user.vacations)
def test_reported_by_attribute_is_synonym_of_created_by(self):
"""testing if the reported_by attribute is a synonym for the created_by
attribute
"""
user1 = User(name='user1',
login='******',
password='******',
email='*****@*****.**')
self.test_ticket.reported_by = user1
self.assertEqual(user1, self.test_ticket.created_by)
def test_user_attribute_is_working_properly(self):
"""testing if the user attribute is working properly
"""
new_user = User(name='test user 2',
login='******',
email='*****@*****.**',
password='******')
self.assertNotEqual(self.test_vacation.user, new_user)
self.test_vacation.user = new_user
self.assertEqual(self.test_vacation.user, new_user)
def test_reported_by_attribute_is_synonym_of_created_by(self):
"""testing if the reported_by attribute is a synonym for the created_by
attribute
"""
from stalker import User
user1 = User(name='user1',
login='******',
password='******',
email='*****@*****.**')
self.test_ticket.reported_by = user1
assert user1 == self.test_ticket.created_by
def test_user_attribute_is_working_properly(self):
"""testing if the user attribute is working properly
"""
from stalker import User
new_user = User(name='test user 2',
login='******',
email='*****@*****.**',
password='******')
assert self.test_vacation.user != new_user
self.test_vacation.user = new_user
assert self.test_vacation.user == new_user
