def test_argsForwarded(self): """ Test that the search aggregator forwards arguments given to C{search} to L{xmantissa.ixmantissa.ISearchProvider}s """ s = Store() installOn(ArgumentPassthroughSearchProvider(store=s), s) agg = search.SearchAggregator(store=s) installOn(agg, s) args = (((u'foo', { u'bar': u'baz' }), { 'sortAscending': False }), ((u'bar', { u'foo': u'oof' }), { 'sortAscending': True }), ((u'', {}), { 'sortAscending': True, 'count': 5, 'offset': 1 })) def checkArgs(gotArgs): for ((success, gotArgset), expectedArgset) in zip(gotArgs, args): self.assertEquals(gotArgset[0], expectedArgset) dl = defer.DeferredList([agg.search(*a[0], **a[1]) for a in args]) dl.addCallback(checkArgs) return dl
def setUp(self): """ Create an in-memory L{Store} with an L{AMPConfiguration} in it. """ self.store = Store() self.conf = AMPConfiguration(store=self.store) installOn(self.conf, self.store)
def postOptions(self): s = self.parent.getStore() didSomething = False if self['admin']: didSomething = True if self['disable']: for app in s.query(webadmin.AdminStatsApplication): app.deleteFromStore() break else: raise UsageError('Administrator controls already disabled.') else: installOn(webadmin.AdminStatsApplication(store=s), s) if self['developer']: didSomething = True if self['disable']: for app in s.query(webadmin.DeveloperApplication): app.deleteFromStore() break else: raise UsageError('Developer controls already disabled.') else: installOn(webadmin.DeveloperApplication(store=s), s) if not didSomething: raise UsageError("Specify something or I won't do anything.")
def setUp(self): self.store = Store() privApp = PrivateApplication(store=self.store) installOn(privApp, self.store) # Create some data to test with in an order which is not naturally # sorted in any way. # 4 1s, 4 0s, 4 2s self.data = [] for number in [1, 0, 2, 2, 0, 1, 1, 0, 2, 0, 2, 1]: self.data.append(DataThunk(store=self.store, a=number)) # But order it for the sake of simplicity while testing. self.data.sort(key=lambda item: (item.a, item.storeID)) self.model = TestableInequalityModel( self.store, DataThunk, None, [DataThunk.a, DataThunk.b, DataThunk.c], DataThunk.a, True)
def setUp(self): self.clock = Clock() scheduler = Scheduler(store=self.siteStore) self.stubTime(scheduler) installOn(scheduler, self.siteStore) IService(self.siteStore).startService()
def setUp(self): # XXX Incorrect setup. See xquotient.test.test_compose.CompositionTestMixin self.store = Store(self.mktemp()) LoginMethod(store=self.store, internal=False, protocol=u'email', localpart=u'recipient', domain=u'host', verified=True, account=self.store) self.fromAddr = smtpout.FromAddress(address=u'recipient@host', store=self.store) self.inbox = inbox.Inbox(store=self.store) installOn(self.inbox, self.store) self.composer = compose.Composer(store=self.store) installOn(self.composer, self.store) self.defaultFromAddress = self.store.findUnique( smtpout.FromAddress, smtpout.FromAddress._address == None) self.message = testMessageFactory( store=self.store, spam=False, impl=DummyMessageImplWithABunchOfAddresses(store=self.store)) self.messageDetail = MessageDetail(self.message)
def postOptions(self): strport = self['strport'] factoryIdentifier = self['factory-identifier'] if strport is None or factoryIdentifier is None: self.opt_help() store = self.parent.parent.getStore() storeID = int(factoryIdentifier) try: factory = store.getItemByID(storeID) except KeyError: print "%d does not identify an item." % (storeID,) raise SystemExit(1) else: if not IProtocolFactoryFactory.providedBy(factory): print "%d does not identify a factory." % (storeID,) raise SystemExit(1) else: description = self.decodeCommandLine(strport) try: serverFromString(reactor, description.encode('ascii')) except ValueError: print "%r is not a valid port description." % (strport,) raise SystemExit(1) port = StringEndpointPort( store=store, description=description, factory=factory) installOn(port, store) print "Created." raise SystemExit(0)
def testAvatarStoreState(self): """ You can only pass an 'avatars' argument if it doesn't already have an account in it. Some accounts want to have their stores in slightly odd places (like offering.py) but you can't have two accounts added which both point to the same store. """ dbdir = FilePath(self.mktemp()) s = Store(dbdir) ls = userbase.LoginSystem(store=s) dependency.installOn(ls, s) acc = ls.addAccount('alice', 'dom.ain', 'password') # this is allowed, if weird unrelatedAccount = ls.addAccount( 'elseice', 'dom.ain', 'password', avatars=SubStore.createNew(s, ('crazy', 'what'))) # this is not allowed. self.assertRaises(errors.DuplicateUniqueItem, ls.addAccount, 'bob', 'ain.dom', 'xpassword', avatars=acc.avatars) # Make sure that our stupid call to addAccount did not corrupt # anything, because we are stupid self.assertEqual(acc.avatars.open().query(userbase.LoginAccount).count(), 1)
def test_retrain(self): """ Verify that retraining a few messages will tell our new test filter to learn about a bunch of new messages. """ f = Filter(store=self.store) installOn(f, self.store) tf = TestFilter(store=self.store, test=self) installOn(tf, self.store) COUNT = 10 for j in range(2): for x in range(COUNT): msg = Message.createIncoming( self.store, DummyMessageImplementation(store=self.store), u"test://retrain" ) _spamState(msg, (x % 2), j) # This isn't quite correct. We're relying on the fact that the batch # processor is supposed to run in a subprocess (which isn't going) so # the callback is only going to be triggered for our set of messages # during the test. Bleah. def _(ign): self.assertEquals(tf.trainCount, COUNT) return f.retrain().addCallback(_)
def setUp(self): """ Make a store, an account/substore, an indexer, and call startService() on the superstore's IService so the batch process interactions that happen in fulltext.py work """ self.dbdir = self.mktemp() self.path = u'index' superstore = store.Store(self.dbdir) loginSystem = LoginSystem(store=superstore) installOn(loginSystem, superstore) account = loginSystem.addAccount(u'testuser', u'example.com', None) substore = account.avatars.open() self.store = substore self.indexer = self.createIndexer() self.svc = IService(superstore) self.svc.startService() # Make sure the indexer is actually available writer = self.openWriteIndex() writer.close()
def inbox5to6(old): """ Copy over all attributes except C{scheduler}. """ new = old.upgradeVersion( Inbox.typeName, 5, 6, privateApplication=old.privateApplication, messageSource=old.messageSource, quotientPrefs=old.quotientPrefs, messageDisplayPrefs=old.messageDisplayPrefs, deliveryAgent=old.deliveryAgent, uiComplexity=old.uiComplexity, showMoreDetail=old.showMoreDetail, filter=old.filter, focus=old.focus) # If the old item was original schema version 5 in the database, focus and # filter have already been installed, because the 4 to 5 upgrader used to # install them. However, now that 5 is not the newest version of Inbox, it # cannot do that. Only the upgrader to the newest version can. So do it # here, instead, if it is necessary (which is when the original schema # version was older than 5). if installedOn(new.filter) is None: installOn(new.filter, new.store) if installedOn(new.focus) is None: installOn(new.focus, new.store) return new
def test_requiresFromSiteInSiteStore(self): """ L{axiom.dependency.requiresFromSite} should use the C{siteDefaultFactory} rather than the C{defaultFactory} to satisfy the dependency for items stored in a site store. It should use this default whether or not any item which could satisfy the requirement is installed on the site store. This behavior is important because some powerup interfaces are provided for site and user stores with radically different behaviors; for example, the substore implementation of L{IScheduler} depends on the site implementation of L{IScheduler}; if a user's substore were opened accidentally as a site store (i.e. with no parent) then the failure of the scheduler API should be obvious and immediate so that it can compensate; it should not result in an infinite recursion as the scheduler is looking for its parent. Items which wish to be stored in a site store and also depend on items in the site store can specifically adapt to the appropriate interface in the C{siteDefaultFactory} supplied to L{dependency.requiresFromSite}. """ plant = PowerPlant(store=self.store) self.assertEquals(plant.grid.siteStore, self.store) self.assertEquals(plant.grid.draw(100), FAKE_POWER) dependency.installOn(RealGrid(store=self.store), self.store) self.assertEquals(plant.grid.siteStore, self.store) self.assertEquals(plant.grid.draw(100), FAKE_POWER)
def test_properOrphaning(self): """ If two installed items both depend on a third, it should be removed as soon as both installed items are removed, but no sooner. """ foo = Kitchen(store=self.store) e = Toaster(store=self.store) dependency.installOn(e, foo) ps = self.store.findUnique(PowerStrip) bb = self.store.findUnique(Breadbox) f = Blender(store=self.store) dependency.installOn(f, foo) self.assertEquals(list(self.store.query(PowerStrip)), [ps]) #XXX does ordering matter? self.assertEquals(set(dependency.installedDependents(ps, foo)), set([e, f])) self.assertEquals(set(dependency.installedRequirements(e, foo)), set([bb, ps])) self.assertEquals(list(dependency.installedRequirements(f, foo)), [ps]) dependency.uninstallFrom(e, foo) self.assertEquals(dependency.installedOn(ps), foo) dependency.uninstallFrom(f, foo) self.assertEquals(dependency.installedOn(ps), None)
def setUp(self): """ Create an in-memory L{Store} with a L{ShellAccount} in it. """ self.store = Store() self.account = ShellAccount(store=self.store) installOn(self.account, self.store)
def test_authenticatedApplicationNavigation(self): """ The I{applicationNavigation} renderer should add primary navigation elements to the tag it is passed if it is called on a L{_PublicPageMixin} being rendered for an authenticated user. """ navigable = FakeNavigableElement(store=self.userStore) installOn(navigable, self.userStore) navigable.tabs = [Tab('foo', 123, 0, [Tab('bar', 432, 0)])] request = FakeRequest() page = self.createPage(self.username) navigationPattern = div[ span(id='app-tab', pattern='app-tab'), span(id='tab-contents', pattern='tab-contents')] ctx = context.WebContext(tag=navigationPattern) ctx.remember(request) tag = page.render_applicationNavigation(ctx, None) self.assertEqual(tag.tagName, 'div') self.assertEqual(tag.attributes, {}) children = [child for child in tag.children if child.pattern is None] self.assertEqual(children, []) self.assertEqual(len(tag.slotData['tabs']), 1) fooTab = tag.slotData['tabs'][0] self.assertEqual(fooTab.attributes, {'id': 'app-tab'}) self.assertEqual(fooTab.slotData['name'], 'foo') fooContent = fooTab.slotData['tab-contents'] self.assertEqual(fooContent.attributes, {'id': 'tab-contents'}) self.assertEqual(fooContent.slotData['href'], self.privateApp.linkTo(123))
def upgradeProcessor1to2(oldProcessor): """ Batch processors stopped polling at version 2, so they no longer needed the idleInterval attribute. They also gained a scheduled attribute which tracks their interaction with the scheduler. Since they stopped polling, we also set them up as a timed event here to make sure that they don't silently disappear, never to be seen again: running them with the scheduler gives them a chance to figure out what's up and set up whatever other state they need to continue to run. Since this introduces a new dependency of all batch processors on a powerup for the IScheduler, install a Scheduler or a SubScheduler if one is not already present. """ newProcessor = oldProcessor.upgradeVersion( oldProcessor.typeName, 1, 2, busyInterval=oldProcessor.busyInterval) newProcessor.scheduled = extime.Time() s = newProcessor.store sch = iaxiom.IScheduler(s, None) if sch is None: if s.parent is None: # Only site stores have no parents. sch = Scheduler(store=s) else: # Substores get subschedulers. sch = SubScheduler(store=s) installOn(sch, s) # And set it up to run. sch.schedule(newProcessor, newProcessor.scheduled) return newProcessor
def postOptions(self): store = self.getStore() fact = store.findOrCreate(IRCBotFactoryFactory) svc = store.findOrCreate(IRCBotService, serviceID=self['id'], factory=fact) installOn(svc, store)
def _testPartDisplayerScrubbing(self, input, scrub=True): """ Set up a store, a PartItem with a body of C{input}, pass it to the PartDisplayer, render it, and return a deferred that'll fire with the string result of the rendering. @param scrub: if False, the noscrub URL arg will be added to the PartDisplayer request """ s = Store() installOn(PrivateApplication(store=s), s) part = PartItem(store=s, contentType=u'text/html', body=input) pd = PartDisplayer(None) pd.item = part req = makeRequest() if not scrub: req.args = {'noscrub': True} return deferredRender(pd, req)
def setUp(self): """ Set up an inequality model (by way of L{TestableInequalityModel}) backed by a user store with some sample data, and an L{IWebTranslator} powerup, to provide a somewhat realistic test setup. The data provided has some duplicates in the sort column, and it is intentionally inserted out of order, so that storeID order and sort column ordering will not coincide. """ self.store = Store() privApp = PrivateApplication(store=self.store) installOn(privApp, self.store) self.data = [] for a, b, c in [ (9, 1928, u'nine'), (1, 983, u'one'), (8, 843, u'eight'), (2, 827, u'two'), # (8, 1874, u'eight (DUP)'), (2, 294, u'two (DUP)'), (7, 18, u'seven'), (3, 19, u'three'), (6, 218, u'six'), (4, 2198, u'four'), (5, 1982, u'five'), (0, 10, u'zero') ]: self.data.append(DataThunk(store=self.store, a=a, b=b, c=c)) self.data.sort(key=lambda item: (item.a, item.storeID)) self.model = TestableInequalityModel( self.store, DataThunk, None, [DataThunk.a, DataThunk.b, DataThunk.c], DataThunk.a, True)
def postOptions(self): strport = self['strport'] factoryIdentifier = self['factory-identifier'] if strport is None or factoryIdentifier is None: self.opt_help() store = self.parent.parent.getStore() storeID = int(factoryIdentifier) try: factory = store.getItemByID(storeID) except KeyError: print "%d does not identify an item." % (storeID, ) raise SystemExit(1) else: if not IProtocolFactoryFactory.providedBy(factory): print "%d does not identify a factory." % (storeID, ) raise SystemExit(1) else: description = self.decodeCommandLine(strport) try: serverFromString(reactor, description.encode('ascii')) except ValueError: print "%r is not a valid port description." % (strport, ) raise SystemExit(1) port = StringEndpointPort(store=store, description=description, factory=factory) installOn(port, store) print "Created." raise SystemExit(0)
def upgradeMailTransferAgent3to4(oldMTA): """ Create TCPPort and SSLPort items as appropriate. """ if isinstance(oldMTA, MailDeliveryAgent): return oldMTA newMTA = oldMTA.upgradeVersion( MailTransferAgent.typeName, 3, 4, userbase=oldMTA.userbase, certificateFile=oldMTA.certificateFile, messageCount=oldMTA.messageCount, domain=oldMTA.domain) if oldMTA.portNumber is not None: port = TCPPort(store=newMTA.store, portNumber=oldMTA.portNumber, factory=newMTA) installOn(port, newMTA.store) securePortNumber = oldMTA.securePortNumber certificateFile = oldMTA.certificateFile if securePortNumber is not None and certificateFile: oldCertPath = newMTA.store.dbdir.preauthChild(certificateFile) if oldCertPath.exists(): newCertPath = newMTA.store.newFilePath('mta.pem') oldCertPath.copyTo(newCertPath) port = SSLPort(store=newMTA.store, portNumber=securePortNumber, certificatePath=newCertPath, factory=newMTA) installOn(port, newMTA.store) newMTA.store.powerDown(newMTA, IService) return newMTA
def test_incompleteUsername(self): """ Test that a login attempt using a username without a domain part results in a customized authentication failure message which points out that a domain part should be included in the username. """ mta = mail.MailTransferAgent(store=self.store) installOn(mta, self.store) factory = mta.getFactory() protocol = factory.buildProtocol(('192.168.1.1', 12345)) transport = StringTransport() transport.getHost = lambda: IPv4Address('TCP', '192.168.1.1', 54321) transport.getPeer = lambda: IPv4Address('TCP', '192.168.1.1', 12345) protocol.makeConnection(transport) protocol.dataReceived('EHLO example.net\r\n') protocol.dataReceived('AUTH LOGIN\r\n') protocol.dataReceived('testuser'.encode('base64') + '\r\n') transport.clear() protocol.dataReceived('password'.encode('base64') + '\r\n') written = transport.value() protocol.connectionLost(failure.Failure(error.ConnectionDone())) self.assertEquals( written, '535 Authentication failure [Username without domain name (ie ' '"yourname" instead of "yourname@yourdomain") not allowed; try ' 'with a domain name.]\r\n')
def setUp(self): """ Set up an inequality model (by way of L{TestableInequalityModel}) backed by a user store with some sample data, and an L{IWebTranslator} powerup, to provide a somewhat realistic test setup. The data provided has some duplicates in the sort column, and it is intentionally inserted out of order, so that storeID order and sort column ordering will not coincide. """ self.store = Store() privApp = PrivateApplication(store=self.store) installOn(privApp, self.store) self.data = [] for a, b, c in [(9, 1928, u'nine'), (1, 983, u'one'), (8, 843, u'eight'), (2, 827, u'two'), # (8, 1874, u'eight (DUP)'), (2, 294, u'two (DUP)'), (7, 18, u'seven'), (3, 19, u'three'), (6, 218, u'six'), (4, 2198, u'four'), (5, 1982, u'five'), (0, 10, u'zero')]: self.data.append(DataThunk(store=self.store, a=a, b=b, c=c)) self.data.sort(key=lambda item: (item.a, item.storeID)) self.model = TestableInequalityModel( self.store, DataThunk, None, [DataThunk.a, DataThunk.b, DataThunk.c], DataThunk.a, True)
def setUp(self): """ Extend L{_MessageRetrievalMixin.setUp} to also install an L{Organizer}, L{Person} and L{EmailAddress}, and an L{Message} from that person """ super(MessagesByPersonRetrievalTestCase, self).setUp() self.organizer = Organizer(store=self.store) installOn(self.organizer, self.store) self.person = Person(store=self.store, organizer=self.organizer, name=u'The Person') EmailAddress(store=self.store, address=u'the@person', person=self.person) self.messageFromPerson = testMessageFactory( store=self.store, read=False, spam=False, receivedWhen=Time(), sender=u'the@person')
def testPolicy(self): """ Test that only internal or verified L{userbase.LoginMethod}s with protocol=email are considered candidates for from addresses """ s = store.Store(self.mktemp()) ls = userbase.LoginSystem(store=s) installOn(ls, s) acc = ls.addAccount('username', 'dom.ain', 'password', protocol=u'not email') ss = acc.avatars.open() # not verified or internal, should explode self.assertRaises( RuntimeError, lambda: smtpout._getFromAddressFromStore(ss)) # ANY_PROTOCOL acc.addLoginMethod(u'yeah', u'x.z', internal=True) # should work self.assertEquals( '[email protected]', smtpout._getFromAddressFromStore(ss)) ss.findUnique( userbase.LoginMethod, userbase.LoginMethod.localpart == u'yeah').deleteFromStore() # external, verified acc.addLoginMethod(u'yeah', u'z.a', internal=False, verified=True) # should work self.assertEquals( '[email protected]', smtpout._getFromAddressFromStore(ss))
def createDatabase(store): scheduler = Scheduler(store=store) installOn(scheduler, store) installOn( _SubSchedulerParentHook( store=store, loginAccount=SubStore(store=store)), store)
def pop3listener2to3(oldPOP3): """ Create TCPPort and SSLPort items as appropriate. """ newPOP3 = oldPOP3.upgradeVersion(POP3Listener.typeName, 2, 3, userbase=oldPOP3.userbase, certificateFile=oldPOP3.certificateFile) if oldPOP3.portNumber is not None: port = TCPPort(store=newPOP3.store, portNumber=oldPOP3.portNumber, factory=newPOP3) installOn(port, newPOP3.store) securePortNumber = oldPOP3.securePortNumber certificateFile = oldPOP3.certificateFile if securePortNumber is not None and certificateFile: oldCertPath = newPOP3.store.dbdir.preauthChild(certificateFile) if oldCertPath.exists(): newCertPath = newPOP3.store.newFilePath('pop3.pem') oldCertPath.copyTo(newCertPath) port = SSLPort(store=newPOP3.store, portNumber=oldPOP3.securePortNumber, certificatePath=newCertPath, factory=newPOP3) installOn(port, newPOP3.store) newPOP3.store.powerDown(newPOP3, IService) return newPOP3
def test_retrain(self): """ Verify that retraining a few messages will tell our new test filter to learn about a bunch of new messages. """ f = Filter(store=self.store) installOn(f, self.store) tf = TestFilter(store=self.store, test=self) installOn(tf, self.store) COUNT = 10 for j in range(2): for x in range(COUNT): msg = Message.createIncoming( self.store, DummyMessageImplementation(store=self.store), u'test://retrain') _spamState(msg, (x % 2), j) # This isn't quite correct. We're relying on the fact that the batch # processor is supposed to run in a subprocess (which isn't going) so # the callback is only going to be triggered for our set of messages # during the test. Bleah. def _(ign): self.assertEquals(tf.trainCount, COUNT) return f.retrain().addCallback(_)
def doRendering(self, fragmentClass): """ Verify that the given fragment class will render without raising an exception. """ siteStore = Store() loginSystem = LoginSystem(store=siteStore) installOn(loginSystem, siteStore) p = Product( store=siteStore, types=["xmantissa.webadmin.LocalUserBrowser", "xmantissa.signup.SignupConfiguration"] ) account = loginSystem.addAccount(u"testuser", u"localhost", None) p.installProductOn(account.avatars.open()) f = fragmentClass(None, u"testuser", account) p = LivePage(docFactory=stan(html[head(render=directive("liveglue")), body(render=lambda ctx, data: f)])) f.setFragmentParent(p) ctx = WovenContext() req = FakeRequest() ctx.remember(req, IRequest) d = p.renderHTTP(ctx) def rendered(ign): p.action_close(None) d.addCallback(rendered) return d
def postOptions(self): store = self.parent.getStore() util.setAPIKey(store, SuperfeedrService.apiKeyName, self['key']) svc = store.findOrCreate(SuperfeedrService) installOn(svc, store)
def testGetLoginMethods(self): """ Test L{userbase.getLoginMethods} """ dbdir = FilePath(self.mktemp()) s = Store(dbdir) ls = userbase.LoginSystem(store=s) dependency.installOn(ls, s) acc = ls.addAccount('username', 'dom.ain', 'password', protocol='speech') ss = acc.avatars.open() for protocol in (None, 'speech'): self.assertEqual(list(userbase.getAccountNames(ss, protocol)), [('username', 'dom.ain')]) # defaults to ANY_PROTOCOL acc.addLoginMethod('username2', 'dom.ain') # check that searching for protocol=speech also gives us the # ANY_PROTOCOL LoginMethod for protocol in (None, 'speech'): self.assertEqual(sorted(userbase.getAccountNames(ss, protocol)), [('username', 'dom.ain'), ('username2', 'dom.ain')])
def doRendering(self, fragmentClass): """ Verify that the given fragment class will render without raising an exception. """ siteStore = Store() loginSystem = LoginSystem(store=siteStore) installOn(loginSystem, siteStore) p = Product(store=siteStore, types=["xmantissa.webadmin.LocalUserBrowser", "xmantissa.signup.SignupConfiguration"]) account = loginSystem.addAccount(u'testuser', u'localhost', None) p.installProductOn(account.avatars.open()) f = fragmentClass(None, u'testuser', account) p = LivePage( docFactory=stan( html[ head(render=directive('liveglue')), body(render=lambda ctx, data: f)])) f.setFragmentParent(p) ctx = WovenContext() req = FakeRequest() ctx.remember(req, IRequest) d = p.renderHTTP(ctx) def rendered(ign): p.action_close(None) d.addCallback(rendered) return d
def test_authenticatedApplicationNavigation(self): """ The I{applicationNavigation} renderer should add primary navigation elements to the tag it is passed if it is called on a L{_PublicPageMixin} being rendered for an authenticated user. """ navigable = FakeNavigableElement(store=self.userStore) installOn(navigable, self.userStore) navigable.tabs = [Tab("foo", 123, 0, [Tab("bar", 432, 0)])] request = FakeRequest() page = self.createPage(self.username) navigationPattern = div[span(id="app-tab", pattern="app-tab"), span(id="tab-contents", pattern="tab-contents")] ctx = context.WebContext(tag=navigationPattern) ctx.remember(request) tag = page.render_applicationNavigation(ctx, None) self.assertEqual(tag.tagName, "div") self.assertEqual(tag.attributes, {}) children = [child for child in tag.children if child.pattern is None] self.assertEqual(children, []) self.assertEqual(len(tag.slotData["tabs"]), 1) fooTab = tag.slotData["tabs"][0] self.assertEqual(fooTab.attributes, {"id": "app-tab"}) self.assertEqual(fooTab.slotData["name"], "foo") fooContent = fooTab.slotData["tab-contents"] self.assertEqual(fooContent.attributes, {"id": "tab-contents"}) self.assertEqual(fooContent.slotData["href"], self.privateApp.linkTo(123))
def inbox5to6(old): """ Copy over all attributes except C{scheduler}. """ new = old.upgradeVersion( Inbox.typeName, 5, 6, privateApplication=old.privateApplication, messageSource=old.messageSource, quotientPrefs=old.quotientPrefs, messageDisplayPrefs=old.messageDisplayPrefs, deliveryAgent=old.deliveryAgent, uiComplexity=old.uiComplexity, showMoreDetail=old.showMoreDetail, filter=old.filter, focus=old.focus, ) # If the old item was original schema version 5 in the database, focus and # filter have already been installed, because the 4 to 5 upgrader used to # install them. However, now that 5 is not the newest version of Inbox, it # cannot do that. Only the upgrader to the newest version can. So do it # here, instead, if it is necessary (which is when the original schema # version was older than 5). if installedOn(new.filter) is None: installOn(new.filter, new.store) if installedOn(new.focus) is None: installOn(new.focus, new.store) return new
def test_orphanedSubSchedule(self): """ The same as test_scheduler, except using a subscheduler that is orphaned. """ subscheduler = SubScheduler(store=self.store) installOn(subscheduler, self.store) return self._testSchedule(subscheduler)
def test_authenticatedApplicationNavigation(self): """ The I{applicationNavigation} renderer should add primary navigation elements to the tag it is passed if it is called on a L{_PublicPageMixin} being rendered for an authenticated user. """ navigable = FakeNavigableElement(store=self.userStore) installOn(navigable, self.userStore) navigable.tabs = [Tab('foo', 123, 0, [Tab('bar', 432, 0)])] request = FakeRequest() page = self.createPage(self.username) navigationPattern = div[ span(id='app-tab', pattern='app-tab'), span(id='tab-contents', pattern='tab-contents')] ctx = context.WebContext(tag=navigationPattern) ctx.remember(request) tag = page.render_applicationNavigation(ctx, None) self.assertEqual(tag.tagName, 'div') self.assertEqual(tag.attributes, {}) children = [child for child in tag.children if child.pattern is None] self.assertEqual(children, []) self.assertEqual(len(tag.slotData['tabs']), 1) fooTab = tag.slotData['tabs'][0] self.assertEqual(fooTab.attributes, {'id': 'app-tab'}) self.assertEqual(fooTab.slotData['name'], 'foo') fooContent = fooTab.slotData['tab-contents'] self.assertEqual(fooContent.attributes, {'id': 'tab-contents'}) self.assertEqual( fooContent.slotData['href'], self.privateApp.linkTo(123))
def test_partDisplayerScrubbedContentLength(self): """ Test that L{PartDisplayer} sets the C{Content-Length} header to the length of the content after it has been transformed by the scrubber. """ s = Store() installOn(PrivateApplication(store=s), s) body = u'<div><script>haha</script>this is ok</div>' part = PartItem(store=s, contentType=u'text/html', bodyLength=len(body), body=body) partDisplayer = PartDisplayer(None) partDisplayer.item = part req = makeRequest() D = deferredRender(partDisplayer, req) def checkLength(renderedBody): self.assertEqual(int(req.headers.get('content-length')), len(renderedBody)) D.addCallback(checkLength) return D
def createPort(self, portNumber, ssl, certPath, factory, interface=u''): """ Create a new listening port. @type portNumber: C{int} @param portNumber: Port number on which to listen. @type ssl: C{bool} @param ssl: Indicates whether this should be an SSL port or not. @type certPath: C{str} @param ssl: If C{ssl} is true, a path to a certificate file somewhere within the site store's files directory. Ignored otherwise. @param factory: L{Item} which provides L{IProtocolFactoryFactory} which will be used to get a protocol factory to associate with this port. @return: C{None} """ store = self.store.parent if ssl: port = SSLPort(store=store, portNumber=portNumber, certificatePath=FilePath(certPath), factory=factory, interface=interface) else: port = TCPPort(store=store, portNumber=portNumber, factory=factory, interface=interface) installOn(port, store)
def setUp(self): s = Store() installOn(QuotientPreferenceCollection(store=s), s) installOn(people.Organizer(store=s), s) self.store = s self.md = MessageDetail(Message(store=s, subject=u'a/b/c', sender=u''))
def testPolicy(self): """ Test that only internal or verified L{userbase.LoginMethod}s with protocol=email are considered candidates for from addresses """ s = store.Store(self.mktemp()) ls = userbase.LoginSystem(store=s) installOn(ls, s) acc = ls.addAccount('username', 'dom.ain', 'password', protocol=u'not email') ss = acc.avatars.open() # not verified or internal, should explode self.assertRaises(RuntimeError, lambda: smtpout._getFromAddressFromStore(ss)) # ANY_PROTOCOL acc.addLoginMethod(u'yeah', u'x.z', internal=True) # should work self.assertEquals('[email protected]', smtpout._getFromAddressFromStore(ss)) ss.findUnique( userbase.LoginMethod, userbase.LoginMethod.localpart == u'yeah').deleteFromStore() # external, verified acc.addLoginMethod(u'yeah', u'z.a', internal=False, verified=True) # should work self.assertEquals('[email protected]', smtpout._getFromAddressFromStore(ss))
def test_buildTerminalProtocol(self): """ L{ImaginaryApp.buildTerminalProtocol} returns a L{CharacterSelectionTextServer} instance with a role representing the store it is in, a reference to the L{ImaginaryWorld} installed on the Imaginary application store, and a list of L{Thing} items shared to the role. """ # XXX This is too many stores for a unit test to need to create. siteStore = Store(filesdir=FilePath(self.mktemp())) Mantissa().installSite(siteStore, u'example.com', u'', False) installOffering(siteStore, imaginaryOffering, {}) login = siteStore.findUnique(LoginSystem) account = login.addAccount(u'alice', u'example.com', u'password') userStore = account.avatars.open() app = ImaginaryApp(store=userStore) installOn(app, userStore) imaginary = login.accountByAddress(u'Imaginary', None).avatars.open() world = imaginary.findUnique(ImaginaryWorld) # Alice connects to her own ImaginaryApp (all that is possible at the # moment). viewer = _AuthenticatedShellViewer(getAccountNames(userStore)) proto = app.buildTerminalProtocol(viewer) self.assertIdentical(proto.world, world) self.assertEqual(proto.role.externalID, u'*****@*****.**') self.assertEqual(proto.choices, [])
def test_incompleteUsername(self): """ Test that a login attempt using a username without a domain part results in a customized authentication failure message which points out that a domain part should be included in the username. """ mta = mail.MailTransferAgent(store=self.store) installOn(mta, self.store) factory = mta.getFactory() protocol = factory.buildProtocol(("192.168.1.1", 12345)) transport = StringTransport() transport.getHost = lambda: IPv4Address("TCP", "192.168.1.1", 54321) transport.getPeer = lambda: IPv4Address("TCP", "192.168.1.1", 12345) protocol.makeConnection(transport) protocol.dataReceived("EHLO example.net\r\n") protocol.dataReceived("AUTH LOGIN\r\n") protocol.dataReceived("testuser".encode("base64") + "\r\n") transport.clear() protocol.dataReceived("password".encode("base64") + "\r\n") written = transport.value() protocol.connectionLost(failure.Failure(error.ConnectionDone())) self.assertEquals( written, "535 Authentication failure [Username without domain name (ie " '"yourname" instead of "yourname@yourdomain") not allowed; try ' "with a domain name.]\r\n", )
def pop3listener2to3(oldPOP3): """ Create TCPPort and SSLPort items as appropriate. """ newPOP3 = oldPOP3.upgradeVersion( POP3Listener.typeName, 2, 3, userbase=oldPOP3.userbase, certificateFile=oldPOP3.certificateFile) if oldPOP3.portNumber is not None: port = TCPPort(store=newPOP3.store, portNumber=oldPOP3.portNumber, factory=newPOP3) installOn(port, newPOP3.store) securePortNumber = oldPOP3.securePortNumber certificateFile = oldPOP3.certificateFile if securePortNumber is not None and certificateFile: oldCertPath = newPOP3.store.dbdir.preauthChild(certificateFile) if oldCertPath.exists(): newCertPath = newPOP3.store.newFilePath('pop3.pem') oldCertPath.copyTo(newCertPath) port = SSLPort(store=newPOP3.store, portNumber=oldPOP3.securePortNumber, certificatePath=newCertPath, factory=newPOP3) installOn(port, newPOP3.store) newPOP3.store.powerDown(newPOP3, IService) return newPOP3
def setUp(self): self.store = Store() self.scheduler = IScheduler(self.store) self.inbox = Inbox(store=self.store) installOn(self.inbox, self.store) self.translator = self.inbox.privateApplication self.inboxScreen = InboxScreen(self.inbox) self.viewSelection = dict(self.inboxScreen.viewSelection)
def installOn(self, other): # XXX check installation on other, not store for ls in self.store.query(userbase.LoginSystem): raise usage.UsageError("UserBase already installed") else: ls = userbase.LoginSystem(store=self.store) dependency.installOn(ls, other) return ls
def test_service(self): """ Test that C{self.portType} becomes a service on the store it is installed on. """ port = self.port(store=self.store) installOn(port, self.store) self.assertEqual(list(self.store.powerupsFor(IService)), [port])