cpp-logger/test/console_appender_test.cxx

//
//  console_appender_test.cxx
//  logger_test
//
//  Created by Sam Jaffe on 4/13/19.
//

#include <gmock/gmock.h>

#include "resource_factory/prototype_factory.hpp"
#include "scoped_buffer_capture.h"

#include "logger/log_manager.h"
#include "logger/properties.h"
#include "logger_impl.h"
#include "mock_logger.h"

class ConsoleAppenderTest : public testing::Test {
protected:
  void SetUp() override;
  void TearDown() override;
  
  std::string cout() const { return cout_->str(); }
  std::string cerr() const { return cerr_->str(); }
  std::shared_ptr<logging::log_appender>
  get(logging::properties const &) const;
private:
  std::shared_ptr<StubLayout> playout;
  std::unique_ptr<scoped_buffer_capture_t> cout_, cerr_;
};

void ConsoleAppenderTest::SetUp() {
  playout.reset(new StubLayout);
  cout_.reset(new scoped_buffer_capture_t(std::cout));
  cerr_.reset(new scoped_buffer_capture_t(std::cerr));
}

void ConsoleAppenderTest::TearDown() {
  cerr_.reset();
  cout_.reset();
  playout.reset();
}

std::shared_ptr<logging::log_appender>
ConsoleAppenderTest::get(logging::properties const & props) const {
  auto pappender = logging::appenders::instance().get("Console", props);
  return std::make_shared<logging::log_appender>(pappender, playout);
}

TEST_F(ConsoleAppenderTest, ErrorOnUnknownTarget) {
  using namespace logging::property;
  logging::properties props{_obj({
    {"target", _v("COUT")}
  })};
  
  EXPECT_THROW(logging::appenders::instance().get("Console", props),
               std::logic_error);
}

TEST_F(ConsoleAppenderTest, LogsToStdOut) {
  using namespace logging;
  using namespace logging::property;
  properties props{_obj({
    {"target", _v("SYSTEM_OUT")}
  })};
  
  using testing::Eq;
  using testing::IsEmpty;
  logpacket pkt{{}, level::error, {}, {}, "This is a test message"};
  EXPECT_NO_THROW(get(props)->write(pkt));
  EXPECT_THAT(cout(), Eq("This is a test message"));
  EXPECT_THAT(cerr(), IsEmpty());
}

TEST_F(ConsoleAppenderTest, WillNotLogBelowThreshold) {
  using namespace logging;
  using namespace logging::property;
  properties props{_obj({
    {"target", _v("SYSTEM_OUT")}
  })};
  
  EXPECT_FALSE(get(props)->should_log(level::warn));
  EXPECT_TRUE(get(props)->should_log(level::error));
}

TEST_F(ConsoleAppenderTest, LogsToStdErr) {
  using namespace logging;
  using namespace logging::property;
  properties props{_obj({
    {"target", _v("SYSTEM_ERR")},
    {"threshold", _v("FATAL")}
  })};
  
  using testing::Eq;
  using testing::IsEmpty;
  logpacket pkt{{}, level::error, {}, {}, "This is a test message"};
  EXPECT_NO_THROW(get(props)->write(pkt));
  EXPECT_THAT(cout(), IsEmpty());
  EXPECT_THAT(cerr(), Eq("This is a test message"));
}