test_helpers.cc

Go to the documentation of this file.

/*
 SPDX-License-Identifier: GPL-2.0-only
 Author: Dietmar Helmut Leher <helmut.leher.ext@vaillant-group.com>
 SPDX-FileCopyrightText: © 2026 Vaillant GmbH
*/
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
 
#include "ReuserDatabaseHandler.hpp"
#include "MockReuserDatabaseHandler.hpp"
 
class ReuserHelpersAccessor : public MockReuserDatabaseHandler
{
public:
  using MockReuserDatabaseHandler::MockReuserDatabaseHandler;
 
  bool callIsValidIdentifier(const std::string& s)
  {
    return isValidIdentifier(s);
  }
 
  std::string callReplaceUnicodeControlChars(const std::string& s)
  {
    return replaceUnicodeControlChars(s);
  }
 
  int callGetDecisionTypePriority(int decisionType)
  {
    return getDecisionTypePriority(decisionType);
  }
};
 
// isValidIdentifier tests
 
class IsValidIdentifierTest : public CPPUNIT_NS::TestFixture
{
  CPPUNIT_TEST_SUITE(IsValidIdentifierTest);
  CPPUNIT_TEST(testEmptyStringIsInvalid);
  CPPUNIT_TEST(testLowercaseLettersAreValid);
  CPPUNIT_TEST(testUppercaseLettersAreValid);
  CPPUNIT_TEST(testDigitsAreValid);
  CPPUNIT_TEST(testUnderscoreIsValid);
  CPPUNIT_TEST(testMixedAlphanumericUnderscoreIsValid);
  CPPUNIT_TEST(testSpaceIsInvalid);
  CPPUNIT_TEST(testHyphenIsInvalid);
  CPPUNIT_TEST(testDotIsInvalid);
  CPPUNIT_TEST(testSemicolonIsInvalid);
  CPPUNIT_TEST(testSingleQuoteIsInvalid);
  CPPUNIT_TEST(testDoubleQuoteIsInvalid);
  CPPUNIT_TEST(testDollarIsInvalid);
  CPPUNIT_TEST(testNullByteIsInvalid);
  CPPUNIT_TEST(testSqlInjectionPatternIsInvalid);
  CPPUNIT_TEST(testKnownTableNamesAreValid);
  CPPUNIT_TEST_SUITE_END();
 
  ReuserHelpersAccessor acc;
 
protected:
  void testEmptyStringIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier(""));
  }
 
  void testLowercaseLettersAreValid()
  {
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("abc"));
  }
 
  void testUppercaseLettersAreValid()
  {
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("ABC"));
  }
 
  void testDigitsAreValid()
  {
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("123"));
  }
 
  void testUnderscoreIsValid()
  {
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("_"));
  }
 
  void testMixedAlphanumericUnderscoreIsValid()
  {
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("uploadtree_a"));
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("upload_fk_123"));
  }
 
  void testSpaceIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("upload tree"));
  }
 
  void testHyphenIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("upload-tree"));
  }
 
  void testDotIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("public.uploadtree"));
  }
 
  void testSemicolonIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("foo;DROP TABLE uploadtree"));
  }
 
  void testSingleQuoteIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("up'load"));
  }
 
  void testDoubleQuoteIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("up\"load"));
  }
 
  void testDollarIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("$1"));
  }
 
  void testNullByteIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier(std::string("up\x00load", 8)));
  }
 
  void testSqlInjectionPatternIsInvalid()
  {
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("t WHERE 1=1--"));
    CPPUNIT_ASSERT(!acc.callIsValidIdentifier("t UNION SELECT 1"));
  }
 
  void testKnownTableNamesAreValid()
  {
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("uploadtree"));
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("uploadtree_a"));
    // upload-specific table names follow the pattern uploadtree_<pk>
    CPPUNIT_ASSERT(acc.callIsValidIdentifier("uploadtree_42"));
  }
};
 
CPPUNIT_TEST_SUITE_REGISTRATION(IsValidIdentifierTest);
 
// replaceUnicodeControlChars tests
 
class ReplaceUnicodeControlCharsTest : public CPPUNIT_NS::TestFixture
{
  CPPUNIT_TEST_SUITE(ReplaceUnicodeControlCharsTest);
  CPPUNIT_TEST(testPlainAsciiIsUnchanged);
  CPPUNIT_TEST(testTabAndNewlineAreKept);
  CPPUNIT_TEST(testCarriageReturnIsKept);
  CPPUNIT_TEST(testNullByteIsStripped);
  CPPUNIT_TEST(testC0ControlCharsAreStripped);
  CPPUNIT_TEST(testC1ControlCharsAreStripped);
  CPPUNIT_TEST(testDeleteCharIsStripped);
  CPPUNIT_TEST(testUtf8MultiBytePrintableIsKept);
  CPPUNIT_TEST(testSurrogatePairCodepointIsKept);
  CPPUNIT_TEST(testMixedControlAndPrintableFiltered);
  CPPUNIT_TEST(testEmptyStringIsUnchanged);
  CPPUNIT_TEST_SUITE_END();
 
  ReuserHelpersAccessor acc;
 
  std::string call(const std::string& s)
  {
    return acc.callReplaceUnicodeControlChars(s);
  }
 
protected:
  void testPlainAsciiIsUnchanged()
  {
    CPPUNIT_ASSERT_EQUAL(std::string("hello world"), call("hello world"));
  }
 
  void testTabAndNewlineAreKept()
  {
    CPPUNIT_ASSERT_EQUAL(std::string("\t\n"), call("\t\n"));
  }
 
  void testCarriageReturnIsKept()
  {
    CPPUNIT_ASSERT_EQUAL(std::string("\r"), call("\r"));
  }
 
  void testNullByteIsStripped()
  {
    std::string in(1, '\x00');
    CPPUNIT_ASSERT_EQUAL(std::string(""), call(in));
  }
 
  void testC0ControlCharsAreStripped()
  {
    // U+0001 through U+0008
    for (char c = '\x01'; c <= '\x08'; ++c)
    {
      std::string in(1, c);
      CPPUNIT_ASSERT_EQUAL_MESSAGE(
        "Expected control char 0x" + std::to_string((unsigned char)c) + " to be stripped",
        std::string(""), call(in));
    }
    // U+000B (VT) and U+000C (FF) are also stripped
    CPPUNIT_ASSERT_EQUAL(std::string(""), call("\x0B"));
    CPPUNIT_ASSERT_EQUAL(std::string(""), call("\x0C"));
    // U+000E through U+001F
    for (char c = '\x0E'; c <= '\x1F'; ++c)
    {
      std::string in(1, c);
      CPPUNIT_ASSERT_EQUAL_MESSAGE(
        "Expected control char 0x" + std::to_string((unsigned char)c) + " to be stripped",
        std::string(""), call(in));
    }
  }
 
  void testC1ControlCharsAreStripped()
  {
    // U+0080 in UTF-8 is \xC2\x80
    std::string c1_80 = "\xC2\x80";
    CPPUNIT_ASSERT_EQUAL(std::string(""), call(c1_80));
    // U+009F in UTF-8 is \xC2\x9F
    std::string c1_9f = "\xC2\x9F";
    CPPUNIT_ASSERT_EQUAL(std::string(""), call(c1_9f));
  }
 
  void testDeleteCharIsStripped()
  {
    CPPUNIT_ASSERT_EQUAL(std::string(""), call("\x7F"));
  }
 
  void testUtf8MultiBytePrintableIsKept()
  {
    // © = U+00A9 = \xC2\xA9 in UTF-8
    std::string copyright_sign = "\xC2\xA9";
    CPPUNIT_ASSERT_EQUAL(copyright_sign, call(copyright_sign));
  }
 
  void testSurrogatePairCodepointIsKept()
  {
    // U+1F600 GRINNING FACE in UTF-8: \xF0\x9F\x98\x80
    std::string emoji = "\xF0\x9F\x98\x80";
    CPPUNIT_ASSERT_EQUAL(emoji, call(emoji));
  }
 
  void testMixedControlAndPrintableFiltered()
  {
    // "hello\x01world" -> "helloworld"
    std::string in = "hello\x01world";
    CPPUNIT_ASSERT_EQUAL(std::string("helloworld"), call(in));
 
    // control sandwiched between emoji
    // \xF0\x9F\x98\x80 \x01 \xF0\x9F\x98\x80  ->  emoji + emoji
    std::string emoji = "\xF0\x9F\x98\x80";
    std::string mixed = emoji + "\x01" + emoji;
    CPPUNIT_ASSERT_EQUAL(emoji + emoji, call(mixed));
  }
 
  void testEmptyStringIsUnchanged()
  {
    CPPUNIT_ASSERT_EQUAL(std::string(""), call(""));
  }
};
 
CPPUNIT_TEST_SUITE_REGISTRATION(ReplaceUnicodeControlCharsTest);
 
class DecisionTypePriorityTest : public CPPUNIT_NS::TestFixture
{
  CPPUNIT_TEST_SUITE(DecisionTypePriorityTest);
  CPPUNIT_TEST(testPriorityOrdering);
  CPPUNIT_TEST(testStrongerTypeBeatsWeakerRegardlessOfPkOrder);
  CPPUNIT_TEST_SUITE_END();
 
protected:
  int prio(int decisionType)
  {
    ReuserHelpersAccessor accessor;
    return accessor.callGetDecisionTypePriority(decisionType);
  }
 
  void testPriorityOrdering()
  {
    CPPUNIT_ASSERT(prio(0) < prio(3));
    CPPUNIT_ASSERT(prio(3) < prio(4));
    CPPUNIT_ASSERT(prio(4) < prio(7));
    CPPUNIT_ASSERT(prio(7) < prio(6));
    CPPUNIT_ASSERT(prio(6) < prio(5));
    CPPUNIT_ASSERT_EQUAL(0, prio(999));
  }
 
  void testStrongerTypeBeatsWeakerRegardlessOfPkOrder()
  {
    const int irrelevantPk = 50;
    const int irrelevantType = 4;
    const int identifiedPk = 40;
    const int identifiedType = 5;
 
    int chosenPk = irrelevantPk;
    int chosenType = irrelevantType;
 
    auto applyRow = [&](int pk, int type)
    {
      if (prio(type) > prio(chosenType))
      {
        chosenPk = pk;
        chosenType = type;
      }
    };
 
    applyRow(irrelevantPk, irrelevantType);
    applyRow(identifiedPk, identifiedType);
 
    CPPUNIT_ASSERT_EQUAL(identifiedPk, chosenPk);
    CPPUNIT_ASSERT_EQUAL(identifiedType, chosenType);
  }
};
 
CPPUNIT_TEST_SUITE_REGISTRATION(DecisionTypePriorityTest);