def setup(self):
self.request = testing.DummyRequest()
self.request.POST = MultiDict()
self.request.method = 'POST'
self.request.y_path = Mock()
self.request.y_repo = Mock()
ContentMoveForm.csrf_enabled = False
def test_calls_paginate_and_forwards_property(self):
query = Mock()
query.configure_mock(**{'paginate.return_value.total': 30})
total = LazyPagination(query, 4).total
query.paginate.assert_called_with(4)
assert total == 30
def setup(self):
self.context = Mock()
self.request_mock = Mock()
self.request_mock.path_qs = '/a'
get_request_mock = patch('yoshimi.templating.get_current_request')
self.get_request_mock = get_request_mock.start()
self.get_request_mock.return_value = self.request_mock
def test_context_redirect_back(self, url_func_mock):
from yoshimi.url import redirect_back_to_context
request_mock = Mock()
context_mock = Mock()
redirect_back_to_context(context_mock, request_mock)
url_func_mock.assert_called_once_with(context_mock, request_mock)
def test_returns_trash_contents(self):
request = Mock()
trash_contents = Mock()
self.lazy_pagination.return_value = trash_contents
rv = trash_index(Mock(), request)
request.y_repo.trash.items.assert_called_once_with()
assert rv['trash_contents'] == trash_contents
def test_move(self, move_class):
session = Mock()
repo = get_repo_mock(session=session)
subject = Mock()
rv = repo.move(subject)
assert isinstance(rv, MoveOperation)
move_class.assert_called_once_with(session, subject)
def test_delete(self, delete_class):
session = Mock()
repo = get_repo_mock(session=session)
subject = Mock()
repo.delete(subject)
delete_class.assert_called_once_with(session)
delete_class.return_value.delete.assert_called_once_with(subject)
def test_extension(self):
# callable(query, *args, **kwargs)
session = Mock()
callable = Mock()
query = Query(session, None, {'test_func': callable})
query.test_func('a').get_query()
# Unable to assert that callable was called with a lambda so simply
# asserting that it was called
assert callable.call_count == 1
def test_func_only_called_once(self):
from yoshimi.utils import run_once
func = Mock()
func.return_value = 'string'
new_func = run_once(func)
rv = new_func()
rv2 = new_func()
func.assert_called_once_with()
assert rv == 'string'
assert rv2 == 'string'
def test_query(self, query_class):
session = Mock()
registry = Mock()
query_extension = Mock(autospec=_QueryExtensions)
query_extension.methods = {}
registry.queryUtility.return_value = query_extension
repo = Repo(registry, session)
subject = Mock()
rv = repo.query(subject)
assert isinstance(rv, Query)
query_class.assert_called_once_with(session, subject, {})
def get_repo_mock(registry=None, session=None, query_extensions=None):
if not session:
session = Mock()
if not registry:
registry = Mock()
if not query_extensions:
query_extensions = {}
query_extension = Mock(autospec=_QueryExtensions)
query_extension.methods = query_extensions
registry.queryUtility.return_value = query_extension
repo = Repo(registry, session)
return repo
def get_repo_mock(registry=None, session=None, query_extensions=None):
if not session:
session = Mock()
if not registry:
registry = Mock()
if not query_extensions:
query_extensions = {}
query_extension = Mock(autospec=_QueryExtensions)
query_extension.methods = query_extensions
registry.queryUtility.return_value = query_extension
repo = Repo(registry, session)
return repo
def setup(self):
self.request = DummyRequest()
self.request.matchdict['traverse'] = ("a", "b-1")
self.request.resource_path = Mock()
self.request.resource_path.return_value = '/a/b-1'
self.request.y_path = Mock()
self.request.y_path.return_value = '/a/b-1'
self.loc1 = Mock()
self.loc2 = Mock()
self.loc2.lineage = [self.loc1, self.loc2]
self.context_getter = lambda id: self.loc2
self.patched_url = patch('yoshimi.url.path').start()
self.patched_url.return_value = '/a/b-1'
def test_returns_none_with_invalid_url_format(self):
self.request.matchdict['traverse'] = ('a', 'b2')
self.context_getter = Mock()
self.context_getter.return_value = None
root = self.fut(self.context_getter)(self.request)
assert root is None
def test_trash(self, trash_class):
session = Mock()
repo = get_repo_mock(session=session)
rv = repo.trash
assert isinstance(rv, Trash)
trash_class.assert_called_once_with(session)
def setup(self):
self.request = testing.DummyRequest()
self.request.POST = MultiDict({
'email': '*****@*****.**',
'password': '******'
})
self.request.method = 'POST'
self.request.y_user = Mock(spec_set=AuthCoordinator)
def test_trash_empty(self, redirect_back):
redirect_back.return_value = '/return'
request = Mock()
request.route_url.return_value = '/redir'
rv = trash_empty(request)
assert rv == '/return'
request.y_repo.trash.empty.assert_called_once_with()
redirect_back.assert_called_once_with(request, fallback='/redir')
def test_moves_content_when_new_parent_id_is_provided(self):
self.request.y_path.return_value = '/move'
self.request.POST['parent_id'] = 123
self.request.context = Mock()
rv = move(self.request.context, self.request)
assert isinstance(rv, HTTPFound)
assert self.request.y_repo.move.called is True
def test_query(self, query_class):
session = Mock()
registry = Mock()
query_extension = Mock(autospec=_QueryExtensions)
query_extension.methods = {}
registry.queryUtility.return_value = query_extension
repo = Repo(registry, session)
subject = Mock()
rv = repo.query(subject)
assert isinstance(rv, Query)
query_class.assert_called_once_with(session, subject, {})
def setup(self):
self.request = testing.DummyRequest()
self.request.session['_csrft_'] = 'some token'
self.request.y_user = Mock(spec_set=AuthCoordinator)
self.request.y_user.logout.return_value = {}
def test_redirects_to_slash_without_parent(self, redirect_func):
context = Mock()
context.parent = None
self.fut(self.req, context)
redirect_func.assert_called_once_with(self.req)
def test_can_select_when_have_parent_and_is_available(self):
trash_content = Mock()
trash_content.content.parent.is_available = True
rv = trash_index(Mock(), Mock())
assert rv['can_select'](trash_content) is True
def setup(self):
self.req = Mock()
self.req.matched_route.name = 'route_name'
self.content = Mock()
self.fut = None
def test_redirects_to_slash_without_parent(self, redirect_func):
context = Mock()
context.parent = None
self.fut(self.req, context)
redirect_func.assert_called_once_with(self.req)
def mock_load_user(user):
a = auth.AuthCoordinator(testing.DummyRequest())
a.load = Mock(return_value=user)
return a
def test_can_not_select_without_available_parent(self):
trash_content = Mock()
trash_content.content.parent.is_available = False
rv = trash_index(Mock(), Mock())
assert rv['can_select'](trash_content) is False
def setup(self):
from yoshimi.views import delete
self.fut = delete
self.req = Mock()
self.context = Mock()
def test_index(self):
assert index(Mock(), Mock()) == {}
