test_cli.cpp File Reference

#include <array>
#include <chrono>
#include <cstdio>
#include <curl/curl.h>
#include <doctest.h>
#include <functional>
#include <iostream>
#include <memory>
#include <nlohmann/json.hpp>
#include <stdexcept>
#include <string>
#include <thread>

Go to the source code of this file.

Macros
#define	DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

Functions
std::string	run_command (const std::string &cmd)
std::string	http_get (const std::string &url)
bool	wait_for_server (int max_retries=10)
void	stop_server ()
	TEST_CASE ("Default user fetch")
	TEST_CASE ("Custom user fetch (wycats)")
	TEST_CASE ("Run server mode and fetch user data")

Macro Definition Documentation

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

Definition at line 1 of file test_cli.cpp.

Function Documentation

http_get()

std::string http_get

(

const std::string &

url

)

Definition at line 36 of file test_cli.cpp.

                                         {
  CURL *curl = curl_easy_init();
  if (!curl)
    throw std::runtime_error("Failed to init curl");
 
  std::string response;
  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
  curl_easy_setopt(
      curl, CURLOPT_WRITEFUNCTION,
      +[](char *ptr, size_t size, size_t nmemb, void *userdata) -> size_t {
        std::string *resp = static_cast<std::string *>(userdata);
        resp->append(ptr, size * nmemb);
        return size * nmemb;
      });
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
 
  CURLcode res = curl_easy_perform(curl);
  if (res != CURLE_OK) {
    curl_easy_cleanup(curl);
    throw std::runtime_error("CURL request failed: " +
                             std::string(curl_easy_strerror(res)));
  }
 
  curl_easy_cleanup(curl);
  return response;
}

References curl_easy_cleanup(), curl_easy_init(), curl_easy_perform(), curl_easy_setopt, curl_easy_strerror(), and CURLE_OK.

Referenced by TEST_CASE(), and wait_for_server().

run_command()

std::string run_command

(

const std::string &

cmd

)

Definition at line 16 of file test_cli.cpp.

                                            {
  std::array<char, 128> buffer;
  std::string result;
 
  // Use std::function to manage the deleter for pclose
  std::unique_ptr<FILE, std::function<void(FILE *)>> pipe(
      popen(cmd.c_str(), "r"), [](FILE *f) { pclose(f); });
 
  if (!pipe)
    throw std::runtime_error("popen() failed");
 
  while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
    result += buffer.data();
  }
 
  return result;
}

Referenced by TEST_CASE(), and TEST_CASE().

stop_server()

void stop_server

(

)

Definition at line 75 of file test_cli.cpp.

                   {
  int ret = system("pkill -f 'github_user_fetcher --server'");
  if (ret != 0) {
    std::cerr << "Warning: Failed to stop server process\n";
  }
}

Referenced by TEST_CASE().

TEST_CASE() [1/3]

TEST_CASE

(

"Custom user fetch (wycats)"

)

Definition at line 95 of file test_cli.cpp.

                                        {
  std::string output = run_command("./github_user_fetcher --user wycats");
 
  std::cout << "Output for custom user fetch (wycats):\n"
            << output << std::endl;
 
  CHECK(output.find("Login: wycats") != std::string::npos);
}

References CHECK, output, and run_command().

TEST_CASE() [2/3]

TEST_CASE

(

"Default user fetch"

)

Definition at line 82 of file test_cli.cpp.

                                {
  std::string output = run_command("./github_user_fetcher");
 
  // Print the output for debugging purposes
  std::cout << "Output for default user fetch:\n" << output << std::endl;
 
  // Check if other specific information is in the output
  CHECK(output.find("Login: izelnakri") != std::string::npos);
  CHECK(output.find("Name: Izel Nakri") != std::string::npos);
  CHECK(output.find("Company: Ruby, JavaScript") != std::string::npos);
  CHECK(output.find("Location: Madrid") != std::string::npos);
}

References CHECK, output, and run_command().

TEST_CASE() [3/3]

TEST_CASE

(

"Run server mode and fetch user data"

)

Definition at line 104 of file test_cli.cpp.

                                                 {
  // Run the server in a background thread
  std::thread server_thread([]() {
    int ret = system("./github_user_fetcher --server");
    if (ret != 0) {
      std::cerr << "Server exited with code: " << ret << std::endl;
    }
  });
 
  // Allow the server some time to start
  wait_for_server();
 
  try {
    // Make the HTTP request to the server for the `izelnakri` user
    std::string url = "http://localhost:1234/izelnakri";
    std::string json_response = http_get(url);
 
    // Parse the JSON response
    auto json = nlohmann::json::parse(json_response);
 
    // Check that the response contains the expected fields
    CHECK(json["login"] == "izelnakri");
    CHECK(json["name"] == "Izel Nakri | izelnakri.eth");
    CHECK(json["company"] ==
          "Ruby, JavaScript, TS, elixir, rust, k8s, lua, nix, pkl, android");
    CHECK(json["location"] == "Madrid | Amsterdam");
 
    json_response = http_get("http://localhost:1234/wycats");
    json = nlohmann::json::parse(json_response);
 
    // Check that the response contains the expected fields for `wycats`
    CHECK(json["login"] == "wycats");
  } catch (const std::exception &e) {
    // If there was an error in any of the steps, make sure the server is
    // stopped
    std::cerr << "Test failed: " << e.what() << std::endl;
    stop_server();
    MESSAGE("Test failed: ", e.what());
    FAIL_CHECK("Exception was thrown");
  }
 
  // Ensure the server is stopped after the test
  stop_server();
 
  if (server_thread.joinable())
    server_thread.detach(); // Don't join, since we already stopped it
}

References CHECK, FAIL_CHECK, http_get(), MESSAGE, stop_server(), and wait_for_server().

wait_for_server()

bool wait_for_server

(

int

max_retries = 10

)

Definition at line 63 of file test_cli.cpp.

                                           {
  for (int i = 0; i < max_retries; ++i) {
    try {
      std::string res = http_get("http://localhost:1234/wycats");
      return !res.empty();
    } catch (...) {
      std::this_thread::sleep_for(std::chrono::milliseconds(300));
    }
  }
  return false;
}

References http_get().

Referenced by TEST_CASE().