Http/Test/HttpClient.cpp

#include "Test.h"
#include "HttpClient.h"
#include <Logging.h>
#include <sstream>


namespace Http {
namespace Test {

bool Execute(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;

	try
	{
		client.Open(request);
		ss << "|                        SUCCESS |" << std::endl;
		Logging::Log(Logging::Severity::Info, ss.str());
		return true;
	}
	catch (const std::exception& e)
	{
		ss << "| FAIL                           |" << e.what() << std::endl;
		Logging::Log(Logging::Severity::Info, ss.str());
		return false;
	}
}

// -----

bool TestHttpClientGet(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|              GET               |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::GET);
	return Execute(client, request);
}

bool TestHttpClientHead(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|             HEAD               |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::HEAD);
	return Execute(client, request);
}

bool TestHttpClientPost(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|             POST               |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::POST);
	return Execute(client, request);
}

bool TestHttpClientPut(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|              PUT               |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::PUT);
	return Execute(client, request);
}

bool TestHttpClientDelete(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|             DELETE             |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::DELETE);
	return Execute(client, request);
}

bool TestHttpClientConnect(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|            CONNECT             |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::CONNECT);
	return Execute(client, request);
}

bool TestHttpClientTrace(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|             TRACE              |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::TRACE);
	return Execute(client, request);
}

bool TestHttpClientPatch(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|             PATCH              |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::PATCH);
	return Execute(client, request);
}

// -----

bool TestHttpClientNone(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|             None               |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.ReturnType(HttpRequest::ReturnType::Code);
	return Execute(client, request);
}

bool TestHttpClientCode(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|             Code               |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.ReturnType(HttpRequest::ReturnType::Code);
	return Execute(client, request);
}

bool TestHttpClientContent(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|            Content             |" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.ReturnType(HttpRequest::ReturnType::Content);
	return Execute(client, request);
}

bool TestHttpClientRedirect(HttpClient& client, HttpRequest& request)
{
	std::stringstream ss;
	ss << "|            Redirect            |";
	Logging::Log(Logging::Severity::Info, ss.str());

	request.ReturnType(HttpRequest::ReturnType::Redirect);
	return Execute(client, request);
}

// -----

bool TestHttpClient()
{
	std::stringstream ss;
	ss << "----------------------------------" << std::endl;
	ss << "|         TestHttpClient         |" << std::endl;
	ss << "----------------------------------" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	HttpClient client;
	HttpRequest request("http://nginx.dierkse.nl");

	bool success = true;
	request.ReturnType(HttpRequest::ReturnType::Code);
	success = TestHttpClientGet(client, request) && success;
	success = TestHttpClientHead(client, request) && success;
	success = TestHttpClientPost(client, request) && success;
	success = TestHttpClientPut(client, request) && success;
	success = TestHttpClientDelete(client, request) && success;
	success = TestHttpClientConnect(client, request) && success;
	success = TestHttpClientTrace(client, request) && success;
	success = TestHttpClientPatch(client, request) && success;

	ss.str("");
	ss << "----------------------------------" << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	request.Method(HttpRequest::Method::GET);
	success = TestHttpClientNone(client, request) && success;
	success = TestHttpClientCode(client, request) && success;
	success = TestHttpClientContent(client, request) && success;
	success = TestHttpClientRedirect(client, request) && success;

	ss.str("");
	ss << "==================================" << std::endl << std::endl;
	Logging::Log(Logging::Severity::Info, ss.str());

	return success;
}

} // namespace Test
} // namespace Http