def setUp(self):
     self.defaultview = config.get('tg.defaultview', 'kid')
     config.update({
         'toscawidgets.on': True,
         'tg.defaultview': 'genshi'
     })
     super(ToscaWidgetsTest, self).setUp()

def register_static_directory(modulename, directory):
    """
    Sets up a static directory for JavaScript and css files. You can refer
    to this static directory in templates as ${tg.widgets}/modulename
    """
    directory = os.path.abspath(directory)
    config.update({"/tg_widgets/%s" % modulename: {"static_filter.on": True, "static_filter.dir": directory}})

def enable_csrf():
    '''A startup function to setup :ref:`CSRF-Protection`.

    This should be run at application startup.  Code like the following in the
    start-APP script or the method in :file:`commands.py` that starts it::

        from turbogears import startup
        from fedora.tg.util import enable_csrf
        startup.call_on_startup.append(enable_csrf)

    If we can get the :ref:`CSRF-Protection` into upstream :term:`TurboGears`,
    we might be able to remove this in the future.

    .. versionadded:: 0.3.10
       Added to enable :ref:`CSRF-Protection`
    '''
    # Override the turbogears.url function with our own
    # Note, this also changes turbogears.absolute_url since that calls
    # turbogears.url
    turbogears.url = url
    turbogears.controllers.url = url

    # Ignore the _csrf_token parameter
    ignore = config.get('tg.ignore_parameters', [])
    if '_csrf_token' not in ignore:
        ignore.append('_csrf_token')
        config.update({'tg.ignore_parameters': ignore})

    # Add a function to the template tg stdvars that looks up a template.
    turbogears.view.variable_providers.append(add_custom_stdvars)

    def test_new_text_format(self):
        """Verify that our view is able to send new text format to Genshi."""

        # make sure we have asked for new format in the config
        new_syntax = config.get("genshi.new_text_syntax", False)
        config.update({"genshi.new_text_syntax": True})
        # we need to reload the engines for the config changes to take effect
        view.load_engines()

        # load our expected result in memory
        expected_result = 'Dear Florent Aide\nYour items:\n  * Apples\n  * Bananas\n  * Cherries\n\n'

        info = dict(
            name=u"Florent Aide",
            itemlist=[u'Apples', u'Bananas', u'Cherries']
        )
        template = "genshi-text:turbogears.tests.genshi_new_text_format"
        headers = {}
        val = view.render(info, template, headers=headers, format="text")
        config.update({"genshi.new_text_syntax": new_syntax})

        print "Got this:"
        print "*" * 35
        print "%r" % val
        print "*" * 35
        print "Expected that:"
        print "*" * 35
        print "%r" % expected_result
        print "*" * 35
        assert val == expected_result

 def test_invalid_createrepo_command_fail(self):
     update({'beaker.createrepo_command': 'iamnotarealcommand'})
     rpm_file = pkg_resources.resource_filename('bkr.server.tests', \
         'tmp-distribution-beaker-task_test-2.0-5.noarch.rpm')
     copy(rpm_file, self.tasklibrary.rpmspath)
     with self.assertRaises(OSError):
         self.tasklibrary.update_repo()

 def test_content_types(self):
     info = dict(someval="someval")
     template = "turbogears.tests.simple"
     headers = {}
     view.render(info, template, headers=headers)
     assert headers.get('Content-Type') == 'text/html; charset=utf-8'
     headers = {}
     view.render(info, template, headers=headers, format='html')
     assert headers.get('Content-Type') == 'text/html; charset=utf-8'
     headers = {}
     view.render(info, template, headers=headers, format='html-strict')
     assert headers.get('Content-Type') == 'text/html; charset=utf-8'
     headers = {}
     view.render(info, template, headers=headers, format='xhtml')
     assert headers.get('Content-Type') == 'text/html; charset=utf-8'
     headers = {}
     view.render(info, template, headers=headers, format='xhtml-strict')
     assert headers.get('Content-Type') == 'text/html; charset=utf-8'
     headers = {}
     view.render(info, template, headers=headers, format='xml')
     assert headers.get('Content-Type') == 'text/xml; charset=utf-8'
     headers = {}
     view.render(info, template, headers=headers, format='json')
     assert headers.get('Content-Type') == 'application/json'
     config.update({'global':
         {'tg.format_mime_types': {'xhtml': 'application/xhtml+xml'}}})
     headers = {}
     view.render(info, template, headers=headers, format='xhtml')
     assert headers.get('Content-Type') == 'application/xhtml+xml; charset=utf-8'
     headers = {}
     view.render(info, template, headers=headers, format='xhtml-strict')
     assert headers.get('Content-Type') == 'application/xhtml+xml; charset=utf-8'
     config.update({'global': {'tg.format_mime_types': {}}})

 def test_default_output_encoding(self):
     info = dict(someval="someval")
     # default encoding is utf-8
     val = view.render(info, template="turbogears.tests.simple")
     assert 'utf-8' in view.cherrypy.response.headers["Content-Type"]
     config.update({'tg.defaultview':'kid', 'kid.encoding':'iso-8859-1'})
     val = view.render(info, template="turbogears.tests.simple")
     assert 'iso-8859-1' in view.cherrypy.response.headers["Content-Type"]

 def test_authenticate_header(self):
     """Test that identity returns correct WWW-Authenticate header."""
     response = self.app.get('/logged_in_only', status=403)
     assert 'WWW-Authenticate' not in response.headers
     config.update({'identity.http_basic_auth': True,
                    'identity.http_auth_realm': 'test realm'})
     response = self.app.get('/logged_in_only', status=401)
     assert response.headers['WWW-Authenticate'] == 'Basic realm="test realm"'

 def test_redirect(self):
     config.update({"server.webpath": "/coolsite/root"})
     response = self.app.get("/redirect")
     assert response.location == 'http://localhost:80/coolsite/root/foo'
     self.app.get("/raise_redirect")
     assert response.location == 'http://localhost:80/coolsite/root/foo'
     self.app.get("/relative_redirect")
     assert response.location == 'http://localhost:80/coolsite/root/foo'

 def test_redirect(self):
     config.update({"server.webpath": "/coolsite/root"})
     startup.startTurboGears()
     testutil.create_request("/coolsite/root/subthing/")
     try:
         redirect("/foo")
         assert False, "redirect exception should have been raised"
     except cherrypy.HTTPRedirect, e:
         assert "http://localhost/coolsite/root/subthing/foo" in e.urls

def start_server():
    """Start the server if it's not already started."""
    if not config.get("cp_started"):
        cherrypy.server.start(server_class=None, init_only=True)
        config.update({"cp_started" : True})

    if not config.get("server_started"):
        startup.startTurboGears()
        config.update({"server_started" : True})

 def test_throw_out_random(self):
     """Can append random value to the URL to avoid caching problems."""
     response = self.app.get("/test?tg_random=1")
     assert "Paging all niggles" in response
     config.update({"tg.strict_parameters": True})
     response = self.app.get("/test?tg_random=1", status=200)
     assert "Paging all niggles" in response
     response = self.app.get("/test?tg_not_random=1", status=500)
     assert "unexpected keyword argument" in response

 def setUp(self):
     self._visit_on = config.get('visit.on', False)
     self._visit_source = config.get('visit.source', 'cookie')
     config.update({'visit.on': True})
     self._visit_timeout = config.get('visit.timeout', 20)
     config.update({'visit.timeout': 50})
     self.cookie_name = config.get("visit.cookie.name", 'tg-visit')
     self._visit_key_param = config.get("visit.form.name", 'tg_visit')
     cherrypy.root = VisitRoot()

def test_suppress_mochikit():
    """MochiKit inclusion can be suppressed"""
    config.update({"global":{"tg.mochikit_suppress" : True}})
    suppressed = app.get("/usemochi")
    # repair the fixture
    config.update({"global":{"tg.mochikit_suppress" : False}})

    included = app.get("/usemochi")
    assert "MochiKit.js" not in suppressed.body
    assert "MochiKit.js" in included.body

 def setUp(self):
     self._identity_on = config.get('identity.on', False)
     config.update({'identity.on': False})
     try:
         self._provider = cherrypy.request.identityProvider
     except AttributeError:
         self._provider= None
     cherrypy.request.identityProvider = None
     startup.startTurboGears()
     testutil.DBTest.setUp(self)

 def _config_update(self, data=None, **kw):
     self.config_backup = {}
     if not data:
         data = {}
     else:
         data = data.copy()
     data.update(kw)
     for k in data:
         self.config_backup[k] = config.get(k)
     config.update(data)

 def test_createrepo_c_command(self):
     update({'beaker.createrepo_command': 'createrepo_c'})
     rpm_file = pkg_resources.resource_filename('bkr.server.tests', \
         'tmp-distribution-beaker-task_test-2.0-5.noarch.rpm')
     copy(rpm_file, self.tasklibrary.rpmspath)
     try:
         self.tasklibrary.update_repo()
     except OSError, e:
         if e.errno is errno.ENOENT:
             raise SkipTest('Could not find createrepo_c')

 def test_include_widgets(self):
     """Any widget can be included everywhere by setting tg.include_widgets."""
     config.update({'global': {'tg.include_widgets': [
         'turbogears.tests.test_toscawidgets.js_link',
         'turbogears.tests.test_toscawidgets.css_src']}})
     response = self.app.get('/show_table_form')
     config.update({'global': {'tg.include_widgets': []}})
     assert "foo.js" in response
     assert "body {font-size: 1.em;}" in response
     assert "foo.css" not in response
     assert "alert('head');" not in response

 def test_user_password_unicode(self):
     """Test if we can set a non-ascii user password (no encryption)."""
     config.update({'identity.soprovider.encryption_algorithm': None})
     self.app.get('/')
     hub.begin()
     u = TG_User.by_user_name('samIam')
     u.password = u'garçon'
     u.sync()
     assert u.password == u'garçon'
     hub.rollback()
     hub.end()

 def test_user_password_hashed_sha(self):
     """Test if a sha hashed password is stored in the database."""
     config.update({'identity.soprovider.encryption_algorithm': 'sha1'})
     self.app.get('/')
     hub.begin()
     u = TG_User.by_user_name('samIam')
     u.password = 'password'
     u.sync()
     assert u.password =='5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'
     hub.rollback()
     hub.end()