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 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 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 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()) == {}