def test_submit_form(self):
from repoze.sendmail.interfaces import IMailDelivery
testing.registerDummyRenderer("templates/join_community.pt")
c = karltesting.DummyCommunity()
c.moderator_names = set(["moderator1", "moderator2"])
site = c.__parent__.__parent__
profiles = site["profiles"] = testing.DummyModel()
profiles["user"] = karltesting.DummyProfile()
profiles["moderator1"] = karltesting.DummyProfile()
profiles["moderator2"] = karltesting.DummyProfile()
mailer = karltesting.DummyMailer()
testing.registerUtility(mailer, IMailDelivery)
testing.registerDummySecurityPolicy("user")
request = testing.DummyRequest({
"form.submitted": "1",
"message": "Message text.",
})
testing.registerDummyRenderer(
'karl.views:templates/email_join_community.pt')
response = self._callFUT(c, request)
self.assertEqual(response.location,
"http://example.com/communities/community/"
"?status_message=Your+request+has+been+sent+"
"to+the+moderators.")
self.assertEqual(len(mailer), 1)
msg = mailer.pop()
self.assertEqual(msg.mto, ["*****@*****.**",
"*****@*****.**"])
def test_getMessageTarget_report_alias_w_subdomain(self):
from repoze.bfg.interfaces import ISettings
from repoze.bfg.testing import registerUtility
from repoze.bfg.traversal import model_path
from zope.interface import directlyProvides
from karl.models.interfaces import IPeopleDirectory
class DummySettings:
system_list_subdomain = 'lists.example.com'
registerUtility(DummySettings(), ISettings)
context = self._makeRoot()
cf = context['communities'] = self._makeContext()
cf['testing'] = self._makeContext()
pd = context['people'] = self._makeContext()
directlyProvides(pd, IPeopleDirectory)
section = pd['section'] = self._makeContext()
extant = section['extant'] = self._makeContext()
context.list_aliases['testing'] = model_path(extant)
mailin = self._makeOne(context)
message = DummyMessage()
message.to = ('*****@*****.**',)
info = mailin.getMessageTargets(message)
self.failIf(info.get('error'), info)
targets = info['targets']
self.assertEqual(len(targets), 1)
info = targets[0]
self.assertEqual(info['report'], 'section+extant')
self.assertEqual(info['community'], None)
self.assertEqual(info['tool'], None)
self.failIf(info.get('in_reply_to'), info)
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
testing.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)
testing.registerAdapter(DummySearch, (Interface),
ICatalogSearch)
testing.registerAdapter(DummySearchResultsDisplay,
(Interface, Interface),
IAdvancedSearchResultsDisplay)
result = self._callFUT(context, request)
self.assertEqual(result['terms'], ['People'])
self.assertEqual(len(result['results']), 1)
def test_comment_ordering(self):
context = DummyBlogEntry()
context['comments']['2'] = DummyComment(now=1233149510, text=u'before')
from karl.models.interfaces import ISite
from zope.interface import directlyProvides
from karl.testing import DummyProfile
directlyProvides(context, ISite)
from karl.content.interfaces import IBlog
from zope.interface import alsoProvides
alsoProvides(context, IBlog)
context['profiles'] = profiles = testing.DummyModel()
profiles['dummy'] = DummyProfile(title='Dummy Profile')
request = testing.DummyRequest()
def dummy_byline_info(context, request):
return context
from zope.interface import Interface
from karl.content.views.interfaces import IBylineInfo
testing.registerAdapter(dummy_byline_info, (Interface, Interface),
IBylineInfo)
self._register()
from karl.utilities.interfaces import IKarlDates
testing.registerUtility(dummy, IKarlDates)
renderer = testing.registerDummyRenderer('templates/show_blogentry.pt')
self._callFUT(context, request)
self.assertEqual(len(renderer.comments), 2)
self.assertEqual('before', renderer.comments[0]['text'])
self.assertEqual('sometext', renderer.comments[1]['text'])
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
testing.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_respect_alert_prefs(self):
from repoze.sendmail.interfaces import IMailDelivery
from repoze.bfg.interfaces import IRequest
from karl.models.interfaces import IProfile
from karl.testing import DummyMailer
mailer = DummyMailer()
testing.registerUtility(mailer, IMailDelivery)
community = DummyCommunity()
community["foo"] = context = testing.DummyModel()
directlyProvides(context, IDummy)
site = community.__parent__.__parent__
site["profiles"] = profiles = testing.DummyModel()
profiles["a"] = DummyProfile()
profiles["b"] = DummyProfile()
profiles["b"].set_alerts_preference(community.__name__,
IProfile.ALERT_DIGEST)
profiles["c"] = DummyProfile()
profiles["c"].set_alerts_preference(community.__name__,
IProfile.ALERT_NEVER)
community.member_names = set(("a","c",))
community.moderator_names = set(("b",))
request = testing.DummyRequest()
testing.registerAdapter(DummyEmailAlertAdapter,
(IDummy, IProfile, IRequest), IAlert)
self._get_instance().emit(context, request)
self.assertEqual(1, len(mailer))
self.assertEqual(1, len(profiles["b"]._pending_alerts))
def test_crackPayload_multiple_w_text(self):
from repoze.bfg.testing import registerUtility
from karl.utilities.interfaces import IMailinTextScrubber
_called_with = []
def _fooScrubber(text, text_mimetype=None):
_called_with.append((text, text_mimetype))
return text.upper()
registerUtility(_fooScrubber, IMailinTextScrubber, 'foo')
mailin = self._makeOne()
mailin.text_scrubber = 'foo'
message = DummyMessage()
filepart = DummyMessage()
filepart.filename = 'file1.bin'
filepart.payload = '0123456789ABCDEF'
filepart.content_type = 'application/octet-stream'
textpart = DummyMessage()
textpart.payload = 'payload'
textpart.charset = 'rot13'
textpart.content_type = 'text/plain'
message.payload = (filepart, textpart)
text, attachments = mailin.crackPayload(message)
self.assertEqual(text, u'CNLYBNQ')
self.assertEqual(len(attachments), 1)
filename, mimetype, data = attachments[0]
self.assertEqual(filename, 'file1.bin')
self.assertEqual(mimetype, 'application/octet-stream')
self.assertEqual(data, '0123456789ABCDEF')
self.assertEqual(len(_called_with), 1)
self.assertEqual(_called_with[0][0], 'cnlybnq')
self.assertEqual(_called_with[0][1], 'text/plain')
def test_no_security_policy(self):
context = DummyBlogEntry()
from karl.models.interfaces import ISite
from zope.interface import directlyProvides
from karl.testing import DummyProfile
directlyProvides(context, ISite)
from karl.content.interfaces import IBlog
from zope.interface import alsoProvides
alsoProvides(context, IBlog)
context['profiles'] = profiles = testing.DummyModel()
profiles['dummy'] = DummyProfile(title='Dummy Profile')
request = testing.DummyRequest()
def dummy_byline_info(context, request):
return context
from zope.interface import Interface
from karl.content.views.interfaces import IBylineInfo
testing.registerAdapter(dummy_byline_info, (Interface, Interface),
IBylineInfo)
self._register()
from karl.utilities.interfaces import IKarlDates
testing.registerUtility(dummy, IKarlDates)
renderer = testing.registerDummyRenderer('templates/show_blogentry.pt')
self._callFUT(context, request)
self.assertEqual(len(renderer.comments), 1)
c0 = renderer.comments[0]
self.assertEqual(c0['text'], 'sometext')
self.assertEqual(d1, renderer.comments[0]['date'])
self.assertEqual(c0['author_name'], 'Dummy Profile')
self.assertEqual(renderer.comments[0]['edit_url'],
'http://example.com/blogentry/comments/1/edit.html')
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
testing.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+invited.++'
)
invitation = context['A'*6]
self.assertEqual(invitation.email, '*****@*****.**')
self.assertEqual(1, len(mailer))
self.assertEqual(mailer[0].mto, [u"*****@*****.**",])
def test_configure_by_utility(self):
from repoze.bfg.interfaces import ISettings
testing.registerUtility(DummySettings(None), ISettings)
logger = self._makeOne()
self.assertEquals(logger._configured, False)
logger(DummyQueryEvent())
self.assertEquals(logger._configured, True)
self.assertEquals(logger.log_dir, None)
def test_with_settings_and_suppress_mail(self):
from repoze.bfg.interfaces import ISettings
from opencore.utilities.mailer import FakeMailDelivery
settings = DummySettings()
testing.registerUtility(settings, ISettings)
os = FakeOS(SUPPRESS_MAIL='1')
delivery = self._callFUT(os)
self.assertEqual(delivery.__class__, FakeMailDelivery)
def zztest_with_settings_for_real_messenger(self):
from repoze.bfg.interfaces import ISettings
from opencore.utilities.messenger import Messenger
settings = DummySettings()
testing.registerUtility(settings, ISettings)
os = FakeOS()
delivery = self._callFUT(os)
self.assertEqual(delivery.__class__, Messenger)
def test_custom_logo_url(self):
context = testing.DummyModel()
request = testing.DummyRequest()
from repoze.bfg.interfaces import ISettings
settings = karltesting.DummySettings()
settings.logo_path = 'mylogo.png'
testing.registerUtility(settings, ISettings)
api = self._makeOne(context, request)
self.assertEqual(api.logo_url, api.static_url + '/mylogo.png')
def test_mimeinfo_with_mimetype(self):
def m(mimetype):
return 123
from karl.utilities.interfaces import IMimeInfo
testing.registerUtility(m, IMimeInfo)
context = testing.DummyModel(mimetype='abc')
request = testing.DummyRequest()
adapter = self._makeOne(context, request)
self.assertEqual(adapter.mimeinfo, 123)
def _register(self):
d1 = 'Wednesday, January 28, 2009 08:32 AM'
def dummy(date, flavor):
return d1
from karl.utilities.interfaces import IKarlDates
testing.registerUtility(dummy, IKarlDates)
from karl.models.interfaces import ITagQuery
testing.registerAdapter(DummyTagQuery, (Interface, Interface),
ITagQuery)
def _set_whitelist(self, white_list):
from repoze.bfg.testing import registerUtility
from repoze.bfg.interfaces import ISettings
settings = DummySettings(mail_white_list=self.tmp_name)
registerUtility(settings, ISettings)
with open(self.tmp_name, "w") as f:
for email in white_list:
print >>f, email
def setUp(self):
self._cleanUp()
from karl.utilities.interfaces import IAlerts
from repoze.bfg.testing import registerUtility
self.alerts = DummyAlerts()
registerUtility(self.alerts, IAlerts)
from karl.testing import registerSettings
registerSettings()
def zztest_send_to_suppressed_messenger(self):
from repoze.bfg.interfaces import ISettings
settings = DummySettings()
testing.registerUtility(settings, ISettings)
os = FakeOS(SUPPRESS_MESSENGER='1')
delivery = self._callFUT(os)
joe = DummyProfile(name='joe')
delivery.quiet = False
delivery.send("a", joe, "frankly I don't give a damn!")
def _register(self):
from zope.interface import Interface
from karl.utilities.interfaces import IKarlDates
from karl.models.interfaces import ITagQuery
testing.registerUtility(dummy, IKarlDates)
testing.registerAdapter(DummyTagQuery, (Interface, Interface),
ITagQuery)
from repoze.workflow.testing import registerDummyWorkflow
registerDummyWorkflow('security')
def _register(self):
from zope.interface import Interface
from karl.models.interfaces import ITagQuery
from repoze.bfg.formish import IFormishRenderer
testing.registerAdapter(DummyTagQuery, (Interface, Interface),
ITagQuery)
def renderer(template, args):
return ''
testing.registerUtility(renderer, IFormishRenderer)
def test_with_white_list(self):
from tempfile import NamedTemporaryFile
from repoze.bfg.interfaces import ISettings
from opencore.utilities.mailer import WhiteListMailDelivery
settings = DummySettings()
f = NamedTemporaryFile()
settings.mail_white_list = f.name
testing.registerUtility(settings, ISettings)
delivery = self._callFUT()
self.assertEqual(delivery.__class__, WhiteListMailDelivery)
def test_mail_queue_path_unspecified(self):
import sys
from repoze.bfg.interfaces import ISettings
settings = DummySettings()
testing.registerUtility(settings, ISettings)
delivery = self._callFUT()
exe = sys.executable
sandbox = os.path.dirname(os.path.dirname(os.path.abspath(exe)))
queue_path = os.path.join(os.path.join(sandbox, "var"), "mail_queue")
self.assertEqual(delivery.queuePath, queue_path)
def test_with_converter(self):
from karl.utilities.converters.interfaces import IConverter
converter = DummyConverter('stuff')
testing.registerUtility(converter, IConverter, 'mimetype')
context = testing.DummyModel()
context.title = 'Some Title'
context.mimetype = 'mimetype'
context.blobfile = DummyBlobFile()
adapter = self._makeOne(context)
self.assertEqual(adapter(), 'Some Title ' * 10 + 'stuff')
def test_posted_date(self):
context = DummyContext()
from karl.utilities.interfaces import IKarlDates
d1 = 'Wednesday, January 28, 2009 08:32 AM'
def dummy(date, flavor):
return d1
testing.registerUtility(dummy, IKarlDates)
request = testing.DummyRequest()
adapter = self._makeOne(context, request)
self.assertEqual(adapter.posted_date, context.posted_date)
def _registerMailDelivery(self):
from repoze.sendmail.interfaces import IMailDelivery
class DummyMailDelivery:
def __init__(self):
self._sent = []
def send(self, to, message):
self._sent.append((to, message))
md = DummyMailDelivery()
testing.registerUtility(md, IMailDelivery)
return md
def setUp(self):
from repoze.bfg.testing import registerUtility
from opencore.models.interfaces import ISite
testing.setUp()
self._set_alerts_off()
from opencore.utilities import mbox
self.tx = mbox.transaction = DummyTransaction()
self.root = testing.DummyModel()
self.root['mailbox'] = testing.DummyModel()
registerUtility(self.root, ISite)
def _registerSecurityPolicy(self, permissions):
if permissions is None:
from repoze.bfg.testing import registerDummySecurityPolicy
registerDummySecurityPolicy("userid")
else:
from repoze.bfg.interfaces import IAuthenticationPolicy
from repoze.bfg.interfaces import IAuthorizationPolicy
from repoze.bfg.testing import registerUtility
policy = DummySecurityPolicy("userid", permissions=permissions)
registerUtility(policy, IAuthenticationPolicy)
registerUtility(policy, IAuthorizationPolicy)
def _set_whitelist(self, white_list):
import tempfile
from repoze.bfg.testing import registerUtility
from repoze.bfg.interfaces import ISettings
tmp = self.tmp_file = tempfile.NamedTemporaryFile()
settings = DummySettings(mail_white_list=tmp.name)
registerUtility(settings, ISettings)
for email in white_list:
print >>tmp, email
tmp.flush()
def setUp(self):
Base.setUp(self)
self.request = testing.DummyRequest()
self.context = self._makeContext()
self.request.api = get_template_api(self.context, self.request)
self.mailer = self._registerMailer()
def nonrandom(size=6):
return 'A' * size
testing.registerUtility(nonrandom, IRandomId)
registerContentFactory(DummyInvitation, IInvitation)
self.context['profiles'] = self.profiles = DummyProfiles()
def test___call___app_url_trailing_slash(self):
from repoze.bfg.interfaces import ISettings
from repoze.bfg.testing import DummyModel
from repoze.bfg.testing import registerUtility
class DummySettings(dict):
offline_app_url = "http://offline.example.com/app/"
registerUtility(DummySettings(), ISettings)
parent = DummyModel()
context = parent['foo'] = DummyModel()
url = self._makeOne(context)
self.assertEqual(url(), 'http://offline.example.com/app/foo')
