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           9 : TEST_CASE("Logger: Use test")
      21             : {
      22          16 :     GIVEN("a logger")
      23             :     {
      24          14 :         std::string name{"test"};
      25          14 :         auto testLogger = Logger::get(name);
      26             : 
      27           8 :         WHEN("checking the logger")
      28             :         {
      29           2 :             THEN("the parameters fit")
      30             :             {
      31           1 :                 REQUIRE(testLogger->name() == name);
      32           1 :                 REQUIRE(testLogger->level() == spdlog::level::info);
      33           1 :                 REQUIRE(testLogger->sinks().size() == 1);
      34             :             }
      35             :         }
      36             : 
      37           8 :         WHEN("getting the logger again")
      38             :         {
      39           2 :             auto sameLogger = Logger::get(name);
      40             : 
      41           2 :             THEN("it has the same settings")
      42             :             {
      43           1 :                 REQUIRE(sameLogger->name() == name);
      44           1 :                 REQUIRE(sameLogger->level() == spdlog::level::info);
      45           1 :                 REQUIRE(sameLogger->sinks().size() == 1);
      46             :             }
      47             :         }
      48             : 
      49           9 :         WHEN("setting the log level")
      50             :         {
      51           2 :             Logger::setLevel(Logger::LogLevel::ERR);
      52             : 
      53           3 :             THEN("our logger is updated to that level")
      54             :             {
      55           1 :                 REQUIRE(testLogger->level() == spdlog::level::err);
      56             :             }
      57             : 
      58           3 :             THEN("new loggers have the correct level")
      59             :             {
      60           2 :                 auto newLogger = Logger::get("newLogger");
      61           1 :                 REQUIRE(newLogger->level() == spdlog::level::err);
      62             :             }
      63             :         }
      64             : 
      65          10 :         WHEN("adding file logging")
      66             :         {
      67           6 :             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           4 :             THEN("a new logger has file logging enabled")
      73             :             {
      74           2 :                 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             :             }
      80             : 
      81           4 :             THEN("actually logging works")
      82             :             {
      83           1 :                 testLogger->info("This is another warning");
      84           1 :                 REQUIRE(true);
      85             :             }
      86             :         }
      87             :     }
      88             : 
      89             :     // Add buffer as sink to test the logging
      90          18 :     std::stringstream buffer;
      91             : 
      92             :     // Keep this flat, as it would at everything multiple times, which duplicates the messages
      93          10 :     GIVEN("A logger at info level")
      94             :     {
      95           1 :         Logger::addSink(buffer);
      96             : 
      97           1 :         Logger::setLevel(Logger::LogLevel::INFO);
      98           3 :         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           2 :         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             :     }
     132             : 
     133          10 :     GIVEN("A logger at debug level")
     134             :     {
     135             :         // reset buffer
     136           1 :         buffer = std::stringstream();
     137             : 
     138           1 :         Logger::setLevel(Logger::LogLevel::DEBUG);
     139           3 :         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           2 :         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             :     }
     173           9 : }
     174             : 
     175             : TEST_SUITE_END();