def _store(self): store = Store(self.mktemp()) store.inMemoryPowerUp(NullUploadScheduler(), IUploadScheduler) contentStore = ContentStore(store=store) store.powerUp(contentStore, IContentStore) object.__setattr__(contentStore, '_deferToThreadPool', execute) return contentStore
def testStoreServicePowerup(self): s = Store() ss = SillyService(store=s) s.powerUp(ss, IService) IService(s).startService() IService(s).stopService() self.assertEquals(ss.started, 1) self.assertEquals(ss.stopped, 1) self.assertEquals(ss.running, 0)
def test_powerItUp(self): """ Powering up a store with an C{AboutPlugin} results in it being installed as an L{ISiteRootPlugin} powerup. """ s = Store() ap = self.aboutpage.AboutPlugin(store=s) s.powerUp(ap) self.assertEquals([ap], list(s.powerupsFor(ISiteRootPlugin)))
def testStoreServicePowerup(self): s = Store() ss = SillyService(store=s) s.powerUp(ss, IService) IService(s).startService() IService(s).stopService() self.assertEqual(ss.started, 1) self.assertEqual(ss.stopped, 1) self.assertEqual(ss.running, 0)
def test_powerUp(self): """ L{Calendar} is an L{IMessageReceiver} powerup. """ store = Store() calendar = self.cal.Calendar(store=store) self.assertTrue(verifyObject(IMessageReceiver, calendar)) store.powerUp(calendar) self.assertEquals(list(store.powerupsFor(IMessageReceiver)), [calendar])
def test_automaticPowerDown(self): """ Powerups with 'powerupInterfaces' attributes can be powered down automatically on the interfaces they specify. """ s = Store() p = PlusTwo(store=s) s.powerUp(p) s.powerDown(p) self.assertEquals(len(list(s.powerupsFor(IValueHaver))), 0)
def test_listUnlisteningFactory(self): """ I{axiomatic port list} displays factories even if they aren't associate with any port. """ store = Store() factory = DummyFactory(store=store) store.powerUp(factory, IProtocolFactoryFactory) self.assertSuccessStatus(self._makeConfig(store), ["list"]) self.assertEqual("%d) %r is not listening.\n" % (factory.storeID, factory), sys.stdout.getvalue())
def test_powerUp(self): """ L{Calendar} is an L{IMessageReceiver} powerup. """ store = Store() calendar = self.cal.Calendar(store=store) self.assertTrue(verifyObject(IMessageReceiver, calendar)) store.powerUp(calendar) self.assertEquals( list(store.powerupsFor(IMessageReceiver)), [calendar])
def test_automaticPowerDown(self): """ Powerups with 'powerupInterfaces' attributes can be powered down automatically on the interfaces they specify. """ s = Store() p = PlusTwo(store=s) s.powerUp(p) s.powerDown(p) self.assertEqual(len(list(s.powerupsFor(IValueHaver))), 0)
def test_automaticDynamicPowerDown(self): """ Powerups with '__getPowerupInterfaces__' methods can be powered down automatically on the interfaces they specify. """ s = Store() p = PlusOneTimesFour(store=s) s.powerUp(p) s.powerDown(p) self.assertEqual(len(list(s.powerupsFor(IValueHaver))), 0) self.assertEqual(len(list(s.powerupsFor(IScalingFactor))), 0)
def testIndirectedPowerups(self): """ Powerups which implement L{IPowerupIndirector} should not be returned directly, the values that they return from indirect() should be returned directly. """ s = Store() mm = Summer(store=s) s.powerUp(SubtractThree(store=s, valueHaver=SumContributor(store=s, value=5)), IValueHaver) self.assertEquals(mm.doSum(), 2) s.close()
def test_automaticDynamicPowerDown(self): """ Powerups with '__getPowerupInterfaces__' methods can be powered down automatically on the interfaces they specify. """ s = Store() p = PlusOneTimesFour(store=s) s.powerUp(p) s.powerDown(p) self.assertEquals(len(list(s.powerupsFor(IValueHaver))), 0) self.assertEquals(len(list(s.powerupsFor(IScalingFactor))), 0)
def test_listUnlisteningFactory(self): """ I{axiomatic port list} displays factories even if they aren't associate with any port. """ store = Store() factory = DummyFactory(store=store) store.powerUp(factory, IProtocolFactoryFactory) self.assertSuccessStatus(self._makeConfig(store), ["list"]) self.assertEqual( "%d) %r is not listening.\n" % (factory.storeID, factory), sys.stdout.getvalue())
def test_dynamicAutomaticPowerupInstall(self): """ Powerups with '__getPowerupInterfaces__' methods can be installed on the interfaces in the iterable that method returns. """ s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) p = PlusOneTimesFour(store=s) s.powerUp(p) self.assertEqual(mm.doSum(), 4)
def test_automaticPowerupInstall(self): """ Powerups with 'powerupInterfaces' attributes can be installed on those interfaces without the caller needing to refer to them directly. """ s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) p = PlusTwo(store=s) s.powerUp(p) self.assertEqual(mm.doSum(), 2)
def test_notOtherResources(self): """ C{AboutPlugin} will only respond to about.php, not every page on the site. """ s = Store(self.mktemp()) s.powerUp(self.aboutpage.AboutPlugin(store=s)) s.powerUp(AnonymousSite(store=s)) root = IMantissaSite(s) viewer = StubViewer() result = root.siteProduceResource(FakeRequest(), tuple(['undefined']), viewer) self.assertIdentical(result, None)
def test_dynamicAutomaticPowerupFailure(self): """ Powerups with '__getPowerupInterfaces__' methods that don't return iterables of pairs report an informative error message when powered up. """ s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) p = BrokenPowerup(store=s) err = self.assertRaises(ValueError, s.powerUp, p) self.assertEquals( str(err), "return value from %r.__getPowerupInterfaces__" " not an iterable of 2-tuples" % (p,) )
def test_dynamicAutomaticPowerupInstall(self): """ Powerups with '__getPowerupInterfaces__' methods can be installed on the interfaces in the iterable that method returns. """ s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) p = PlusOneTimesFour(store=s) s.powerUp(p) self.assertEquals(mm.doSum(), 4)
def test_dynamicAutomaticPowerupFailure(self): """ Powerups with '__getPowerupInterfaces__' methods that don't return iterables of pairs report an informative error message when powered up. """ s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) p = BrokenPowerup(store=s) err = self.assertRaises(ValueError, s.powerUp, p) self.assertEqual( str(err), 'return value from %r.__getPowerupInterfaces__' ' not an iterable of 2-tuples' % (p, ))
def test_automaticPowerupInstall(self): """ Powerups with 'powerupInterfaces' attributes can be installed on those interfaces without the caller needing to refer to them directly. """ s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) p = PlusTwo(store=s) s.powerUp(p) self.assertEquals(mm.doSum(), 2)
def testIndirectedPowerups(self): """ Powerups which implement L{IPowerupIndirector} should not be returned directly, the values that they return from indirect() should be returned directly. """ s = Store() mm = Summer(store=s) s.powerUp( SubtractThree(store=s, valueHaver=SumContributor(store=s, value=5)), IValueHaver) self.assertEqual(mm.doSum(), 2) s.close()
def test_adminRedirect(self): """ When the admin redirect is installed on a store, it should return an URL which should redirect to /private. """ s = Store(self.mktemp()) s.powerUp(self.adminpage.RedirectPlugin(store=s)) m = Mantissa() m.installSite(s, u'localhost', u'', False) root = IMantissaSite(s) viewer = StubViewer() result, segments = root.siteProduceResource(FakeRequest(), tuple(['admin.php']), viewer) self.assertEquals(result, URL.fromString("http://localhost/private"))
class AMPAvatarTests(TestCase): """ Tests for L{AMPAvatar} which provides an L{IBoxReceiver} implementation that supports routing messages to other L{IBoxReceiver} implementations. """ def setUp(self): """ Create a L{Store} with an L{AMPAvatar} installed on it. """ self.store = Store() self.avatar = AMPAvatar(store=self.store) installOn(self.avatar, self.store) self.factory = StubBoxReceiverFactory( store=self.store, protocol=u"bar") self.store.powerUp(self.factory, IBoxReceiverFactory) def test_interface(self): """ L{AMPAvatar} powers up the item on which it is installed for L{IBoxReceiver} and indirects that interface to the real router implementation of L{IBoxReceiver}. """ router = IBoxReceiver(self.store) self.assertTrue(verifyObject(IBoxReceiver, router)) self.assertNotIdentical(self.avatar, router) def test_connectorStarted(self): """ L{AMPAvatar.indirect} returns a L{Router} with a started route connector as its default receiver. """ receiver = SomeReceiver() self.avatar.__dict__['connectorFactory'] = lambda router: receiver router = self.avatar.indirect(IBoxReceiver) router.startReceivingBoxes(object()) self.assertTrue(receiver.started) def test_reactor(self): """ L{AMPAvatar.connectorFactory} returns a L{_RouteConnector} constructed using the global reactor. """ connector = self.avatar.connectorFactory(object()) self.assertIdentical(connector.reactor, reactor)
class MigrationManagerTests(TestCase): """ Tests for L{MigrationManager}. """ def setUp(self): self.store = Store() self.manager = MigrationManager(store=self.store) def test_installService(self): """ The service is started when it is installed into a running store, and stopped when it is deleted. """ IService(self.store).startService() installOn(self.manager, self.store) self.assertTrue(self.manager.running) self.manager.deleteFromStore() self.assertFalse(self.manager.running) def test_serviceRunsMigrations(self): """ Starting the service runs all existing migrations. """ m1 = TestMigration(store=self.store) m2 = TestMigration(store=self.store) self.store.powerUp(m1) self.store.powerUp(m2) self.assertEquals(m1.ran, 0) self.assertEquals(m2.ran, 0) self.manager.startService() self.assertEquals(m1.ran, 1) self.assertEquals(m2.ran, 1) def test_startMigration(self): """ Starting a migration invokes the implementation on the source store. """ source = MockContentStore() destination = MockContentStore(store=self.store) result = self.manager.migrate(source, destination) self.assertEquals(result.ran, 1) self.assertEquals(source.migrationDestination, destination) self.assertEquals(IMigration(self.store), result)
def test_produceAboutResource(self): """ When C{AboutPlugin} is installed on a site store created by 'axiomatic mantissa', requests for 'about.php' will be responded to by a helpful message wrapped in a shell page. """ s = Store(self.mktemp()) s.powerUp(self.aboutpage.AboutPlugin(store=s)) m = Mantissa() m.installSite(s, u"localhost", u"", False) root = IMantissaSite(s) viewer = StubViewer() result, segments = root.siteProduceResource(FakeRequest(), tuple(['about.php']), viewer) self.assertIdentical(result, viewer.shell) self.assertIsInstance(result.model, self.aboutpage.AboutText)
def test_makeService(self): """ L{AxiomaticStart.makeService} returns the L{IService} powerup of the L{Store} at the directory in the options object it is passed. """ dbdir = FilePath(self.mktemp()) store = Store(dbdir) recorder = RecorderService(store=store) self.assertFalse(recorder.started) store.powerUp(recorder, IService) store.close() service = AxiomaticStart.makeService({"dbdir": dbdir, "debug": False}) service.startService() service.stopService() store = Store(dbdir) self.assertTrue(store.getItemByID(recorder.storeID).started)
class AMPAvatarTests(TestCase): """ Tests for L{AMPAvatar} which provides an L{IBoxReceiver} implementation that supports routing messages to other L{IBoxReceiver} implementations. """ def setUp(self): """ Create a L{Store} with an L{AMPAvatar} installed on it. """ self.store = Store() self.avatar = AMPAvatar(store=self.store) installOn(self.avatar, self.store) self.factory = StubBoxReceiverFactory(store=self.store, protocol=u"bar") self.store.powerUp(self.factory, IBoxReceiverFactory) def test_interface(self): """ L{AMPAvatar} powers up the item on which it is installed for L{IBoxReceiver} and indirects that interface to the real router implementation of L{IBoxReceiver}. """ router = IBoxReceiver(self.store) self.assertTrue(verifyObject(IBoxReceiver, router)) self.assertNotIdentical(self.avatar, router) def test_connectorStarted(self): """ L{AMPAvatar.indirect} returns a L{Router} with a started route connector as its default receiver. """ receiver = SomeReceiver() self.avatar.__dict__['connectorFactory'] = lambda router: receiver router = self.avatar.indirect(IBoxReceiver) router.startReceivingBoxes(object()) self.assertTrue(receiver.started) def test_reactor(self): """ L{AMPAvatar.connectorFactory} returns a L{_RouteConnector} constructed using the global reactor. """ connector = self.avatar.connectorFactory(object()) self.assertIdentical(connector.reactor, reactor)
class DeletionTestCase(TestCase): """ Tests for the interaction between message deletion and the indexer. """ def setUp(self): """ Create a Store with a Message in it. """ self.store = Store() self.message = Message(store=self.store) def test_deletionNotification(self): """ Test that when a Message is deleted, all L{ixmantissa.IFulltextIndexer} powerups on that message's store are notified of the event. """ indexers = [] for i in range(2): indexers.append(DummyIndexer(store=self.store)) self.store.powerUp(indexers[-1], ixmantissa.IFulltextIndexer) self.assertEqual(indexers[-1].removed, []) self.message.deleteFromStore() for i in range(2): self.assertEqual(indexers[i].removed, [self.message]) def test_deletionWithoutIndexers(self): """ Test that deletion of a message can succeed even if there are no L{ixmantissa.IFulltextIndexer} powerups on the message's store. """ self.message.deleteFromStore() self.assertEqual(list(self.store.query(Message)), [])
def testBasicPowerups(self): # tests an interaction between __conform__ and other stuff s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) s.powerUp(SumContributor(store=s, value=1), IValueHaver) s.powerUp(SumContributor(store=s, value=2), IValueHaver) s.powerUp(SumContributor(store=s, value=3), IValueHaver) self.assertEquals(mm.doSum(), 6) s.close()
def testBasicPowerups(self): # tests an interaction between __conform__ and other stuff s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) s.powerUp(SumContributor(store=s, value=1), IValueHaver) s.powerUp(SumContributor(store=s, value=2), IValueHaver) s.powerUp(SumContributor(store=s, value=3), IValueHaver) self.assertEqual(mm.doSum(), 6) s.close()
def testPowerupIdentity(self): s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) sc3 = SumContributor(store=s, value=3) s.powerUp(SumContributor(store=s, value=1), IValueHaver) s.powerUp(SumContributor(store=s, value=2), IValueHaver) s.powerUp(sc3, IValueHaver) s.powerUp(sc3, IValueHaver) self.assertEquals(mm.doSum(), 6) s.close()
def testPowerupIdentity(self): s = Store() mm = Summer(store=s) s.powerUp(mm, ISumProducer) sc3 = SumContributor(store=s, value=3) s.powerUp(SumContributor(store=s, value=1), IValueHaver) s.powerUp(SumContributor(store=s, value=2), IValueHaver) s.powerUp(sc3, IValueHaver) s.powerUp(sc3, IValueHaver) self.assertEqual(mm.doSum(), 6) s.close()
from axiom.store import Store from twisted.application.service import IService from squeal.web.service import WebService from squeal.net.slimproto import SlimService from squeal.net.discovery import DiscoveryService from squeal.playlist.service import Playlist from squeal.event import EventReactor from squeal.extension import PluginManager from squeal.isqueal import * store = Store("db") services = ( EventReactor, WebService, SlimService, DiscoveryService, Playlist, PluginManager, ) for srv in services: s = srv(store=store) for iface in s.powerupInterfaces: store.powerUp(s, iface) store.powerUp(s, IService)
def initializeAPIs(Store: store.Store): PublicAPI = Store.findOrCreate(API, name="Public API") Store.powerUp(PublicAPI, IAPI) EmployeeAPI = Store.findOrCreate(API, name="Employee API") Store.powerUp(EmployeeAPI, IAPI) SupervisorAPI = Store.findOrCreate(API, name="Supervisor API") Store.powerUp(SupervisorAPI, IAPI) AdministratorAPI = Store.findOrCreate(API, name="Administrator API") Store.powerUp(AdministratorAPI, IAPI) findCommand = commandFinder(Store) PublicAPI.powerUp(findCommand("Login"), ICommand) PublicAPI.powerUp(findCommand("AsyncLogin"), ICommand) AdministratorAPI.powerUp(findCommand("MakeAdministrator"), ICommand) AdministratorAPI.powerUp(findCommand("MakeSupervisor"), ICommand) AdministratorAPI.powerUp(findCommand("AddToArea"), ICommand) AdministratorAPI.powerUp(findCommand("CheckForNewEmployees"), ICommand) AdministratorAPI.powerUp(findCommand("NewArea"), ICommand) AdministratorAPI.powerUp(findCommand("ApproveTime"), ICommand) AdministratorAPI.powerUp(findCommand("EditTime"), ICommand) AdministratorAPI.powerUp(findCommand("ClockOut"), ICommand) AdministratorAPI.powerUp(findCommand("ViewHours"), ICommand) AdministratorAPI.powerUp(findCommand("ViewAverageHours"), ICommand) AdministratorAPI.powerUp(findCommand("ViewEmployees"), ICommand) AdministratorAPI.powerUp(findCommand("AssumeRole"), ICommand) AdministratorAPI.powerUp(findCommand("ClockIn"), ICommand) AdministratorAPI.powerUp(findCommand("SetSupervisor"), ICommand) AdministratorAPI.powerUp(findCommand("SetWorkLocations"), ICommand) AdministratorAPI.powerUp(findCommand("SetSubAccounts"), ICommand) AdministratorAPI.powerUp(findCommand("ChangePassword"), ICommand) AdministratorAPI.powerUp(findCommand("ViewReports"), ICommand) AdministratorAPI.powerUp(findCommand("AssignTask"), ICommand) AdministratorAPI.powerUp(findCommand("CreateTask"), ICommand) AdministratorAPI.powerUp(findCommand("ManageSubAccounts"), ICommand) AdministratorAPI.powerUp(findCommand("ManageWorkLocations"), ICommand) AdministratorAPI.powerUp(findCommand("ScheduleTimeOff"), ICommand) AdministratorAPI.powerUp(findCommand("ApproveTimeOff"), ICommand) AdministratorAPI.powerUp(findCommand("ViewBenefits"), ICommand) AdministratorAPI.powerUp(findCommand("SetSupervisorSubAccounts"), ICommand) sv = findCommand("ScheduleVacation") if sv: for api in [AdministratorAPI, EmployeeAPI, SupervisorAPI]: if sv in api.powerupsFor(ICommand): api.powerDown(sv, ICommand) sv.deleteFromStore(Store) sv = findCommand("ApproveVacation") if sv: for api in [AdministratorAPI, EmployeeAPI, SupervisorAPI]: if sv in api.powerupsFor(ICommand): api.powerDown(sv, ICommand) sv.deleteFromStore(Store) EmployeeAPI.powerUp(findCommand("ClockIn"), ICommand) EmployeeAPI.powerUp(findCommand("ClockOut"), ICommand) EmployeeAPI.powerUp(findCommand("ViewHours"), ICommand) EmployeeAPI.powerUp(findCommand("ViewAverageHours"), ICommand) EmployeeAPI.powerUp(findCommand("ChangePassword"), ICommand) EmployeeAPI.powerUp(findCommand("ScheduleTimeOff"), ICommand) EmployeeAPI.powerUp(findCommand("ViewBenefits"), ICommand) SupervisorAPI.powerUp(findCommand("ClockOut"), ICommand) SupervisorAPI.powerUp(findCommand("ViewHours"), ICommand) SupervisorAPI.powerUp(findCommand("ViewAverageHours"), ICommand) # SupervisorAPI.powerUp(findCommand("ViewEmployees"), ICommand) SupervisorAPI.powerUp(findCommand("AssumeRole"), ICommand) SupervisorAPI.powerUp(findCommand("ClockIn"), ICommand) SupervisorAPI.powerUp(findCommand("EditTime"), ICommand) SupervisorAPI.powerUp(findCommand("ApproveTime"), ICommand) SupervisorAPI.powerUp(findCommand("ChangePassword"), ICommand) SupervisorAPI.powerUp(findCommand("AssignTask"), ICommand) SupervisorAPI.powerUp(findCommand("CreateTask"), ICommand) SupervisorAPI.powerUp(findCommand("ScheduleTimeOff"), ICommand) SupervisorAPI.powerUp(findCommand("ApproveTimeOff"), ICommand) SupervisorAPI.powerUp(findCommand("ViewBenefits"), ICommand)
class StoreBackendTests(TestCase): """ Tests for content store backend functionality. """ def setUp(self): self.store = Store(self.mktemp()) self.contentStore1 = ContentStore(store=self.store) object.__setattr__(self.contentStore1, '_deferToThreadPool', execute) self.contentStore1.storeObject(content='somecontent', contentType=u'application/octet-stream') self.testObject = self.store.findUnique(ImmutableObject) self.contentStore2 = ContentStore(store=self.store) object.__setattr__(self.contentStore2, '_deferToThreadPool', execute) def test_getSiblingExists(self): """ Calling getSiblingObject with an object ID that is present in the local store just returns the local object. """ d = self.contentStore1.getSiblingObject(self.testObject.objectId) def _cb(o): self.o = o d.addCallback(_cb) self.assertIdentical(self.o, self.testObject) def _retrievalTest(self): o = self.successResultOf( self.contentStore2.getSiblingObject(self.testObject.objectId)) self.assertEquals( self.successResultOf(o.getContent()), 'somecontent') o2 = self.successResultOf( self.contentStore2.getObject(self.testObject.objectId)) self.assertIdentical(o, o2) def test_getSiblingExistsRemote(self): """ Calling getSiblingObject with an object ID that is missing locally, but present in one of the sibling stores, will retrieve the object, as well as inserting it into the local store. """ self.store.powerUp(self.contentStore1, ISiblingStore) self._retrievalTest() def test_getSiblingExistsBackend(self): """ If an object is missing in local and sibling stores, but present in a backend store, the object will be retrieved from the backend store. """ self.store.powerUp(self.contentStore1, IBackendStore) self._retrievalTest() def test_siblingBeforeBackend(self): """ When looking for a missing object, sibling stores are tried before backend stores. """ events = [] siblingStore = MockContentStore(store=self.store, events=events) self.store.powerUp(siblingStore, ISiblingStore) backendStore = MockContentStore(store=self.store, events=events) self.store.powerUp(backendStore, IBackendStore) def _cb(e): self.assertEquals( events, [('getObject', siblingStore, u'sha256:aoeuaoeu'), ('getObject', backendStore, u'sha256:aoeuaoeu')]) return self.assertFailure( self.contentStore2.getSiblingObject(u'sha256:aoeuaoeu'), NonexistentObject).addCallback(_cb) def test_getSiblingMissing(self): """ Calling getSiblingObject with an object ID that is missing everywhere raises L{NonexistentObject}. """ self.store.powerUp(self.contentStore1, ISiblingStore) objectId = u'sha256:NOSUCHOBJECT' d = self.contentStore2.getSiblingObject(objectId) return self.assertFailure(d, NonexistentObject ).addCallback(lambda e: self.assertEquals(e.objectId, objectId)) def test_storeObject(self): """ Storing an object also causes it to be scheduled for storing in all backend stores. """ contentStore = ContentStore(store=self.store) backendStore = MockContentStore(store=self.store) self.store.powerUp(backendStore, IBackendStore) backendStore2 = MockContentStore(store=self.store) self.store.powerUp(backendStore2, IBackendStore) scheduler = MockUploadScheduler() self.store.inMemoryPowerUp(scheduler, IUploadScheduler) contentStore.storeObject(content='somecontent', contentType=u'application/octet-stream') testObject = self.store.findUnique(ImmutableObject) pu = scheduler.uploads self.assertEquals(len(pu), 2) self.assertEquals(pu[0][0], testObject.objectId) self.assertEquals(pu[1][0], testObject.objectId) for objectId, backend in pu: if backend is backendStore: break else: self.fail('No pending upload for backendStore') for objectId, backend in pu: if backend is backendStore2: break else: self.fail('No pending upload for backendStore2')
class _PendingUploadTests(TestCase): """ Tests for L{_PendingUpload}. """ def setUp(self): self.store = Store(self.mktemp()) self.contentStore = ContentStore(store=self.store) object.__setattr__(self.contentStore, '_deferToThreadPool', execute) self.store.powerUp(self.contentStore, IContentStore) self.contentStore.storeObject(content='somecontent', contentType=u'application/octet-stream') self.testObject = self.store.findUnique(ImmutableObject) self.backendStore = MockContentStore(store=self.store) self.pendingUpload = _PendingUpload(store=self.store, objectId=self.testObject.objectId, backend=self.backendStore) def test_successfulUpload(self): """ When an upload attempt is made, the object is stored to the backend store. If this succeeds, the L{_PendingUpload} item is deleted. """ def _cb(ign): self.assertEquals( self.backendStore.events, [('storeObject', self.backendStore, 'somecontent', u'application/octet-stream', {}, self.testObject.created, self.testObject.objectId)]) self.assertRaises(ItemNotFound, self.store.findUnique, _PendingUpload) return self.pendingUpload.attemptUpload().addCallback(_cb) def test_failedUpload(self): """ When an upload attempt is made, the object is stored to the backend store. If this fails, the L{_PendingUpload} item has its scheduled time updated. """ def _storeObject(content, contentType, metadata={}, created=None, objectId=None): raise ValueError('blah blah') object.__setattr__(self.backendStore, 'storeObject', _storeObject) nextScheduled = self.pendingUpload.scheduled + timedelta(minutes=5) def _nextAttempt(): return nextScheduled object.__setattr__(self.pendingUpload, '_nextAttempt', _nextAttempt) self.successResultOf(self.pendingUpload.attemptUpload()) self.assertIdentical(self.store.findUnique(_PendingUpload), self.pendingUpload) self.assertEquals(self.pendingUpload.scheduled, nextScheduled) errors = self.flushLoggedErrors(ValueError) self.assertEquals(len(errors), 1)
class RouteConnectorTests(TestCase): """ Tests for L{_RouteConnector}. """ def setUp(self): """ Create a L{Store} with an L{AMPAvatar} installed on it. """ self.clock = Clock() self.store = Store() self.factory = StubBoxReceiverFactory(store=self.store, protocol=u"bar") self.store.powerUp(self.factory, IBoxReceiverFactory) self.router = Router() self.sender = CollectingSender() self.connector = _RouteConnector(self.clock, self.store, self.router) self.router.startReceivingBoxes(self.sender) self.router.bindRoute(self.connector, None).connectTo(None) def test_accept(self): """ L{_RouteConnector.accept} returns a C{dict} with a C{'route'} key associated with a new route identifier which may be used to send AMP boxes to a new instance of the L{IBoxReceiver} indicated by the C{protocol} argument passed to C{connect}. """ firstIdentifier = self.connector.accept("first origin", u"bar")['route'] firstReceiver = self.factory.receivers.pop() secondIdentifier = self.connector.accept("second origin", u"bar")['route'] secondReceiver = self.factory.receivers.pop() self.clock.advance(0) self.router.ampBoxReceived({_ROUTE: firstIdentifier, 'foo': 'bar'}) self.router.ampBoxReceived({_ROUTE: secondIdentifier, 'baz': 'quux'}) self.assertEqual(firstReceiver.boxes, [{'foo': 'bar'}]) self.assertEqual(secondReceiver.boxes, [{'baz': 'quux'}]) def test_acceptResponseBeforeApplicationBox(self): """ If the protocol L{_RouteConnector.accept} binds to a new route sends a box in its C{startReceivingBoxes} method, that box is sent to the network after the I{Connect} response is sent. """ earlyBox = {'foo': 'bar'} class EarlyReceiver: def startReceivingBoxes(self, sender): sender.sendBox(earlyBox) object.__setattr__(self.factory, 'receiverFactory', EarlyReceiver) self.connector.ampBoxReceived({ COMMAND: Connect.commandName, ASK: 'unique-identifier', 'origin': 'an origin', 'protocol': 'bar' }) self.clock.advance(0) self.assertEqual(len(self.sender.boxes), 2) route, app = self.sender.boxes expectedBox = earlyBox.copy() expectedBox[_ROUTE] = 'an origin' self.assertEqual(app, expectedBox) def test_unknownProtocol(self): """ L{_RouteConnector.accept} raises L{ProtocolUnknown} if passed the name of a protocol for which no factory can be found. """ self.assertRaises(ProtocolUnknown, self.connector.accept, "origin", u"foo") def test_originRoute(self): """ The L{IBoxReceiver}s created by L{_RouteConnector.accept} are started with L{IBoxSender}s which are associated with the origin route specified to C{accept}. """ origin = u'origin route' self.connector.accept(origin, u'bar') self.clock.advance(0) [bar] = self.factory.receivers self.assertTrue(bar.started) bar.sender.sendBox({'foo': 'bar'}) self.assertEqual(self.sender.boxes, [{_ROUTE: origin, 'foo': 'bar'}]) bar.sender.unhandledError(Failure(RuntimeError("test failure"))) self.assertEqual(self.sender.errors, ["test failure"])
class RouteConnectorTests(TestCase): """ Tests for L{_RouteConnector}. """ def setUp(self): """ Create a L{Store} with an L{AMPAvatar} installed on it. """ self.clock = Clock() self.store = Store() self.factory = StubBoxReceiverFactory( store=self.store, protocol=u"bar") self.store.powerUp(self.factory, IBoxReceiverFactory) self.router = Router() self.sender = CollectingSender() self.connector = _RouteConnector(self.clock, self.store, self.router) self.router.startReceivingBoxes(self.sender) self.router.bindRoute(self.connector, None).connectTo(None) def test_accept(self): """ L{_RouteConnector.accept} returns a C{dict} with a C{'route'} key associated with a new route identifier which may be used to send AMP boxes to a new instance of the L{IBoxReceiver} indicated by the C{protocol} argument passed to C{connect}. """ firstIdentifier = self.connector.accept( "first origin", u"bar")['route'] firstReceiver = self.factory.receivers.pop() secondIdentifier = self.connector.accept( "second origin", u"bar")['route'] secondReceiver = self.factory.receivers.pop() self.clock.advance(0) self.router.ampBoxReceived( {_ROUTE: firstIdentifier, 'foo': 'bar'}) self.router.ampBoxReceived( {_ROUTE: secondIdentifier, 'baz': 'quux'}) self.assertEqual(firstReceiver.boxes, [{'foo': 'bar'}]) self.assertEqual(secondReceiver.boxes, [{'baz': 'quux'}]) def test_acceptResponseBeforeApplicationBox(self): """ If the protocol L{_RouteConnector.accept} binds to a new route sends a box in its C{startReceivingBoxes} method, that box is sent to the network after the I{Connect} response is sent. """ earlyBox = {'foo': 'bar'} class EarlyReceiver: def startReceivingBoxes(self, sender): sender.sendBox(earlyBox) object.__setattr__(self.factory, 'receiverFactory', EarlyReceiver) self.connector.ampBoxReceived({ COMMAND: Connect.commandName, ASK: 'unique-identifier', 'origin': 'an origin', 'protocol': 'bar'}) self.clock.advance(0) self.assertEqual(len(self.sender.boxes), 2) route, app = self.sender.boxes expectedBox = earlyBox.copy() expectedBox[_ROUTE] = 'an origin' self.assertEqual(app, expectedBox) def test_unknownProtocol(self): """ L{_RouteConnector.accept} raises L{ProtocolUnknown} if passed the name of a protocol for which no factory can be found. """ self.assertRaises( ProtocolUnknown, self.connector.accept, "origin", u"foo") def test_originRoute(self): """ The L{IBoxReceiver}s created by L{_RouteConnector.accept} are started with L{IBoxSender}s which are associated with the origin route specified to C{accept}. """ origin = u'origin route' self.connector.accept(origin, u'bar') self.clock.advance(0) [bar] = self.factory.receivers self.assertTrue(bar.started) bar.sender.sendBox({'foo': 'bar'}) self.assertEqual(self.sender.boxes, [{_ROUTE: origin, 'foo': 'bar'}]) bar.sender.unhandledError(Failure(RuntimeError("test failure"))) self.assertEqual(self.sender.errors, ["test failure"])
def initializeCommands(Store: store.Store): Store.powerUp(Store.findOrCreate(MakeSupervisor, name="Make Supervisor"), ICommand) Store.powerUp(Store.findOrCreate(MakeAdministrator, name="Make Administrator"), ICommand) Store.powerUp(Store.findOrCreate(AddToArea, name="Add to SubAccount"), ICommand) Store.powerUp(Store.findOrCreate(CheckForNewEmployees, name="Check For New Employees"), ICommand) Store.powerUp(Store.findOrCreate(ClockIn, name="Clock In"), ICommand) Store.powerUp(Store.findOrCreate(NewArea, name="New SubAccount"), ICommand) Store.powerUp(Store.findOrCreate(ClockOut, name="Clock Out"), ICommand) Store.powerUp(Store.findOrCreate(ApproveTime, name="Approve Time"), ICommand) Store.powerUp(Store.findOrCreate(Login, name="Login"), ICommand) Store.powerUp(Store.findOrCreate(AsyncLogin), ICommand) Store.powerUp(Store.findOrCreate(EditTime, name="Edit Time"), ICommand) Store.powerUp(Store.findOrCreate(ViewHours, name="View Hours"), ICommand) Store.powerUp(Store.findOrCreate(ViewAverageHours, name="View Average Hours"), ICommand) Store.powerUp(Store.findOrCreate(ViewEmployees, name="View Employees"), ICommand) Store.powerUp(Store.findOrCreate(AssumeRole, name="Assume Role"), ICommand) Store.powerUp(Store.findOrCreate(SetSupervisor, name="Set Supervisor"), ICommand) Store.powerUp(Store.findOrCreate(SetWorkLocations, name="Set Work Locations"), ICommand) Store.powerUp(Store.findOrCreate(SetSubAccounts, name="Set Sub Accounts"), ICommand) Store.powerUp(Store.findOrCreate(ChangeAuthentication, name="Change Password"), ICommand) Store.powerUp(Store.findOrCreate(ViewReports, name="View Reports"), ICommand) Store.powerUp(Store.findOrCreate(ManageSubAccounts, name="Manage Sub Accounts"), ICommand) Store.powerUp(Store.findOrCreate(ManageWorkLocations, name="Manage Work Locations"), ICommand) Store.powerUp(Store.findOrCreate(CreateTask), ICommand) Store.powerUp(Store.findOrCreate(AssignTask), ICommand) Store.powerUp(Store.findOrCreate(ScheduleTimeOff), ICommand) Store.powerUp(Store.findOrCreate(ApproveTimeOff), ICommand) Store.powerUp(Store.findOrCreate(ViewBenefits), ICommand) Store.powerUp(Store.findOrCreate(SetSupervisorSubAccounts), ICommand)