def test_put_tiddler_via_recipe():
    http = httplib2.Http()
    json = simplejson.dumps(
        dict(
            text="i fight for the users 2",
            tags=["tagone", "tagtwo"],
            modifier="",
            modified="200803030303",
            created="200803030303",
        )
    )

    response, content = http.request(
        "http://our_test_domain:8001/recipes/long/tiddlers/FantasticVoyage",
        method="PUT",
        headers={"Content-Type": "application/json"},
        body=json,
    )

    assert response["status"] == "204"
    etag_hash = sha("GUEST:application/json").hexdigest()
    assert response["etag"] == '"bag1/FantasticVoyage/1;%s"' % etag_hash
    url = response["location"]

    reponse, content = http.request(url, method="GET", headers={"Accept": "application/json"})
    tiddler_dict = simplejson.loads(content)
    assert tiddler_dict["bag"] == "bag1"
    etag_hash = sha("GUEST:application/json").hexdigest()
    assert response["etag"] == '"bag1/FantasticVoyage/1;%s"' % etag_hash

def test_put_tiddler_cache_fakey():
    [os.unlink('.test_cache/%s' % x) for x in os.listdir('.test_cache')]
    http_caching = httplib2.Http('.test_cache')
    http = httplib2.Http()

    json = simplejson.dumps(dict(text='i fight for the users 2', tags=['tagone','tagtwo'], modifier='', modified='200803030303', created='200803030303'))

    response, content = http_caching.request('http://our_test_domain:8001/recipes/long/tiddlers/CashForCache',
            method='PUT', headers={'Content-Type': 'application/json'}, body=json)
    assert response['status'] == '204'
    etag_hash = sha('GUEST:application/json').hexdigest()
    assert response['etag'] == '"bag1/CashForCache/1;%s"' % etag_hash

    response, content = http_caching.request('http://our_test_domain:8001/recipes/long/tiddlers/CashForCache',
            method='GET', headers={'Accept': 'application/json'})
    assert response['status'] == '200'
    etag_hash = sha('GUEST:application/json').hexdigest()
    assert response['etag'] == '"bag1/CashForCache/1;%s"' % etag_hash

    response, content = http.request('http://our_test_domain:8001/recipes/long/tiddlers/CashForCache',
            method='PUT', headers={'Content-Type': 'application/json'}, body=json)
    assert response['status'] == '204'
    etag_hash = sha('GUEST:application/json').hexdigest()
    assert response['etag'] == '"bag1/CashForCache/2;%s"' % etag_hash

    response, content = http_caching.request('http://our_test_domain:8001/recipes/long/tiddlers/CashForCache',
            method='PUT', headers={'Content-Type': 'application/json'}, body=json)
    assert response['status'] == '412'

def test_put_tiddler_cache_fakey():
    [os.unlink(".test_cache/%s" % x) for x in os.listdir(".test_cache")]
    http_caching = httplib2.Http(".test_cache")
    http = httplib2.Http()

    json = simplejson.dumps(
        dict(
            text="i fight for the users 2",
            tags=["tagone", "tagtwo"],
            modifier="",
            modified="200803030303",
            created="200803030303",
        )
    )

    response, content = http_caching.request(
        "http://our_test_domain:8001/recipes/long/tiddlers/CashForCache",
        method="PUT",
        headers={"Content-Type": "application/json"},
        body=json,
    )
    assert response["status"] == "204"
    etag_hash = sha("GUEST:application/json").hexdigest()
    assert response["etag"] == '"bag1/CashForCache/1;%s"' % etag_hash

    response, content = http_caching.request(
        "http://our_test_domain:8001/recipes/long/tiddlers/CashForCache",
        method="GET",
        headers={"Accept": "application/json"},
    )
    assert response["status"] == "200"
    etag_hash = sha("GUEST:application/json").hexdigest()
    assert response["etag"] == '"bag1/CashForCache/1;%s"' % etag_hash

    response, content = http.request(
        "http://our_test_domain:8001/recipes/long/tiddlers/CashForCache",
        method="PUT",
        headers={"Content-Type": "application/json"},
        body=json,
    )
    assert response["status"] == "204"
    etag_hash = sha("GUEST:application/json").hexdigest()
    assert response["etag"] == '"bag1/CashForCache/2;%s"' % etag_hash

    response, content = http_caching.request(
        "http://our_test_domain:8001/recipes/long/tiddlers/CashForCache",
        method="PUT",
        headers={"Content-Type": "application/json"},
        body=json,
    )
    assert response["status"] == "412"

def _validate_tiddler_list(environ, tiddlers):
    """
    Do Etag and Last modified checks on the
    collection of tiddlers.

    If ETag testing is done, no last modified handling
    is done, even if the ETag testing fails.

    If no 304 is raised, then just return last-modified
    and ETag for the caller to use in constructing
    its HTTP response.
    """
    last_modified_string = http_date_from_timestamp(tiddlers.modified)
    last_modified = ('Last-Modified', last_modified_string)

    username = environ.get('tiddlyweb.usersign', {}).get('name', '')

    try:
        _, mime_type = get_serialize_type(environ)
        mime_type = mime_type.split(';', 1)[0].strip()
    except TypeError:
        mime_type = ''
    etag_string = '"%s:%s"' % (tiddlers.hexdigest(),
            sha('%s:%s' % (username.encode('utf-8'), mime_type)).hexdigest())
    etag = ('Etag', etag_string)

    incoming_etag = check_incoming_etag(environ, etag_string)
    if not incoming_etag:  # only check last modified when no etag
        check_last_modified(environ, last_modified_string)

    return last_modified, etag

def make_user(username, password):
    user = User(username)
    user.set_password(password)
    store.put(user)

    secret_string = sha('%s%s' % (username, config['secret'])).hexdigest()
    return secret_string

def test_validator_nonce_success():
    """
    test the validator directly
    ensure that it succeeds when the nonce passed in is correct
    """
    store = get_store(config)
    username = 'foo'
    spacename = 'foo'
    secret = '12345'
    timestamp = datetime.now().strftime('%Y%m%d%H')
    nonce = '%s:%s:%s' % (timestamp, username,
        sha('%s:%s:%s:%s' % (username, timestamp, spacename, secret)).
        hexdigest())
    environ = {
       'tiddlyweb.usersign': {'name': username},
       'tiddlyweb.config': {
           'secret': secret,
           'server_host': {
               'host': '0.0.0.0',
               'port': '8080'
           }
        },
        'HTTP_HOST': 'foo.0.0.0.0:8080'
    }
    make_fake_space(store, spacename)

    csrf = CSRFProtector({})
    result = csrf.check_csrf(environ, nonce)

    assert result == True

def test_no_cookie_sent():
    """
    Test no cookie is sent if one is already present
    """
    store = get_store(config)
    space = 'foo'
    make_fake_space(store, space)
    user = User('foo')
    user.set_password('foobar')
    store.put(user)

    user_cookie = get_auth('foo', 'foobar')
    time = datetime.now().strftime('%Y%m%d%H')
    cookie = 'csrf_token=%s:%s:%s' % (time, user.usersign,
        sha('%s:%s:%s:%s' % (user.usersign,
        time, space, config['secret'])).hexdigest())

    response, _ = http.request('http://foo.0.0.0.0:8080/status',
        method='GET',
        headers={
            'Cookie': 'tiddlyweb_user="%s"; %s' % (user_cookie, cookie)
        })

    cookie = response.get('set-cookie')
    if cookie:
        assert 'csrf_token' not in cookie

def test_cookie_set():
    """
    test that we get a cookie relating to the space we are in
    """
    store = get_store(config)
    space = 'foo'
    make_fake_space(store, space)
    user = User('foo')
    user.set_password('foobar')
    store.put(user)

    user_cookie = get_auth('foo', 'foobar')

    response, content = http.request('http://foo.0.0.0.0:8080/status',
        method='GET',
        headers={
            'Cookie': 'tiddlyweb_user="%s"' % user_cookie
        })

    assert response['status'] == '200', content

    time = datetime.now().strftime('%Y%m%d%H')
    cookie = 'csrf_token=%s:%s:%s' % (time, user.usersign,
        sha('%s:%s:%s:%s' % (user.usersign,
        time, space, config['secret'])).hexdigest())
    assert response['set-cookie'] == cookie

def test_cookie_set():
    """
    test that we get a cookie relating to the space we are in
    """
    store = get_store(config)
    hostname = "foo.0.0.0.0:8080"
    user = User(u"f\u00F6o")
    user.set_password("foobar")
    store.put(user)

    user_cookie = get_auth(u"f\u00F6o", "foobar")

    response, content = http.request(
        "http://foo.0.0.0.0:8080/", method="GET", headers={"Cookie": 'tiddlyweb_user="%s"' % user_cookie}
    )

    assert response["status"] == "200", content

    time = datetime.utcnow().strftime("%Y%m%d%H")
    cookie = "csrf_token=%s:%s:%s" % (
        time,
        user.usersign,
        sha("%s:%s:%s:%s" % (user.usersign, time, hostname, config["secret"])).hexdigest(),
    )
    assert response["set-cookie"] == quote(cookie.encode("utf-8"), safe=".!~*'():=")

def validate_mapuser(tiddler, environ):
    """
    If a tiddler is put to the MAPUSER bag clear
    out the tiddler and set fields['mapped_user']
    to the current username. There will always be
    a current username because the create policy
    for the bag is set to ANY.
    """
    if tiddler.bag == 'MAPUSER':
        try:
            user_cookie = environ['HTTP_COOKIE']
            cookie = Cookie.SimpleCookie()
            cookie.load(str(user_cookie))
            cookie_value = cookie['tiddlyweb_secondary_user'].value
            secret = environ['tiddlyweb.config']['secret']
            usersign, cookie_secret = cookie_value.rsplit(':', 1)
        except KeyError:
            raise InvalidTiddlerError('secondary cookie not present')

        if cookie_secret != sha('%s%s' % (usersign, secret)).hexdigest():
            raise InvalidTiddlerError('secondary cookie invalid')

        if usersign != tiddler.title:
            raise InvalidTiddlerError('secondary cookie mismatch')

        store = environ['tiddlyweb.store']
        # XXX this is a potentially expensive operation but let's not
        # early optimize
        if tiddler.title in (user.usersign for user in store.list_users()):
            raise InvalidTiddlerError('username exists')
        tiddler.text = ''
        tiddler.tags = []
        tiddler.fields = {}
        tiddler.fields['mapped_user'] = environ['tiddlyweb.usersign']['name']
    return tiddler

def make_cookie(name, value, mac_key=None, path=None, expires=None, httponly=True, domain=None):
    """
    Create a cookie string, optionally with a MAC, path and
    expires value. If ``expires`` is provided, its value should be
    in seconds.
    """
    cookie = SimpleCookie()

    value = encode_name(value)

    if mac_key:
        secret_string = sha("%s%s" % (value, mac_key)).hexdigest()
        cookie[name] = "%s:%s" % (value, secret_string)
    else:
        cookie[name] = value

    if path:
        cookie[name]["path"] = path

    if expires:
        cookie[name]["max-age"] = expires

    if domain:
        cookie[name]["domain"] = domain

    output = cookie.output(header="").lstrip().rstrip()
    if httponly:
        output += "; httponly"
    return output

def send_entity(environ, start_response, entity):
    """
    Send a bag or recipe out HTTP, first serializing to
    the correct type.
    """
    username = environ['tiddlyweb.usersign']['name']
    try:
        serialize_type, mime_type = get_serialize_type(environ)
        serializer = Serializer(serialize_type, environ)
        serializer.object = entity
        content = serializer.to_string()
    except NoSerializationError:
        raise HTTP415('Content type %s not supported' % mime_type)

    etag_string = '"%s"' % (sha(_entity_etag(entity) +
        encode_name(username) + encode_name(mime_type)).hexdigest())

    start_response("200 OK",
            [('Content-Type', mime_type),
                ('ETag', etag_string),
                ('Vary', 'Accept')])

    if isinstance(content, basestring):
        return [content]
    else:
        return content

def make_cookie(name, value, mac_key=None, path=None,
        expires=None, httponly=True, domain=None):
    """
    Create a cookie string, optionally with a MAC, path and
    expires value. Expires is in seconds.
    """
    cookie = Cookie.SimpleCookie()

    value = value.encode('utf-8')

    if mac_key:
        secret_string = sha('%s%s' % (value, mac_key)).hexdigest()
        cookie[name] = '%s:%s' % (value, secret_string)
    else:
        cookie[name] = value

    if path:
        cookie[name]['path'] = path

    if expires:
        cookie[name]['max-age'] = expires

    if domain:
        cookie[name]['domain'] = domain

    output = cookie.output(header='').lstrip().rstrip()
    if httponly:
        output += '; httponly'
    return output

def test_get_tiddler_revision_3():
    http = httplib2.Http()
    response, content = http.request('http://our_test_domain:8001/bags/bag1/tiddlers/TestOne/revisions/3',
            method='GET')
    assert response['status'] == '200'
    etag_hash = sha('GUEST:text/html').hexdigest()
    assert response['etag'] == '"bag1/TestOne/3;%s"' % etag_hash

def _remotebag_key(environ, uri):
    """
    Generate a tiddler title to use as the key in the REMOTEURI_BAG.
    """
    server_host = environ.get('tiddlyweb.config', {}).get(
            'server_host')['host']
    return sha(uri + server_host).hexdigest()

def test_put_tiddler_txt_4():
    http = httplib2.Http()
    encoded_body = text_put_body2.encode('utf-8')
    response, content = http.request('http://our_test_domain:8001/bags/bag1/tiddlers/TestOne',
            method='PUT', headers={'Content-Type': 'text/plain'}, body=encoded_body)
    assert response['status'] == '204'
    etag_hash = sha('GUEST:text/plain').hexdigest()
    assert response['etag'] == '"bag1/TestOne/4;%s"' % etag_hash

 def check_password(self, candidate_password):
     """
     Check the password for this user. Return ``True`` if correct.
     """
     if not self._password:
         return False
     crypted_thing = sha(candidate_password.strip()).hexdigest()
     return crypted_thing == self._password

 def check_password(self, candidate_password):
     """
     Check the password for this user. Return true if correct.
     """
     if self._password is None:
         return False
     crypted_thing = sha(candidate_password.strip().encode("utf-8")).hexdigest()
     return crypted_thing == self._password

def test_put_tiddler_via_recipe():
    http = httplib2.Http()
    json = simplejson.dumps(dict(text='i fight for the users 2', tags=['tagone','tagtwo'], modifier='', modified='200803030303', created='200803030303'))

    response, content = http.request('http://our_test_domain:8001/recipes/long/tiddlers/FantasticVoyage',
            method='PUT', headers={'Content-Type': 'application/json'}, body=json)

    assert response['status'] == '204'
    etag_hash = sha('GUEST:application/json').hexdigest()
    assert response['etag'] == '"bag1/FantasticVoyage/1;%s"' % etag_hash
    url = response['location']

    reponse, content = http.request(url, method='GET', headers={'Accept': 'application/json'})
    tiddler_dict = simplejson.loads(content)
    assert tiddler_dict['bag'] == 'bag1'
    etag_hash = sha('GUEST:application/json').hexdigest()
    assert response['etag'] == '"bag1/FantasticVoyage/1;%s"' % etag_hash

def test_get_tiddler_etag_bag():
    http = httplib2.Http()
    response, content = http.request("http://our_test_domain:8001/bags/bag28/tiddlers/tiddler8.json", method="GET")

    etag_hash = sha("GUEST:application/json").hexdigest()
    assert response["status"] == "200"
    assert response["etag"] == '"bag28/tiddler8/1;%s"' % etag_hash
    tiddler_info = simplejson.loads(content)
    assert tiddler_info["bag"] == "bag28"