From 1573a8c4cde1cd9528b422b2dcc598e37ffe94a7 Mon Sep 17 00:00:00 2001 From: jacqueline Date: Thu, 2 May 2024 19:12:26 +1000 Subject: WIP merge cyclically dependent components into one big component --- src/tangara/database/test/CMakeLists.txt | 8 ++ src/tangara/database/test/test_database.cpp | 210 ++++++++++++++++++++++++++++ src/tangara/database/test/test_records.cpp | 146 +++++++++++++++++++ 3 files changed, 364 insertions(+) create mode 100644 src/tangara/database/test/CMakeLists.txt create mode 100644 src/tangara/database/test/test_database.cpp create mode 100644 src/tangara/database/test/test_records.cpp (limited to 'src/tangara/database/test') diff --git a/src/tangara/database/test/CMakeLists.txt b/src/tangara/database/test/CMakeLists.txt new file mode 100644 index 00000000..a9f2cedb --- /dev/null +++ b/src/tangara/database/test/CMakeLists.txt @@ -0,0 +1,8 @@ +# Copyright 2023 jacqueline +# +# SPDX-License-Identifier: GPL-3.0-only + +idf_component_register( + SRCS "test_records.cpp" "test_database.cpp" + INCLUDE_DIRS "." + REQUIRES catch2 cmock database drivers fixtures) diff --git a/src/tangara/database/test/test_database.cpp b/src/tangara/database/test/test_database.cpp new file mode 100644 index 00000000..6aec9bfb --- /dev/null +++ b/src/tangara/database/test/test_database.cpp @@ -0,0 +1,210 @@ +/* + * Copyright 2023 jacqueline + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#include "database.hpp" + +#include +#include +#include +#include +#include + +#include "catch2/catch.hpp" +#include "driver_cache.hpp" +#include "esp_log.h" +#include "file_gatherer.hpp" +#include "i2c_fixture.hpp" +#include "leveldb/db.h" +#include "spi_fixture.hpp" +#include "tag_parser.hpp" +#include "track.hpp" + +namespace database { + +class TestBackends : public IFileGatherer, public ITagParser { + public: + std::map tracks; + + auto MakeTrack(const std::pmr::string& path, const std::pmr::string& title) + -> void { + TrackTags tags; + tags.encoding = Encoding::kMp3; + tags.title = title; + tracks[path] = tags; + } + + auto FindFiles(const std::pmr::string& root, + std::function cb) + -> void override { + for (auto keyval : tracks) { + std::invoke(cb, keyval.first); + } + } + + auto ReadAndParseTags(const std::pmr::string& path, TrackTags* out) + -> bool override { + if (tracks.contains(path)) { + *out = tracks.at(path); + return true; + } + return false; + } +}; + +TEST_CASE("track database", "[integration]") { + I2CFixture i2c; + SpiFixture spi; + drivers::DriverCache drivers; + auto storage = drivers.AcquireStorage(); + + Database::Destroy(); + + TestBackends tracks; + auto open_res = Database::Open(&tracks, &tracks); + REQUIRE(open_res.has_value()); + std::unique_ptr db(open_res.value()); + + SECTION("empty database") { + std::unique_ptr> res(db->GetTracks(10).get()); + REQUIRE(res->values().size() == 0); + } + + SECTION("add new tracks") { + tracks.MakeTrack("track1.mp3", "Track 1"); + tracks.MakeTrack("track2.wav", "Track 2"); + tracks.MakeTrack("track3.exe", "Track 3"); + + db->Update(); + + std::unique_ptr> res(db->GetTracks(10).get()); + REQUIRE(res->values().size() == 3); + CHECK(*res->values().at(0).tags().title == "Track 1"); + CHECK(res->values().at(0).data().id() == 1); + CHECK(*res->values().at(1).tags().title == "Track 2"); + CHECK(res->values().at(1).data().id() == 2); + CHECK(*res->values().at(2).tags().title == "Track 3"); + CHECK(res->values().at(2).data().id() == 3); + + SECTION("update with no filesystem changes") { + db->Update(); + + std::unique_ptr> new_res(db->GetTracks(10).get()); + REQUIRE(new_res->values().size() == 3); + CHECK(res->values().at(0) == new_res->values().at(0)); + CHECK(res->values().at(1) == new_res->values().at(1)); + CHECK(res->values().at(2) == new_res->values().at(2)); + } + + SECTION("update with all tracks gone") { + tracks.tracks.clear(); + + db->Update(); + + std::unique_ptr> new_res(db->GetTracks(10).get()); + CHECK(new_res->values().size() == 0); + + SECTION("update with one track returned") { + tracks.MakeTrack("track2.wav", "Track 2"); + + db->Update(); + + std::unique_ptr> new_res(db->GetTracks(10).get()); + REQUIRE(new_res->values().size() == 1); + CHECK(res->values().at(1) == new_res->values().at(0)); + } + } + + SECTION("update with one track gone") { + tracks.tracks.erase("track2.wav"); + + db->Update(); + + std::unique_ptr> new_res(db->GetTracks(10).get()); + REQUIRE(new_res->values().size() == 2); + CHECK(res->values().at(0) == new_res->values().at(0)); + CHECK(res->values().at(2) == new_res->values().at(1)); + } + + SECTION("update with tags changed") { + tracks.MakeTrack("track3.exe", "The Track 3"); + + db->Update(); + + std::unique_ptr> new_res(db->GetTracks(10).get()); + REQUIRE(new_res->values().size() == 3); + CHECK(res->values().at(0) == new_res->values().at(0)); + CHECK(res->values().at(1) == new_res->values().at(1)); + CHECK(*new_res->values().at(2).tags().title == "The Track 3"); + // The id should not have changed, since this was just a tag update. + CHECK(res->values().at(2).data().id() == + new_res->values().at(2).data().id()); + } + + SECTION("update with one new track") { + tracks.MakeTrack("my track.midi", "Track 1 (nightcore remix)"); + + db->Update(); + + std::unique_ptr> new_res(db->GetTracks(10).get()); + REQUIRE(new_res->values().size() == 4); + CHECK(res->values().at(0) == new_res->values().at(0)); + CHECK(res->values().at(1) == new_res->values().at(1)); + CHECK(res->values().at(2) == new_res->values().at(2)); + CHECK(*new_res->values().at(3).tags().title == + "Track 1 (nightcore remix)"); + CHECK(new_res->values().at(3).data().id() == 4); + } + + SECTION("get tracks with pagination") { + std::unique_ptr> res(db->GetTracks(1).get()); + + REQUIRE(res->values().size() == 1); + CHECK(res->values().at(0).data().id() == 1); + REQUIRE(res->next_page()); + + res.reset(db->GetPage(&res->next_page().value()).get()); + + REQUIRE(res->values().size() == 1); + CHECK(res->values().at(0).data().id() == 2); + REQUIRE(res->next_page()); + + res.reset(db->GetPage(&res->next_page().value()).get()); + + REQUIRE(res->values().size() == 1); + CHECK(res->values().at(0).data().id() == 3); + REQUIRE(!res->next_page()); + + SECTION("page backwards") { + REQUIRE(res->prev_page()); + + res.reset(db->GetPage(&res->prev_page().value()).get()); + + REQUIRE(res->values().size() == 1); + CHECK(res->values().at(0).data().id() == 2); + REQUIRE(res->prev_page()); + + res.reset(db->GetPage(&res->prev_page().value()).get()); + + REQUIRE(res->values().size() == 1); + CHECK(res->values().at(0).data().id() == 1); + REQUIRE(!res->prev_page()); + + SECTION("page forwards again") { + REQUIRE(res->next_page()); + + res.reset(db->GetPage(&res->next_page().value()).get()); + + REQUIRE(res->values().size() == 1); + CHECK(res->values().at(0).data().id() == 2); + CHECK(res->next_page()); + CHECK(res->prev_page()); + } + } + } + } +} + +} // namespace database diff --git a/src/tangara/database/test/test_records.cpp b/src/tangara/database/test/test_records.cpp new file mode 100644 index 00000000..2f59489c --- /dev/null +++ b/src/tangara/database/test/test_records.cpp @@ -0,0 +1,146 @@ +/* + * Copyright 2023 jacqueline + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#include "records.hpp" + +#include +#include +#include + +#include "catch2/catch.hpp" + +std::pmr::string ToHex(const std::pmr::string& s) { + std::ostringstream ret; + + for (std::pmr::string::size_type i = 0; i < s.length(); ++i) + ret << std::hex << std::setfill('0') << std::setw(2) << std::uppercase + << (int)s[i]; + + return ret.str(); +} + +namespace database { + +TEST_CASE("database record encoding", "[unit]") { + SECTION("track id to bytes") { + TrackId id = 1234678; + OwningSlice as_bytes = TrackIdToBytes(id); + + SECTION("encodes correctly") { + // Purposefully a brittle test, since we need to be very careful about + // changing the way records are encoded. + REQUIRE(as_bytes.data.size() == 5); + // unsigned value + CHECK(as_bytes.data[0] == 0x1A); + // TODO(jacqueline): what's up with these failing? + // 12345678 + // CHECK(as_bytes.data[1] == 0x00); + // CHECK(as_bytes.data[2] == 0x01); + // CHECK(as_bytes.data[3] == 0xE2); + // CHECK(as_bytes.data[4] == 0x40); + } + + SECTION("round-trips") { + CHECK(*BytesToTrackId(as_bytes.data) == id); + } + + SECTION("encodes compactly") { + OwningSlice small_id = TrackIdToBytes(1); + OwningSlice large_id = TrackIdToBytes(999999); + + CHECK(small_id.data.size() < large_id.data.size()); + } + + SECTION("decoding rejects garbage") { + std::optional res = BytesToTrackId("i'm gay"); + + CHECK(res.has_value() == false); + } + } + + SECTION("data keys") { + OwningSlice key = CreateDataKey(123456); + + REQUIRE(key.data.size() == 7); + CHECK(key.data[0] == 'D'); + CHECK(key.data[1] == '\0'); + // unsigned int + CHECK(key.data[2] == 0x1A); + // assume the int encoding is fine. + } + + SECTION("data values") { + TrackData data(123, "/some/path.mp3", 0xACAB, 69, true); + + OwningSlice enc = CreateDataValue(data); + + SECTION("encodes correctly") { + REQUIRE(enc.data.size() == 24); + + // Array, length 5 + CHECK(enc.data[0] == 0x85); + + // unsigned int, value 123 + CHECK(enc.data[1] == 0x18); + CHECK(enc.data[2] == 0x7B); + + // text, 14 chars + CHECK(enc.data[3] == 0x6E); + // ... assume the text looks okay. + + // unsigned int, value 44203 + CHECK(enc.data[18] == 0x19); + CHECK(enc.data[19] == 0xAC); + CHECK(enc.data[20] == 0xAB); + + // unsigned int, value 69 + CHECK(enc.data[21] == 0x18); + CHECK(enc.data[22] == 0x45); + + // primitive 21, true + CHECK(enc.data[23] == 0xF5); + } + + SECTION("round-trips") { + CHECK(ParseDataValue(enc.slice) == data); + } + + SECTION("decoding rejects garbage") { + std::optional res = ParseDataValue("hi!"); + + CHECK(res.has_value() == false); + } + } + + SECTION("hash keys") { + OwningSlice key = CreateHashKey(123456); + + REQUIRE(key.data.size() == 7); + CHECK(key.data[0] == 'H'); + CHECK(key.data[1] == '\0'); + // unsigned int + CHECK(key.data[2] == 0x1A); + // assume the int encoding is fine. + } + + SECTION("hash values") { + OwningSlice val = CreateHashValue(123456); + + CHECK(val.data == TrackIdToBytes(123456).data); + + SECTION("round-trips") { + CHECK(ParseHashValue(val.slice) == 123456); + } + + SECTION("decoding rejects garbage") { + std::optional res = ParseHashValue("the first track :)"); + + CHECK(res.has_value() == false); + } + } +} + +} // namespace database -- cgit v1.2.3