WIP merge cyclically dependent components into one big component

3 files changed, 364 insertions, 0 deletions

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 <me@jacqueline.id.au>
+#
+# 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 <me@jacqueline.id.au>
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#include "database.hpp"
+
+#include <stdint.h>
+#include <iomanip>
+#include <map>
+#include <memory>
+#include <string>
+
+#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<std::pmr::string, TrackTags> 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<void(const std::pmr::string&)> 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<Database> db(open_res.value());
+
+  SECTION("empty database") {
+    std::unique_ptr<Result<Track>> 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<Result<Track>> 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<Result<Track>> 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<Result<Track>> 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<Result<Track>> 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<Result<Track>> 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<Result<Track>> 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<Result<Track>> 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<Result<Track>> 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 <me@jacqueline.id.au>
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#include "records.hpp"
+
+#include <stdint.h>
+#include <iomanip>
+#include <string>
+
+#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<TrackId> 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<TrackData> 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<TrackId> res = ParseHashValue("the first track :)");
+
+      CHECK(res.has_value() == false);
+    }
+  }
+}
+
+}  // namespace database