Wt

/*

 * Copyright (C) 2011 Emweb bv, Herent, Belgium.

 *

 * See the LICENSE file for terms of use.

 */

#include <Wt/WConfig.h>

#ifdef WT_THREADED

#include <boost/test/unit_test.hpp>

#include <Wt/WResource.h>

#include <Wt/WServer.h>

#include <Wt/WIOService.h>

#include <Wt/Http/Client.h>

#include <Wt/Http/Response.h>

#include <Wt/Http/ResponseContinuation.h>

#include <Wt/Http/Request.h>

#include <chrono>

#include <condition_variable>

#include <mutex>

#include <thread>

using namespace Wt;

namespace {

  class TestRecursive : public WResource {

    public:

      TestRecursive ()

      { }

      virtual ~TestRecursive () {

        beingDeleted();

      }

      virtual void handleRequest(const Http::Request& request,

              Http::Response& response) override;

      std::function<std::string(void)> address_;

  };

  class TestResource : public WResource

  {

  public:

    TestResource()

      : continuation_(false),

	delaySendingBody_(false),

	haveEverMoreData_(false),

	haveRandomMoreData_(false),

	aborted_(0)

    { }

    virtual ~TestResource() {

      beingDeleted();

    }

    void useContinuation() {

      continuation_ = true;

    }

    void delaySendingBody() {

      delaySendingBody_ = true;

    }

    void haveEverMoreData() {

      haveEverMoreData_ = true;

    }

    void haveRandomMoreData() {

      haveRandomMoreData_ = true;

    }

    int abortedCount() const {

      return aborted_;

    }

    virtual void handleRequest(const Http::Request& request,

			       Http::Response& response) override

    {

      if (continuation_)

	handleWithContinuation(request, response);

      else

	handleSimple(request, response);

    }

    virtual void handleAbort(const Http::Request& request) override

    {

      ++aborted_;

    }

  private:

    bool continuation_;

    bool delaySendingBody_;

    bool haveEverMoreData_;

    bool haveRandomMoreData_;

    int aborted_;

    void handleSimple(const Http::Request& request,

		      Http::Response& response)

    {

      response.setStatus(200);

      response.out() << "Hello";

    }

    void handleWithContinuation(const Http::Request& request,

				Http::Response& response) 

    {

      if (request.continuation()) {

	response.out() << "Hello";

	if (haveEverMoreData_ ||

	    (haveRandomMoreData_ && (rand() % 10 != 0)))

	  response.createContinuation();

      } else {

	response.setStatus(200);

	Http::ResponseContinuation *c = response.createContinuation();

	if (delaySendingBody_)

	  c->waitForMoreData();

      }

    }

  };

  class Server : public WServer

  {

  public:

    Server() {

      int argc = 7;

      const char *argv[]

	= { "test",

	    "--http-address", "127.0.0.1",

	    "--http-port", "0",

	    "--docroot", "." 

          };

      setServerConfiguration(argc, (char **)argv);

      addResource(&resource_, "/test");

      addResource(&recursive_, "/recursive");

      recursive_.address_ = std::bind(&Server::address, this);

    }

    std::string address() 

    {

      return "127.0.0.1:" + std::to_string(httpPort());

    }

    TestResource& resource() { return resource_; }

  private:

    TestResource resource_;

    TestRecursive recursive_;

  };

  class Client : public Http::Client

  {

  public:

    Client()

      : done_(false),

	abortAfterHeaders_(false)

    { 

      done().connect(this, &Client::onDone);

      headersReceived().connect(this, &Client::onHeadersReceived);

      bodyDataReceived().connect(this, &Client::onDataReceived);

    }

    void abortAfterHeaders()

    {

      abortAfterHeaders_ = true;

    }

    void waitDone()

    {

      std::unique_lock<std::mutex> guard(doneMutex_);

      while (!done_)

	doneCondition_.wait(guard);

    }

    void reset() 

    {

      done_ = false;

    }

    bool isDone()

    {

      return done_;

    }

    void onDone(Wt::AsioWrapper::error_code err, const Http::Message& m)

    {

      std::unique_lock<std::mutex> guard(doneMutex_);

      err_ = err;

      message_ = m;

      done_ = true;

      doneCondition_.notify_one();

    }

    void onHeadersReceived(const Http::Message& m)

    {

      if (abortAfterHeaders_)

	abort();

    }

    void onDataReceived(const std::string& d)

    {

    }

    Wt::AsioWrapper::error_code err() { return err_; }

    const Http::Message& message() { return message_; }

  private:

    bool done_;

    bool abortAfterHeaders_;

    std::condition_variable doneCondition_;

    std::mutex doneMutex_;

    Wt::AsioWrapper::error_code err_;

    Http::Message message_;

  };

  void TestRecursive::handleRequest(const Http::Request& request,

          Http::Response& response) {

            Client client;

            client.get("http://" + address_() + "/test");

            client.waitDone();

            response.out() << client.message().body();

          }

}

BOOST_AUTO_TEST_CASE( http_client_server_recursive ) 

{

  Server server;

  if (server.start()) {

    for (int i = 0; i < 1000; ++i) {

      Client client;

      client.get("http://" + server.address() + "/recursive");

      client.waitDone();

      BOOST_REQUIRE(!client.err());

      BOOST_REQUIRE(client.message().status() == 200);

      BOOST_REQUIRE(client.message().body() == "Hello");    

    }

  }

}

#endif // WT_THREADED