Line data    Source code

       1             : /**
       2             :  * @file test_Logger.cpp
       3             :  *
       4             :  * @brief Tests for the Logger class
       5             :  *
       6             :  * @author Tobias Lasser - initial code
       7             :  */
       8             : 
       9             : #include "doctest/doctest.h"
      10             : #include "Logger.h"
      11             : #include <sstream>
      12             : 
      13             : using namespace elsa;
      14             : using namespace doctest;
      15             : 
      16             : using namespace std::string_literals;
      17             : 
      18             : TEST_SUITE_BEGIN("logging");
      19             : 
      20             : TEST_CASE("Logger: Use test")
      21           9 : {
      22           9 :     GIVEN("a logger")
      23           9 :     {
      24           7 :         std::string name{"test"};
      25           7 :         auto testLogger = Logger::get(name);
      26             : 
      27           7 :         WHEN("checking the logger")
      28           7 :         {
      29           1 :             THEN("the parameters fit")
      30           1 :             {
      31           1 :                 REQUIRE(testLogger->name() == name);
      32           1 :                 REQUIRE(testLogger->level() == spdlog::level::info);
      33           1 :                 REQUIRE(testLogger->sinks().size() == 1);
      34           1 :             }
      35           1 :         }
      36             : 
      37           7 :         WHEN("getting the logger again")
      38           7 :         {
      39           1 :             auto sameLogger = Logger::get(name);
      40             : 
      41           1 :             THEN("it has the same settings")
      42           1 :             {
      43           1 :                 REQUIRE(sameLogger->name() == name);
      44           1 :                 REQUIRE(sameLogger->level() == spdlog::level::info);
      45           1 :                 REQUIRE(sameLogger->sinks().size() == 1);
      46           1 :             }
      47           1 :         }
      48             : 
      49           7 :         WHEN("setting the log level")
      50           7 :         {
      51           2 :             Logger::setLevel(Logger::LogLevel::ERR);
      52             : 
      53           2 :             THEN("our logger is updated to that level")
      54           2 :             {
      55           1 :                 REQUIRE(testLogger->level() == spdlog::level::err);
      56           1 :             }
      57             : 
      58           2 :             THEN("new loggers have the correct level")
      59           2 :             {
      60           1 :                 auto newLogger = Logger::get("newLogger");
      61           1 :                 REQUIRE(newLogger->level() == spdlog::level::err);
      62           1 :             }
      63           2 :         }
      64             : 
      65           7 :         WHEN("adding file logging")
      66           7 :         {
      67           3 :             std::string filename = "log.txt";
      68           3 :             Logger::enableFileLogging(filename);
      69             : 
      70           3 :             THEN("We still should only have one sink") { REQUIRE(testLogger->sinks().size() == 1); }
      71             : 
      72           3 :             THEN("a new logger has file logging enabled")
      73           3 :             {
      74           1 :                 auto newLogger = Logger::get("fileLogger");
      75           1 :                 REQUIRE(newLogger->sinks().size() == 1);
      76             : 
      77           1 :                 newLogger->info("This is an info");
      78           1 :                 REQUIRE(true);
      79           1 :             }
      80             : 
      81           3 :             THEN("actually logging works")
      82           3 :             {
      83           1 :                 testLogger->info("This is another warning");
      84           1 :                 REQUIRE(true);
      85           1 :             }
      86           3 :         }
      87           7 :     }
      88             : 
      89             :     // Add buffer as sink to test the logging
      90           9 :     std::stringstream buffer;
      91             : 
      92             :     // Keep this flat, as it would at everything multiple times, which duplicates the messages
      93           9 :     GIVEN("A logger at info level")
      94           9 :     {
      95           1 :         Logger::addSink(buffer);
      96             : 
      97           1 :         Logger::setLevel(Logger::LogLevel::INFO);
      98           1 :         auto logger = Logger::get("logger");
      99             : 
     100             :         // Set pattern that we can easily check it
     101           1 :         logger->set_pattern("%v");
     102             : 
     103             :         // we expect there to be exactly 1 sink
     104           1 :         REQUIRE(logger->sinks().size() == 1);
     105             : 
     106           1 :         auto msg = "This is a test"s;
     107           1 :         logger->info(msg);
     108             : 
     109             :         // Get string from buffer
     110           1 :         auto resultString = buffer.str();
     111           1 :         REQUIRE(resultString == (msg + '\n'));
     112             : 
     113             :         // reset buffer
     114           1 :         buffer = std::stringstream();
     115             : 
     116           1 :         msg = "This is a test"s;
     117           1 :         logger->debug(msg);
     118             : 
     119             :         // Get string from buffer
     120           1 :         resultString = buffer.str();
     121           1 :         REQUIRE(resultString == "");
     122             : 
     123             :         // reset buffer
     124           1 :         buffer = std::stringstream();
     125             : 
     126           1 :         msg = "This is a warning"s;
     127           1 :         logger->warn(msg);
     128             : 
     129           1 :         resultString = buffer.str();
     130           1 :         REQUIRE(resultString == (msg + '\n'));
     131           1 :     }
     132             : 
     133           9 :     GIVEN("A logger at debug level")
     134           9 :     {
     135             :         // reset buffer
     136           1 :         buffer = std::stringstream();
     137             : 
     138           1 :         Logger::setLevel(Logger::LogLevel::DEBUG);
     139           1 :         auto logger = Logger::get("logger");
     140             : 
     141             :         // Set pattern that we can easily check it
     142           1 :         logger->set_pattern("%v");
     143             : 
     144             :         // we expect there to be exactly 1 sink
     145           1 :         REQUIRE(logger->sinks().size() == 1);
     146             : 
     147           1 :         auto msg = "This is a test"s;
     148           1 :         logger->info(msg);
     149             : 
     150             :         // Get string from buffer
     151           1 :         auto resultString = buffer.str();
     152           1 :         REQUIRE(resultString == (msg + '\n'));
     153             : 
     154             :         // reset buffer
     155           1 :         buffer = std::stringstream();
     156             : 
     157           1 :         msg = "This is a debug"s;
     158           1 :         logger->debug(msg);
     159             : 
     160             :         // Get string from buffer
     161           1 :         resultString = buffer.str();
     162           1 :         REQUIRE(resultString == (msg + '\n'));
     163             : 
     164             :         // reset buffer
     165           1 :         buffer = std::stringstream();
     166             : 
     167           1 :         msg = "This is a warning"s;
     168           1 :         logger->warn(msg);
     169             : 
     170           1 :         resultString = buffer.str();
     171           1 :         REQUIRE(resultString == (msg + '\n'));
     172           1 :     }
     173           9 : }
     174             : 
     175             : TEST_SUITE_END();