Add Tests

Makefile.conf

@@ -12,8 +12,10 @@ CFLAGS += -I$(ROOTPATH)/Libraries/Logging/include
 
 CFLAGS += -I$(ROOTPATH)/Libraries/asio/include
 
-LFLAGS += -lHttp
+LFLAGS += -lHttp -lcrypto -lcurl -lssl -lz
 LFLAGS += -L$(ROOTPATH)/lib/$(ARCH)
 CFLAGS += -I$(ROOTPATH) -I$(ROOTPATH)/include
 
+LFLAGS += -pthread
+
 DEBUGDIR := .debug

Makefile.target

@@ -7,6 +7,11 @@ Http.a.$(ARCH) : $(OBJECTS)
 Http.a:
 	$(call build_target,$@)
 
+test.$(ARCH): $(OBJECTS) Test/Test.o.$(ARCH) | Http.a.$(ARCH)
+	$(call build_target_arch,$@,$^)
+test:
+	$(call build_target,$@)
+
 .DEFAULT_GOAL := Http.a
 
-TARGETS += Http.a
+TARGETS += Http.a test

Test/HttpClient.cpp

@@ -0,0 +1,195 @@
+#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

Test/Makefile

@@ -0,0 +1 @@
+../Makefile

Test/Test.cc

@@ -0,0 +1,24 @@
+#include "Test.h"
+#include <Logging.h>
+
+
+int main(int /*argc*/, char** /*argv*/)
+{
+	Logging::OpenLog();
+	Logging::SetLogMask(Logging::Severity::Info);
+
+	if (
+		Http::Test::TestHttpClient()
+	)
+	{
+		Logging::Log(Logging::Severity::Info, "Pass");
+		Logging::CloseLog();
+
+		return 0;
+	}
+
+	Logging::Log(Logging::Severity::Info, "Error");
+	Logging::CloseLog();
+
+	return -1;
+}

Test/Test.h

@@ -0,0 +1,7 @@
+namespace Http {
+namespace Test {
+
+bool TestHttpClient();
+
+} // namespace Test
+} // namespace Http