def test_known_kind_no_text_term(self): from webob.multidict import MultiDict from karl.models.interfaces import IGroupSearchFactory from repoze.lemonade.testing import registerContentFactory from zope.interface import Interface content = DummyCommunityContent() def search_factory(*arg, **kw): return DummySearchFactory(content) search_factory.icon = "foo.jpg" search_factory.advanced_search = True karltesting.registerUtility(search_factory, IGroupSearchFactory, name="People") context = testing.DummyModel() context.catalog = {} context["profiles"] = profiles = testing.DummyModel() profiles["tweedle dee"] = testing.DummyModel(title="Tweedle Dee") request = testing.DummyRequest(params=MultiDict({"kind": "People"})) request.layout_manager = mock.Mock() from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result["terms"], ["People"]) self.assertEqual(len(result["results"]), 1)
def test_community_search(self): context = testing.DummyModel() context.title = "Citizens" context.catalog = {} context["profiles"] = profiles = testing.DummyModel() profiles["tweedle dee"] = testing.DummyModel(title="Tweedle Dee") from webob.multidict import MultiDict from karl.models.interfaces import ICommunity from zope.interface import directlyProvides directlyProvides(context, ICommunity) request = testing.DummyRequest(params=MultiDict({"body": "yo"})) request.layout_manager = mock.Mock() from zope.interface import Interface from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result["community"], "Citizens") self.assertEqual(result["terms"], ["yo"]) self.assertEqual(len(result["results"]), 1)
def test_handle_submit_full_path_filename(self): from schemaish.type import File as SchemaFile from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory from repoze.bfg.formish import ValidationError self._register() self._registerLayoutProvider() testing.registerDummySecurityPolicy('userid') context = self._makeContext() context.catalog = DummyCatalog() fs = SchemaFile('abc', r"C:\Documents and Settings\My Tests\filename", 'x/foo') converted = { 'file': fs, 'title': 'a title', 'sendalert': False, 'security_state': 'public', 'tags':['thetesttag'], } request = self._makeRequest() registerContentFactory(DummyCommunityFile, ICommunityFile) controller = self._makeOne(context, request) response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/filename/') self.assertEqual(context['filename'].title, u'a title') self.assertEqual(context['filename'].creator, 'userid') self.assertEqual(context['filename'].stream, 'abc') self.assertEqual(context['filename'].mimetype, 'x/foo') self.assertEqual(context['filename'].filename, 'filename') # attempt a duplicate upload self.assertRaises(ValidationError, controller.handle_submit, converted)
def test_handle_submit_inactive_user(self): from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IInvitation from karl.utilities.interfaces import IRandomId request = testing.DummyRequest() context = self._makeCommunity() self._registerMailer() registerCatalogSearch() profile = karltesting.DummyProfile(security_state='inactive') profile.__name__ = 'd' registerCatalogSearch(results={'[email protected]': [ profile, ]}) def nonrandom(size=6): return 'A' * size karltesting.registerUtility(nonrandom, IRandomId) registerContentFactory(DummyInvitation, IInvitation) controller = self._makeOne(context, request) converted = { 'email_addresses': [u'*****@*****.**'], 'text': u'some text', } karltesting.registerDummyRenderer( 'karl.views:templates/email_add_existing.pt') from pyramid_formish import ValidationError self.assertRaises(ValidationError, controller.handle_submit, converted)
def test_submitted_toobig(self): self._register() self._registerLayoutProvider() from repoze.bfg.formish import ValidationError def check_upload_size(*args): raise ValidationError(file='TEST VALIDATION ERROR') testing.registerDummySecurityPolicy('userid') context = self._makeContext() context.catalog = DummyCatalog() request = self._makeRequest() from schemaish.type import File as SchemaFile fs = SchemaFile('abc', 'filename', 'x/foo') converted = { 'file': fs, 'title': 'a title', 'sendalert': False, 'security_state': 'public', 'tags':[], } from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyCommunityFile, ICommunityFile) controller = self._makeOne(context, request, check_upload_size) self.assertRaises(ValidationError, controller.handle_submit, converted)
def test_handle_submit(self): from karl.testing import DummyUpload attachment = DummyUpload(filename='newfile.txt') converted = { 'title': u'New Title', 'text': u'New page text.', 'tags': [u'foo', u'bar'], 'attachments': [attachment], } self._registerTags(self.parent) from karl.content.interfaces import ICommunityFile from karl.testing import DummyFile registerContentFactory(DummyFile, ICommunityFile) context = self.context controller = self._makeOne(context, self.request) response = controller.handle_submit(converted) self.failUnless('Page%20edited' in response.location) self.failUnless( response.location.startswith('http://example.com/child/')) self.assertEqual(context.title, u'New Title') self.assertEqual(context.text, u'New page text.') attachments_folder = context['attachments'] self.failUnless('newfile.txt' in attachments_folder) self.failIf(len(attachments_folder) > 1) self.assertEqual(self.parent.tags._called_with[1]['tags'], [u'foo', u'bar'])
def test_handle_submit_already_in_community(self): from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IInvitation from karl.utilities.interfaces import IRandomId request = testing.DummyRequest() context = self._makeCommunity() mailer = self._registerMailer() registerCatalogSearch() profile = karltesting.DummyProfile() profile.__name__ = 'a' registerCatalogSearch(results={'[email protected]': [profile,]}) def nonrandom(size=6): return 'A' * size karltesting.registerUtility(nonrandom, IRandomId) registerContentFactory(DummyInvitation, IInvitation) controller = self._makeOne(context, request) converted = { 'email_addresses': [u'*****@*****.**'], 'text': u'some text', } response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/manage.html?status_message=One+user+already+member.' ) self.failIf('A'*6 in context) self.assertEqual(context.users.added_groups, [])
def test_no_creator(self): from webob.multidict import MultiDict context = testing.DummyModel() context.catalog = {} context['profiles'] = profiles = testing.DummyModel() request = testing.DummyRequest(params=MultiDict({'body': 'yo'})) request.layout_manager = mock.Mock() from zope.interface import Interface from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) class LocalDummyContent(testing.DummyModel): implements(IDummyContent) import datetime title = 'Dummy Content' modified = datetime.datetime(2010, 5, 12, 2, 42) class LocalDummySearch(DummySearch): content = LocalDummyContent() karltesting.registerAdapter(LocalDummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result['terms'], ['yo']) self.assertEqual(len(result['results']), 1)
def test_with_tag_multiple_users(self): from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory context = testing.DummyModel() context.title = 'title' karltesting.registerModels({'/foo': context}) directlyProvides(context, IDummyBlogEntry) registerContentFactory(testing.DummyModel, IDummyBlogEntry) tags = context.tags = DummyTags(users=('dummy', 'dummy2')) def _getRelated(tag, degree=1, community=None, user=None): assert tag == 'tag1' assert degree == 1 assert community is None assert user is None return [] tags.getRelatedTags = _getRelated context.catalog = karltesting.DummyCatalog({1:'/foo'}) request = testing.DummyRequest() request.subpath = [u'tag1'] result = self._callFUT(context, request) self.assertEqual(result['tag'], u'tag1') self.assertEqual(len(result['entries']), 1) entry = result['entries'][0] self.assertEqual(entry['description'], '') self.assertEqual(entry['title'], 'title') self.assertEqual(entry['href'], 'http://example.com/') self.assertEqual(entry['tagusers_count'], '2 people') self.assertEqual(entry['type'], 'Blog Entry') self.assertEqual(entry['tagusers_href'], 'http://example.com/tagusers.html?tag=tag1&docid=1') self.assertEqual(len(result['related']), 0)
def test_known_kind_no_text_term(self): from webob.multidict import MultiDict from karl.models.interfaces import IGroupSearchFactory from repoze.lemonade.testing import registerContentFactory from zope.interface import Interface content = DummyCommunityContent() def search_factory(*arg, **kw): return DummySearchFactory(content) search_factory.icon = 'foo.jpg' search_factory.advanced_search = True karltesting.registerUtility(search_factory, IGroupSearchFactory, name='People') context = testing.DummyModel() context.catalog = {} context['profiles'] = profiles = testing.DummyModel() profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee') request = testing.DummyRequest(params=MultiDict({'kind': 'People'})) request.layout_manager = mock.Mock() from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result['terms'], ['People']) self.assertEqual(len(result['results']), 1)
def setUp(self): cleanUp() testing.setUp(request=testing.DummyRequest()) from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IProfile def profile_factory(**kw): kw['security_state'] = 'active' return testing.DummyModel(**kw) registerContentFactory(profile_factory, IProfile) from karl.testing import DummyUsers self.root = root = testing.DummyModel() root.users = DummyUsers() root['profiles'] = testing.DummyModel() root['people'] = people = testing.DummyModel() people['categories'] = categories = testing.DummyModel() people.update_indexes = lambda: None categories['offices'] = testing.DummyModel() categories['entities'] = testing.DummyModel() categories['departments'] = testing.DummyModel() categories['boards'] = testing.DummyModel() from osi.sync import gsa_sync self._save_urllib2 = gsa_sync.urllib2 self.urllib2 = gsa_sync.urllib2 = DummyUrllib2() gsa_sync.reindex_peopledirectory = lambda x: None gsa_sync.RETRY_SLEEP = 0 from karl.testing import registerDummyMailer registerDummyMailer()
def test_known_since(self): from webob.multidict import MultiDict context = testing.DummyModel() context.catalog = {} context['profiles'] = profiles = testing.DummyModel() profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee') request = testing.DummyRequest(params=MultiDict({ 'body': 'yo', 'since': 'week' })) request.layout_manager = mock.Mock() from zope.interface import Interface from karl.content.interfaces import IBlogEntry from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) registerContentFactory(DummyContent, IBlogEntry) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result['terms'], ['yo', 'Past week']) self.assertEqual(len(result['results']), 1)
def test_community_search(self): context = testing.DummyModel() context.title = 'Citizens' context.catalog = {} context['profiles'] = profiles = testing.DummyModel() profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee') from webob.multidict import MultiDict from karl.models.interfaces import ICommunity from zope.interface import directlyProvides directlyProvides(context, ICommunity) request = testing.DummyRequest(params=MultiDict({'body': 'yo'})) request.layout_manager = mock.Mock() from zope.interface import Interface from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result['community'], 'Citizens') self.assertEqual(result['terms'], ['yo']) self.assertEqual(len(result['results']), 1)
def test_handle_submit_already_in_karl(self): from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IInvitation from karl.utilities.interfaces import IRandomId request = testing.DummyRequest() context = self._makeCommunity() self._registerMailer() registerCatalogSearch() profile = karltesting.DummyProfile(security_state='active') profile.__name__ = 'd' registerCatalogSearch(results={'[email protected]': [ profile, ]}) def nonrandom(size=6): return 'A' * size karltesting.registerUtility(nonrandom, IRandomId) registerContentFactory(DummyInvitation, IInvitation) controller = self._makeOne(context, request) converted = { 'email_addresses': [u'*****@*****.**'], 'text': u'some text', } karltesting.registerDummyRenderer( 'karl.views:templates/email_add_existing.pt') response = controller.handle_submit(converted) self.assertEqual( response.location, 'http://example.com/manage.html?status_message=One+existing+Karl+user+added+to+community.++' ) self.failIf('A' * 6 in context) self.assertEqual(context.users.added_groups, [('d', 'group:community:members')])
def test_handle_submit_new_to_karl(self): from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IInvitation from karl.utilities.interfaces import IRandomId request = testing.DummyRequest() context = self._makeCommunity() mailer = self._registerMailer() registerCatalogSearch() def nonrandom(size=6): return 'A' * size karltesting.registerUtility(nonrandom, IRandomId) registerContentFactory(DummyInvitation, IInvitation) controller = self._makeOne(context, request) converted = { 'email_addresses': [u'*****@*****.**'], 'text': u'some text', } karltesting.registerDummyRenderer( 'karl.views:templates/email_invite_new.pt') response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/manage.html?status_message=One+user+invited.++' ) invitation = context['A'*6] self.assertEqual(invitation.email, '*****@*****.**') self.assertEqual(1, len(mailer)) self.assertEqual(mailer[0].mto, [u"*****@*****.**",])
def test_handle_submit_already_in_karl(self): from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IInvitation from karl.utilities.interfaces import IRandomId request = testing.DummyRequest() context = self._makeCommunity() mailer = self._registerMailer() registerCatalogSearch() profile = karltesting.DummyProfile(security_state='active') profile.__name__ = 'd' registerCatalogSearch(results={'[email protected]': [profile,]}) def nonrandom(size=6): return 'A' * size karltesting.registerUtility(nonrandom, IRandomId) registerContentFactory(DummyInvitation, IInvitation) controller = self._makeOne(context, request) converted = { 'email_addresses': [u'*****@*****.**'], 'text': u'some text', } karltesting.registerDummyRenderer( 'karl.views:templates/email_add_existing.pt') response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/manage.html?status_message=One+existing+Karl+user+added+to+community.++' ) self.failIf('A'*6 in context) self.assertEqual(context.users.added_groups, [('d', 'group:community:members')])
def test_handle_submit(self): from repoze.lemonade.testing import registerContentFactory from karl.content.interfaces import IForum def factory(title, desc, creator): return testing.DummyModel(title=title, description=desc, creator=creator) registerContentFactory(factory, IForum) converted = { 'title': 'title', 'description': 'desc', 'security_state': 'public' } context = testing.DummyModel() request = testing.DummyRequest() workflow = self._registerDummyWorkflow() controller = self._makeOne(context, request) response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/title/') self.assertEqual(context['title'].title, 'title') self.assertEqual(context['title'].description, 'desc') self.assertEqual(context['title'].creator, None) self.assertEqual(workflow.initialized, True)
def test_handle_submit_already_in_community(self): from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IInvitation from karl.utilities.interfaces import IRandomId request = testing.DummyRequest() context = self._makeCommunity() self._registerMailer() registerCatalogSearch() profile = karltesting.DummyProfile() profile.__name__ = 'a' registerCatalogSearch(results={'[email protected]': [ profile, ]}) def nonrandom(size=6): return 'A' * size karltesting.registerUtility(nonrandom, IRandomId) registerContentFactory(DummyInvitation, IInvitation) controller = self._makeOne(context, request) converted = { 'email_addresses': [u'*****@*****.**'], 'text': u'some text', } response = controller.handle_submit(converted) self.assertEqual( response.location, 'http://example.com/manage.html?status_message=One+user+already+member.' ) self.failIf('A' * 6 in context) self.assertEqual(context.users.added_groups, [])
def test_upload_has_mimetype_instead_of_type(self): from cStringIO import StringIO from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory karl.testing.registerDummySecurityPolicy("userid") def make_image(title, stream, mimetype, filename, creator): res = testing.DummyModel() res.title = title res.mimetype = mimetype res.data = stream.read() res.filename = filename res.creator = creator res.is_image = True return res registerContentFactory(make_image, ICommunityFile) context = testing.DummyModel() context.title = 'Howdy Doody' context.__name__ = 'howdydoody' dummy_upload = DummyUpload(StringIO(one_pixel_jpeg), 'image/jpeg') dummy_upload.mimetype = dummy_upload.type del dummy_upload.type form = {'photo': dummy_upload} self._callFUT(context, form) self.assertTrue('photo' in context) photo = context['photo'] self.assertEqual(photo.title, 'Photo of Howdy Doody') self.assertEqual(photo.mimetype, 'image/jpeg') self.assertEqual(photo.data, one_pixel_jpeg) self.assertEqual(photo.filename, 'test.dat') self.assertEqual(photo.creator, 'userid')
def test_no_creator(self): from webob.multidict import MultiDict context = testing.DummyModel() context.catalog = {} context['profiles'] = testing.DummyModel() request = testing.DummyRequest(params=MultiDict({'body':'yo'})) from zope.interface import Interface from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) class LocalDummyContent(testing.DummyModel): implements(IDummyContent) import datetime title = 'Dummy Content' modified = datetime.datetime(2010, 5, 12, 2, 42) class LocalDummySearch(DummySearch): content = LocalDummyContent() karltesting.registerAdapter(LocalDummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result['terms'], ['yo']) self.assertEqual(len(result['results']), 1)
def test_handle_submit(self): from karl.testing import DummyUpload attachment = DummyUpload(filename='newfile.txt') converted = {'title': u'New Title', 'text': u'New page text.', 'tags': [u'foo', u'bar'], 'attachments': [attachment], } self._registerTags(self.parent) from karl.content.interfaces import ICommunityFile from karl.testing import DummyFile registerContentFactory(DummyFile, ICommunityFile) context = self.context controller = self._makeOne(context, self.request) response = controller.handle_submit(converted) self.failUnless('Page%20edited' in response.location) self.failUnless( response.location.startswith('http://example.com/child/')) self.assertEqual(context.title, u'New Title') self.assertEqual(context.text, u'New page text.') attachments_folder = context['attachments'] self.failUnless('newfile.txt' in attachments_folder) self.failIf(len(attachments_folder) > 1) self.assertEqual(self.parent.tags._called_with[1]['tags'], [u'foo', u'bar'])
def test_upload_has_mimetype_instead_of_type(self): from cStringIO import StringIO from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory karl.testing.registerDummySecurityPolicy("userid") def make_image(title, stream, mimetype, filename, creator): res = testing.DummyModel() res.title = title res.mimetype = mimetype res.data = stream.read() res.filename = filename res.creator = creator res.is_image = True return res registerContentFactory(make_image, ICommunityFile) context = makeRoot() context.title = 'Howdy Doody' context.__name__ = 'howdydoody' context.size = 1000 dummy_upload = DummyUpload(StringIO(one_pixel_jpeg), 'image/jpeg') dummy_upload.mimetype = dummy_upload.type del dummy_upload.type form = {'photo': dummy_upload} self._callFUT(context, form) self.assertTrue('photo' in context) photo = context['photo'] self.assertEqual(photo.title, 'Photo of Howdy Doody') self.assertEqual(photo.mimetype, 'image/jpeg') self.assertEqual(photo.data, one_pixel_jpeg) self.assertEqual(photo.filename, 'test.dat') self.assertEqual(photo.creator, 'userid')
def test_handle_submit_new_to_karl(self): from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IInvitation from karl.utilities.interfaces import IRandomId request = testing.DummyRequest() context = self._makeCommunity() mailer = self._registerMailer() registerCatalogSearch() def nonrandom(size=6): return 'A' * size karltesting.registerUtility(nonrandom, IRandomId) registerContentFactory(DummyInvitation, IInvitation) controller = self._makeOne(context, request) converted = { 'email_addresses': [u'*****@*****.**'], 'text': u'some text', } karltesting.registerDummyRenderer( 'karl.views:templates/email_invite_new.pt') response = controller.handle_submit(converted) self.assertEqual( response.location, 'http://example.com/manage.html?status_message=One+user+invited.++' ) invitation = context['A' * 6] self.assertEqual(invitation.email, '*****@*****.**') self.assertEqual(1, len(mailer)) self.assertEqual(mailer[0].mto, [ u"*****@*****.**", ])
def test_with_tag_multiple_users(self): from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory context = testing.DummyModel() context.title = 'title' karltesting.registerModels({'/foo': context}) directlyProvides(context, IDummyBlogEntry) registerContentFactory(testing.DummyModel, IDummyBlogEntry) tags = context.tags = DummyTags(users=('dummy', 'dummy2')) def _getRelated(tag, degree=1, community=None, user=None): assert tag == 'tag1' assert degree == 1 assert community is None assert user is None return [] tags.getRelatedTags = _getRelated context.catalog = karltesting.DummyCatalog({1: '/foo'}) request = testing.DummyRequest() request.subpath = [u'tag1'] result = self._callFUT(context, request) self.assertEqual(result['tag'], u'tag1') self.assertEqual(len(result['entries']), 1) entry = result['entries'][0] self.assertEqual(entry['description'], '') self.assertEqual(entry['title'], 'title') self.assertEqual(entry['href'], 'http://example.com/') self.assertEqual(entry['tagusers_count'], '2 people') self.assertEqual(entry['type'], 'Blog Entry') self.assertEqual(entry['tagusers_href'], 'http://example.com/tagusers.html?tag=tag1&docid=1') self.assertEqual(len(result['related']), 0)
def test_known_kind_no_text_term(self): from webob.multidict import MultiDict from karl.models.interfaces import IGroupSearchFactory from repoze.lemonade.testing import registerContentFactory from zope.interface import Interface content = DummyCommunityContent() def search_factory(*arg, **kw): return DummySearchFactory(content) search_factory.icon = 'foo.jpg' search_factory.advanced_search = True karltesting.registerUtility( search_factory, IGroupSearchFactory, name='People') context = testing.DummyModel() context.catalog = {} context['profiles'] = profiles = testing.DummyModel() profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee') request = testing.DummyRequest( params=MultiDict({'kind':'People'})) from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result['terms'], ['People']) self.assertEqual(len(result['results']), 1)
def test_community_search(self): context = testing.DummyModel() context.title = 'Citizens' context.catalog = {} context['profiles'] = profiles = testing.DummyModel() profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee') from webob.multidict import MultiDict from karl.models.interfaces import ICommunity from zope.interface import directlyProvides directlyProvides(context, ICommunity) request = testing.DummyRequest(params=MultiDict({'body':'yo'})) from zope.interface import Interface from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) result = self._callFUT(context, request) self.assertEqual(result['community'], 'Citizens') self.assertEqual(result['terms'], ['yo']) self.assertEqual(len(result['results']), 1)
def test_handle_submit(self): from karl.models.interfaces import IComment from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyComment, IComment) registerContentFactory(DummyFile, ICommunityFile) from karl.testing import DummyUpload attachment1 = DummyUpload(filename="test1.txt") attachment2 = DummyUpload(filename=r"C:\My Documents\Ha Ha\test2.txt") converted = { 'add_comment': u'This is my comment', 'attachments': [attachment1, attachment2], 'sendalert': False } context = self.context controller = self._makeOne(context, self.request) response = controller.handle_submit(converted) location = ('http://example.com/communities/community/blog/foo/' '?status_message=Comment%20added') self.assertEqual(response.location, location) self.failUnless(u'99' in context) comment = context[u'99'] self.assertEqual(comment.title, 'Re: Dummy Blog Entry') self.assertEqual(comment.text, u'This is my comment') self.assertEqual(len(comment), 2) self.failUnless('test1.txt' in comment) self.failUnless('test2.txt' in comment) # try again w/ a workflow, and w/ sendalert == True del context[u'99'] workflow = self._registerSecurityWorkflow() blogentry = context.__parent__ blogentry.creator = 'b' blogentry.created = datetime.now() blogentry.text = u'Blog entry text' converted = { 'add_comment': u'This is my OTHER comment', 'attachments': [], 'sendalert': True, 'security_state': 'public' } karl.testing.registerDummyRenderer( 'karl.content.views:templates/email_blog_comment_alert.pt') response = controller.handle_submit(converted) self.assertEqual(response.location, location) self.failUnless(u'99' in context) comment = context[u'99'] self.assertEqual(len(comment), 0) mailer = self.mailer self.assertEqual(len(mailer), 3) recipients = [mail.mto[0] for mail in mailer] self.failUnless('*****@*****.**' in recipients) self.failUnless('*****@*****.**' in recipients) self.failUnless('*****@*****.**' in recipients) self.failUnless(comment in workflow.initialized) self.assertEqual(len(workflow.transitioned), 1) transition = workflow.transitioned[0] self.failUnless(transition['content'] is comment) self.assertEqual(transition['to_state'], 'public')
def test_handle_submit(self): from karl.models.interfaces import ISite from zope.interface import directlyProvides site = testing.DummyModel(sessions=DummySessions()) directlyProvides(site, ISite) from karl.testing import DummyCatalog from karl.models.adapters import CatalogSearch from karl.models.interfaces import ICatalogSearch from zope.interface import Interface site.catalog = DummyCatalog() testing.registerAdapter(CatalogSearch, (Interface), ICatalogSearch) context = self.context site['newsitem'] = context tags = DummyTags() site.tags = tags controller = self._makeOne(context, self.request) from karl.content.views.newsitem import _now now = _now() simple = { 'title': 'NewFoo', 'text': 'text', 'caption': 'caption', 'publication_date': now } from karl.models.tests.test_image import one_pixel_jpeg as dummy_photo from karl.testing import DummyUpload attachment1 = DummyUpload(filename='test1.txt') attachment2 = DummyUpload(filename=r'C:\My Documents\Ha Ha\test2.txt') photo = DummyUpload(filename='test.jpg', mimetype='image/jpeg', data=dummy_photo) converted = { 'tags': ['tag1', 'tag2'], 'attachments': [attachment1, attachment2], 'photo': photo, } converted.update(simple) from karl.models.interfaces import IImageFile from karl.content.interfaces import ICommunityFile from karl.views.tests.test_file import DummyImageFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyImageFile, IImageFile) registerContentFactory(DummyFile, ICommunityFile) response = controller.handle_submit(converted) msg = "?status_message=News%20Item%20edited" self.assertEqual(response.location, 'http://example.com/newsitem/%s' % msg) for field, value in simple.items(): self.assertEqual(getattr(context, field), value) attachments_folder = context['attachments'] self.failUnless('test1.txt' in attachments_folder) self.failUnless('test2.txt' in attachments_folder) self.assertEqual(attachments_folder['test1.txt'].filename, 'test1.txt') self.assertEqual(attachments_folder['test2.txt'].filename, 'test2.txt') self.failUnless('photo.jpg' in context) self.assertEqual(site.tags._called_with[1]['tags'], ['tag1', 'tag2'])
def test_handle_submit(self): from karl.models.interfaces import ISite from zope.interface import directlyProvides site = testing.DummyModel(sessions=DummySessions()) directlyProvides(site, ISite) from karl.testing import DummyCatalog from karl.models.adapters import CatalogSearch from karl.models.interfaces import ICatalogSearch from zope.interface import Interface site.catalog = DummyCatalog() karl.testing.registerAdapter(CatalogSearch, (Interface), ICatalogSearch) context = self.context site['newsfolder'] = context tags = DummyTags() site.tags = tags controller = self._makeOne(context, self.request) from karl.content.views.newsitem import _now from karl.testing import DummyUpload attachment1 = DummyUpload(filename='test1.txt') attachment2 = DummyUpload(filename=r'C:\My Documents\Ha Ha\test2.txt') photo = DummyUpload(filename='test.jpg', mimetype='image/jpeg', data=dummy_photo) now = _now() converted = { 'title': 'Foo', 'text': 'text', 'publication_date': now, 'caption': 'caption', 'tags': ['tag1', 'tag2'], 'attachments': [attachment1, attachment2], 'photo': photo } from karl.content.interfaces import INewsItem from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyNewsItem, INewsItem) registerContentFactory(DummyFile, ICommunityFile) response = controller.handle_submit(converted) newsitem_url = 'http://example.com/newsfolder/foo/' self.assertEqual(response.location, newsitem_url) self.failUnless('foo' in context) newsitem = context['foo'] self.assertEqual(newsitem.title, 'Foo') self.assertEqual(newsitem.text, 'text') self.assertEqual(newsitem.publication_date, now) self.assertEqual(newsitem.caption, 'caption') self.failUnless('attachments' in newsitem) attachments_folder = newsitem['attachments'] self.failUnless('test1.txt' in attachments_folder) self.failUnless('test2.txt' in attachments_folder) self.assertEqual(attachments_folder['test1.txt'].filename, 'test1.txt') self.assertEqual(attachments_folder['test2.txt'].filename, 'test2.txt') self.failUnless('photo' in newsitem) self.assertEqual(newsitem['photo'].data, dummy_photo) self.assertEqual(site.tags._called_with[1]['tags'], ['tag1', 'tag2'])
def test_handle_submit(self): context = self.context # register dummy IPage content factory def factory(title, text, description, creator): page = DummyPage(title=title, text=text, description=description, creator=creator) page['attachments'] = DummyModel() return page registerContentFactory(factory, IPage) # set up attachments from karl.content.interfaces import ICommunityFile from karl.testing import DummyFile registerContentFactory(DummyFile, ICommunityFile) from karl.testing import DummyUpload attachment1 = DummyUpload(filename='test1.txt') attachment2 = DummyUpload(filename=r"C:\My Documents\Ha Ha\test2.txt") # set up tags infrastructure from karl.testing import DummyCommunity from karl.testing import DummyTags community = DummyCommunity() site = community.__parent__.__parent__ site.sessions = DummySessions() site.catalog = DummyCatalog() site.tags = DummyTags() community['pages'] = context # construct converted dict and call handle_submit converted = { 'title': u'Page Title', 'text': u'page text', 'tags': [u'foo', u'bar'], 'attachments': [attachment1, attachment2], } context.ordering = DummyOrdering() controller = self._makeOne(context, self.request) controller.handle_submit(converted) # make sure everything looks good # basic fields self.failUnless(u'page-title' in context) page = context['page-title'] self.assertEqual(page.title, u'Page Title') self.assertEqual(page.text, u'page text') # attachments attachments_folder = page['attachments'] self.failUnless('test1.txt' in attachments_folder) self.failUnless('test2.txt' in attachments_folder) self.assertEqual(attachments_folder['test1.txt'].filename, 'test1.txt') self.assertEqual(attachments_folder['test2.txt'].filename, 'test2.txt') # ordering self.assertEqual(context.ordering.names_added, ['page-title']) # tags self.assertEqual(site.tags._called_with[1]['tags'], [u'foo', u'bar'])
def test_handle_submit(self): context = self.context # register dummy IPage content factory def factory(title, text, description, creator): page = DummyModel(title=title, text=text, description=description, creator=creator) page['attachments'] = DummyModel() return page registerContentFactory(factory, IPage) # set up attachments from karl.content.interfaces import ICommunityFile from karl.testing import DummyFile registerContentFactory(DummyFile, ICommunityFile) from karl.testing import DummyUpload attachment1 = DummyUpload(filename='test1.txt') attachment2 = DummyUpload(filename=r"C:\My Documents\Ha Ha\test2.txt") # set up tags infrastructure from karl.testing import DummyCommunity from karl.testing import DummyTags community = DummyCommunity() site = community.__parent__.__parent__ site.sessions = DummySessions() site.catalog = DummyCatalog() site.tags = DummyTags() community['pages'] = context # construct converted dict and call handle_submit converted = {'title': u'Page Title', 'text': u'page text', 'tags': [u'foo', u'bar'], 'attachments': [attachment1, attachment2], } context.ordering = DummyOrdering() controller = self._makeOne(context, self.request) response = controller.handle_submit(converted) # make sure everything looks good # basic fields self.failUnless(u'page-title' in context) page = context['page-title'] self.assertEqual(page.title, u'Page Title') self.assertEqual(page.text, u'page text') # attachments attachments_folder = page['attachments'] self.failUnless('test1.txt' in attachments_folder) self.failUnless('test2.txt' in attachments_folder) self.assertEqual(attachments_folder['test1.txt'].filename, 'test1.txt') self.assertEqual(attachments_folder['test2.txt'].filename, 'test2.txt') # ordering self.assertEqual(context.ordering.names_added, ['page-title']) # tags self.assertEqual(site.tags._called_with[1]['tags'], [u'foo', u'bar'])
def test_blog_entry(self): from karl.content.interfaces import IBlogEntry as ctype from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory registerContentFactory(testing.DummyModel, ctype) context = testing.DummyModel() directlyProvides(context, ctype) self.assertEqual(self._callFUT(context), ('Blog Entry', 'blog.png'))
def test_wiki_page(self): from karl.content.interfaces import IWikiPage as ctype from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory registerContentFactory(testing.DummyModel, ctype) context = testing.DummyModel() directlyProvides(context, ctype) self.assertEqual(self._callFUT(context), ('Wiki Page', 'wiki.png'))
def test_community(self): from karl.models.interfaces import ICommunity as ctype from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory registerContentFactory(testing.DummyModel, ctype) context = testing.DummyModel() directlyProvides(context, ctype) self.assertEqual(self._callFUT(context), ('Community', 'building.png'))
def setUp(self): self.config = setUp() from adhocracy.core.models.references import child_factory from repoze.lemonade.testing import registerContentFactory registerContentFactory(child_factory, self._target_marker_interface) from adhocracy.core.models.references import Child self.config.registry.registerAdapter(Child) self.graph = get_graph()
def test_calendar_event(self): from karl.content.interfaces import ICalendarEvent as ctype from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory registerContentFactory(testing.DummyModel, ctype) context = testing.DummyModel() directlyProvides(context, ctype) self.assertEqual(self._callFUT(context), ('Event', 'calendar-select.png'))
def test_news_item(self): from karl.content.interfaces import INewsItem as ctype from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory registerContentFactory(testing.DummyModel, ctype) context = testing.DummyModel() directlyProvides(context, ctype) self.assertEqual(self._callFUT(context), ('News Item', 'newspaper.png'))
def test_file(self): from karl.content.interfaces import ICommunityFile as ctype from zope.interface import directlyProvides from repoze.lemonade.testing import registerContentFactory registerContentFactory(testing.DummyModel, ctype) context = testing.DummyModel() directlyProvides(context, ctype) self.assertEqual(self._callFUT(context), ('File', 'blue-document-text.png'))
def setUp(self): self.config = setUp() from adhocracy.core.models.adhocracyroot import adhocracyroot_factory registerContentFactory(adhocracyroot_factory, \ self._target_marker_interface) from adhocracy.core.models.adhocracyroot\ import AdhocracyRootLocationAware self.config.registry.registerAdapter(AdhocracyRootLocationAware) self.graph = get_graph()
def test_handle_submit_success(self): registerContentFactory(oitesting.DummyProfile, IProfile) class DummyWhoPlugin(object): def remember(self, environ, identity): self.identity = identity return [] plugin = DummyWhoPlugin() whoplugins = {'auth_tkt':plugin} self.request.environ['repoze.who.plugins'] = whoplugins community = self.context community.members_group_name = 'community:members' context = testing.DummyModel() community['invite'] = context community.title = 'Community' community.description = 'Community' community.sessions = DummySessions() context.email = '*****@*****.**' self.context = context controller = self._makeOne() self.request.POST = MultiDict([ ('__start__', u'account:mapping'), ('username', u'username'), ('__start__', u'password:mapping'), ('value', u'safe'), ('confirm', u'safe'), ('__end__', u'password:mapping'), ('__end__', u'account:mapping'), ('__start__', u'details:mapping'), ('first_name', u'Joe'), ('last_name', u'Marks'), ('country', u'ZW'), ('__start__', u'date_of_birth:mapping'), ('year', u''), ('month', u''), ('day', u''), ('__end__', u'date_of_birth:mapping'), ('gender', u''), ('__end__', u'details:mapping'), ('__start__', u'terms:mapping'), ('terms_of_use', u'true'), ('__end__', u'terms:mapping'), ('join up', u'join up') ]) response = controller() self.assertEqual(response.location, 'http://example.com/?status_message=Welcome%21') self.assertEqual(community.users.added, ('username', 'username', 'safe', ['community:members'])) self.assertEqual(plugin.identity, {'repoze.who.userid':'username'}) profiles = community['profiles'] self.failUnless('username' in profiles) self.assertEqual(profiles['username'].security_state, 'active') self.failIf('invite' in community) self.assertEqual(len(self.mailer), 1)
def test_calendar_search_layout(self): root = testing.DummyModel() root.catalog = {} root['profiles'] = profiles = testing.DummyModel() profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee') from webob.multidict import MultiDict from karl.models.interfaces import ICommunity from zope.interface import directlyProvides root['communities'] = testing.DummyModel() community = root['communities']['default'] = testing.DummyModel( title='citizens') office = root['offices'] = testing.DummyModel(title='all rights') directlyProvides(community, ICommunity) directlyProvides(office, ICommunity) request = testing.DummyRequest(params=MultiDict({'body': 'yo'})) request.layout_manager = mock.Mock() from zope.interface import Interface from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) import karl.views.api save_community = karl.views.api.TemplateAPI.community_layout save_generic = karl.views.api.TemplateAPI.generic_layout try: karl.views.api.TemplateAPI.community_layout = 'COMMUNITY' karl.views.api.TemplateAPI.generic_layout = 'GENERIC' # not on community result = self._callFUT(root, request) self.assertEqual(result['community'], None) self.assertEqual(result['old_layout'], 'GENERIC') self.assertEqual(result['show_search_knobs'], False) # normal community result = self._callFUT(community, request) self.assertEqual(result['community'], 'citizens') self.assertEqual(result['old_layout'], 'COMMUNITY') self.assertEqual(result['show_search_knobs'], False) # office (generic layout, ie, wide here) result = self._callFUT(office, request) self.assertEqual(result['community'], 'all rights') self.assertEqual(result['old_layout'], 'GENERIC') self.assertEqual(result['show_search_knobs'], False) finally: karl.views.api.TemplateAPI.community_layout = save_community karl.views.api.TemplateAPI.generic_layout = save_generic
def test_handle_submit(self): from karl.models.interfaces import IComment from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyComment, IComment) registerContentFactory(DummyFile, ICommunityFile) from karl.testing import DummyUpload attachment1 = DummyUpload(filename="test1.txt") attachment2 = DummyUpload(filename=r"C:\My Documents\Ha Ha\test2.txt") converted = {'add_comment': u'This is my comment', 'attachments': [attachment1, attachment2], 'sendalert': False} context = self.context controller = self._makeOne(context, self.request) response = controller.handle_submit(converted) location = ('http://example.com/communities/community/blog/foo/' '?status_message=Comment%20added') self.assertEqual(response.location, location) self.failUnless(u'99' in context) comment = context[u'99'] self.assertEqual(comment.title, 'Re: Dummy Blog Entry') self.assertEqual(comment.text, u'This is my comment') self.assertEqual(len(comment), 2) self.failUnless('test1.txt' in comment) self.failUnless('test2.txt' in comment) # try again w/ a workflow, and w/ sendalert == True del context[u'99'] workflow = self._registerSecurityWorkflow() blogentry = context.__parent__ blogentry.creator = 'b' blogentry.created = datetime.now() blogentry.text = u'Blog entry text' converted = {'add_comment': u'This is my OTHER comment', 'attachments': [], 'sendalert': True, 'security_state': 'public'} karl.testing.registerDummyRenderer( 'karl.content.views:templates/email_blog_comment_alert.pt') response = controller.handle_submit(converted) self.assertEqual(response.location, location) self.failUnless(u'99' in context) comment = context[u'99'] self.assertEqual(len(comment), 0) mailer = self.mailer self.assertEqual(len(mailer), 3) recipients = [mail.mto[0] for mail in mailer] self.failUnless('*****@*****.**' in recipients) self.failUnless('*****@*****.**' in recipients) self.failUnless('*****@*****.**' in recipients) self.failUnless(comment in workflow.initialized) self.assertEqual(len(workflow.transitioned), 1) transition = workflow.transitioned[0] self.failUnless(transition['content'] is comment) self.assertEqual(transition['to_state'], 'public')
def test_handle_submit(self): from karl.testing import registerSettings registerSettings() context = self.blog self.site.system_email_domain = 'example.com' tags = DummyTags() self.site.tags = tags from karl.testing import DummyCatalog self.site.catalog = DummyCatalog() self.site.sessions = DummySessions() from karl.testing import DummyUpload attachment1 = DummyUpload(filename="test1.txt") attachment2 = DummyUpload(filename=r"C:\My Documents\Ha Ha\test2.txt") converted = { 'title':'foo', 'text':'text', 'tags':['tag1', 'tag2'], 'sendalert':True, 'security_state':'public', 'attachments':[attachment1, attachment2], } self._register() from karl.content.interfaces import IBlogEntry from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyBlogEntry, IBlogEntry) registerContentFactory(DummyFile, ICommunityFile) request = self._makeRequest() controller = self._makeOne(context, request) response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/communities/community/blog/foo/') self.assertEqual(3, len(self.mailer)) for x in self.mailer: self.assertEqual(x.mfrom, '*****@*****.**') recipients = reduce(lambda x,y: x+y, [x.mto for x in self.mailer]) recipients.sort() self.assertEqual(["*****@*****.**", "*****@*****.**", "*****@*****.**",], recipients) blogentry_url = "http://example.com/communities/community/blog/foo/" attachments_url = "%sattachments" % blogentry_url self.failUnless(context['foo']['attachments']['test1.txt']) self.failUnless(context['foo']['attachments']['test2.txt']) from base64 import decodestring body = self.mailer[0].msg.get_payload(decode=True) self.failUnless("%s/test1.txt" % attachments_url in body) self.failUnless("%s/test2.txt" % attachments_url in body) attachment1 = context['foo']['attachments']['test1.txt'] self.assertEqual(attachment1.filename, "test1.txt") attachment2 = context['foo']['attachments']['test2.txt'] self.assertEqual(attachment2.filename, "test2.txt")
def test_calendar_search_layout(self): root = testing.DummyModel() root.catalog = {} root['profiles'] = profiles = testing.DummyModel() profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee') from webob.multidict import MultiDict from karl.models.interfaces import ICommunity from zope.interface import directlyProvides root['communities'] = testing.DummyModel() community = root['communities']['default'] = testing.DummyModel(title='citizens') office = root['offices'] = testing.DummyModel(title='all rights') directlyProvides(community, ICommunity) directlyProvides(office, ICommunity) request = testing.DummyRequest(params=MultiDict({'body':'yo'})) request.layout_manager = mock.Mock() from zope.interface import Interface from karl.models.interfaces import ICatalogSearch from karl.views.interfaces import IAdvancedSearchResultsDisplay from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyContent, IDummyContent) karltesting.registerAdapter(DummySearch, (Interface), ICatalogSearch) karltesting.registerAdapter(DummySearchResultsDisplay, (Interface, Interface), IAdvancedSearchResultsDisplay) import karl.views.api save_community = karl.views.api.TemplateAPI.community_layout save_generic = karl.views.api.TemplateAPI.generic_layout try: karl.views.api.TemplateAPI.community_layout = 'COMMUNITY' karl.views.api.TemplateAPI.generic_layout = 'GENERIC' # not on community result = self._callFUT(root, request) self.assertEqual(result['community'], None) self.assertEqual(result['old_layout'], 'GENERIC') self.assertEqual(result['show_search_knobs'], False) # normal community result = self._callFUT(community, request) self.assertEqual(result['community'], 'citizens') self.assertEqual(result['old_layout'], 'COMMUNITY') self.assertEqual(result['show_search_knobs'], False) # office (generic layout, ie, wide here) result = self._callFUT(office, request) self.assertEqual(result['community'], 'all rights') self.assertEqual(result['old_layout'], 'GENERIC') self.assertEqual(result['show_search_knobs'], False) finally: karl.views.api.TemplateAPI.community_layout = save_community karl.views.api.TemplateAPI.generic_layout = save_generic
def test_handle_submit_success(self): from karl.models.interfaces import IProfile from repoze.lemonade.testing import registerContentFactory from repoze.sendmail.interfaces import IMailDelivery from repoze.workflow.testing import registerDummyWorkflow from karl.models.interfaces import ICommunity from zope.interface import directlyProvides workflow = registerDummyWorkflow('security') mailer = karltesting.DummyMailer() karltesting.registerUtility(mailer, IMailDelivery) registerContentFactory(DummyContent, IProfile) class DummyWhoPlugin(object): def remember(self, environ, identity): self.identity = identity return [] request = self._makeRequest() community = testing.DummyModel() profiles = testing.DummyModel() community['profiles'] = profiles community.users = karltesting.DummyUsers() community.members_group_name = 'community:members' directlyProvides(community, ICommunity) context = self._makeContext() community['invite'] = context community.title = 'Community' community.description = 'Community' community.sessions = DummySessions() context.email = '*****@*****.**' controller = self._makeOne(context, request) converted = {'password':'******', 'password_confirm':'1', 'username':'******', 'firstname':'firstname', 'lastname':'lastname', 'phone':'phone', 'extension':'extension', 'department':'department', 'position':'position', 'organization':'organization', 'location':'location', 'country':'country', 'websites':['website'], 'languages':'languages', 'date_format':'en-US', 'biography':'bio', } karltesting.registerDummyRenderer( 'karl.views:templates/email_accept_invitation.pt') response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/?status_message=Welcome%21') self.assertEqual(community.users.added, ('username', 'username', '1', ['community:members'])) profiles = community['profiles'] self.failUnless('username' in profiles) self.assertEqual(workflow.initialized,[profiles['username']]) profile = profiles['username'] self.assertEqual('phone', profile.phone) self.assertEqual('firstname', profile.firstname) self.assertEqual('lastname', profile.lastname) self.assertEqual('bio', profile.biography) self.failIf('invite' in community) self.assertEqual(len(mailer), 1)
def setUp(self): cleanUp() self.root = root = testing.DummyModel() root.users = testing.DummyUsers() root['profiles'] = testing.DummyModel() from repoze.lemonade.testing import registerContentFactory from karl.models.interfaces import IProfile registerContentFactory(testing.DummyProfile, IProfile)
def test_handle_submit(self): from karl.models.interfaces import ISite from zope.interface import directlyProvides site = testing.DummyModel(sessions=DummySessions()) directlyProvides(site, ISite) from karl.testing import DummyCatalog from karl.models.adapters import CatalogSearch from karl.models.interfaces import ICatalogSearch from zope.interface import Interface site.catalog = DummyCatalog() karl.testing.registerAdapter(CatalogSearch, (Interface), ICatalogSearch) context = self.context site['newsitem'] = context tags = DummyTags() site.tags = tags controller = self._makeOne(context, self.request) from karl.content.views.newsitem import _now now = _now() simple = { 'title': 'NewFoo', 'text': 'text', 'caption': 'caption', 'publication_date': now } from karl.testing import DummyUpload attachment1 = DummyUpload(filename='test1.txt') attachment2 = DummyUpload(filename=r'C:\My Documents\Ha Ha\test2.txt') photo = DummyUpload(filename='test.jpg', mimetype='image/jpeg', data=dummy_photo) converted = { 'tags': ['tag1', 'tag2'], 'attachments': [attachment1, attachment2], 'photo': photo, } converted.update(simple) from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyFile, ICommunityFile) response = controller.handle_submit(converted) msg = "?status_message=News%20Item%20edited" self.assertEqual(response.location, 'http://example.com/newsitem/%s' % msg) for field, value in simple.items(): self.assertEqual(getattr(context, field), value) attachments_folder = context['attachments'] self.failUnless('test1.txt' in attachments_folder) self.failUnless('test2.txt' in attachments_folder) self.assertEqual(attachments_folder['test1.txt'].filename, 'test1.txt') self.assertEqual(attachments_folder['test2.txt'].filename, 'test2.txt') self.failUnless('photo' in context) self.assertEqual(site.tags._called_with[1]['tags'], ['tag1', 'tag2'])
def test_handle_submit(self): from karl.models.interfaces import IComment from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyComment, IComment) registerContentFactory(DummyFile, ICommunityFile) from karl.testing import DummyUpload attachment1 = DummyUpload(filename="test1.txt") attachment2 = DummyUpload(filename=r"C:\My Documents\Ha Ha\test2.txt") converted = { 'add_comment': u'This is my comment', 'attachments': [attachment1, attachment2], 'sendalert': False } context = self.context controller = self._makeOne(context, self.request) response = controller.handle_submit(converted) location = ('http://example.com/communities/community/blog/foo/' 'comments/99/') self.assertEqual(response.location, location) self.assertEqual(context.title, 'Re: foo') self.assertEqual(context.text, u'This is my comment') self.assertEqual(len(context), 2) self.failUnless('test1.txt' in context) self.failUnless('test2.txt' in context) # try again w/ a workflow, and delete an attachment blogentry = context.__parent__ workflow = self._registerSecurityWorkflow() blogentry.text = u'Blog entry text' attachment1 = DummyUpload(None, None) attachment1.file = None attachment1.metadata = {} attachment2 = DummyUpload(None, None) attachment2.file = None attachment2.metadata = { 'default': 'test2.txt', 'remove': True, 'name': '' } converted = { 'add_comment': u'This is my OTHER comment', 'attachments': [attachment1, attachment2], 'security_state': 'public' } response = controller.handle_submit(converted) self.assertEqual(response.location, location) self.assertEqual(len(context), 1) self.failUnless('test1.txt' in context) self.failIf('test2.txt' in context) self.assertEqual(len(workflow.transitioned), 1) transition = workflow.transitioned[0] self.failUnless(transition['content'] is context) self.assertEqual(transition['to_state'], 'public')
def test_handle_submit(self): from karl.testing import registerSettings registerSettings() context = self.blog self.site.system_email_domain = 'example.com' tags = DummyTags() self.site.tags = tags from karl.testing import DummyCatalog self.site.catalog = DummyCatalog() self.site.sessions = DummySessions() from karl.testing import DummyUpload attachment1 = DummyUpload(filename="test1.txt") attachment2 = DummyUpload(filename=r"C:\My Documents\Ha Ha\test2.txt") converted = { 'title': 'foo', 'text': 'text', 'tags': ['tag1', 'tag2'], 'sendalert': True, 'security_state': 'public', 'attachments': [attachment1, attachment2], } self._register() from karl.content.interfaces import IBlogEntry from karl.content.interfaces import ICommunityFile from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyBlogEntry, IBlogEntry) registerContentFactory(DummyFile, ICommunityFile) request = self._makeRequest() controller = self._makeOne(context, request) karl.testing.registerDummyRenderer( 'templates/email_blog_entry_alert.pt') response = controller.handle_submit(converted) self.assertEqual(response.location, 'http://example.com/communities/community/blog/foo/') self.assertEqual(3, len(self.mailer)) recipients = reduce(lambda x, y: x + y, [x.mto for x in self.mailer]) recipients.sort() self.assertEqual([ "*****@*****.**", "*****@*****.**", "*****@*****.**", ], recipients) self.failUnless(context['foo']['attachments']['test1.txt']) self.failUnless(context['foo']['attachments']['test2.txt']) body = self.mailer[0].msg.get_payload(decode=True) self.assertEqual(body, '') attachment1 = context['foo']['attachments']['test1.txt'] self.assertEqual(attachment1.filename, "test1.txt") attachment2 = context['foo']['attachments']['test2.txt'] self.assertEqual(attachment2.filename, "test2.txt")
def test_create(self): from repoze.lemonade.testing import registerContentFactory from zope.interface import Interface registerContentFactory(testing.DummyModel, Interface) adapter = self._make_one() adapter.create(self.profiles) self.failUnless('crossi' in self.profiles.keys()) profile = self.profiles['crossi'] self.assertEqual(profile.__name__, 'crossi') self.assertEqual(profile.firstname, 'User') self.assertEqual(profile.lastname, 'Two') self.assertEqual(profile.email, '*****@*****.**') self.assertEqual(profile.phone, '212-555-1212') self.assertEqual(profile.extension, '123') self.assertEqual(profile.department, 'Human Resources') self.assertEqual(profile.position, 'Responsable Bibliotheque Monique Calixte') self.assertEqual(profile.organization, 'Open Society Institute') self.assertEqual(profile.location, 'Port-au-Prince') self.assertEqual(profile.country, 'HT') self.assertEqual(profile.websites, ('http://www.example.com/profile', )) self.assertEqual(profile.languages, 'Italian, English, Esperanto') self.assertEqual(profile.office, 'Fondation Connaissance et Liberte') self.assertEqual(profile.room_no, '1234') self.assertEqual(profile.biography, 'Was born, grew up, is still alive.') self.assertEqual(profile.home_path, 'offices/national-foundation') self.assertEqual(profile.categories['entities'], [ 'open-society-institute', 'hardees', ]) self.assertEqual(profile.categories['offices'], [ 'fondation-connaissance-et-liberte', 'hand-creme', ]) self.assertEqual(profile.categories['departments'], [ 'information-retrieval', 'paper-chase', ]) self.assertEqual(profile.categories['boards'], [ '1-x-3', ]) info = self.root.users.get_by_id('crossi') info.pop('password') self.assertEqual( info, { 'id': 'crossi', 'login': '******', 'groups': set(['group.KarlStaff', 'group.AnotherGroup']), })
def test_with_filename(self): from karl.content.interfaces import ICommunityFile from StringIO import StringIO attachments = [ DummyFile(filename='abc', mimetype='text/plain', file=StringIO('abc')) ] folder = testing.DummyModel() from repoze.lemonade.testing import registerContentFactory registerContentFactory(DummyFile, ICommunityFile) request = testing.DummyRequest() self._callFUT(attachments, folder, 'chris', request) self.failUnless('abc' in folder)