UriTest.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "../Uri.h"
#include "Imports.cpp"

using namespace Utils::Testing;


namespace Utils {
namespace Testing {

class UriTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (UriTest);
    CPPUNIT_TEST (testNoEncodingScheme);
    CPPUNIT_TEST (testNoEncodingSchemeWithEmptyAuthority);
    CPPUNIT_TEST (testNoEncodingSchemeWithAuthority);
    CPPUNIT_TEST (testNoEncodingSchemeWithEmptyAuthorityWithPath);
    CPPUNIT_TEST (testNoEncodingSchemeWithEmptyAuthorityWithEmptyPathWithEmptyQuery);
    CPPUNIT_TEST (testNoEncodingSchemeWithEmptyAuthorityWithEmptyPathWithEmptyFragment);
    CPPUNIT_TEST (testNoEncodingSchemeWithEmptyAuthorityWithEmptyPathWithEmptyQueryWithEmptyFragment);
    CPPUNIT_TEST (testNoEncodingSchemeWithAuthorityWithPath);
    CPPUNIT_TEST (testNoEncodingSchemeWithAuthorityWithQuery);
    CPPUNIT_TEST (testNoEncodingSchemeWithAuthorityWithFragment);
    CPPUNIT_TEST (testNoEncodingSchemeWithAuthorityWithPathWithQueryWithFragment);
    CPPUNIT_TEST (testNoEncodingAuthorityWithPathWithQueryWithFragment);
    CPPUNIT_TEST (testNoEncodingPathWithQueryWithFragment);
    CPPUNIT_TEST (testNoEncodingQueryWithFragment);
    CPPUNIT_TEST (testNoEncodingQuery);
    CPPUNIT_TEST (testNoEncodingFragment);
    CPPUNIT_TEST (testEncodingIncorrectlyUncodedUriIsNull);
    CPPUNIT_TEST (testEncodingCorrectlyEncodedUri);
    CPPUNIT_TEST (testParseUriWithoutQueryThenAppendQueryTwice);
    CPPUNIT_TEST (testParseUriWithQueryThenAppendQueryTwice);
    CPPUNIT_TEST (testParseUriWithoutQueryThenAppendQueryItemAFewTimes);
    CPPUNIT_TEST (testParseUriWithQueryThenAppendQueryItemAFewTimes);
    CPPUNIT_TEST (testParseUnencodedProduceEncoded);
    CPPUNIT_TEST (testCompareTwoEqualNonEmptyUris);
    CPPUNIT_TEST (testCompareTwoEqualEmptyUris);
    CPPUNIT_TEST (testCompareTwoDifferentNonEmptyUris);
    CPPUNIT_TEST (testCompareEmptyAndNonEmptyUris);
    CPPUNIT_TEST (testCompareUrisWithEmptyAndNullQuery);
    CPPUNIT_TEST (testKeysAndValuesInQueryItemsGetCorrectlyEncoded);
    CPPUNIT_TEST (testParseEncodedUriQueryIsNotPrematurelyDecoded);
    CPPUNIT_TEST (testParseQueryItemsFromQueryTwoItems);
    CPPUNIT_TEST (testParseQueryItemsFromEmptyQuery);
    CPPUNIT_TEST (testEncodingAllCharsInQuery);
    CPPUNIT_TEST (testQueryItemValueNoneValueAssociated);
    CPPUNIT_TEST (testQueryItemValueOneValueAssociated);
    CPPUNIT_TEST (testQueryItemValueTwoValuesAssociated);
    CPPUNIT_TEST (testParsingUriWithPortButWithoutHostFails);
    CPPUNIT_TEST (testParsingUriWithUserinfoButWithoutHostFails);
    CPPUNIT_TEST (testParsingUriWithUserinfoAndPortButWithoutHostFails);
    CPPUNIT_TEST (testGettingSubsetsOfEncodedRepresentation);
    CPPUNIT_TEST_SUITE_END();

    static const QByteArray validUriUnencoded1;
    static const QByteArray validUriUnencoded2;

public:

    void scenarioParseAndWrite (bool encoded,
                                const QByteArray &bytes,
                                const QByteArray &scheme,
                                const QByteArray &authority,
                                const QByteArray &path,
                                const QByteArray &query,
                                const QByteArray &fragment)
    {
        Uri uri;
        if (encoded)
            uri = Uri::fromEncoded (bytes);
        else
            uri = Uri::fromUnencoded (bytes);
        /*
        qDebug() << encoded << bytes;
        qDebug() << uri.scheme() << uri.authority() << uri.path()
                 << uri.query() << uri.fragment();
        qDebug() << uri.encoded();
        qDebug() << uri.unencoded();
        */
        CPPUNIT_ASSERT (uri.scheme() == scheme);
        CPPUNIT_ASSERT (uri.authority() == authority);
        CPPUNIT_ASSERT (uri.path() == path);
        CPPUNIT_ASSERT (uri.query() == query);
        CPPUNIT_ASSERT (uri.fragment() == fragment);

        if (encoded)
            CPPUNIT_ASSERT (uri.encoded() == bytes);
        else
            CPPUNIT_ASSERT (uri.unencoded() == bytes);
    }

    void testNoEncodingScheme()
    {
        scenarioParseAndWrite (false, "my-scheme:",
                               "my-scheme", "", "", "", "");
    }

    void testNoEncodingSchemeWithEmptyAuthority()
    {
        scenarioParseAndWrite (false, "my-scheme://",
                               "my-scheme", "", "", "", "");
    }

    void testNoEncodingSchemeWithAuthority()
    {
        scenarioParseAndWrite (false, "my-scheme://test",
                               "my-scheme", "test", "", "", "");
    }

    void testNoEncodingSchemeWithEmptyAuthorityWithEmptyPathWithEmptyQuery()
    {
        scenarioParseAndWrite (false, "schema://?",
                               "schema", "", "", "", "");
    }

    void testNoEncodingSchemeWithEmptyAuthorityWithEmptyPathWithEmptyFragment()
    {
        scenarioParseAndWrite (false, "schema://#",
                               "schema", "", "", "", "");
    }

    void testNoEncodingSchemeWithEmptyAuthorityWithEmptyPathWithEmptyQueryWithEmptyFragment()
    {
        scenarioParseAndWrite (false, "schema://?#",
                               "schema", "", "", "", "");
    }

    void testNoEncodingSchemeWithEmptyAuthorityWithPath()
    {
        scenarioParseAndWrite (false, "file:///",
                               "file", "", "/", "", "");
    }

    void testNoEncodingSchemeWithAuthorityWithPath()
    {
        scenarioParseAndWrite (false, "http://www.calitko.org/source-talk",
                               "http", "www.calitko.org",
                               "/source-talk", "", "");
    }

    void testNoEncodingSchemeWithAuthorityWithQuery()
    {
        scenarioParseAndWrite (false, "http://www.calitko.org?p=1",
                               "http", "www.calitko.org", "", "p=1", "");
    }

    void testNoEncodingSchemeWithAuthorityWithFragment()
    {
        scenarioParseAndWrite (false, "http://www.calitko.org#Welcome",
                               "http", "www.calitko.org", "", "", "Welcome");
    }

    void testNoEncodingSchemeWithAuthorityWithPathWithQueryWithFragment()
    {
        scenarioParseAndWrite (false, "http://www.calitko.org/?p=1#Welcome",
                               "http", "www.calitko.org",
                               "/", "p=1", "Welcome");
    }

    void testNoEncodingAuthorityWithPathWithQueryWithFragment()
    {
        scenarioParseAndWrite (false, "//www.calitko.org/?p=1#Welcome",
                               "", "www.calitko.org", "/", "p=1", "Welcome");
    }

    void testNoEncodingPathWithQueryWithFragment()
    {
        scenarioParseAndWrite (false, "/?p=1#Welcome",
                               "", "", "/", "p=1", "Welcome");
    }

    void testNoEncodingQueryWithFragment()
    {
        scenarioParseAndWrite (false, "?p=1#Welcome",
                               "", "", "", "p=1", "Welcome");
    }

    void testNoEncodingQuery()
    {
        scenarioParseAndWrite (false, "?p=1",
                               "", "", "", "p=1", "");
    }

    void testNoEncodingFragment()
    {
        scenarioParseAndWrite (false, "#Welcome",
                               "", "", "", "", "Welcome");
    }

    void testEncodingIncorrectlyUncodedUriIsNull()
    {
        // "%bv" is invalid percent encoding:
        Uri uri = Uri::fromEncoded ("http://www.calitko.org?%bva");
        CPPUNIT_ASSERT (uri == Uri());
    }

    void testEncodingCorrectlyEncodedUri()
    {
        scenarioParseAndWrite (true, "http://calitko.org?name%26=%3Dval",
                               "http", "calitko.org", "", "name&==val", "");
    }

    void scenarioParseUriAndAppendQuery (const QByteArray &bytes,
                                         const QByteArray &initialQuery,
                                         const QList <QByteArray> &extraQueries)
    {
        Uri uri;
        if (initialQuery.isEmpty())
            uri = Uri::fromUnencoded (bytes);
        else
            uri = Uri::fromUnencoded (bytes + '?' + initialQuery);

        QByteArray fullQuery = initialQuery;
        foreach (QByteArray query, extraQueries) {
            uri.appendQuery (query);
            fullQuery += query;
            CPPUNIT_ASSERT (uri.query() == fullQuery);
            CPPUNIT_ASSERT (uri.unencoded() == bytes + '?' + fullQuery);
        }
    }

    void testParseUriWithoutQueryThenAppendQueryTwice()
    {
        scenarioParseUriAndAppendQuery ("http://tracker.com/announce.php",
                                        "",
                                        QList <QByteArray> ()
                                        += QByteArray ("name1=val1&name2=val2")
                                        += QByteArray ("&name3"));
    }

    void testParseUriWithQueryThenAppendQueryTwice()
    {
        scenarioParseUriAndAppendQuery ("http://tracker.com/announce.php",
                                        "someparam=somevalue",
                                        QList <QByteArray> ()
                                        += QByteArray ("name1=val1&name2=val2")
                                        += QByteArray ("&name3"));
    }

    void scenarioParseUriAndAppendQueryItem (const QByteArray &bytes,
                                             const QByteArray &initialQuery,
                                             const Uri::QueryItemList &items)
    {
        Uri uri;
        if (initialQuery.isEmpty())
            uri = Uri::fromUnencoded (bytes);
        else
            uri = Uri::fromUnencoded (bytes + '?' + initialQuery);

        Uri uri2 (uri), uri3 (uri);
        QByteArray fullQuery = initialQuery;
        foreach (Uri::QueryItem item, items) {
            uri.appendQueryItem (item.first, item.second);
            uri2.appendQueryItem (item);
            if (!fullQuery.isEmpty())
                fullQuery += '&';
            fullQuery += item.first;
            if (!item.second.isEmpty())
                fullQuery += '=' + item.second;
        }
        uri3.appendQueryItems (items);
        CPPUNIT_ASSERT (uri.query() == fullQuery);
        CPPUNIT_ASSERT (uri.unencoded() == bytes + '?' + fullQuery);
        CPPUNIT_ASSERT (uri2.query() == fullQuery);
        CPPUNIT_ASSERT (uri2.unencoded() == bytes + '?' + fullQuery);
        CPPUNIT_ASSERT (uri3.query() == fullQuery);
        CPPUNIT_ASSERT (uri3.unencoded() == bytes + '?' + fullQuery);
    }

    void testParseUriWithoutQueryThenAppendQueryItemAFewTimes()
    {
        Uri::QueryItemList items;
        items += Uri::QueryItem (QByteArray ("key1"), QByteArray ("value1"));
        items += Uri::QueryItem (QByteArray ("key2"), QByteArray ("value2"));
        items += Uri::QueryItem (QByteArray ("key3"), QByteArray (""));
        items += Uri::QueryItem (QByteArray (""), QByteArray ("value2"));
        scenarioParseUriAndAppendQueryItem ("http://tracker.com/announce.php",
                                            "", items);
    }

    void testParseUriWithQueryThenAppendQueryItemAFewTimes()
    {
        Uri::QueryItemList items;
        items += Uri::QueryItem (QByteArray ("key1"), QByteArray ("value1"));
        items += Uri::QueryItem (QByteArray ("key2"), QByteArray ("value2"));
        items += Uri::QueryItem (QByteArray ("key3"), QByteArray (""));
        items += Uri::QueryItem (QByteArray (""), QByteArray ("value2"));
        scenarioParseUriAndAppendQueryItem ("http://tracker.com/announce.php",
                                            "someparam=somevalue", items);
    }

    void testParseUnencodedProduceEncoded()
    {
        QByteArray unencoded ("file:///This is a test.txt~");
        QByteArray encoded ("file:///This%20is%20a%20test.txt~");
        Uri uri = Uri::fromUnencoded (unencoded);
        CPPUNIT_ASSERT (unencoded == uri.unencoded());
        CPPUNIT_ASSERT (encoded == uri.encoded());
        uri = Uri::fromEncoded (encoded);
        CPPUNIT_ASSERT (unencoded == uri.unencoded());
        CPPUNIT_ASSERT (encoded == uri.encoded());
    }

    void testCompareTwoEqualNonEmptyUris()
    {
        Uri uri1 = Uri::fromUnencoded (validUriUnencoded1);
        Uri uri2 = Uri::fromUnencoded (validUriUnencoded1);

        CPPUNIT_ASSERT (uri1 == uri2);
        CPPUNIT_ASSERT (!(uri1 != uri2));
    }

    void testCompareTwoEqualEmptyUris()
    {
        Uri uri1, uri2;

        CPPUNIT_ASSERT (uri1 == uri2);
        CPPUNIT_ASSERT (!(uri1 != uri2));
    }
    void testCompareTwoDifferentNonEmptyUris()
    {
        Uri uri1 = Uri::fromUnencoded (validUriUnencoded1);
        Uri uri2 = Uri::fromUnencoded (validUriUnencoded2);

        CPPUNIT_ASSERT (uri1 != uri2);
        CPPUNIT_ASSERT (!(uri1 == uri2));
    }

    void testCompareEmptyAndNonEmptyUris()
    {
        Uri uri1 = Uri::fromUnencoded (validUriUnencoded1);
        Uri uri2;

        CPPUNIT_ASSERT (uri1 != uri2);
        CPPUNIT_ASSERT (!(uri1 == uri2));
    }

    void testCompareUrisWithEmptyAndNullQuery()
    {
        Uri uri1 = Uri::fromUnencoded ("http://localhost?");
        Uri uri2 = Uri::fromUnencoded ("http://localhost");

        CPPUNIT_ASSERT (uri1 != uri2);
        CPPUNIT_ASSERT (!(uri1 == uri2));
    }

    void testKeysAndValuesInQueryItemsGetCorrectlyEncoded()
    {
        Uri uri;
        Uri::QueryItemList queryItems;
        queryItems += Uri::QueryItem ("o&k", "n=o");
        uri.appendQueryItems (queryItems);

        CPPUNIT_ASSERT (uri.query() == "o&k=n=o");
        CPPUNIT_ASSERT (uri.queryItems() == queryItems);
        CPPUNIT_ASSERT (uri.encoded() == "?o%26k=n%3Do");
        CPPUNIT_ASSERT (uri.unencoded() == "?o&k=n=o");
    }

    void testParseEncodedUriQueryIsNotPrematurelyDecoded()
    {
        Uri uri = Uri::fromEncoded ("http://www.calitko.org?name=va%26lue&key");
        Uri::QueryItemList queryItems;
        queryItems += Uri::QueryItem ("name", "va&lue");
        queryItems += Uri::QueryItem ("key", "");

        CPPUNIT_ASSERT (uri.queryItems() == queryItems);
    }

    void testParseQueryItemsFromQueryTwoItems()
    {
        Uri uri = Uri::fromEncoded ("http://www.calitko.org?name=value&key");
        Uri::QueryItemList queryItems;
        queryItems += Uri::QueryItem ("name", "value");
        queryItems += Uri::QueryItem ("key", "");

        CPPUNIT_ASSERT (uri.queryItems() == queryItems);
    }

    void testParseQueryItemsFromEmptyQuery()
    {
        Uri uri = Uri::fromEncoded ("http://www.calitko.org?");
        CPPUNIT_ASSERT (uri.queryItems() == Uri::QueryItemList());
    }

    void testEncodingAllCharsInQuery()
    {
        const QByteArray allBytes =
            "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
            "\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20"
            "\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30"
            "\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40"
            "\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50"
            "\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60"
            "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
            "\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80"
            "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90"
            "\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0"
            "\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0"
            "\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0"
            "\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0"
            "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0"
            "\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0"
            "\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";

        const QByteArray allBytesEncoded =
            "%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15"
            "%16%17%18%19%1A%1B%1C%1D%1E%1F%20!%22%23$%25%26'()*+,-./01234"
            "56789:;%3C%3D%3E?@ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E"
            "_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D~%7F%80%81%82%83%84%85"
            "%86%87%88%89%8A%8B%8C%8D%8E%8F%90%91%92%93%94%95%96%97%98%99%9A"
            "%9B%9C%9D%9E%9F%A0%A1%A2%A3%A4%A5%A6%A7%A8%A9%AA%AB%AC%AD%AE%AF"
            "%B0%B1%B2%B3%B4%B5%B6%B7%B8%B9%BA%BB%BC%BD%BE%BF%C0%C1%C2%C3%C4"
            "%C5%C6%C7%C8%C9%CA%CB%CC%CD%CE%CF%D0%D1%D2%D3%D4%D5%D6%D7%D8%D9"
            "%DA%DB%DC%DD%DE%DF%E0%E1%E2%E3%E4%E5%E6%E7%E8%E9%EA%EB%EC%ED%EE"
            "%EF%F0%F1%F2%F3%F4%F5%F6%F7%F8%F9%FA%FB%FC%FD%FE%FF";

        Uri uri;
        uri.appendQueryItem ("bytes", allBytes);

        CPPUNIT_ASSERT (uri.encoded() == "?bytes=" + allBytesEncoded);
    }

    void testQueryItemValueNoneValueAssociated()
    {
        Uri uri = Uri::fromUnencoded ("http://www.calitko.org?");
        CPPUNIT_ASSERT (uri.queryItemValue ("key") == QByteArray());
    }

    void testQueryItemValueOneValueAssociated()
    {
        Uri uri = Uri::fromUnencoded ("http://www.calitko.org?key=value");
        CPPUNIT_ASSERT (uri.queryItemValue ("key") == QByteArray ("value"));
    }

    void testQueryItemValueTwoValuesAssociated()
    {
        Uri uri = Uri::fromUnencoded ("http://www.calitko.org?key=value1&key=value2");
        CPPUNIT_ASSERT (uri.queryItemValue ("key") == QByteArray ("value1"));
    }

    void testParsingUriWithPortButWithoutHostFails()
    {
        Uri uri = Uri::fromUnencoded ("scheme://:80");
        CPPUNIT_ASSERT (uri == Uri());
    }

    void testParsingUriWithUserinfoButWithoutHostFails()
    {
        Uri uri = Uri::fromUnencoded ("scheme://userinfo@/");
        CPPUNIT_ASSERT (uri == Uri());
    }

    void testParsingUriWithUserinfoAndPortButWithoutHostFails()
    {
        Uri uri = Uri::fromUnencoded ("scheme://userinfo@:80");
        CPPUNIT_ASSERT (uri == Uri());
    }

    void testGettingSubsetsOfEncodedRepresentation()
    {
        Uri uri = Uri::fromUnencoded (validUriUnencoded1);

        CPPUNIT_ASSERT (uri.unencoded() == uri.unencoded (Uri::AllFields));
        CPPUNIT_ASSERT (uri.unencoded (Uri::Scheme) == uri.scheme() + ":");
        CPPUNIT_ASSERT (uri.unencoded (Uri::UserInfo)
                                        == "//" + uri.userInfo() + "@");
        CPPUNIT_ASSERT (uri.unencoded (Uri::Host) == "//" + uri.host());
        CPPUNIT_ASSERT (uri.unencoded (Uri::Port) == "//:" + uri.port());
        CPPUNIT_ASSERT (uri.unencoded (Uri::Authority)
                                        == "//" + uri.authority());
        CPPUNIT_ASSERT (uri.unencoded (Uri::Path) == uri.path());
        CPPUNIT_ASSERT (uri.unencoded (Uri::Query) == "?" + uri.query());
        CPPUNIT_ASSERT (uri.unencoded (Uri::Fragment) == "#" + uri.fragment());
        CPPUNIT_ASSERT (uri.unencoded (Uri::Fragment) == "#" + uri.fragment());
    }
};

const QByteArray UriTest::validUriUnencoded1 (
    "http://user@domain.com:81/some/path?param=value#fragment");
const QByteArray UriTest::validUriUnencoded2 (
    "ftp://username@server.net/data/");

CPPUNIT_TEST_SUITE_REGISTRATION (UriTest);

} // namespace Testing
} // namespace Utils

Copyright © 2006 Peter Dimov.
Powered by Doxygen.