def test_appStoreLinkTo(self):
"""
When L{websharing.linkTo} is called on a shared item in an app store,
it returns an URL with a single path segment consisting of the app's
name.
"""
s = Store(dbdir=self.mktemp())
Mantissa().installSite(s, u"localhost", u"", False)
Mantissa().installAdmin(s, u'admin', u'localhost', u'asdf')
off = offering.Offering(
name=u'test_offering',
description=u'Offering for creating a sample app store',
siteRequirements=[],
appPowerups=[TestAppPowerup],
installablePowerups=[],
loginInterfaces=[],
themes=[],
)
userbase = s.findUnique(LoginSystem)
adminAccount = userbase.accountByAddress(u'admin', u'localhost')
conf = adminAccount.avatars.open().findUnique(
offering.OfferingConfiguration)
conf.installOffering(off, None)
ss = userbase.accountByAddress(off.name, None).avatars.open()
sharedItem = sharing.getEveryoneRole(ss).getShare(
websharing.getDefaultShareID(ss))
linkURL = websharing.linkTo(sharedItem)
self.failUnless(
isinstance(linkURL, url.URL),
"linkTo should return a nevow.url.URL, not %r" % (type(linkURL)))
self.assertEquals(str(linkURL), '/test_offering/')
def test_baseOffering(self):
"""
L{Mantissa.installSite} installs the Mantissa base offering.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.com", u"", False)
self.assertEqual(IOfferingTechnician(self.siteStore).getInstalledOfferingNames(), [baseOffering.name])
def test_hostname(self):
"""
L{Mantissa.installSite} sets the C{hostname} of the
L{SiteConfiguration} to the domain name it is called with.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.net", u"", False)
site = self.siteStore.findUnique(SiteConfiguration)
self.assertEqual(site.hostname, u"example.net")
def test_hostname(self):
"""
L{Mantissa.installSite} sets the C{hostname} of the
L{SiteConfiguration} to the domain name it is called with.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.net", u"", False)
site = self.siteStore.findUnique(SiteConfiguration)
self.assertEqual(site.hostname, u"example.net")
def test_baseOffering(self):
"""
L{Mantissa.installSite} installs the Mantissa base offering.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.com", u"", False)
self.assertEqual(
IOfferingTechnician(self.siteStore).getInstalledOfferingNames(),
[baseOffering.name])
def setUp(self):
self.siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(self.siteStore, u"localhost", u"", False)
Mantissa().installAdmin(self.siteStore, u'admin', u'localhost', '')
self.loginSystem = self.siteStore.findUnique(LoginSystem)
self.adminStore = self.loginSystem.accountByAddress(
u'admin', u'localhost').avatars.open()
sc = self.adminStore.findUnique(signup.SignupConfiguration)
self.signup = sc.createSignup(
u'testuser@localhost', signup.UserInfoSignup, {'prefixURL': u''},
product.Product(store=self.siteStore, types=[]), u'', u'')
def test_commonName(self):
"""
C{axiomatic mantissa} generates an SSL certificate with the domain part
of the admin username as its common name.
"""
m = Mantissa()
m.parent = self
self.dbdir = self.mktemp()
self.store = Store(filesdir=FilePath(self.dbdir).child("files").path)
m.parseOptions(['--admin-user', '*****@*****.**', '--admin-password', 'foo'])
cert = self._getCert()
self.assertEqual(cert.getSubject().commonName, "example.com")
def setUp(self):
"""
Create a site store containing an admin user, then do
implementation-specific setup.
"""
self.siteStore = Store(filesdir=self.mktemp())
m = Mantissa()
m.installSite(self.siteStore, u"localhost", u"", False)
m.installAdmin(self.siteStore, u'admin', u'localhost', u'asdf')
self.loginSystem = self.siteStore.findUnique(LoginSystem)
self.adminStore = self.loginSystem.accountByAddress(
u'admin', u'localhost').avatars.open()
self.setupPageFactory()
def test_commonName(self):
"""
C{axiomatic mantissa} generates an SSL certificate with the domain part
of the admin username as its common name.
"""
m = Mantissa()
m.parent = self
self.dbdir = self.mktemp()
self.store = Store(filesdir=FilePath(self.dbdir).child("files").path)
m.parseOptions(
['--admin-user', '*****@*****.**', '--admin-password', 'foo'])
cert = self._getCert()
self.assertEqual(cert.getSubject().commonName, "example.com")
def setUp(self):
"""
Create a store as described in the test case docstring.
"""
site = Store(self.mktemp())
Mantissa().installSite(site, u"example.com", u"", False)
Mantissa().installAdmin(site, u'admin', u'example.com', u'asdf')
anonsite = site.findUnique(AnonymousSite)
user = site.findUnique(LoginSystem).accountByAddress(
u"admin", u"example.com").avatars.open()
self.website = user.findUnique(WebSite)
self.privapp = user.findUnique(PrivateApplication)
self.site = site
def test_sshPorts(self):
"""
L{Mantissa.installSite} creates a TCP port for the
L{SecureShellConfiguration} which comes with the base offering it
installs.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.com", u"", False)
shell = self.siteStore.findUnique(SecureShellConfiguration)
tcps = list(self.siteStore.query(TCPPort, TCPPort.factory == shell))
self.assertEqual(len(tcps), 1)
self.assertEqual(tcps[0].portNumber, 8022)
def test_sshPorts(self):
"""
L{Mantissa.installSite} creates a TCP port for the
L{SecureShellConfiguration} which comes with the base offering it
installs.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.com", u"", False)
shell = self.siteStore.findUnique(SecureShellConfiguration)
tcps = list(self.siteStore.query(TCPPort, TCPPort.factory == shell))
self.assertEqual(len(tcps), 1)
self.assertEqual(tcps[0].portNumber, 8022)
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"))
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"))
def setUp(self):
"""
Create a L{Store} with a L{WebSite} in it. Get a protocol factory from
the website and save it for tests to use. Patch L{twisted.web.http}
and L{nevow.guard} so that they don't create garbage timed calls that
have to be cleaned up.
"""
self.store = Store(filesdir=self.mktemp()) # See #2484
Mantissa().installSite(self.store, self.domain, u'',
False) # See #2483
self.site = self.store.findUnique(SiteConfiguration)
self.login = self.store.findUnique(LoginSystem)
# Ports should be offering installation parameters. This assumes a
# TCPPort and an SSLPort are created by Mantissa.installSite. See
# #538. -exarkun
self.store.query(SSLPort,
SSLPort.factory == self.site).deleteFromStore()
self.factory = self.site.getFactory()
self.origFunctions = (http._logDateTimeStart,
GuardSession.checkExpired.im_func,
athena.ReliableMessageDelivery)
http._logDateTimeStart = lambda: None
GuardSession.checkExpired = lambda self: None
athena.ReliableMessageDelivery = lambda *a, **kw: None
def setUp(self):
"""
Construct a site and user store with an administrator that can invoke the
web administrative tools, setting the instance variables described in
this class's docstring.
"""
self.siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(self.siteStore, u"localhost", u"", False)
Mantissa().installAdmin(self.siteStore, u'admin', u'localhost', u'asdf')
self.siteMethod = self.siteStore.findUnique(
LoginMethod, LoginMethod.localpart == u'admin')
self.siteAccount = self.siteMethod.account
userStore = self.siteAccount.avatars.open()
lub = userStore.findUnique(LocalUserBrowser)
self.localUserBrowserFragment = LocalUserBrowserFragment(lub)
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 makeLivePage(self):
"""
Create a MantissaLivePage instance for testing.
"""
siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(siteStore, self.hostname.decode('ascii'), u"",
False)
return MantissaLivePage(ISiteURLGenerator(siteStore))
def test_httpPorts(self):
"""
L{Mantissa.installSite} creates a TCP port and an SSL port for the
L{SiteConfiguration} which comes with the base offering it installs.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.com", u"", False)
site = self.siteStore.findUnique(SiteConfiguration)
tcps = list(self.siteStore.query(TCPPort, TCPPort.factory == site))
ssls = list(self.siteStore.query(SSLPort, SSLPort.factory == site))
self.assertEqual(len(tcps), 1)
self.assertEqual(tcps[0].portNumber, 8080)
self.assertEqual(len(ssls), 1)
self.assertEqual(ssls[0].portNumber, 8443)
self.assertNotEqual(ssls[0].certificatePath, None)
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_httpPorts(self):
"""
L{Mantissa.installSite} creates a TCP port and an SSL port for the
L{SiteConfiguration} which comes with the base offering it installs.
"""
options = Mantissa()
options.installSite(self.siteStore, u"example.com", u"", False)
site = self.siteStore.findUnique(SiteConfiguration)
tcps = list(self.siteStore.query(TCPPort, TCPPort.factory == site))
ssls = list(self.siteStore.query(SSLPort, SSLPort.factory == site))
self.assertEqual(len(tcps), 1)
self.assertEqual(tcps[0].portNumber, 8080)
self.assertEqual(len(ssls), 1)
self.assertEqual(ssls[0].portNumber, 8443)
self.assertNotEqual(ssls[0].certificatePath, None)
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 siteStoreTxn():
Mantissa().installSite(self.siteStore, self.userinfo[1], u"",
False)
ticketed = signup.FreeTicketSignup(store=self.siteStore,
prefixURL=self.signupURL,
prompt=self.signupPrompt)
signup._SignupTracker(store=self.siteStore, signupItem=ticketed)
return Create().addAccount(self.siteStore, self.userinfo[0],
self.userinfo[1],
u'password').avatars.open()
def setUp(self):
self.siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(self.siteStore, u"example.com", u"", False)
self.userAccount = Create().addAccount(
self.siteStore, u'testuser', u'example.com', u'password')
self.userStore = self.userAccount.avatars.open()
self.privapp = PrivateApplication(store=self.userStore)
installOn(self.privapp, self.userStore)
self.webViewer = IWebViewer(self.userStore)
def setUp(self):
self.store = Store(filesdir=self.mktemp())
Mantissa().installSite(self.store, u"localhost", u"", False)
Mantissa().installAdmin(self.store, u'admin', u'localhost', u'asdf')
self.userbase = self.store.findUnique(userbase.LoginSystem)
self.adminAccount = self.userbase.accountByAddress(
u'admin', u'localhost')
off = offering.Offering(
name=u'test_offering',
description=u'This is an offering which tests the offering '
'installation mechanism',
siteRequirements=[(ITestInterface, TestSiteRequirement)],
appPowerups=[TestAppPowerup],
installablePowerups=[],
loginInterfaces=[],
themes=[],
)
self.offering = off
# Add this somewhere that the plugin system is going to see it.
self._originalGetOfferings = offering.getOfferings
offering.getOfferings = self.fakeGetOfferings
def _tx():
Mantissa().installSite(self.store, self.domain, u'', False)
self.site = self.store.findUnique(SiteConfiguration)
self.login = self.store.findUnique(LoginSystem)
# Ports should be offering installation parameters. This assumes a
# TCPPort and an SSLPort are created by Mantissa.installSite. See
# #538. -exarkun
self.store.query(SSLPort,
SSLPort.factory == self.site).deleteFromStore()
self.factory = self.site.getFactory()
def setUp(self):
"""
Create a L{Store}, L{WebSite} and necessary request-related objects to
test L{LoginPage}.
"""
self.siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(self.siteStore, self.domain, u"", False)
self.site = self.siteStore.findUnique(SiteConfiguration)
installOn(
TCPPort(store=self.siteStore, factory=self.site, portNumber=80),
self.siteStore)
self.context = WebContext()
self.request = FakeRequest()
self.context.remember(self.request)
def test_rotate(self):
"""
The C{keyrotate} subcommand replaces the host key with a new one.
"""
options = Mantissa()
options.parent = self
options.installSite(self.store, u'example.com', u'', False)
oldKey = self.store.findUnique(SecureShellConfiguration).hostKey
options.parseOptions(['ssh', 'keyrotate'])
newKey = self.store.findUnique(SecureShellConfiguration).hostKey
self.assertNotEqual(oldKey, newKey)
def setUp(self):
"""
Create a site store and a user store with the L{Focus} powerup.
"""
# Make the site store within which the test user will be created.
self.dbdir = self.mktemp()
self.siteStore = Store(self.dbdir)
Mantissa().installSite(self.siteStore, u'example.com', u"", False)
# Create a store for the user which is set up appropriately.
self.userAccount = Create().addAccount(self.siteStore, u'testuser',
u'example.com', u'password')
self.userStore = self.userAccount.avatars.open()
self.focus = Focus(store=self.userStore)
installOn(self.focus, self.userStore)
def createDatabase(store):
"""
Initialize the given Store for use as a Mantissa webserver.
"""
Mantissa().installSite(store, u'')
site = store.findUnique(WebSite)
site.portNumber = 8088
site.securePortNumber = 6443
site.certificateFile = 'server.pem'
store.dbdir.child('server.pem').setContent(cert)
site.httpLog = 'path/to/httpd.log'
site.hitCount = 123
site.hostname = u'example.net'
loginSystem = store.findUnique(LoginSystem)
account = loginSystem.addAccount(u'testuser', u'localhost', None)
subStore = account.avatars.open()
installOn(WebSite(store=subStore, hitCount=321), subStore)
def test_stylesheetLocation(self):
"""
L{XHTMLDirectoryTheme.head} returns a link tag which gives the location
of the stylesheet given by I{stylesheetLocation} if there is one.
"""
siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(siteStore, u"example.com", u"", False)
site = ISiteURLGenerator(siteStore)
self.theme.stylesheetLocation = ['foo', 'bar']
request = FakeRequest()
link = self.theme.head(request, site)
self.assertEqual(link.tagName, 'link')
self.assertEqual(link.attributes['rel'], 'stylesheet')
self.assertEqual(link.attributes['type'], 'text/css')
self.assertEqual(
site.rootURL(request).child('foo').child('bar'),
link.attributes['href'])
def createDatabase(store):
"""
Initialize the given Store for use as a Mantissa webserver.
"""
Mantissa().installSite(store, u'example.net')
site = store.findUnique(WebSite)
site.httpLog = store.filesdir.child('httpd.log').path
site.hitCount = 123
site.hostname = u'example.net'
tcp = store.findUnique(TCPPort, TCPPort.factory == site)
tcp.portNumber = 8088
ssl = store.findUnique(SSLPort, SSLPort.factory == site)
ssl.portNumber = 6443
ssl.certificatePath.setContent(cert)
loginSystem = store.findUnique(LoginSystem)
account = loginSystem.addAccount(u'testuser', u'localhost', None)
subStore = account.avatars.open()
installOn(WebSite(store=subStore, hitCount=321), subStore)
def test_rotate(self):
"""
The C{keyrotate} subcommand replaces the host key with a new one.
"""
options = Mantissa()
options.parent = self
options.installSite(self.store, u'example.com', u'', False)
oldKey = self.store.findUnique(SecureShellConfiguration).hostKey
options.parseOptions(['ssh', 'keyrotate'])
newKey = self.store.findUnique(SecureShellConfiguration).hostKey
self.assertNotEqual(oldKey, newKey)
def setUp(self):
self.siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(self.siteStore, u'example.com', u"", False)
self.loginSystem = self.siteStore.findUnique(LoginSystem)
userAccount = self.loginSystem.addAccount(u'alice', u'example.com',
u'password')
self.userStore = userAccount.avatars.open()
product = Product(
store=self.siteStore,
types=[qual(hyperbola_model.HyperbolaPublicPresence)])
product.installProductOn(self.userStore)
self.publicPresence = self.userStore.findUnique(
hyperbola_model.HyperbolaPublicPresence)
self.me = Role(store=self.userStore,
externalID=u'*****@*****.**',
description=u'foobar')
self.you = Role(store=self.userStore,
externalID=u'*****@*****.**',
description=u'rad yo')
blog = self.blog = hyperblurb.Blurb(store=self.userStore,
title=u"Hello World",
body=u"Hello World!~!!",
author=self.me,
hits=0,
dateCreated=Time(),
dateLastEdited=Time(),
flavor=hyperblurb.FLAVOR.BLOG)
blog.permitChildren(self.me, hyperblurb.FLAVOR.BLOG_POST,
ihyperbola.ICommentable)
blog.permitChildren(self.me, hyperblurb.FLAVOR.BLOG_COMMENT,
ihyperbola.ICommentable)
blog.permitChildren(self.you, hyperblurb.FLAVOR.BLOG_POST,
ihyperbola.ICommentable)
blog.permitChildren(self.you, hyperblurb.FLAVOR.BLOG_COMMENT,
ihyperbola.ICommentable)
shareItem(blog,
getEveryoneRole(self.userStore),
shareID=u'blog',
interfaces=[ihyperbola.IViewable])
def setUp(self):
"""
Create a site store containing an admin user, then do
implementation-specific setup.
"""
self.siteStore = Store(filesdir=self.mktemp())
m = Mantissa()
m.installSite(self.siteStore, u"localhost", u"", False)
m.installAdmin(self.siteStore, u'admin', u'localhost', u'asdf')
self.loginSystem = self.siteStore.findUnique(LoginSystem)
self.adminStore = self.loginSystem.accountByAddress(
u'admin', u'localhost').avatars.open()
self.setupPageFactory()
def setUpMailStuff(self, extraPowerups=(), dbdir=None, generateCert=False):
filesdir = None
if dbdir is None:
filesdir = self.mktemp()
self.siteStore = store.Store(dbdir=dbdir, filesdir=filesdir)
Mantissa().installSite(self.siteStore, u"example.com", u"", generateCert)
IOfferingTechnician(self.siteStore).installOffering(quotientOffering)
loginSystem = self.siteStore.findUnique(LoginSystem)
account = loginSystem.addAccount(u'testuser', u'example.com', None)
self.substore = account.avatars.open()
product = Product(
store=self.siteStore,
types=[qual(Inbox)] + map(qual, extraPowerups))
product.installProductOn(self.substore)
self.deliveryAgent = self.substore.findUnique(DeliveryAgent)
return self.createMIMEReceiver()
def createDatabase(store):
"""
Initialize the given Store for use as a Mantissa webserver.
"""
Mantissa().installSite(store, u'')
ws = store.findUnique(WebSite)
ws.portNumber = 8088
ws.securePortNumber = 6443
ws.certificateFile = 'path/to/cert.pem'
certPath = store.dbdir.child('path').child('to').child('cert.pem')
certPath.parent().makedirs()
fObj = certPath.open('w')
fObj.write(cert)
fObj.close()
ws.httpLog = 'path/to/httpd.log'
ws.hitCount = 123
loginSystem = store.findUnique(LoginSystem)
account = loginSystem.addAccount(u'testuser', u'localhost', None)
subStore = account.avatars.open()
WebSite(store=subStore, hitCount=321).installOn(subStore)
def test_uniqueSerial(self):
"""
Test that 'axiomatic mantissa' generates SSL certificates with a
different unique serial on each invocation.
"""
m = Mantissa()
m.parent = self
self.dbdir = self.mktemp()
self.store = Store(self.dbdir)
m.parseOptions(['--admin-password', 'foo'])
cert1 = self._getCert()
self.dbdir = self.mktemp()
self.store = Store(self.dbdir)
m.parseOptions(['--admin-password', 'foo'])
cert2 = self._getCert()
self.assertNotEqual(cert1.serialNumber(), cert2.serialNumber())
def setUp(self):
"""
Set up a fake objects and methods for the password reset tests.
"""
siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(siteStore, u"divmod.com", u"", False)
self.loginSystem = siteStore.findUnique(userbase.LoginSystem)
self.site = siteStore.findUnique(SiteConfiguration)
la = self.loginSystem.addAccount(
u'joe', u'divmod.com', u'secret', internal=True)
la.addLoginMethod(
u'joe', u'external.com',
protocol=u'zombie dance',
verified=False,
internal=False)
# create an account with no external mail address
account = self.loginSystem.addAccount(
u'jill', u'divmod.com', u'secret', internal=True)
account.addLoginMethod(
u'jill', u'divmod.com',
protocol=u'zombie dance',
verified=True,
internal=True)
self.siteStore = siteStore
# Set up the user store to have all the elements necessary to redirect
# in the case where the user is already logged in.
substore = la.avatars.open()
installOn(PrivateApplication(store=substore), substore)
self.userStore = substore
self.loginAccount = la
self.nonExternalAccount = account
self.reset = PasswordResetResource(self.siteStore)
def test_uniqueSerial(self):
"""
Test that 'axiomatic mantissa' generates SSL certificates with a
different unique serial on each invocation.
"""
m = Mantissa()
m.parent = self
self.dbdir = self.mktemp()
self.store = Store(self.dbdir)
m.parseOptions(['--admin-password', 'foo'])
cert1 = self._getCert()
self.dbdir = self.mktemp()
self.store = Store(self.dbdir)
m.parseOptions(['--admin-password', 'foo'])
cert2 = self._getCert()
self.assertNotEqual(cert1.serialNumber(), cert2.serialNumber())
