Cleaning up log files for C++ Approval Tests

I wrote about the Gilded Rose kata a while back (https://barneydellar.blogspot.com/2020/07/gilded-rose-katas.html) and one thing I looked at was the use of Approval Testing to get the code under control. 

And I went further, and investigated using the same library to test logging behaviour. 

Approval Testing relies on consistent output given consistent input. But logging code typically adds the date and time to the log file. This is desired behaviour, but it makes testing against the log file hard.

The C++ Approval Test library (https://github.com/approvals/ApprovalTests.cpp) always had support for dealing with this, but it was quite verbose. You had to create a derived TextFileComparator, override the contentsAreEquivalent() method, and then use regex to find and replace the date and time with something hard-coded.

class SpdLogComparator : public TextFileComparator {
public:
    [[nodiscard]]
    bool contentsAreEquivalent(
        std::string receivedPath,
        std::string approvedPath
    ) const override {
        spdlog::shutdown();
        const auto new_contents = MungedFileContents(receivedPath);
        WriteFileContents(receivedPath, new_contents);
        return TextFileComparator::contentsAreEquivalent(receivedPath, approvedPath);
    }
private:
    [[nodiscard]]
    std::string MungedFileContents(std::string receivedPath) const {
        std::stringstream new_contents;
        std::regex word_regex("[.*] [(.*)] [(.*)] (.*)");
        std::smatch sm;
        std::string line;
 
        std::ifstream rstream(receivedPath);
        while (std::getline(rstream, line)) {
            std::regex_match(line, sm, word_regex);
            if (sm.size() >= 2) {
                new_contents << "[TIME_AND_DATE MUNGED BY TESTS] [" << sm[1] << "] [" << sm[2].str() << "] " << sm[3].str() << '';
            } else {
                new_contents << line << '';
            }
        }
        return new_contents.str();
    }
 
    void WriteFileContents(std::string receivedPath, std::string new_contents) const {
        std::ofstream fileout(receivedPath, std::ifstream::out);
        fileout << new_contents;
    }
};

This works, but it's quite long winded. 

You also needed to register an instance of the comparator in order to use it:

TEST_CASE("Test log") {
    FileApprover::registerComparator(".log", std::make_shared< SpdLogComparator>());
    WriteLog();
    Approvals::verifyExistingFile(log_file);
}

But now the library has been improved a lot, and this is all much simpler. 

You can now just create a function that will return an ApprovalTests::Scrubber or an ApprovalTests::Options instance. The scrubber does the work of replacing the text using a regex, and the Options can be obtained from it, in order to specify the file extension to work on. This can be done in just a handful of lines, with no boilerplate:

inline ApprovalTests::Options Munger() {
    const std::string dateRegex = "\\[[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{3}\\]";
    const std::string replacementText = "[MUNGED_DATE_TIME]";
    const auto munger = ApprovalTests::Scrubbers::createRegexScrubber(dateRegex, replacementText);
    return ApprovalTests::Options(munger).fileOptions().withFileExtension(".log");
}

And the use has been simplified too: 

TEST_CASE("Test log") {
    WriteLog();
    Approvals::verifyExistingFile(log_file, Munger());
}

This is a very nice improvement to the library, simplifying the test code a lot. Thanks to Clare Macrae for pointing this out to me :and helping me to get it working :-)

Comments

Post a Comment

Popular posts from this blog

SoCraTes UK 2024 trip report

In September 2024 I attended my second SoCraTes conference, and once again, it was enlightening and fun. There are two formal parts to the conference - a training day, and then two days for the unconference. I say formal parts, because there are plenty of informal sessions as well. One of the great things about SoCrcaTes is that we all stay at the same hotel, so there is loads of opportunities for social interaction. You meet people at breakfast, you maybe go for a walk with other people, there are board games and music sessions in the evenings... It's a strange mixture of really intense and very relaxing! There's a lovely Italian Garden at the hotel, which is a very nice place to sit and chat: SoCraTes has a pretty strong XP focus, but there are plenty of non-technical discussions and workshops too.  The day before This year, the conference was at Milton House Hotel just outside Didcot in Oxfordshire. So on the day before the conference, I took the train from Edinburgh to Lon...
Read more

We always start from where we are

Image
Earlier on in this year, I had a really interesting discussion online with Duncan Hothersall about Scottish Independence, and Brexit. I support independence, and Duncan very much doesn't. Scotland is currently about evenly split between supporters and opponents of independence, with a small number of hardcore unionists and nationalists on either side. But many people are in the middle, and weigh up the decision based on the perceived pros and cons. In itself, this disagreement between Duncan and myself is interesting. We share a similar world-view and similar hopes for the future. We agree in many ways on the kind of future we would like to see. But we disagree on how we want to get there.  This is of course a common pattern. We often share a purpose with other people, but we disagree on the tactics or maybe even the strategy for how to achieve it, and there is a wealth of literature on how to resolve such disagreements.  But what I found fascinating was how we both responded...
Read more

Naming things and Cunningham’s Law

Naming things is hard.  Naming things is very hard.  And, in software, we often want to name things when we know least about them. We create a variable that we plan to use later. What should it be called? How should it be used? We only have a vague plan at this point. And plans, of course, can change.  In my mob, we sometimes struggled to name things. And we would then fall into long discussions about what to call a variable. This often felt like bike-shedding, but we wanted a good name, so we carried on talking.  Then one day, we came up with a new plan. If we couldn’t name something within ten seconds, the person at the keyboard would just hit the keys at random and produce a gibberish name.  We would then use this unpronounceable name in the code, and move on.  And, as we moved on, we would have to talk about the unpronounceable thing. So we call it by what is was doing, by how we were using it. And, often, the name would then become apparent.  By ...
Read more