#include <test/jtx.h>
#include <test/jtx/TrustedPublisherServer.h>
#include <test/unit_test/FileDirGuard.h>

#include <xrpld/app/misc/ValidatorSite.h>

#include <xrpl/basics/strHex.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/jss.h>

#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/asio.hpp>
#include <boost/range/adaptor/transformed.hpp>

#include <date/date.h>

#include <chrono>

namespace ripple {
namespace detail {
constexpr char const*
realValidatorContents()
{
    return R"vl({
        "public_key": "ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734",
        "manifest": "JAAAAAFxIe0md6v/0bM6xvvDBitx8eg5fBUF4cQsZNEa0bKP9z9HNHMh7V0AnEi5D4odY9X2sx+cY8B3OHNjJvMhARRPtTHmWnAhdkDFcg53dAQS1WDMQDLIs2wwwHpScrUnjp1iZwwTXVXXsaRxLztycioto3JgImGdukXubbrjeqCNU02f7Y/+6w0BcBJA3M0EOU+39hmB8vwfgernXZIDQ1+o0dnuXjX73oDLgsacwXzLBVOdBpSAsJwYD+nW8YaSacOHEsWaPlof05EsAg==",
        "blob" : "{"sequence":37,"expiration":594172800,"validators":[{"validation_public_key":"ED49F8EB8071E26D4E067238D62D67CA6EBFB298B4A72DCFAD536A7EC8925C519B","manifest":"JAAAAAFxIe1J+OuAceJtTgZyONYtZ8puv7KYtKctz61Tan7IklxRm3MhAogMmQTRAFK/+m/XWQfJvXTeMcaiyF6gkhgAssdLOciIdkYwRAIgNxYavJPyHANuxogQY7RNBP9tZogZJxF1wZqzm4a37GgCIBOvbeQ8+P46CCIcy4ZCZA5rZZ+93H0aKJZQ3+IA0OOucBJAASTpQKtEJkeqwHz+jKWNvWl0sHRQZSSJuYiMyyUa7ytpsev6NGoFn1bNpYTgvsaPxoz7vHskDh2Z6gebSDCRCA=="},{"validation_public_key":"ED8108F7D9EE779DC1075EC3CF8EB9004DDF84CD0A0FF5775C9E375CCACDAA3022","manifest":"JAAAAAFxIe2BCPfZ7nedwQdew8+OuQBN34TNCg/1d1yeN1zKzaowInMhAlvPJANQcRUSNUR+NlZuo4kGpYF8l9pHPP1ZROOUcNYRdkYwRAIgRWZZuJLAf3SNMGoFygUlu+eAD51ZoHFMcyoicn0WKucCIGw4n9cVDPOBGC8wlJDy9282x9RdOwo1co2g+NZlc/DNcBJAKJhK/am6L7KE450NVzhpVVoL8OFMo0mFxk8BDG6QO2cSNMN3Oywf40D+Iles9LXxxvvPB6gWSmPlwF7dNR9GAQ=="},{"validation_public_key":"ED7E3BAFF901DE525B00B2C1FE19AF449A080B5F3100C6EC182C867AF61F710FFD","manifest":"JAAAAAFxIe1+O6/5Ad5SWwCywf4Zr0SaCAtfMQDG7Bgshnr2H3EP/XMhA5+GDJh2ApWKCh2N5omx4FAOFEqXMjqy1HJ5E7WA3FrOdkcwRQIhAMRezwjTAL35jpjj15jqoHUvRm7+7iHpU47aKE6HEChZAiBSMIZaMWv6qNJHniYpsYHx4OPPpBoCMMdMVAGfFi9fK3ASQE0TYiIsGv0/ylpqGEBiLkk2XjrA8++Akzpr9vcTtrkHiDDo0cHKO9mRULAXesRrOyFb5QcO0l0VswevD5jlswk="},{"validation_public_key":"ED45E80A04D79CB9DF00AEBD86DCDC1686D6419EA9E5E0E71F1A817E08B5076A55","manifest":"JAAAAAFxIe1F6AoE15y53wCuvYbc3BaG1kGeqeXg5x8agX4ItQdqVXMhAxZo157pcB9de6Smk7hoK3wNCAr4aFZtfAPi7CE4mNJldkcwRQIhALlVjXCfiy/mtXBWsNt77t4jKcNEBpRV8zv+SpU5lCh0AiBa8vo8xxpviYlf4zdG+nQhB2OgfkQZZPMHOt7CaXzXgXASQL8O5p083mg4KKL8uZfMaUqdgzuJ0Gta1lyUWPctTPCxY135XwK+nJAdFsIUFNJ9MPjnpCmSjYVzVa6M5/nAcAI="},{"validation_public_key":"EDD8C88642795CE69C5B780E01702C370F9507D0B64433F17EFE70F2637A40ADB7","manifest":"JAAAAAFxIe3YyIZCeVzmnFt4DgFwLDcPlQfQtkQz8X7+cPJjekCtt3MhAnFfr+r9BXdsXE/cBlJMyd/XsO1A5XEYCctrsvLEX+DmdkcwRQIhANRcRMg9SAXoaOvHDZ2av9RzEaZaVENfQiVgsi+Ox3F0AiB2snSIOm6c4/inbtU0UmWLQTzuwkOdUFPIB8Ax8dmGuHASQMUIfXMj96kcFTSJnMFC/mW/AQ8bKXkFrrk0CUTFFKweEjTq+STrFi6qLL2MT7nveGxsXBCgztjc0qGas9KFWgM="},{"validation_public_key":"EDBDEB901F7C75D0E20C6C42AF03BE0DA40377AF1939A18B3CB3679661DD5F9F74","manifest":"JAAAAAFxIe2965AffHXQ4gxsQq8Dvg2kA3evGTmhizyzZ5Zh3V+fdHMhAg3cyKNPMPqKgR7kIi7c/8GL/YgdBtg4mSAWvwmaevVGdkYwRAIgWzG8GqYg3YpwDs8xXa9XqLHss76KT2uAHRhUXFVUqCQCIG2EvbFKnxezRd9cpPHSt32HXK+P4+aL3p2+vqlCxRR9cBJAboXTmYTayocA3zf9dWEXtyaeOGC1k5WdYURzPleevvalR4xVoXzs38iGPxFr/pA9nL+M4duu0GKCHlVir+fBAg=="},{"validation_public_key":"EDA17871E72B0C570AC4345C60CF02AFBBB740A631B7AD0E1E573216574D9AEA02","manifest":"JAAAAAFxIe2heHHnKwxXCsQ0XGDPAq+7t0CmMbetDh5XMhZXTZrqAnMhAojyuzgtreQkxQj8prHxOsbDcF5fu4XXb0KxEL/Pq5HhdkcwRQIhANfPDLZP47aCWwt5kBnp75BuuCgp9c4BfJPd66SFCw61AiAJvegBvvPIrec+XOSzKRfi5uuXWxtl9Eyr2aPBYXvbRHASQMULYEo7beRfoUCnjk1sTYyY91tLIGLgnnaWXhUm80+zs5IGegk8qijKAtBOMuBC71lAB4KhJc+dB2rpMOFc5gw="},{"validation_public_key":"EDF46EE27AD0E1A714AFECDA816EAB7114614FCB92D0CB4D97B6A88ED43434AFC9","manifest":"JAAAAAFxIe30buJ60OGnFK/s2oFuq3EUYU/LktDLTZe2qI7UNDSvyXMhAw0ATWjVTt4FfeKO7kv6fFgd/go2+d5BSyUcURmRWnTtdkcwRQIhAMwOgDec7QYYNngspg90wEvVbsoh2ux14RPTw+GHaXNlAiALgfEsz+AF4eyX/Y5i44VrFjFFIMWUfOZaQJtsxteM1XASQLOaF0t2ZpqVKd8JESQVY+zU567iAAG2amTPZx95875S9A6Pl+kH5TGHMAeWjgWSqfh3m2HBJX7NIcXb98vy9AA="},{"validation_public_key":"ED6E4C41E59FFBEB51726E54468502FE6437238FA78EA51634E7BF0D09171AEE8F","manifest":"JAAAAAFxIe1uTEHln/vrUXJuVEaFAv5kNyOPp46lFjTnvw0JFxruj3MhAuztGWb/Oi1/V5m5dujWr9HmbKRyK4XYk+kmuFPSgAFrdkYwRAIgfQ+BgXX6QblZy4H05o7GPSIwqS7QQRUW7dqF54IAiiMCIH4XfLw956iEaoxZOk7Kctin2X9hMfaLN7wys9yAUFoZcBJAueEi84XR3Ll1GLJWanW1g1MdUj/0PAxJbw6EEQRuG3zdnuRHNXld6UZAbIkVcP0ztfqulBzjbcsLDOKFEicSBg=="},{"validation_public_key":"EDB6FC8E803EE8EDC2793F1EC917B2EE41D35255618DEB91D3F9B1FC89B75D4539","manifest":"JAAAAAFxIe22/I6APujtwnk/HskXsu5B01JVYY3rkdP5sfyJt11FOXMhA8VdvHFyScByQGTYNGeOvB0+67gWaqefcfvRk5+KwgV1dkYwRAIgZFulO/AiMoczng6i/4BkfzT7j9lxF4PP1ufgrOQaJ8sCIBX/E8Zbpn7tWqgAyNyWpVPkhFmaUMqEry8WoUT1fdGQcBJAv51RqJxgg/VrnrZwiLK2Dc0CKbiLPO5HJ4ZMsjdPT2gRc97rWkAXuV2L6PNFO59xyuoaZmSMlZYvqSGPpfF7Bw=="},{"validation_public_key":"ED691303992FEC64E6BC4BACD36AE6E5AEDC23F2861B6D8EFB9FD77EE3EADE3435","manifest":"JAAAAAFxIe1pEwOZL+xk5rxLrNNq5uWu3CPyhhttjvuf137j6t40NXMhAi2AXJQgo/JuW3r7f/6CcVsGN1YmIj11GiIESHBnQSk8dkcwRQIhANCDEQymrd6veT3ouacF6fhBr5wLw3GmXg1rMCLVvBzZAiA8uWQ+tqd46WmfBexjSBQ2Jd6UAGdrHvjcCQ2ZgSooCnASQFkHl+D7/U3WByYP384+pcFDf2Gi4WIRHVTo58cqdk5CDiwc1T0rDoLhmo41a3f+dsftfwR4aMmwFcPXLnrjrAI="},{"validation_public_key":"EDAD16667F0185DDBB7FA65B22F4B7D310BF5C3E2D9B823FB06A3A41AF8AC83BC1","manifest":"JAAAAAFxIe2tFmZ/AYXdu3+mWyL0t9MQv1w+LZuCP7BqOkGvisg7wXMhAqweE3PIS3E44KhMqKjKtbkBe8H8GbiuoAXAYDRoVRHodkYwRAIgagGkXtowUybdltKojv0lvvflrlQ9IRnPOjekF60iHzgCICg6ZocIMzkUuvO91BEormIWmX4G/MGT2zro6I/PvB8XcBJAcJLXkt/w/kcwEvNiZmi2i2nMn1wiP3LS9NJjBPju8KFLAMg0O9ydQT67U/ALYOeTPTO2/i2Yw9OSlibtqhgzDA=="},{"validation_public_key":"EDC245027A52EE5318095598EC3AB65FF4A3B9F9428E10B2F3C6F39DE15A15C90A","manifest":"JAAAAAFxIe3CRQJ6Uu5TGAlVmOw6tl/0o7n5Qo4QsvPG853hWhXJCnMhA/8/9rKUdA61j/fIEP/cqLpxBlmIhP2rg1d7NaEPyKV+dkcwRQIhAIxE0M/FJ50vfZW6fPpy4yCZumY9n0obrOojUkjm55a0AiBj56O0MpopGoY9HxC/+4wNO36Ho7E9CQeHsnKreDdsAXASQIYUd81jbiVUlET4dGoG2p+cf+2GqEXX5fJMSSyX/qe0XfR4cO+4qlgmjMQdCRDBWABHVvdN/yZyi/rL2c+WrQc="},{"validation_public_key":"ED4246AA3AE9D29863944800CCA91829E4447498A20CD9C3973A6B59346C75AB95","manifest":"JAAAAAFxIe1CRqo66dKYY5RIAMypGCnkRHSYogzZw5c6a1k0bHWrlXMhAkm1lz0c8QXWfJ9b1vB72dLabw8wYId8MtnpsHHBEC8pdkYwRAIgQlb6HJ53hsTAfVid+AOdBVvMF7rahIKNLBHUgn52zBECIGLUqFu8a1AAHRJcVonKYEnmhJwbCXLn+je7na1WD1/ocBJAE4vfvrGSmZC2uAUGmM5dIBtoSgEUey+2VleDYEsce94txYcjR8Z7QLNaliD8w/bD5/hvYQ8meV1Wg1jJFNe0CA=="},{"validation_public_key":"ED2C1468B4A11D281F93EF337C95E4A08DF0000FDEFB6D0EA9BC05FBD5D61A1F5A","manifest":"JAAAAAFxIe0sFGi0oR0oH5PvM3yV5KCN8AAP3vttDqm8BfvV1hofWnMhAkMUmCD2aPmgFDDRmimvSicSIScw6YNr42Dw4RAdwrOAdkcwRQIhAJFOHMg6qTG8v60dhrenYYk6cwOaRXq0RNmLjyyCiz5lAiAdU0YkDUJQhnN8Ry8s+6zTJLiNLbtM8oO/cLnurVpRM3ASQGALarHAsJkSZQtGdM2AaR/joFK/jhDU57+l+RSYjri/ydE20DaKanwkMEoVlBTg7lX4hYjEnmkqo73wIthLOAQ="},{"validation_public_key":"EDA54C85F91219FD259134B6B126AD64AE7204B81DD4052510657E1A5697246AD2","manifest":"JAAAAAJxIe2lTIX5Ehn9JZE0trEmrWSucgS4HdQFJRBlfhpWlyRq0nMhAl8cJerPv+vo1BK611xVTpGxjjr/CuxPTgU8URM4eTZ5dkYwRAIgdK3cQV2Y/viZne/PboKSKewngTuIN2M6c8azwqc20uUCIAc6GoNT+P2YBy49gdau4P7ySwWoQX5nf9dQxiQav5wIcBJAqiCK0d6QRZSpiVHp8O9nlKXCSEhsiSNcWcEFm/fGhJAnAN0Ov9HINId1pxrBn2dKRegLTvYG3Bpbz//HLgEdDA=="},{"validation_public_key":"ED9AE4F5887BA029EB7C0884486D23CF281975F773F44BD213054219882C411CC7","manifest":"JAAAAAFxIe2a5PWIe6Ap63wIhEhtI88oGXX3c/RL0hMFQhmILEEcx3MhAmG2zgv8FBZsZJU8aPapwo9cIqQv4/MSS1oVA5eVMiwLdkYwRAIgF+LOe4eY0gp9ttqh2gnv+z75OqLyOQMpGPALgm+NtOsCICDXBZVPtprmBDkBJkPFSnE55D9eKYRH8z/iY1EtpNplcBJAADEWGVT80Owhd1lh2JsU/oZlmeNF5WN7YvlB8llExaRKEVC+GW9Wg+iNIQ3rmV7P8aNaVuaabG00fOgkgzNhDw=="},{"validation_public_key":"EDA8D29F40CEB28995617641A3BC42692E1DE883214F612FBB62087A148E5F6F9A","manifest":"JAAAAAFxIe2o0p9AzrKJlWF2QaO8QmkuHeiDIU9hL7tiCHoUjl9vmnMhAnYnP7Eg6VgNnEUTRE29d64jQT/iBcWTQtNrUzyD6MJ+dkcwRQIhAOEsV5anTkloSmTZRbimMyBKqHoJYXcBBe8lLiPYC7mUAiAz2aNOpfQ/1LycWloIMvdhxzinq5X7Uas/uOSb9wh8d3ASQLVkfpW/GO6wdT6AuuSJ56TtM343pDNH+iSzxltIfdrPiUxT5rf4k21lQQuPClXm9+SfKrCiUXZK7dj0/GWTYQg="},{"validation_public_key":"ED38B0288EA240B4CDEC18A1A6289EB49007E4EBC0DE944803EB7EF141C5664073","manifest":"JAAAAAFxIe04sCiOokC0zewYoaYonrSQB+TrwN6USAPrfvFBxWZAc3MhAgOKcvIuchalrZw/glTuOxV3IOCcporxMB7JqAVupk1edkcwRQIhAOvRzpe+IYZK1MyInIQZ87JvP2J8SIXCXZMPBCdITBamAiASavJXi9pws8rDDJSxhGMlmE7zI5bSA8ivtRC9Lgq+UXASQDl3eoqLID+ETJNM+zbMuvwvcHEIxeBZkZ9fp5jJv6OCTPwlj4TJSuy1avEWqUYS2riv5Dvl2haFUoCHf4yawAA="},{"validation_public_key":"EDEE10DC36ACD995C8E0E86E3CD2FBF8301A4AC2B8847B61A1935DE4973B407C0E","manifest":"JAAAAAFxIe3uENw2rNmVyODobjzS+/gwGkrCuIR7YaGTXeSXO0B8DnMhAmX0vb7j+lgBjFjbN9RlA86J7AO2Vn6HLquO3aisK4mwdkYwRAIgfxBLn7i4jg/di0U25q6kIbVfTzqbA0SCpQ0I57TOFkcCIFMtJQpENjB2K2EmvBHPvNcwuSPc3vsEeqE2rNJ/cT5DcBJAf68XPFu5RjCeLgpFJM7PKFLgoV8e1nxO5ewjq9Q+TAEGnFyS0IOwf6pOOtIVMdVeXu1v6p4fhXQkdihHt1x6Ag=="},{"validation_public_key":"ED583ECD06C3B7369980E65C78C440A529300F557ED81256283F7DD5AA3513A334","manifest":"JAAAAAFxIe1YPs0Gw7c2mYDmXHjEQKUpMA9VftgSVig/fdWqNROjNHMhAyuUnzZZ1n2/GaTmE1m7H/v9YlZyDEwHY3gSHUA3ICL9dkYwRAIgHx2PHvidoN+5yG9WeAS2k7nwIM8ajxQW6wjvt8kBenACIDNxQPQkDyDJH9seS5C62mAarQmgiN89YS3jhNtnvEIqcBJAj7Jh0Kac+aJdpoepu/+eJKnnFQ7YByZB8eMZ+SS1zLhE+lip/49qqVNcpAxEqfaGtxJzoDDD1/QbuU7NOSPkCg=="},{"validation_public_key":"ED95C5172B2AD7D39434EEBC436B65B3BB7E58D5C1CEFC820B6972ACAD776E286A","manifest":"JAAAAAFxIe2VxRcrKtfTlDTuvENrZbO7fljVwc78ggtpcqytd24oanMhAiqcRde3MQZ075fa4ZNNyRaYJGMdBNkBnn3bQrKseBDQdkYwRAIgU+LfcE71DPVrO+KtUBjQ9D2u0k/Pr7lukO1nPRj6hSACIDNLYC/JFgobCsIa0BGw+6bUnOw9meU3FdXgR7Q7SoqJcBJAXQakOoQnPp3pcLL7zdKCPUX4b+/FC9Unhqp+O9xQFnRaCWVGmk5MJOIMs4WOQdpM1j3OgSsABmRuCXYvwo/nDw=="},{"validation_public_key":"ED90163D2BF0B7788904C4A4118D7D968920E847D88B79178390837DE3CA261562","manifest":"JAAAAAFxIe2QFj0r8Ld4iQTEpBGNfZaJIOhH2It5F4OQg33jyiYVYnMhA72VTRiGhkJBtqgGHDzHj7YbC6+NsEKrFHNuE/LO3Tn5dkYwRAIgf8s+fYt0llrKQ2qiWPnGmb6qJPoe8OnCM3VS29XKbYYCIHGnlJ4OTs2dXugO6Bto63NpDvvqJ+WIwdYKqZ6BiBfzcBJAGvNtkog4pfE5dZRwmic87ZBeeunOh4YpL0SERdxWj43Cs9815zFJuZysSaUX2R/vdE2VKqvSgqqtDEnrMo2oAw=="}]}",
        "signature" : "9FF30EDC4DED7ABCD0D36389B7C716EED4B5E4F043902853534EBAC7BE966BB3813D5CF25E4DADA5E657CCF019FFD11847FD3CC44B5559A6FCEEE4C3DCFF8D0E",
        "version": 1
}
)vl";
}

auto constexpr default_expires = std::chrono::seconds{3600};
auto constexpr default_effective_overlap = std::chrono::seconds{30};
}  // namespace detail

namespace test {
class ValidatorSite_test : public beast::unit_test::suite
{
private:
    using Validator = TrustedPublisherServer::Validator;

    void
    testConfigLoad()
    {
        testcase("Config Load");

        using namespace jtx;

        Env env(*this, envconfig(), nullptr, beast::severities::kDisabled);
        auto trustedSites =
            std::make_unique<ValidatorSite>(env.app(), env.journal);

        // load should accept empty sites list
        std::vector<std::string> emptyCfgSites;
        BEAST_EXPECT(trustedSites->load(emptyCfgSites));

        // load should accept valid validator site uris
        std::vector<std::string> cfgSites(
            {"http://ripple.com/",
             "http://ripple.com/validators",
             "http://ripple.com:8080/validators",
             "http://207.261.33.37/validators",
             "http://207.261.33.37:8080/validators",
             "https://ripple.com/validators",
             "https://ripple.com:443/validators",
             "file:///etc/opt/ripple/validators.txt",
             "file:///C:/Lib/validators.txt"
#if !_MSC_VER
             ,
             "file:///"
#endif
            });
        BEAST_EXPECT(trustedSites->load(cfgSites));

        // load should reject validator site uris with invalid schemes
        std::vector<std::string> badSites({"ftp://ripple.com/validators"});
        BEAST_EXPECT(!trustedSites->load(badSites));

        badSites[0] = "wss://ripple.com/validators";
        BEAST_EXPECT(!trustedSites->load(badSites));

        badSites[0] = "ripple.com/validators";
        BEAST_EXPECT(!trustedSites->load(badSites));

        // Host names are not supported for file URLs
        badSites[0] = "file://ripple.com/vl.txt";
        BEAST_EXPECT(!trustedSites->load(badSites));

        // Even local host names are not supported for file URLs
        badSites[0] = "file://localhost/home/user/vl.txt";
        BEAST_EXPECT(!trustedSites->load(badSites));

        // Nor IP addresses
        badSites[0] = "file://127.0.0.1/home/user/vl.txt";
        BEAST_EXPECT(!trustedSites->load(badSites));

        // File URL path can not be empty
        badSites[0] = "file://";
        BEAST_EXPECT(!trustedSites->load(badSites));

#if _MSC_VER  // Windows paths strip off the leading /, leaving the path empty
        // File URL path can not be a directory
        // (/ is the only path we can reasonably assume is a directory)
        badSites[0] = "file:///";
        BEAST_EXPECT(!trustedSites->load(badSites));
#endif
    }

    struct FetchListConfig
    {
        std::string path;
        std::string msg;
        bool ssl;
        bool failFetch = false;
        bool failApply = false;
        int serverVersion = 1;
        std::chrono::seconds expiresFromNow = detail::default_expires;
        std::chrono::seconds effectiveOverlap =
            detail::default_effective_overlap;
        int expectedRefreshMin = 0;
    };
    void
    testFetchList(
        detail::DirGuard const& good,
        std::vector<FetchListConfig> const& paths)
    {
        testcase << "Fetch list - "
                 << boost::algorithm::join(
                        paths |
                            boost::adaptors::transformed(
                                [](FetchListConfig const& cfg) {
                                    return cfg.path +
                                        (cfg.ssl ? " [https] v" : " [http] v") +
                                        std::to_string(cfg.serverVersion) +
                                        " " + cfg.msg;
                                }),
                        ", ");

        using namespace jtx;
        using namespace std::chrono_literals;

        Env env(*this, [&]() {
            auto p = test::jtx::envconfig();
            p->legacy("database_path", good.subdir().string());
            return p;
        }());
        auto& trustedKeys = env.app().validators();
        env.timeKeeper().set(env.timeKeeper().now() + 30s);

        test::StreamSink sink;
        beast::Journal journal{sink};

        std::vector<std::string> emptyCfgKeys;
        struct publisher
        {
            publisher(FetchListConfig const& c) : cfg{c}
            {
            }
            std::shared_ptr<TrustedPublisherServer> server;
            std::vector<Validator> list;
            std::string uri;
            FetchListConfig const& cfg;
            bool isRetry;
        };
        std::vector<publisher> servers;

        auto constexpr listSize = 20;
        std::vector<std::string> cfgPublishers;

        for (auto const& cfg : paths)
        {
            servers.push_back(cfg);
            auto& item = servers.back();
            item.isRetry = cfg.path == "/bad-resource";
            item.list.reserve(listSize);
            while (item.list.size() < listSize)
                item.list.push_back(TrustedPublisherServer::randomValidator());

            NetClock::time_point const expires =
                env.timeKeeper().now() + cfg.expiresFromNow;
            NetClock::time_point const effective2 =
                expires - cfg.effectiveOverlap;
            NetClock::time_point const expires2 =
                effective2 + cfg.expiresFromNow;
            item.server = make_TrustedPublisherServer(
                env.app().getIOContext(),
                item.list,
                expires,
                {{effective2, expires2}},
                cfg.ssl,
                cfg.serverVersion);
            std::string pubHex = strHex(item.server->publisherPublic());
            cfgPublishers.push_back(pubHex);

            if (item.cfg.failFetch)
            {
                // Create a cache file
                auto const name = good.subdir() / ("cache." + pubHex);
                std::ofstream o(name.string());
                o << "{}";
            }

            std::stringstream uri;
            uri << (cfg.ssl ? "https://" : "http://")
                << item.server->local_endpoint() << cfg.path;
            item.uri = uri.str();
        }

        BEAST_EXPECT(trustedKeys.load({}, emptyCfgKeys, cfgPublishers));

        // Normally, tests will only need a fraction of this time,
        // but sometimes DNS resolution takes an inordinate amount
        // of time, so the test will just wait.
        auto sites = std::make_unique<ValidatorSite>(env.app(), journal, 12s);

        std::vector<std::string> uris;
        for (auto const& u : servers)
        {
            log << "Testing " << u.uri << std::endl;
            uris.push_back(u.uri);
        }
        sites->load(uris);
        sites->start();
        sites->join();

        auto const jv = sites->getJson();
        for (auto const& u : servers)
        {
            for (auto const& val : u.list)
            {
                BEAST_EXPECT(
                    trustedKeys.listed(val.masterPublic) != u.cfg.failApply);
                BEAST_EXPECT(
                    trustedKeys.listed(val.signingPublic) != u.cfg.failApply);
            }

            Json::Value myStatus;
            for (auto const& vs : jv[jss::validator_sites])
                if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
                    myStatus = vs;
            BEAST_EXPECTS(
                myStatus[jss::last_refresh_message].asString().empty() !=
                    u.cfg.failFetch,
                to_string(myStatus) + "\n" + sink.messages().str());

            if (!u.cfg.msg.empty())
            {
                BEAST_EXPECTS(
                    sink.messages().str().find(u.cfg.msg) != std::string::npos,
                    sink.messages().str());
            }

            if (u.cfg.expectedRefreshMin)
            {
                BEAST_EXPECTS(
                    myStatus[jss::refresh_interval_min].asInt() ==
                        u.cfg.expectedRefreshMin,
                    to_string(myStatus));
            }

            if (u.cfg.failFetch)
            {
                using namespace std::chrono;
                std::stringstream nextRefreshStr{
                    myStatus[jss::next_refresh_time].asString()};
                system_clock::time_point nextRefresh;
                date::from_stream(nextRefreshStr, "%Y-%b-%d %T", nextRefresh);
                BEAST_EXPECT(!nextRefreshStr.fail());
                auto now = system_clock::now();
                BEAST_EXPECTS(
                    nextRefresh <= now + (u.isRetry ? seconds{30} : minutes{5}),
                    "Now: " + to_string(now) + ", NR: " + nextRefreshStr.str());
            }
        }
    }

    void
    testFileList(std::vector<std::pair<std::string, std::string>> const& paths)
    {
        testcase << "File list - " << paths[0].first
                 << (paths.size() > 1 ? ", " + paths[1].first : "");

        using namespace jtx;

        Env env(*this);

        test::StreamSink sink;
        beast::Journal journal{sink};

        struct publisher
        {
            std::string uri;
            std::string expectMsg;
            bool shouldFail;
        };
        std::vector<publisher> servers;

        for (auto const& cfg : paths)
        {
            servers.push_back({});
            auto& item = servers.back();
            item.shouldFail = !cfg.second.empty();
            item.expectMsg = cfg.second;

            std::stringstream uri;
            uri << "file://" << cfg.first;
            item.uri = uri.str();
        }

        auto sites = std::make_unique<ValidatorSite>(env.app(), journal);

        std::vector<std::string> uris;
        for (auto const& u : servers)
            uris.push_back(u.uri);
        sites->load(uris);
        sites->start();
        sites->join();

        for (auto const& u : servers)
        {
            auto const jv = sites->getJson();
            Json::Value myStatus;
            for (auto const& vs : jv[jss::validator_sites])
                if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
                    myStatus = vs;
            BEAST_EXPECTS(
                myStatus[jss::last_refresh_message].asString().empty() !=
                    u.shouldFail,
                to_string(myStatus));
            if (u.shouldFail)
            {
                BEAST_EXPECTS(
                    sink.messages().str().find(u.expectMsg) !=
                        std::string::npos,
                    sink.messages().str());
            }
        }
    }

    void
    testFileURLs()
    {
        auto fullPath = [](detail::FileDirGuard const& guard) {
            auto absPath = absolute(guard.file()).string();
            if (absPath.front() != '/')
                absPath.insert(absPath.begin(), '/');
            return absPath;
        };
        {
            // Create a file with a real validator list
            detail::FileDirGuard good(
                *this, "test_val", "vl.txt", detail::realValidatorContents());
            // Create a file with arbitrary content
            detail::FileDirGuard hello(
                *this, "test_val", "helloworld.txt", "Hello, world!");
            // Create a file with malformed Json
            detail::FileDirGuard json(
                *this,
                "test_val",
                "json.txt",
                R"json({ "version": 2, "extra" : "value" })json");
            auto const goodPath = fullPath(good);
            auto const helloPath = fullPath(hello);
            auto const jsonPath = fullPath(json);
            auto const missingPath = jsonPath + ".bad";
            testFileList({
                {goodPath, ""},
                {helloPath,
                 "Unable to parse JSON response from  file://" + helloPath},
                {jsonPath,
                 "Missing fields in JSON response from  file://" + jsonPath},
                {missingPath, "Problem retrieving from file://" + missingPath},
            });
        }
    }

public:
    void
    run() override
    {
        testConfigLoad();

        detail::DirGuard good(*this, "test_fetch");
        for (auto ssl : {true, false})
        {
            // fetch single site
            testFetchList(good, {{"/validators", "", ssl}});
            testFetchList(good, {{"/validators2", "", ssl}});
            // fetch multiple sites
            testFetchList(
                good, {{"/validators", "", ssl}, {"/validators", "", ssl}});
            testFetchList(
                good, {{"/validators", "", ssl}, {"/validators2", "", ssl}});
            testFetchList(
                good, {{"/validators2", "", ssl}, {"/validators", "", ssl}});
            testFetchList(
                good, {{"/validators2", "", ssl}, {"/validators2", "", ssl}});
            // fetch single site with single redirects
            testFetchList(good, {{"/redirect_once/301", "", ssl}});
            testFetchList(good, {{"/redirect_once/302", "", ssl}});
            testFetchList(good, {{"/redirect_once/307", "", ssl}});
            testFetchList(good, {{"/redirect_once/308", "", ssl}});
            // one redirect, one not
            testFetchList(
                good,
                {{"/validators", "", ssl}, {"/redirect_once/302", "", ssl}});
            testFetchList(
                good,
                {{"/validators2", "", ssl}, {"/redirect_once/302", "", ssl}});
            // UNLs with a "gap" between validUntil of one and validFrom of the
            // next
            testFetchList(
                good,
                {{"/validators2",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  detail::default_expires,
                  std::chrono::seconds{-90}}});
            // fetch single site with undending redirect (fails to load)
            testFetchList(
                good,
                {{"/redirect_forever/301",
                  "Exceeded max redirects",
                  ssl,
                  true,
                  true}});
            // two that redirect forever
            testFetchList(
                good,
                {{"/redirect_forever/307",
                  "Exceeded max redirects",
                  ssl,
                  true,
                  true},
                 {"/redirect_forever/308",
                  "Exceeded max redirects",
                  ssl,
                  true,
                  true}});
            // one undending redirect, one not
            testFetchList(
                good,
                {{"/validators", "", ssl},
                 {"/redirect_forever/302",
                  "Exceeded max redirects",
                  ssl,
                  true,
                  true}});
            // one undending redirect, one not
            testFetchList(
                good,
                {{"/validators2", "", ssl},
                 {"/redirect_forever/302",
                  "Exceeded max redirects",
                  ssl,
                  true,
                  true}});
            // invalid redir Location
            testFetchList(
                good,
                {{"/redirect_to/ftp://invalid-url/302",
                  "Invalid redirect location",
                  ssl,
                  true,
                  true}});
            testFetchList(
                good,
                {{"/redirect_to/file://invalid-url/302",
                  "Invalid redirect location",
                  ssl,
                  true,
                  true}});
            // invalid json
            testFetchList(
                good,
                {{"/validators/bad",
                  "Unable to parse JSON response",
                  ssl,
                  true,
                  true}});
            testFetchList(
                good,
                {{"/validators2/bad",
                  "Unable to parse JSON response",
                  ssl,
                  true,
                  true}});
            // error status returned
            testFetchList(
                good,
                {{"/bad-resource", "returned bad status", ssl, true, true}});
            // location field missing
            testFetchList(
                good,
                {{"/redirect_nolo/308",
                  "returned a redirect with no Location",
                  ssl,
                  true,
                  true}});
            // json fields missing
            testFetchList(
                good,
                {{"/validators/missing",
                  "Missing fields in JSON response",
                  ssl,
                  true,
                  true}});
            testFetchList(
                good,
                {{"/validators2/missing",
                  "Missing fields in JSON response",
                  ssl,
                  true,
                  true}});
            // timeout
            testFetchList(
                good, {{"/sleep/13", "took too long", ssl, true, true}});
            // bad manifest format using known versions
            // * Retrieves a v1 formatted list claiming version 2
            testFetchList(
                good, {{"/validators", "Missing fields", ssl, true, true, 2}});
            // * Retrieves a v2 formatted list claiming version 1
            testFetchList(
                good, {{"/validators2", "Missing fields", ssl, true, true, 0}});
            // bad manifest version
            // Because versions other than 1 are treated as v2, the v1
            // list won't have the blobs_v2 fields, and thus will claim to have
            // missing fields
            testFetchList(
                good, {{"/validators", "Missing fields", ssl, true, true, 4}});
            testFetchList(
                good,
                {{"/validators2",
                  "1 unsupported version",
                  ssl,
                  false,
                  true,
                  4}});
            using namespace std::chrono_literals;
            // get expired validator list
            testFetchList(
                good,
                {{"/validators",
                  "Applied 1 expired validator list(s)",
                  ssl,
                  false,
                  false,
                  1,
                  0s}});
            testFetchList(
                good,
                {{"/validators2",
                  "Applied 1 expired validator list(s)",
                  ssl,
                  false,
                  false,
                  1,
                  0s,
                  -1s}});
            // force an out-of-range validUntil value
            testFetchList(
                good,
                {{"/validators",
                  "1 invalid validator list(s)",
                  ssl,
                  false,
                  true,
                  1,
                  std::chrono::seconds{Json::Value::minInt}}});
            // force an out-of-range validUntil value on the future list
            // The first list is accepted. The second fails. The parser
            // returns the "best" result, so this looks like a success.
            testFetchList(
                good,
                {{"/validators2",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  std::chrono::seconds{Json::Value::maxInt - 300},
                  299s}});
            // force an out-of-range validFrom value
            // The first list is accepted. The second fails. The parser
            // returns the "best" result, so this looks like a success.
            testFetchList(
                good,
                {{"/validators2",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  std::chrono::seconds{Json::Value::maxInt - 300},
                  301s}});
            // force an out-of-range validUntil value on _both_ lists
            testFetchList(
                good,
                {{"/validators2",
                  "2 invalid validator list(s)",
                  ssl,
                  false,
                  true,
                  1,
                  std::chrono::seconds{Json::Value::minInt},
                  std::chrono::seconds{Json::Value::maxInt - 6000}}});
            // verify refresh intervals are properly clamped
            testFetchList(
                good,
                {{"/validators/refresh/0",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  detail::default_expires,
                  detail::default_effective_overlap,
                  1}});  // minimum of 1 minute
            testFetchList(
                good,
                {{"/validators2/refresh/0",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  detail::default_expires,
                  detail::default_effective_overlap,
                  1}});  // minimum of 1 minute
            testFetchList(
                good,
                {{"/validators/refresh/10",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  detail::default_expires,
                  detail::default_effective_overlap,
                  10}});  // 10 minutes is fine
            testFetchList(
                good,
                {{"/validators2/refresh/10",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  detail::default_expires,
                  detail::default_effective_overlap,
                  10}});  // 10 minutes is fine
            testFetchList(
                good,
                {{"/validators/refresh/2000",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  detail::default_expires,
                  detail::default_effective_overlap,
                  60 * 24}});  // max of 24 hours
            testFetchList(
                good,
                {{"/validators2/refresh/2000",
                  "",
                  ssl,
                  false,
                  false,
                  1,
                  detail::default_expires,
                  detail::default_effective_overlap,
                  60 * 24}});  // max of 24 hours
        }
        using namespace boost::filesystem;
        for (auto const& file : directory_iterator(good.subdir()))
        {
            remove_all(file);
        }

        testFileURLs();
    }
};

BEAST_DEFINE_TESTSUITE_PRIO(ValidatorSite, app, ripple, 2);

}  // namespace test
}  // namespace ripple