def setUp(self):
"""
Set up a store for testing.
"""
self.store = Store()
self.account = LoginAccount(store=self.store, password=u'1234')
self.method = LoginMethod(store=self.store,
account=self.account,
localpart=u'username',
domain=u'domain.example.com',
internal=True,
protocol=u'*',
verified=True)
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 test_switchTo(self):
"""
L{ShellServer.switchTo} takes a L{ITerminalServerFactory} and uses it
to create a new L{ITerminalProtocol} which it connects to a
L{_ReturnToMenuWrapper}. L{buildTerminalProtocol} is passed an
L{IViewer}.
"""
terminal = FakeTerminal()
store = Store()
# Put a login method into the store so it can have a role. See #2665.
LoginMethod(
store=store,
internal=True,
protocol=u'*',
verified=True,
localpart=u'alice',
domain=u'example.com',
# Not really an account, but simpler...
account=store)
server = ShellServer(store)
server.makeConnection(terminal)
factory = MockTerminalServerFactory()
server.switchTo(factory)
self.assertIdentical(factory.shellViewer.roleIn(store),
getSelfRole(store))
self.assertTrue(isinstance(server._protocol, MockTerminalProtocol))
self.assertTrue(
isinstance(server._protocol.terminal, _ReturnToMenuWrapper))
self.assertIdentical(server._protocol.terminal._shell, server)
self.assertIdentical(server._protocol.terminal._terminal, terminal)
def createDatabase(store):
LoginMethod(store=store,
localpart=LOCAL,
domain=DOMAIN,
verified=VERIFIED,
protocol=PROTOCOL,
account=store,
internal=INTERNAL)
installOn(Composer(store=store), store)
def createDatabase(s):
LoginMethod(store=s,
localpart=u'foo',
domain=u'bar',
verified=True,
protocol=u'*',
account=s,
internal=False)
DSPAMFilter(store=s)
def setUp(self):
self.store = Store()
# Cheat so getSelfRole will work...
lm = LoginMethod(store=self.store,
localpart=u'me',
domain=u'here',
internal=True,
protocol=u'*',
account=self.store,
verified=True)
def createDatabase(s):
"""
Install a Composer on the given store.
"""
LoginMethod(store=s,
localpart=u'foo',
domain=u'bar',
verified=True,
protocol=u'*',
account=s,
internal=False)
Composer(store=s).installOn(s)
def getInbox(self):
"""
Return a newly created Inbox, in a newly created Store.
"""
s = Store()
LoginMethod(store=s,
internal=False,
protocol=u'email',
localpart=u'default',
domain=u'host',
verified=True,
account=s)
installOn(Composer(store=s), s)
installOn(Catalog(store=s), s)
installOn(MessageLister(store=s), s)
inbox = Inbox(store=s)
installOn(inbox, s)
return inbox
def setUp(self):
self.store = Store(dbdir=self.mktemp())
installOn(inbox.Inbox(store=self.store), self.store)
self.composer = compose.Composer(store=self.store)
installOn(self.composer, self.store)
LoginMethod(store=self.store,
internal=False,
protocol=u'email',
localpart=u'recipient',
domain=u'host',
verified=True,
account=self.store)
self.msg = testMessageFactory(
store=self.store,
spam=False,
impl=DummyMessageImplWithABunchOfAddresses(store=self.store))
self.msgDetail = MessageDetail(self.msg)
def createDatabase(s):
"""
Install a Composer and ComposePreferenceCollection on the given store.
"""
LoginMethod(store=s,
localpart=u'foo',
domain=u'bar',
verified=True,
protocol=u'*',
account=s,
internal=False)
Composer(store=s).installOn(s)
ComposePreferenceCollection(store=s,
smarthostAddress=u'foo2@bar',
smarthostUsername=u'foo2',
smarthostPort=23,
smarthostPassword=u'secret',
preferredSmarthost=u'localhost').installOn(s)
def createStore(testCase):
location = testCase.mktemp()
s = Store(location)
da = DeliveryAgent(store=s)
installOn(da, s)
makeSomeMessages(testCase, da, location)
installOn(POP3Up(store=s), s)
ls = LoginSystem(store=s)
installOn(ls, s)
# Engage in some trickery to allow this to be used as its own user.
la = LoginAccount(store=s, password=u'asdfjkl;', avatars=s, disabled=False)
LoginMethod(store=s,
account=la,
localpart=u'user',
domain=u'example.com',
protocol=u'email',
internal=True,
verified=True)
return s
def createDatabase(s):
LoginMethod(store=s,
localpart=u'foo',
domain=u'bar',
verified=True,
protocol=u'*',
account=s,
internal=False)
FromAddress(store=s,
address=u'foo@bar',
smtpHost=u'bar',
smtpPort=26,
smtpUsername=u'foo',
smtpPassword=u'secret')
FromAddress(store=s,
address=u'foo2@bar',
smtpHost=u'bar',
smtpPort=26,
smtpUsername=u'foo2',
smtpPassword=u'secret')
def getFromAddressScrollTable(self):
s = Store()
LoginMethod(store=s,
internal=False,
protocol=u'email',
localpart=u'default',
domain=u'host',
verified=True,
account=s)
installOn(compose.Composer(store=s), s)
smtpout.FromAddress(store=s,
address=u'notdefault@host',
smtpHost=u'host',
smtpUsername=u'notdefault')
f = smtpout.FromAddressScrollTable(s)
f.setFragmentParent(self)
f.docFactory = getLoader(f.fragmentName)
return f
def _getComposeFragment(self, composeFragFactory=compose.ComposeFragment):
s = Store()
LoginMethod(store=s,
internal=False,
protocol=u'email',
localpart=u'default',
domain=u'host',
verified=True,
account=s)
installOn(Inbox(store=s), s)
smtpout.FromAddress(store=s, address=u'*****@*****.**').setAsDefault()
composer = compose.Composer(store=s)
installOn(composer, s)
composeFrag = composeFragFactory(composer)
composeFrag.jsClass = u'Quotient.Test.ComposeController'
composeFrag.setFragmentParent(self)
composeFrag.docFactory = getLoader(composeFrag.fragmentName)
return (s, composeFrag)
class HeuristicTestCases(unittest.TestCase):
"""
These are tests for sharing APIs which heuristically determine identifying
information about a user's store or a shared item.
"""
def setUp(self):
"""
Set up a store for testing.
"""
self.store = Store()
self.account = LoginAccount(store=self.store, password=u'1234')
self.method = LoginMethod(store=self.store,
account=self.account,
localpart=u'username',
domain=u'domain.example.com',
internal=True,
protocol=u'*',
verified=True)
def test_getSelfRole(self):
"""
The self-role of a store should be determined by its L{LoginMethod}s.
"""
self.assertEquals(list(self.store.query(sharing.Role)), [])
me = sharing.getSelfRole(self.store)
self.assertEquals(me.externalID, u'*****@*****.**')
self.assertEquals(me.store, self.store)
self.assertEquals(list(me.allRoles()),
[me,
sharing.getAuthenticatedRole(self.store),
sharing.getEveryoneRole(self.store)])
def test_getAccountRole(self):
"""
L{getAccountRole} returns a L{Role} in a given store for one of the
account names passed to it.
"""
role = sharing.getAccountRole(
self.store, [(u"username", u"domain.example.com")])
self.assertEquals(role.externalID, u"*****@*****.**")
def test_noAccountRole(self):
"""
L{getAccountRole} raises L{ValueError} if passed an empty list of account names.
"""
self.assertRaises(ValueError, sharing.getAccountRole, self.store, [])
def test_identifierFromSharedItem(self):
"""
L{sharing.Identifier.fromSharedItem} should identify a shared Item's shareID.
"""
t = PrivateThing(store=self.store)
sharing.getEveryoneRole(self.store).shareItem(t, shareID=u'asdf')
sid = sharing.Identifier.fromSharedItem(t)
self.assertEquals(sid.shareID, u'asdf')
self.assertEquals(sid.localpart, u'username')
self.assertEquals(sid.domain, u'domain.example.com')
def test_identifierFromSharedItemMulti(self):
"""
L{sharing.Identifier.fromSharedItem} should identify a shared Item's
shareID even if it is shared multiple times.
"""
t = PrivateThing(store=self.store)
sharing.getEveryoneRole(self.store).shareItem(t, shareID=u'asdf')
sharing.getAuthenticatedRole(self.store).shareItem(t, shareID=u'jkl;')
sid = sharing.Identifier.fromSharedItem(t)
self.assertIn(sid.shareID, [u'asdf', u'jkl;'])
self.assertEquals(sid.localpart, u'username')
self.assertEquals(sid.domain, u'domain.example.com')
def test_identifierFromSharedItemNoShares(self):
"""
L{sharing.Identifier.fromSharedItem} should raise L{NoSuchShare} if the given
item is not shared.
"""
t = PrivateThing(store=self.store)
self.assertRaises(sharing.NoSuchShare, sharing.Identifier.fromSharedItem, t)
def test_identifierFromSharedItemNoMethods(self):
"""
L{sharing.Identifier.fromSharedItem} should raise L{NoSuchShare} if the given
item's store contains no L{LoginMethod} objects.
"""
self.method.deleteFromStore()
t = PrivateThing(store=self.store)
sharing.getEveryoneRole(self.store).shareItem(t, shareID=u'asdf')
self.assertRaises(sharing.NoSuchShare, sharing.Identifier.fromSharedItem, t)
