test_create.py

   1 #!/usr/bin/env python
   2
   3 """Basic infrastructure for creating an environment for testing webservers
   4 This gets used by test_cmdlineserver / test_service / test_apache (which are for different webservers)
   5 The top-level tests are then in test_client / test_ie / test_mozilla etc
   6 These can then be layered on top of different test servers"""
   7
   8 from Pootle import pootle
   9 from Pootle import users
  10 from jToolkit.web import simplewebserver
  11 from jToolkit.web import session
  12 from jToolkit.data import dates
  13 from jToolkit import prefs
  14 import os
  15
  16 sessioncache = session.SessionCache()
  17
  18 def isclassmethod(cls, method):
  19     """returns whether the given method (accessed as a class attribute) is a classmethod"""
  20     return method.im_self == cls
  21
  22 class TestCreate(object):
  23     """a test class to run tests on a test Pootle Server"""
  24     def setup_class(cls):
  25         """create the testing environment"""
  26         print "setup_class called on", cls.__name__
  27         cls.save_attribs = cls.__dict__.keys()
  28         cls.setup_testdir()
  29         # some testing methods find recreating the webserver per test easier
  30         if isclassmethod(cls, cls.setup_webserver):
  31             cls.webserver = cls.setup_webserver()
  32         else:
  33             cls.webserver = None
  34         setupprefs = cls.make_prefs()
  35         open(cls.prefsfile, "w").write(setupprefs.getsource())
  36         cls.prefs = prefs.PrefsParser(cls.prefsfile)
  37         cls.prefs.resolveimportmodules()
  38         if isclassmethod(cls, cls.setup_pootleserver):
  39             cls.setup_pootleserver()
  40
  41     def setup_testdir(cls):
  42         """sets up a test directory"""
  43         cls.testdir = "%s_testdir" % (cls.__name__)
  44         cls.cleardir(cls.testdir)
  45         os.mkdir(cls.testdir)
  46         cls.podir = os.path.join(cls.testdir, "po")
  47         os.mkdir(cls.podir)
  48         cls.prefsfile = os.path.join(cls.testdir, "%s.prefs" % (cls.__name__))
  49     setup_testdir = classmethod(setup_testdir)
  50
  51     def teardown_testdir(cls):
  52         """makes sure the test directory is clear"""
  53         cls.cleardir(cls.testdir)
  54     teardown_testdir = classmethod(teardown_testdir)
  55
  56     def teardown_class(cls):
  57         """removes the attributes set up by setup_class"""
  58         if os.path.exists(cls.prefsfile):
  59             os.remove(cls.prefsfile)
  60         cls.teardown_testdir()
  61         cls.teardown_attribs()
  62
  63     def cleardir(cls, dirname):
  64         """removes the given directory"""
  65         if os.path.exists(dirname):
  66             for dirpath, subdirs, filenames in os.walk(dirname, topdown=False):
  67                 for name in filenames:
  68                     os.remove(os.path.join(dirpath, name))
  69                 for name in subdirs:
  70                     os.rmdir(os.path.join(dirpath, name))
  71         if os.path.exists(dirname): os.rmdir(dirname)
  72         assert not os.path.exists(dirname)
  73     cleardir = classmethod(cleardir)
  74
  75     def teardown_attribs(cls):
  76         """removes class attributes that have been set while running"""
  77         save_attribs = cls.save_attribs
  78         for attrib in cls.__dict__.keys():
  79             if attrib not in save_attribs:
  80                 delattr(cls, attrib)
  81     teardown_attribs = classmethod(teardown_attribs)
  82
  83     def setup_pootleserver(cls):
  84         """Sets up a Pootle server, and a session on it"""
  85         cls.server = pootle.PootleServer(cls.prefs.Pootle, cls.webserver)
  86         cls.server.name = cls.__name__
  87         cls.instance = cls.server.instance
  88         cls.session = cls.setup_session()
  89     setup_pootleserver = classmethod(setup_pootleserver)
  90
  91     def setup_webserver(cls):
  92         """setup the webserver that will be used for the tests"""
  93         return simplewebserver.DummyServer()
  94     setup_webserver = classmethod(setup_webserver)
  95
  96     def setup_session(cls):
  97         """sets up the session for the test"""
  98         session = users.PootleSession(sessioncache, cls.server)
  99         timestamp = dates.formatdate(dates.currentdate(), '%Y%m%d%H%M%S')
 100         session.create("admin","",timestamp,'en')
 101         session.remote_ip = "unit tests..."
 102         return session
 103     setup_session = classmethod(setup_session)
 104
 105     def make_initial_prefs(cls):
 106         return prefs.PrefsParser()
 107     make_initial_prefs = classmethod(make_initial_prefs)
 108
 109     def make_prefs(cls):
 110         prefs = cls.make_initial_prefs()
 111         prefs.setvalue('importmodules.pootle', 'Pootle.pootle')
 112         prefs.setvalue('Pootle.serverclass', 'pootle.PootleServer')
 113         instance = prefs.Pootle
 114         instance.sessionkey = 'change'
 115         instance.errorfile = os.path.join(cls.testdir, "pootle_unittest-%s-errors.log" % cls.__name__)
 116         instance.tracefile = os.path.join(cls.testdir, "pootle_unittest-%s-trace.log" % cls.__name__)
 117         prefs.setvalue("Pootle.languages.zxx.fullname", "Test Language")
 118         prefs.setvalue("Pootle.projects.testproject.fullname", "Pootle Unit Tests")
 119         prefs.setvalue("Pootle.projects.testproject.description", "Test Project for verifying functionality")
 120         prefs.setvalue("Pootle.projects.testproject.localfiletype", "po")
 121         prefs.setvalue("Pootle.users.testuser.activated", 1)
 122         testuserprefs = instance.users.testuser
 123         testuserprefs.passwdhash = session.md5hexdigest("")
 124         instance.podirectory = cls.podir
 125         return prefs
 126     make_prefs = classmethod(make_prefs)
 127
 128     def test_created(self):
 129         """test that the po directory actually exists"""
 130         print self.podir
 131         assert os.path.isdir(self.podir)
 132
 133 class NoReuse(TestCreate):
 134     """don't reuse webserver objects between methods"""
 135     def setup_webserver(self):
 136         """setup the webserver that will be used for the tests"""
 137         return simplewebserver.DummyServer()
 138
 139     def setup_pootleserver(self):
 140         """Sets up a Pootle server, and a session on it"""
 141         self.server = pootle.PootleServer(self.prefs.Pootle, self.webserver)
 142         self.server.name = self.__class__.__name__
 143         self.instance = self.server.instance
 144         self.session = self.setup_session()
 145
 146     def setup_session(self):
 147         """sets up the session for the test"""
 148         session = users.PootleSession(sessioncache, self.server)
 149         timestamp = dates.formatdate(dates.currentdate(), '%Y%m%d%H%M%S')
 150         session.create("admin","",timestamp,'en')
 151         session.remote_ip = "unit tests..."
 152         return session
 153
 154     def setup_method(self, method):
 155         """sets up a webserver and jlogbookserver for this method"""
 156         self.webserver = self.setup_webserver()
 157         self.setup_testdir()
 158         self.setup_pootleserver()
 159
 160     def teardown_method(self, method):
 161         """sets up a webserver and jlogbookserver for this method"""
 162         self.server = None
 163         self.instance = None
 164         self.logtable = None
 165         self.session = None
 166         self.webserver = None
 167         self.teardown_testdir()
 168