def test_generated_string():
    serializer = Serializer('text')
    string = ''.join(serializer.list_tiddlers(tiddler_collection))

    assert 'TiddlerOne' in string
    assert 'TiddlerTwo' in string
    assert 'TiddlerThree' in string

def test_text_list():
    serializer = Serializer('text')
    bags = [Bag('bag' + str(name)) for name in range(2)]
    string = ''.join(serializer.list_bags(bags))

    assert 'bag0' in string
    assert 'bag1' in string

def import_plugin(bag, url):
    """
    Import one plugin, at svn url, into bag, retrieving
    both the .js and .js.meta files.

    If there is no meta file, then set title and tags
    to something appropriate before de-serializing.
    """
    meta_url = "%s.meta" % url
    plugin_content = get_url(url)
    try:
        meta_content = _get_url(meta_url)
    except HTTPError:
        meta_content = "title: %s\ntags: systemConfig\n" % _strip_extension(url, ".js").split("/")[-1]

    title = [line for line in meta_content.split("\n") if line.startswith("title:")][0]
    title = title.split(":", 1)[1].lstrip().rstrip()
    tiddler_meta = "\n".join([line for line in meta_content.split("\n") if not line.startswith("title:")])

    tiddler_meta.rstrip()
    tiddler_text = "%s\n\n%s" % (tiddler_meta, plugin_content)

    tiddler = Tiddler(title, bag)
    serializer = Serializer("text")
    serializer.object = tiddler
    serializer.from_string(tiddler_text)

    _store().put(tiddler)

def get(environ, start_response):
    """
    Get a representation in some serialization of
    a bag (the bag itself not the tiddlers within).
    """
    bag_name = _determine_bag_name(environ)
    bag_name = web.handle_extension(environ, bag_name)
    bag = _get_bag(environ, bag_name, True)

    bag.policy.allows(environ['tiddlyweb.usersign'], 'manage')

    try:
        serialize_type, mime_type = web.get_serialize_type(environ)
        serializer = Serializer(serialize_type, environ)
        serializer.object = bag

        content = serializer.to_string()
    except NoSerializationError:
        raise HTTP415('Content type not supported: %s' % mime_type)

    start_response("200 Ok",
            [('Content-Type', mime_type),
                ('Vary', 'Accept')])

    return [content]

def put(environ, start_response):
    """
    Put a bag to the server, meaning the description and
    policy of the bag, if policy allows.
    """
    bag_name = _determine_bag_name(environ)
    bag_name = web.handle_extension(environ, bag_name)

    bag = Bag(bag_name)
    store = environ["tiddlyweb.store"]
    length = environ["CONTENT_LENGTH"]

    usersign = environ["tiddlyweb.usersign"]

    try:
        bag = store.get(bag)
        bag.policy.allows(usersign, "manage")
    except NoBagError:
        create_policy_check(environ, "bag", usersign)

    try:
        serialize_type = web.get_serialize_type(environ)[0]
        serializer = Serializer(serialize_type, environ)
        serializer.object = bag
        content = environ["wsgi.input"].read(int(length))
        serializer.from_string(content.decode("utf-8"))

        bag.policy.owner = usersign["name"]

        _validate_bag(environ, bag)
        store.put(bag)
    except BagFormatError, exc:
        raise HTTP400("unable to put bag: %s" % exc)

def send_tiddlers(environ, start_response, bag):
    """
    Output the tiddlers contained in the provided
    bag in a Negotiated representation. Often, but
    not always, a wiki.
    """
    last_modified = None
    etag = None
    bags_tiddlers = bag.list_tiddlers()
    download = environ['tiddlyweb.query'].get('download', [None])[0]

    if bags_tiddlers:
        last_modified, etag = _validate_tiddler_list(environ, bags_tiddlers)
    else:
        raise HTTP404('No tiddlers in container')

    serialize_type, mime_type = get_serialize_type(environ)
    serializer = Serializer(serialize_type, environ)

    content_header = ('Content-Type', mime_type)
    cache_header = ('Cache-Control', 'no-cache')
    response = [content_header, cache_header]

    if serialize_type == 'wiki':
        if download:
            response.append(('Content-Disposition',
                'attachment; filename="%s"' % download))
    if last_modified:
        response.append(last_modified)
    if etag:
        response.append(etag)

    output = serializer.list_tiddlers(bag)
    start_response("200 OK", response)
    return [output]

def send_entity(environ, start_response, entity):
    """
    Send a :py:class:`bag <tiddlyweb.model.bag.Bag>` or :py:class:`recipe
    <tiddlyweb.model.recipe.Recipe>` out over HTTP, first
    :py:class:`serializing <tiddlyweb.serializer.Serializer>` to
    the correct type. If an incoming ``Etag`` validates, raise a
    ``304`` response.
    """
    etag_string = entity_etag(environ, entity)
    check_incoming_etag(environ, etag_string)

    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)

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

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

def test_html_list():
    serializer = Serializer('html')
    recipes = [Recipe('recipe' + str(name)) for name in xrange(2)]
    string = ''.join(serializer.list_recipes(recipes))

    assert 'href="recipes/recipe0' in string
    assert 'href="recipes/recipe1' in string

def test_bag_to_html():
    serializer = Serializer("html")

    serializer.object = bagfour
    html = serializer.to_string()

    assert html == expected_bag_html

    def list_tiddlers(self, bag):
        try:
          qs = self.environ["tiddlyweb.query"]["j"][0]
          js = True
        except KeyError:
          js = False
        
        if not js:
          try:
            host = "http://"+self.environ['HTTP_HOST']

            refer = self.environ["HTTP_REFERER"]
            if refer == host or refer == "%s%s"%(host,self.environ['REQUEST_URI']):
              js = True
            else:
              js = False
          except KeyError:
            js = False
        if js:
          s = Serializer("tiddlywebwiki.serialization",self.environ)
          return s.list_tiddlers(bag)
        else:
          if bag.tiddlers[0] and bag.tiddlers[0].recipe:            
            try:
              beefcaked_recipe ="beefcaked_"+bag.tiddlers[0].recipe
              store = self.environ['tiddlyweb.store'] 
              recipe = store.get(Recipe(beefcaked_recipe))
              return generate_index(self.environ,self.get_tiddlers_bag_for_recipe(beefcaked_recipe))
            except NoRecipeError:
              return generate_index(self.environ,bag)
          else:
            return generate_index(self.environ,bag)

def test_generated_html_with_revbag():
    html_serializer = Serializer("html")
    bagfour.revbag = True
    string = html_serializer.list_tiddlers(bagfour)

    assert expected_html_revbag_string in string
    bagfour.revbag = False

def test_generated_text():
    serializer = Serializer("text")
    serializer.object = recipe
    string = serializer.to_string()

    assert string == expected_string
    assert "%s" % serializer == expected_string

def test_html_list():
    serializer = Serializer("html")
    recipes = [Recipe("recipe" + str(name)) for name in range(2)]
    string = "".join(serializer.list_recipes(recipes))

    assert 'href="recipes/recipe0' in string
    assert 'href="recipes/recipe1' in string

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 post_request(environ, start_response):
    length = int(environ["CONTENT_LENGTH"])
    post_content = environ["wsgi.input"].read(length)
    serializer = Serializer("json")  # TODO: use content-type to determine serialization
    rev = Tiddler("untitled")  # N.B.: Serializations need not contain title.
    serializer.object = rev
    serializer.from_string(post_content.decode("utf-8"))

    query = environ["tiddlyweb.query"]
    store = environ["tiddlyweb.store"]

    rev1_id = query.get("rev1", [None])[0]
    rev2_id = query.get("rev2", [None])[0]
    try:
        if not rev1_id:
            rev1 = rev
            rev2 = _get_tiddler(rev2_id, store)
        elif not rev2_id:
            rev1 = _get_tiddler(rev1_id, store)
            rev2 = rev
        else:
            raise HTTP400("ambiguous request")
    except AttributeError:
        raise HTTP400("missing revision parameter")

    format = query.get("format", [None])[0]

    content = compare_tiddlers(rev1, rev2, format)
    return _generate_response(content, environ, start_response)

def send_entity(environ, start_response, entity):
    """
    Send a bag or recipe out HTTP, first serializing to
    the correct type. If the incoming etag matches, raise
    304.
    """
    etag_string = entity_etag(environ, entity)
    incoming_etag = environ.get('HTTP_IF_NONE_MATCH', None)
    if incoming_etag:
        if incoming_etag == etag_string:
            raise HTTP304(incoming_etag)

    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)

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

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

def test_generated_html_with_revbag():
    html_serializer = Serializer("html")
    bagfour.revbag = True
    string = html_serializer.list_tiddlers(bagfour)

    assert '<li><a href="/bags/bagfour/tiddlers/TiddlerTwo/revisions/0">TiddlerTwo:0</a></li>' in string
    bagfour.revbag = False

def put(environ, start_response):
    """
    Put a bag to the server, meaning the description and
    policy of the bag, if policy allows.
    """
    bag_name = web.get_route_value(environ, 'bag_name')
    bag_name = web.handle_extension(environ, bag_name)

    bag = Bag(bag_name)
    store = environ['tiddlyweb.store']
    length, _ = web.content_length_and_type(environ)

    usersign = environ['tiddlyweb.usersign']

    try:
        bag = store.get(bag)
        bag.policy.allows(usersign, 'manage')
    except NoBagError:
        create_policy_check(environ, 'bag', usersign)

    try:
        serialize_type = web.get_serialize_type(environ)[0]
        serializer = Serializer(serialize_type, environ)
        serializer.object = bag
        content = web.read_request_body(environ, length)
        serializer.from_string(content.decode('utf-8'))

        bag.policy.owner = usersign['name']

        _validate_bag(environ, bag)
        store.put(bag)
    except BagFormatError, exc:
        raise HTTP400('unable to put bag: %s' % exc)

def test_text_list():
    serializer = Serializer("text")
    bags = [Bag("bag" + str(name)) for name in xrange(2)]
    string = serializer.list_bags(bags)

    assert "bag0" in string
    assert "bag1" in string

def list(environ, start_response):
    """
    List all the bags that the current user can read.
    """
    store = environ["tiddlyweb.store"]
    bags = store.list_bags()
    kept_bags = []
    for bag in bags:
        try:
            bag.skinny = True
            bag = store.get(bag)
            bag.policy.allows(environ["tiddlyweb.usersign"], "read")
            kept_bags.append(bag)
        except (UserRequiredError, ForbiddenError):
            pass

    try:
        serialize_type, mime_type = web.get_serialize_type(environ)
        serializer = Serializer(serialize_type, environ)

        content = serializer.list_bags(kept_bags)

    except NoSerializationError:
        raise HTTP415("Content type not supported: %s" % mime_type)

    start_response("200 OK", [("Content-Type", mime_type)])

    return [content]