class TestRun(unittest.TestCase):
    def setUp(self):
        self.config = Configurator()
        self.config.begin()
        
    def tearDown(self):
        self.config.end()

    def test_app(self):
        from tattoo.run import app
        myapp = app(None, 
                    setup_db=setup_db, 
                    populate=populate, 
                    db_path='mongo://foo.com:1235/dbname',
                    min_url_len=21,
                    )
        self.assertEquals(myapp.__class__.__name__, 'Router')
        
    def test_app_without_db_string(self):
        from tattoo.run import app
        self.assertRaises(ValueError, app, 
                          None, 
                          setup_db=setup_db, 
                          populate=populate, 
                          min_url_len=21,
                          )

    def test_setup_db(self):
        from tattoo.run import setup_db
        from ming import Session
        from tattoo.models import SESSION_NAME
        db_uri = 'mongo://foo.com:1235/dbname'
        setup_db(db_uri)
        session = Session.by_name(SESSION_NAME)
        self.assertTrue(SESSION_NAME in session._registry.keys())

    def test_handle_submit_key_expired(self):
        reg = get_current_registry()
        config = Configurator(reg)
        renderer = config.testing_add_template('templates/reset_failed.pt')
        request = self.request
        request.params['key'] = '0' * 40
        self._setupUsers()
        context = self.context
        context['profiles'] = testing.DummyModel()
        profile = context['profiles']['me'] = testing.DummyModel()
        profile.password_reset_key = '0' * 40
        controller = self._makeOne(context, request)
        converted = {'login': 'me'}
        # first w/ no profile reset time
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Key Expired')

        # now w/ expired key
        renderer = config.testing_add_template('templates/reset_failed.pt')
        from karl.views.resetpassword import max_reset_timedelta
        import datetime
        keytime = datetime.datetime.now() - max_reset_timedelta
        profile.password_reset_time = keytime
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Key Expired')

 def test_handle_submit_utf8_password(self):
     password = u'password\xe1'
     reg = get_current_registry()
     config = Configurator(reg)
     renderer = config.testing_add_template('templates/reset_complete.pt')
     request = self.request
     request.params['key'] = '0' * 40
     self._setupUsers()
     context = self.context
     context['profiles'] = testing.DummyModel()
     profile = context['profiles']['me'] = testing.DummyModel()
     profile.password_reset_key = '0' * 40
     controller = self._makeOne(context, request)
     converted = {'login': 'me', 'password': password}
     import datetime
     keytime = datetime.datetime.now()
     profile.password_reset_time = keytime
     response = controller.handle_submit(converted)
     self.failUnless(hasattr(renderer, 'api'))
     self.assertEqual(renderer.api.page_title,
                      'Password Reset Complete')
     renderer.assert_(login='me', password=password)
     self.failUnless(profile.password_reset_key is None)
     self.failUnless(profile.password_reset_time is None)
     user = self.context.users.get(login='me')
     from repoze.who.plugins.zodb.users import get_sha_password
     self.assertEqual(user['password'], get_sha_password(password.encode('utf8')))

class ModelUtilTests(unittest.TestCase):
    def setUp(self):
        self.config = Configurator()
        self.config.begin()

    def tearDown(self):
        self.config.end()

    def test_create_child_no_kwargs(self):
        from rfd.models import create_child
        class Thing(object):
            pass
        parent = Thing()
        name = "alice"
        child = create_child(Thing, parent, name)
        self.assertEqual(child.__parent__, parent)
        self.assertEqual(child.__name__, name)

    def test_create_child_with_kwargs(self):
        from rfd.models import create_child
        class Thing(object):
            pass
        parent = Thing()
        name = "alice"
        child = create_child(Thing, parent, name, foo="foo", bar="bar")
        self.assertEqual(child.__parent__, parent)
        self.assertEqual(child.__name__, name)
        self.assertEqual(child.foo, "foo")
        self.assertEqual(child.bar, "bar")

    def test_handle_submit_wrong_key(self):
        reg = get_current_registry()
        config = Configurator(reg)
        renderer = config.testing_add_template('templates/reset_failed.pt')
        request = self.request
        request.params['key'] = '0' * 40
        self._setupUsers()
        context = self.context
        context['profiles'] = testing.DummyModel()
        context['profiles']['me'] = testing.DummyModel()
        controller = self._makeOne(context, request)
        converted = {'login': 'me'}
        # first w/ no profile reset key
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Problem')

        # now w/ wrong profile reset key
        renderer = config.testing_add_template('templates/reset_failed.pt')
        context['profiles']['me'].password_reset_key = '1' * 40
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Problem')

    def test___call__bad_key(self):
        # register dummy renderer for the email template
        reg = get_current_registry()
        config = Configurator(reg)
        renderer = config.testing_add_template('templates/reset_failed.pt')

        request = self.request
        # no key
        controller = self._makeOne(self.context, request)
        response = controller()
        from webob.response import Response
        self.assertEqual(response.__class__, Response)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset URL Problem')

        # reset renderer.api value so we know the test is useful
        renderer = config.testing_add_template('templates/reset_failed.pt')
        # key of wrong length
        request.params['key'] = 'foofoofoo'
        controller = self._makeOne(self.context, request)
        response = controller()
        from webob.response import Response
        self.assertEqual(response.__class__, Response)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset URL Problem')

 def _registerComponents(self):
     # Install a bit of configuration that make_app() usually
     # does for us.
     reg = get_current_registry()
     config = Configurator(reg)
     config.setup_registry()
     config.load_zcml('opencore.includes:configure.zcml')

class CodecTests(unittest.TestCase):
    def setUp(self):
        self.config = Configurator()
        self.config.begin()
    
    def tearDown(self):
        self.config.end()

    def _make_codec(self):
        from tattoo.codec import decode, encode, map_dict
        CHARS = u"ABC123.ä~€+"
        BASE = len(CHARS)
        map_dict.clear()
        for num in range(BASE):
            map_dict[num] = CHARS[num]
            map_dict[CHARS[num]] = num
        return decode, encode, map_dict

    def test_encode(self):
        decode, encode, map_dict = self._make_codec()
        self.assertEqual(encode(0), u'A')
        self.assertEqual(encode(10), u'+')
        self.assertEqual(encode(7), u'\xe4')
        self.assertEqual(encode(4), u'2')

    def test_decode(self):
        decode, encode, map_dict = self._make_codec()
        self.assertEqual(decode(u'A'), 0)
        self.assertEqual(decode(u'+'), 10)
        self.assertEqual(decode(u'\xe4'), 7)
        self.assertEqual(decode(u'2'), 4)

def app(global_config, **settings):
    """ This function returns a WSGI application.
    
    It is usually called by the PasteDeploy framework during 
    ``paster serve``.
    """
    names = ('src_path', 'store_url', 'cache_url', 'max_entries', 'database', 'content_dir')
    values = []
    for name in names:
        val = settings.get(name)
        if val is None: 
            raise ValueError("No ’%s’ value in application configuration." % name) 
        values.append(val)
        
    src_path, store_url, cache_url, max_entries, database, content_dir = values
    
    zcml_file = settings.get('configure_zcml', 'configure.zcml')
    config = Configurator(settings=settings, root_factory=ContentRoot(content_dir))
    # use local component registry
    config.hook_zca()
    config.begin()
    config.load_zcml(zcml_file)
    
    register_source(src_path)
    register_store(store_url, cache_url, max_entries=max_entries)
    register_catalog(database)
    config.end()
    
    return config.make_wsgi_app()

 def _registerComponents(self):
     # Install a bit of configuration that make_app() usually
     # does for us.
     reg = get_current_registry()
     config = Configurator(reg)
     config.setup_registry()
     config.load_zcml('karl.includes:configure.zcml')
     from zope.interface import Interface
     testing.registerAdapter(DummyToolAddables, (Interface, Interface),
                             IToolAddables)

def maintenance(global_config, **local_conf):
    config = Configurator()
    config.begin()
    config.add_static_view('static', 'karl.views:static')
    config.add_route(name='maintenance',
                    path='/*url',
                    view=dummy_view,
                    view_renderer='down_for_maintenance.pt')
    config.end()
    return config.make_wsgi_app()

 def test_handle_submit_bad_key(self):
     reg = get_current_registry()
     config = Configurator(reg)
     renderer = config.testing_add_template('templates/reset_failed.pt')
     request = self.request
     request.params['key'] = 'foofoofoo'
     controller = self._makeOne(self.context, request)
     response = controller.handle_submit({})
     self.failUnless(hasattr(renderer, 'api'))
     self.assertEqual(renderer.api.page_title,
                      'Password Reset URL Problem')

class ViewIntegrationTest(ViewTest):
    def setUp(self):
        import seantisinvoice

        self.config = Configurator(package=seantisinvoice)
        self.config.begin()
        self.config.load_zcml("seantisinvoice:configure.zcml")
        _initTestingDB()

    def test_zcml_registration(self):
        pass

def app(global_config, **settings):
    """ This function returns a WSGI application.
    
    It is usually called by the PasteDeploy framework during 
    ``paster serve``.
    """
    config = Configurator()
    config.begin()
    config.add_view(home, renderer="templates/home.pt")
    config.add_view(expense, name='expense', renderer='templates/expense.pt')
    config.end()
    return config.make_wsgi_app()

class ViewTests(unittest.TestCase):
    def setUp(self):
        self.config = Configurator()
        self.config.begin()

    def tearDown(self):
        self.config.end()

    def test_my_view(self):
        from bmibargains.views import my_view
        request = testing.DummyRequest()
        info = my_view(request)
        self.assertEqual(info['project'], 'bmibargains')

class BaseTest(unittest.TestCase):
    def setUp(self):
        self.config = Configurator()
        self.config.begin()
        _initTestingDB()

    def tearDown(self):
        from seantisinvoice.models import DBSession
        import transaction

        DBSession.remove()
        transaction.abort()
        self.config.end()

class TestUtility(unittest.TestCase):
    def setUp(self):
        self.config = Configurator()
        self.config.begin()
        
    def tearDown(self):
        self.config.end()

    def test_expire_one_year(self):
        import datetime
        from tattoo.utility import expire_one_year
        nowish = datetime.datetime.now()
        delta = expire_one_year()-nowish
        self.assertEquals(delta.days, 365)

def main(global_config, **settings):
    """ This function returns a WSGI application.
    
    It is usually called by the PasteDeploy framework during 
    ``paster serve``.
    """
    from repoze.bfg.authentication import AuthTktAuthenticationPolicy
    from checking.authorization import RouteAuthorizationPolicy
    from checking.authentication import verifyUser

    if not settings.get("sqlalchemy.url"):
        raise ValueError("No 'sqlalchemy.url' value in application configuration.")
    config = Configurator(settings=settings,
            authentication_policy=AuthTktAuthenticationPolicy("secret",
                callback=verifyUser,
                timeout=30*60, max_age=30*60,
                reissue_time=20*60),
            authorization_policy=RouteAuthorizationPolicy())
    config.hook_zca()
    config.begin()
    setupSqlalchemy(settings)
    setupRoutes(config)
    setupChameleon(config)
    setupi18n(config)
    config.end()

    app = config.make_wsgi_app()
    app = TM(app)

    return app

class ViewTests(unittest.TestCase):
    def setUp(self):
        self.config = Configurator()
        self.config.begin()

    def tearDown(self):
        self.config.end()

    def test_filedrop_view(self):
        from rfd.views import filedrop
        request = testing.DummyRequest()
        context = None          # this can't be right
        info = filedrop(context, request)
        self.assertEqual(info['project'], 'rfd (repoze file drop)')

def app(global_config, **settings):
    """ This function returns a WSGI application.
    
    It is usually called by the PasteDeploy framework during 
    ``paster serve``.
    """
    zcml_file = settings.get('configure_zcml', 'configure.zcml')
    db_string = settings.get('db_string')
    if db_string is None:
        raise ValueError("No 'db_string' value in application configuration.")
    initialize_sql(db_string)
    config = Configurator(root_factory=get_root, settings=settings)
    config.begin()
    config.load_zcml(zcml_file)
    config.end()
    # Ugly hack to configure the MapperExtension with the settings.
    removal_extension.path = settings.get('upload_directory')
    
    scheduler = Scheduler()
    # Send out queued mails
    from eportfolio.utilities.mail_delivery import trigger_queued_delivery
    scheduler.add_interval_job(trigger_queued_delivery, seconds=30)
    scheduler.start()
    
    return config.make_wsgi_app()