def test_hashed_password_none_redirects(self):
# given
email = '*****@*****.**'
password = '******'
hashed_password = None #
user = Mock(spec=User)
user.email = email
user.hashed_password = hashed_password
self.ls.check_password_hash.return_value = True
self.ll.pl_get_user_by_email.return_value = user
request = generate_mock_request(method="POST",
form={
'email': email,
'password': password
})
# when
result = self.vl.login(request, self.admin)
# then
self.ls.login_user.assert_not_called()
self.ll.pl_get_user_by_email.assert_called_once_with(email)
self.pl.get_user_by_email.assert_not_called()
self.r.flash.assert_called_once_with('Username or Password is invalid',
'error')
self.r.url_for.assert_called_once_with('login')
self.r.redirect.assert_called_once_with(self.r.url_for.return_value)
self.assertIs(self.r.redirect.return_value, result)
# and
self.ls.check_password_hash.assert_not_called()
self.r.render_template.assert_not_called()
def test_logs_in_user(self):
# given
email = '*****@*****.**'
password = '******'
hashed_password = '******'
user = Mock(spec=User)
user.email = email
user.hashed_password = hashed_password
self.ls.check_password_hash.return_value = True
self.ll.pl_get_user_by_email.return_value = user
request = generate_mock_request(method="POST",
form={
'email': email,
'password': password
})
# when
result = self.vl.login(request, self.admin)
# then
self.ls.login_user.assert_called_once_with(user)
self.r.url_for.assert_called_once_with('index')
self.r.redirect.assert_called_once_with(self.r.url_for.return_value)
self.assertIs(self.r.redirect.return_value, result)
# and
self.r.flash.assert_called_once_with('Logged in successfully')
self.ll.pl_get_user_by_email.assert_called_once_with(email)
self.pl.get_user_by_email.assert_not_called()
self.ls.check_password_hash.assert_called_once_with(
hashed_password, password)
self.r.render_template.assert_not_called()
def test_post_also_logs_out_user(self):
# given
request = generate_mock_request(method="POST")
# when
result = self.vl.logout(request, self.admin)
# then
self.ls.logout_user.assert_called_once_with()
# and
self.r.url_for.assert_called_once_with('index')
self.r.redirect.assert_called_once_with(self.r.url_for.return_value)
self.assertIs(self.r.redirect.return_value, result)
def test_empty_filename_raises(self):
# given
task = Mock(spec=Task)
task.id = 123
form = {'task_id': task.id, 'description': 'asdf'}
files = {'filename': MockFileObject('')}
request = generate_mock_request(form=form, files=files)
admin = self.pl.create_user('admin', is_admin=True)
# expect
self.assertRaises(BadRequest, self.vl.attachment_new, request, admin)
# and
self.r.redirect.assert_not_called()
def test_task_id_not_sepcified_raises(self):
# given
task = Mock(spec=Task)
task.id = 123
form = {}
files = {'filename': MockFileObject('/filename.exe')}
request = generate_mock_request(form=form, files=files)
admin = self.pl.create_user('admin', is_admin=True)
# expect
self.assertRaises(BadRequest, self.vl.attachment_new, request, admin)
# and
self.r.redirect.assert_not_called()
def test_unsets_is_deleted(self):
# given
task_id = 1
user = self.pl.create_user('*****@*****.**', is_admin=True)
req = generate_mock_request(method='GET', args={})
self.r.url_for.return_value = 'http://example.com/'
# when
self.vl.task_undelete(req, current_user=user, task_id=task_id)
# then
self.ll.task_unset_deleted.assert_called_once_with(task_id, user)
self.r.url_for.assert_called_once_with('index')
self.r.redirect.assert_called_once_with('http://example.com/')
def test_creates_new_task(self):
# given
request = generate_mock_request(method="POST")
self.ll.get_lowest_order_num.return_value = 0
# when
result = self.vl.task_new_post(request, self.admin)
# then
self.ll.create_new_task.assert_called()
self.ll.do_add_tag_to_task.assert_not_called()
self.r.url_for.assert_called()
self.r.redirect.assert_called()
self.assertIs(self.r.redirect.return_value, result)
def test_get_request_returns_template(self):
# given
request = generate_mock_request(method='GET')
admin = self.pl.create_user('admin', is_admin=True)
# self.r.render_template
# when
result = self.vl.import_(request, admin)
# then
self.r.render_template.assert_called_once_with('import.t.html')
self.assertIs(self.r.render_template.return_value, result)
# and
self.r.url_for.assert_not_called()
self.r.redirect.assert_not_called()
def test_tag_in_form_adds_tag(self):
# given
request = generate_mock_request(method="POST", form={'tags': 'tag1'})
self.ll.get_lowest_order_num.return_value = 0
# when
result = self.vl.task_new_post(request, self.admin)
# then
self.ll.create_new_task.assert_called()
self.ll.do_add_tag_to_task.assert_called_once_with(
self.ll.create_new_task.return_value, 'tag1', self.admin)
self.r.url_for.assert_called()
self.r.redirect.assert_called()
self.assertIs(self.r.redirect.return_value, result)
def test_takes_redirect_url_from_args_next_if_available(self):
# given
task_id = 1
user = self.pl.create_user('*****@*****.**', is_admin=True)
req = generate_mock_request(method='GET',
args={'next': 'http://example2.org/'})
self.r.url_for.return_value = 'http://example.com/'
# when
self.vl.task_undelete(req, current_user=user, task_id=task_id)
# then
self.ll.task_unset_deleted.assert_called_once_with(task_id, user)
self.r.url_for.assert_not_called()
self.r.redirect.assert_called_once_with('http://example2.org/') #
def test_renders_template_on_get(self):
# given
request = generate_mock_request(method="GET")
# when
result = self.vl.login(request, self.admin)
# then
self.r.render_template.assert_called_once_with('login.t.html')
self.ls.login_user.assert_not_called()
self.assertIs(self.r.render_template.return_value, result)
# and
self.ll.pl_get_user_by_email.assert_not_called()
self.pl.get_user_by_email.assert_not_called()
self.r.flash.assert_not_called()
self.r.redirect.assert_not_called()
self.r.url_for.assert_not_called()
def test_attachment_not_found_raises(self):
# given
self.ll.pl_get_attachment.return_value = None
request = generate_mock_request(method="GET")
attachment_id = 123
# expect
with self.assertRaises(NotFound) as cm:
self.vl.attachment(request, self.admin, attachment_id, 'name')
# then
self.assertEqual("No attachment found for the id '123'",
cm.exception.description)
self.r.send_from_directory.assert_not_called()
# and
self.ll.pl_get_attachment.assert_called_once_with(attachment_id)
self.pl.get_attachment.assert_not_called()
def test_gets_task_data_from_logic_layer(self):
# given
request = generate_mock_request(args={}, cookies={})
user = Mock()
TASK_ID = 1
# when
result = self.vl.task(request, user, TASK_ID)
# then
self.assertIsNotNone(result)
self.ll.get_task_data.assert_called_with(TASK_ID,
user,
include_deleted=None,
include_done=None,
page_num=1,
tasks_per_page=20)
self.r.render_template.assert_called()
def test_task_per_page_not_int_default_to_twenty(self):
# given
request = generate_mock_request(args={'per_page': 'asdf'}, cookies={})
user = Mock()
TASK_ID = 1
# when
result = self.vl.task(request, user, TASK_ID)
# then
self.assertIsNotNone(result)
self.ll.get_task_data.assert_called_with(TASK_ID,
user,
include_deleted=None,
include_done=None,
page_num=1,
tasks_per_page=20)
self.r.render_template.assert_called()
def test_purges_deleted_task(self):
# given
task = Mock(spec=Task)
task.is_deleted = True
self.ll.pl_get_task.return_value = task
request = generate_mock_request(method="GET")
task_id = 123
# when
result = self.vl.task_purge(request, self.admin, task_id)
# then
self.ll.purge_task.assert_called_once_with(task, self.admin)
# and
self.ll.pl_get_task.assert_called_once_with(task_id)
self.pl.get_task.assert_not_called()
self.r.url_for.assert_called_once_with('index')
self.r.redirect.assert_called_once_with(self.r.url_for.return_value)
self.assertIs(self.r.redirect.return_value, result)
def test_two_tags_in_form_adds_both_tags(self):
# given
request = generate_mock_request(method="POST",
form={'tags': 'tag1,tag2'})
self.ll.get_lowest_order_num.return_value = 0
# when
result = self.vl.task_new_post(request, self.admin)
# then
self.ll.create_new_task.assert_called()
self.ll.do_add_tag_to_task.assert_any_call(
self.ll.create_new_task.return_value, 'tag1', self.admin)
self.ll.do_add_tag_to_task.assert_any_call(
self.ll.create_new_task.return_value, 'tag2', self.admin)
self.assertEqual(2, self.ll.do_add_tag_to_task.call_count)
self.r.url_for.assert_called()
self.r.redirect.assert_called()
self.assertIs(self.r.redirect.return_value, result)
def test_task_not_found_raises(self):
# given
self.ll.pl_get_task.return_value = None
request = generate_mock_request(method="GET")
task_id = 123
# expect
with self.assertRaises(NotFound) as cm:
self.vl.task_purge(request, self.admin, task_id)
# then
self.assertEqual("No task found for the id '123'",
cm.exception.description)
self.ll.purge_task.assert_not_called()
# and
self.ll.pl_get_task.assert_called_once_with(task_id)
self.pl.get_task.assert_not_called()
self.r.url_for.assert_not_called()
self.r.redirect.assert_not_called()
def test_task_not_deleted_raises(self):
# given
task = Mock(spec=Task)
task.is_deleted = False
self.ll.pl_get_task.return_value = task
request = generate_mock_request(method="GET")
task_id = 123
# expect
with self.assertRaises(BadRequest) as cm:
self.vl.task_purge(request, self.admin, task_id)
# then
self.assertEqual("Indicated task (id 123) has not been deleted.",
cm.exception.description)
self.ll.purge_task.assert_not_called()
# and
self.ll.pl_get_task.assert_called_once_with(task_id)
self.pl.get_task.assert_not_called()
self.r.url_for.assert_not_called()
self.r.redirect.assert_not_called()
def test_gets_attachment(self):
# given
upload_folder = '/path/to/uploads'
self.ll.upload_folder = upload_folder
attachment_id = 123
attachment_path = 'this/is/the/path'
attachment = Mock(spec=Attachment)
attachment.id = attachment_id
attachment.path = attachment_path
self.ll.pl_get_attachment.return_value = attachment
request = generate_mock_request(method="GET")
# when
result = self.vl.attachment(request, self.admin, attachment_id, 'name')
# then
self.r.send_from_directory.assert_called_once_with(
upload_folder, attachment_path)
# and
self.ll.pl_get_attachment.assert_called_once_with(attachment_id)
self.pl.get_attachment.assert_not_called()
self.assertIs(self.r.send_from_directory.return_value, result)
def test_description_sets_description(self):
# given
task = Mock(spec=Task)
task.id = 123
form = {'task_id': task.id, 'description': 'asdf'}
f = MockFileObject('/filename.txt')
files = {'filename': f}
request = generate_mock_request(form=form, files=files)
admin = self.pl.create_user('admin', is_admin=True)
# when
result = self.vl.attachment_new(request, admin)
# then
self.ll.create_new_attachment.assert_called_once_with(task.id,
f,
'asdf',
admin,
timestamp=None)
# and
self.r.url_for.assert_called_once_with('view_task', id=task.id)
self.r.redirect.assert_called_once_with(self.r.url_for.return_value)
self.assertIs(self.r.redirect.return_value, result)
def test_imports_data_from_form(self):
# given
src = '''{"tasks":[{
"id": 1,
"summary":"summary"
}]}'''
src_dict = {
"tasks": [{
"id": 1,
"summary": "summary",
}]
}
form = {'raw': src}
files = {}
request = generate_mock_request(form=form, files=files)
admin = self.pl.create_user('admin', is_admin=True)
# when
result = self.vl.import_(request, admin)
# then
self.ll.do_import_data.assert_called_once_with(src_dict)
# and
self.r.url_for.assert_called_once_with('index')
self.r.redirect.assert_called_once_with(self.r.url_for.return_value)
self.assertIs(self.r.redirect.return_value, result)
