Create separate method for creating cache in-memory

15 files changed, 449 insertions, 457 deletions

diff --git a/include/cache.h b/include/cache.h
index 846083c7..703c9862 100644
--- a/include/cache.h
+++ b/include/cache.h
@@ -44,8 +44,10 @@ class Cache {
 public:
 	Cache(const Filepath& cachefile, ConfigContainer& c);
 	~Cache();
-	void externalize_rssfeed(RssFeed& feed,
-		bool reset_unread);
+
+	static std::unique_ptr<Cache> in_memory(ConfigContainer& c);
+
+	void externalize_rssfeed(RssFeed& feed, bool reset_unread);
 	std::shared_ptr<RssFeed> internalize_rssfeed(std::string rssurl,
 		RssIgnores* ign);
 	void update_rssitem_unread_and_enqueued(RssItem& item,
diff --git a/src/cache.cpp b/src/cache.cpp
index 0fcade75..a432c27d 100644
--- a/src/cache.cpp
+++ b/src/cache.cpp
@@ -282,6 +282,11 @@ Cache::~Cache()
 	close_database();
 }
 
+std::unique_ptr<Cache> Cache::in_memory(ConfigContainer& c)
+{
+	return std::make_unique<Cache>(Filepath::from_locale_string(":memory:"), c);
+}
+
 void Cache::set_pragmas()
 {
 	std::lock_guard<std::recursive_mutex> lock(mtx);
diff --git a/test/cache.cpp b/test/cache.cpp
index 8fea3463..80d931a4 100644
--- a/test/cache.cpp
+++ b/test/cache.cpp
@@ -19,17 +19,17 @@ using namespace newsboat;
 TEST_CASE("items in search result can be marked read", "[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	const std::string uri = "file://data/rss.xml";
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-	RssParser parser(uri, rsscache, cfg, nullptr);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+	RssParser parser(uri, *rsscache, cfg, nullptr);
 	auto feed = parser.parse(feed_retriever.retrieve(uri));
 	REQUIRE(feed->total_item_count() == 8);
-	rsscache.externalize_rssfeed(*feed, false);
+	rsscache->externalize_rssfeed(*feed, false);
 
 	RssIgnores ign;
-	auto search_items = rsscache.search_for_items("Botox", "", ign);
+	auto search_items = rsscache->search_for_items("Botox", "", ign);
 	REQUIRE(search_items.size() == 1);
 	auto item = search_items.front();
 	REQUIRE(item->unread());
@@ -37,7 +37,7 @@ TEST_CASE("items in search result can be marked read", "[Cache]")
 	item->set_unread(false);
 	search_items.clear();
 
-	search_items = rsscache.search_for_items("Botox", "", ign);
+	search_items = rsscache->search_for_items("Botox", "", ign);
 	REQUIRE(search_items.size() == 1);
 	auto updatedItem = search_items.front();
 	REQUIRE_FALSE(updatedItem->unread());
@@ -160,9 +160,9 @@ TEST_CASE("mark_all_read marks all items in the feed read", "[Cache]")
 	std::shared_ptr<RssFeed> feed, test_feed;
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
-	test_feed = std::make_shared<RssFeed>(&rsscache, "");
+	test_feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	test_feed->set_title("Test feed");
 	auto test_feed_url = "http://example.com/atom.xml";
 	test_feed->set_link(test_feed_url);
@@ -177,22 +177,22 @@ TEST_CASE("mark_all_read marks all items in the feed read", "[Cache]")
 	 * externalize them (put into Cache). */
 	for (const auto& feed_data : feeds) {
 		CurlHandle easyHandle;
-		FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-		RssParser parser(feed_data.first, rsscache, cfg, nullptr);
+		FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+		RssParser parser(feed_data.first, *rsscache, cfg, nullptr);
 		feed = parser.parse(feed_retriever.retrieve(feed_data.first));
 		REQUIRE(feed->total_item_count() == feed_data.second);
 
 		test_feed->add_item(feed->items()[0]);
 
-		rsscache.externalize_rssfeed(*feed, false);
+		rsscache->externalize_rssfeed(*feed, false);
 	}
 
 	SECTION("empty feedurl") {
 		INFO("All items should be marked as read.");
-		rsscache.mark_all_read();
+		rsscache->mark_all_read();
 
 		for (const auto& feed_data : feeds) {
-			feed = rsscache.internalize_rssfeed(
+			feed = rsscache->internalize_rssfeed(
 					feed_data.first, nullptr);
 			for (const auto& item : feed->items()) {
 				REQUIRE_FALSE(item->unread());
@@ -203,16 +203,16 @@ TEST_CASE("mark_all_read marks all items in the feed read", "[Cache]")
 	SECTION("non-empty feedurl") {
 		INFO("All items with particular feedurl should be marked as "
 			"read");
-		rsscache.mark_all_read(feeds[0].first);
+		rsscache->mark_all_read(feeds[0].first);
 
 		INFO("First feed should all be marked read");
-		feed = rsscache.internalize_rssfeed(feeds[0].first, nullptr);
+		feed = rsscache->internalize_rssfeed(feeds[0].first, nullptr);
 		for (const auto& item : feed->items()) {
 			REQUIRE_FALSE(item->unread());
 		}
 
 		INFO("Second feed should all be marked unread");
-		feed = rsscache.internalize_rssfeed(feeds[1].first, nullptr);
+		feed = rsscache->internalize_rssfeed(feeds[1].first, nullptr);
 		for (const auto& item : feed->items()) {
 			REQUIRE(item->unread());
 		}
@@ -221,8 +221,8 @@ TEST_CASE("mark_all_read marks all items in the feed read", "[Cache]")
 	SECTION("actual feed") {
 		INFO("All items that are in the specific feed should be marked "
 			"as read");
-		rsscache.externalize_rssfeed(*test_feed, false);
-		rsscache.mark_all_read(*test_feed);
+		rsscache->externalize_rssfeed(*test_feed, false);
+		rsscache->mark_all_read(*test_feed);
 
 		/* Since test_feed contains the first item of each feed, only
 		 * these two items should be marked read. */
@@ -237,14 +237,14 @@ TEST_CASE("mark_all_read marks all items in the feed read", "[Cache]")
 		};
 
 		{
-			feed = rsscache.internalize_rssfeed(
+			feed = rsscache->internalize_rssfeed(
 					test_feed_url, nullptr);
 			INFO("Test feed should all be marked read");
 			REQUIRE(unread_items_count(feed) == 0);
 		}
 
 		{
-			feed = rsscache.internalize_rssfeed(
+			feed = rsscache->internalize_rssfeed(
 					feeds[0].first, nullptr);
 			INFO("First feed should have just one item read");
 			REQUIRE(unread_items_count(feed) ==
@@ -252,7 +252,7 @@ TEST_CASE("mark_all_read marks all items in the feed read", "[Cache]")
 		}
 
 		{
-			feed = rsscache.internalize_rssfeed(
+			feed = rsscache->internalize_rssfeed(
 					feeds[1].first, nullptr);
 			INFO("Second feed should have just one item read");
 			REQUIRE(unread_items_count(feed) ==
@@ -383,20 +383,20 @@ TEST_CASE(
 TEST_CASE("fetch_descriptions fills out feed item's descriptions", "[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	const auto feedurl = "file://data/rss.xml";
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-	RssParser parser(feedurl, rsscache, cfg, nullptr);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+	RssParser parser(feedurl, *rsscache, cfg, nullptr);
 	auto feed = parser.parse(feed_retriever.retrieve(feedurl));
 
-	rsscache.externalize_rssfeed(*feed, false);
+	rsscache->externalize_rssfeed(*feed, false);
 
 	for (auto& item : feed->items()) {
 		item->set_description("your test failed!", "text/plain");
 	}
 
-	REQUIRE_NOTHROW(rsscache.fetch_descriptions(feed.get()));
+	REQUIRE_NOTHROW(rsscache->fetch_descriptions(feed.get()));
 
 	for (auto& item : feed->items()) {
 		REQUIRE(item->description().text != "your test failed!");
@@ -533,11 +533,11 @@ TEST_CASE(
 	"[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	auto feedurl = "file://data/rss.xml";
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-	RssParser parser(feedurl, rsscache, cfg, nullptr);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+	RssParser parser(feedurl, *rsscache, cfg, nullptr);
 	auto feed = parser.parse(feed_retriever.retrieve(feedurl));
 
 	REQUIRE(feed->total_item_count() == 8);
@@ -549,10 +549,10 @@ TEST_CASE(
 		feed->items()[2]->guid(), feed->items()[5]->guid()
 	};
 
-	rsscache.externalize_rssfeed(*feed, false);
+	rsscache->externalize_rssfeed(*feed, false);
 
 	for (const auto& guid : should_be_absent) {
-		rsscache.mark_item_deleted(guid, true);
+		rsscache->mark_item_deleted(guid, true);
 	}
 
 	std::vector<std::shared_ptr<RssItem>> remaining_items;
@@ -567,17 +567,17 @@ TEST_CASE(
 		}
 	}
 	feed->set_items(remaining_items);
-	REQUIRE_NOTHROW(rsscache.remove_old_deleted_items(feed.get()));
+	REQUIRE_NOTHROW(rsscache->remove_old_deleted_items(feed.get()));
 
 	// Trying to "undelete" items
 	for (const auto& guid : should_be_absent) {
-		rsscache.mark_item_deleted(guid, false);
+		rsscache->mark_item_deleted(guid, false);
 	}
 	for (const auto& guid : should_be_present) {
-		rsscache.mark_item_deleted(guid, false);
+		rsscache->mark_item_deleted(guid, false);
 	}
 
-	feed = rsscache.internalize_rssfeed(feedurl, nullptr);
+	feed = rsscache->internalize_rssfeed(feedurl, nullptr);
 	// Two items should've been removed by remove_old_deleted_items
 	REQUIRE(feed->total_item_count() == 6);
 }
@@ -586,17 +586,17 @@ TEST_CASE("search_for_items finds all items with matching title or content",
 	"[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	std::vector<std::string> feedurls = {
 		"file://data/atom10_1.xml", "file://data/rss20_1.xml"
 	};
 	for (const auto& url : feedurls) {
 		CurlHandle easyHandle;
-		FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-		RssParser parser(url, rsscache, cfg, nullptr);
+		FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+		RssParser parser(url, *rsscache, cfg, nullptr);
 		auto feed = parser.parse(feed_retriever.retrieve(url));
 
-		rsscache.externalize_rssfeed(*feed, false);
+		rsscache->externalize_rssfeed(*feed, false);
 	}
 
 	auto query = "content";
@@ -604,17 +604,17 @@ TEST_CASE("search_for_items finds all items with matching title or content",
 
 	RssIgnores ign;
 	SECTION("Search the whole DB") {
-		REQUIRE_NOTHROW(items = rsscache.search_for_items(query, "", ign));
+		REQUIRE_NOTHROW(items = rsscache->search_for_items(query, "", ign));
 		REQUIRE(items.size() == 4);
 	}
 
 	SECTION("Search specific feed") {
 		REQUIRE_NOTHROW(
-			items = rsscache.search_for_items(query, feedurls[0], ign));
+			items = rsscache->search_for_items(query, feedurls[0], ign));
 		REQUIRE(items.size() == 3);
 
 		REQUIRE_NOTHROW(
-			items = rsscache.search_for_items(query, feedurls[1], ign));
+			items = rsscache->search_for_items(query, feedurls[1], ign));
 		REQUIRE(items.size() == 1);
 	}
 }
@@ -863,9 +863,9 @@ TEST_CASE(
 	"[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	auto feedurl = "query:misc:age between 0:10";
-	auto feed = rsscache.internalize_rssfeed(feedurl, nullptr);
+	auto feed = rsscache->internalize_rssfeed(feedurl, nullptr);
 
 	REQUIRE(feed->total_item_count() == 0);
 	REQUIRE(feed->rssurl() == feedurl);
@@ -875,22 +875,22 @@ TEST_CASE("internalize_rssfeed doesn't return items that are ignored",
 	"[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const std::string feedurl("file://data/rss092_1.xml");
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-	RssParser parser(feedurl, rsscache, cfg, nullptr);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+	RssParser parser(feedurl, *rsscache, cfg, nullptr);
 	auto feed = parser.parse(feed_retriever.retrieve(feedurl));
 	REQUIRE(feed->total_item_count() == 3);
-	rsscache.externalize_rssfeed(*feed, false);
+	rsscache->externalize_rssfeed(*feed, false);
 
 	RssIgnores ign;
 	ign.handle_action("ignore-article", {"*", "title =~ \"third\""});
 
-	feed = rsscache.internalize_rssfeed(feedurl, nullptr);
+	feed = rsscache->internalize_rssfeed(feedurl, nullptr);
 	REQUIRE(feed->total_item_count() == 3);
-	feed = rsscache.internalize_rssfeed(feedurl, &ign);
+	feed = rsscache->internalize_rssfeed(feedurl, &ign);
 	REQUIRE(feed->total_item_count() == 2);
 }
 
@@ -1050,14 +1050,14 @@ TEST_CASE("search_in_items returns items that contain given substring",
 	"[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	const std::string uri = "file://data/rss.xml";
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-	RssParser parser(uri, rsscache, cfg, nullptr);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+	RssParser parser(uri, *rsscache, cfg, nullptr);
 	auto feed = parser.parse(feed_retriever.retrieve(uri));
 	REQUIRE(feed->total_item_count() == 8);
-	rsscache.externalize_rssfeed(*feed, false);
+	rsscache->externalize_rssfeed(*feed, false);
 
 	using guids = std::unordered_set<std::string>;
 
@@ -1080,7 +1080,7 @@ TEST_CASE("search_in_items returns items that contain given substring",
 	}
 
 	const guids with_botox =
-		rsscache.search_in_items("Botox", guids_from_feed);
+		rsscache->search_in_items("Botox", guids_from_feed);
 	for (const auto& guid : with_botox) {
 		INFO("Checking GUID " << guid);
 		REQUIRE_FALSE(
@@ -1093,37 +1093,37 @@ TEST_CASE("search_in_items returns items that contain given substring",
 TEST_CASE("search_in_items returns empty set if input set is empty", "[Cache]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	const std::string uri = "file://data/rss.xml";
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-	RssParser parser(uri, rsscache, cfg, nullptr);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+	RssParser parser(uri, *rsscache, cfg, nullptr);
 	auto feed = parser.parse(feed_retriever.retrieve(uri));
-	rsscache.externalize_rssfeed(*feed, false);
+	rsscache->externalize_rssfeed(*feed, false);
 
 	using guids = std::unordered_set<std::string>;
 	std::unordered_set<std::string> empty;
-	const guids result = rsscache.search_in_items("Botox", empty);
+	const guids result = rsscache->search_in_items("Botox", empty);
 	REQUIRE(result.empty());
 }
 
 TEST_CASE("Ignoring articles in search", "[Cache]")
 {
 	ConfigContainer cfg{};
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const std::string uri = "file://data/rss.xml";
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
-	RssParser parser(uri, rsscache, cfg, nullptr);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
+	RssParser parser(uri, *rsscache, cfg, nullptr);
 	auto feed = parser.parse(feed_retriever.retrieve(uri));
 	REQUIRE(feed->total_item_count() == 8);
-	rsscache.externalize_rssfeed(*feed, false);
+	rsscache->externalize_rssfeed(*feed, false);
 
 	RssIgnores ign, empty_ign;
 	ign.handle_action("ignore-article", {"*", "title =~ \"Botox\""});
-	auto search_items = rsscache.search_for_items("Botox", "", ign);
-	auto no_ignore_items = rsscache.search_for_items("Botox", "", empty_ign);
+	auto search_items = rsscache->search_for_items("Botox", "", ign);
+	auto no_ignore_items = rsscache->search_for_items("Botox", "", empty_ign);
 
 	REQUIRE(search_items.size() == 0 );
 	REQUIRE(no_ignore_items.size() == 1);
diff --git a/test/controller.cpp b/test/controller.cpp
index c1a9785e..fae82e3a 100644
--- a/test/controller.cpp
+++ b/test/controller.cpp
@@ -33,10 +33,10 @@ TEST_CASE("write_item correctly parses path", "[Controller]")
 
 	auto cfg = c.get_config();
 	cfg->set_configvalue("save-path", save_path);
-	Cache rsscache(":memory:", *cfg);
+	auto rsscache = Cache::in_memory(*cfg);
 
 
-	RssItem item(&rsscache);
+	RssItem item(rsscache.get());
 	item.set_title("title");
 	const auto description = "First line.\nSecond one.\nAnd finally the third";
 	item.set_description(description, "text/plain");
diff --git a/test/feedcontainer.cpp b/test/feedcontainer.cpp
index 880fc677..87276622 100644
--- a/test/feedcontainer.cpp
+++ b/test/feedcontainer.cpp
@@ -1,5 +1,3 @@
-#define ENABLE_IMPLICIT_FILEPATH_CONVERSIONS
-
 #include "3rd-party/catch.hpp"
 
 #include <memory>
@@ -32,13 +30,13 @@ TEST_CASE("get_feed() returns feed by its position number", "[FeedContainer]")
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	const std::vector<std::shared_ptr<RssFeed>> feeds = {
-		std::make_shared<RssFeed>(&rsscache, "url/0"),
-		std::make_shared<RssFeed>(&rsscache, "url/1"),
-		std::make_shared<RssFeed>(&rsscache, "url/2"),
-		std::make_shared<RssFeed>(&rsscache, "url/3"),
-		std::make_shared<RssFeed>(&rsscache, "url/4")
+		std::make_shared<RssFeed>(rsscache.get(), "url/0"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/1"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/2"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/3"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/4")
 	};
 	int i = 0;
 	for (const auto& feed : feeds) {
@@ -59,8 +57,8 @@ TEST_CASE("get_all_feeds() returns copy of FeedContainer's feed vector",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
 	REQUIRE(feedcontainer.get_all_feeds() == feeds);
@@ -71,9 +69,9 @@ TEST_CASE("add_feed() adds specific feed to its \"feeds\" vector",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	feedcontainer.set_feeds({});
-	const auto feed = std::make_shared<RssFeed>(&rsscache, "");
+	const auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	feed->set_title("Example feed");
 
 	feedcontainer.add_feed(feed);
@@ -85,15 +83,15 @@ TEST_CASE("populate_query_feeds() populates query feeds", "[FeedContainer]")
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	auto feeds = get_five_empty_feeds(rsscache.get());
 	for (int j = 0; j < 5; ++j) {
-		const auto item = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread_nowrite(true);
 		feeds[j]->add_item(item);
 	}
 
-	const auto feed = std::make_shared<RssFeed>(&rsscache,
+	const auto feed = std::make_shared<RssFeed>(rsscache.get(),
 			"query:a title:unread = \"yes\"");
 	feeds.push_back(feed);
 
@@ -108,8 +106,8 @@ TEST_CASE("set_feeds() sets FeedContainer's feed vector to the given one",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 
 	feedcontainer.set_feeds(feeds);
 
@@ -120,13 +118,13 @@ TEST_CASE("get_feed_by_url() returns feed by its URL", "[FeedContainer]")
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	const std::vector<std::shared_ptr<RssFeed>> feeds = {
-		std::make_shared<RssFeed>(&rsscache, "url/0"),
-		std::make_shared<RssFeed>(&rsscache, "url/1"),
-		std::make_shared<RssFeed>(&rsscache, "url/2"),
-		std::make_shared<RssFeed>(&rsscache, "url/3"),
-		std::make_shared<RssFeed>(&rsscache, "url/4")
+		std::make_shared<RssFeed>(rsscache.get(), "url/0"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/1"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/2"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/3"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/4")
 	};
 	int i = 0;
 	for (const auto& feed : feeds) {
@@ -149,11 +147,11 @@ TEST_CASE(
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	const std::vector<std::shared_ptr<RssFeed>> feeds = {
-		std::make_shared<RssFeed>(&rsscache, "url/0"),
-		std::make_shared<RssFeed>(&rsscache, "url/1"),
-		std::make_shared<RssFeed>(&rsscache, "url/2"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/0"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/1"),
+		std::make_shared<RssFeed>(rsscache.get(), "url/2"),
 	};
 	feedcontainer.set_feeds(feeds);
 
@@ -166,8 +164,8 @@ TEST_CASE("get_feed() returns nullptr if pos is out of range",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	feedcontainer.set_feeds(get_five_empty_feeds(&rsscache));
+	auto rsscache = Cache::in_memory(cfg);
+	feedcontainer.set_feeds(get_five_empty_feeds(rsscache.get()));
 
 	REQUIRE_NOTHROW(feedcontainer.get_feed(4));
 	REQUIRE(feedcontainer.get_feed(5) == nullptr);
@@ -179,8 +177,8 @@ TEST_CASE("Returns correct number using get_feed_count_by_tag()",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	feedcontainer.set_feeds(get_five_empty_feeds(&rsscache));
+	auto rsscache = Cache::in_memory(cfg);
+	feedcontainer.set_feeds(get_five_empty_feeds(rsscache.get()));
 	feedcontainer.get_feed(0)->set_tags({"Chicken", "Horse"});
 	feedcontainer.get_feed(1)->set_tags({"Horse", "Duck"});
 	feedcontainer.get_feed(2)->set_tags({"Duck", "Frog"});
@@ -196,11 +194,11 @@ TEST_CASE("Correctly returns pos of next unread item", "[FeedContainer]")
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	int i = 0;
 	for (const auto& feed : feeds) {
-		const auto item = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
 		if ((i % 2) == 0) {
 			item->set_unread_nowrite(true);
 		} else {
@@ -220,8 +218,8 @@ TEST_CASE("feeds_size() returns FeedContainer's current feed vector size",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
 	REQUIRE(feedcontainer.feeds_size() == feeds.size());
@@ -233,8 +231,8 @@ TEST_CASE("sort_feeds() sorts by position in urls file if `feed-sort-order` "
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
 	feeds[0]->set_order(4);
@@ -272,8 +270,8 @@ TEST_CASE("sort_feeds() sorts by feed's first tag if `feed-sort-order` "
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
 	feeds[0]->set_tags({"tag1"});
@@ -311,8 +309,8 @@ TEST_CASE("sort_feeds() sorts by feed's title if `feed-sort-order` "
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
 	feeds[0]->set_title("tag1");
@@ -350,17 +348,17 @@ TEST_CASE("sort_feeds() sorts by number of articles in a feed "
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
-	feeds[0]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[0]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[1]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[1]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[1]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[2]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[3]->add_item(std::make_shared<RssItem>(&rsscache));
+	feeds[0]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[0]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[1]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[1]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[1]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[2]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[3]->add_item(std::make_shared<RssItem>(rsscache.get()));
 
 	SECTION("`articlecount-asc` -- feed with most items is at the top") {
 		cfg.set_configvalue("feed-sort-order", "articlecount-asc");
@@ -389,7 +387,7 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by unread articles"
 	"[FeedContainer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const std::map<std::string, int> name_to_unreads = {
 		{"a", 3}, {"b", 2}, {"c", 1}, {"d", 1}, {"e", 1}
@@ -397,10 +395,10 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by unread articles"
 
 	std::vector<std::shared_ptr<RssFeed>> feeds;
 	for (const auto& entry : name_to_unreads) {
-		const auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		const auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_title(entry.first);
 		for (int i = 0; i < entry.second; ++i) {
-			feed->add_item(std::make_shared<RssItem>(&rsscache));
+			feed->add_item(std::make_shared<RssItem>(rsscache.get()));
 		}
 		feeds.push_back(feed);
 	}
@@ -443,7 +441,7 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by unread articles"
 TEST_CASE("sort_feeds() and keep in-group order when sorting by order", "[FeedContainer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const std::map<std::string, int> name_to_order = {
 		{"a", 3}, {"b", 2}, {"c", 1}, {"d", 1}, {"e", 1}
@@ -451,7 +449,7 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by order", "[FeedCo
 
 	std::vector<std::shared_ptr<RssFeed>> feeds;
 	for (const auto& entry : name_to_order) {
-		const auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		const auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_title(entry.first);
 		feed->set_order(entry.second);
 		feeds.push_back(feed);
@@ -496,7 +494,7 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by articles",
 	"[FeedContainer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const std::map<std::string, int> name_to_articles = {
 		{"a", 3}, {"b", 2}, {"c", 1}, {"d", 1}, {"e", 1}
@@ -504,10 +502,10 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by articles",
 
 	std::vector<std::shared_ptr<RssFeed>> feeds;
 	for (const auto& entry : name_to_articles) {
-		const auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		const auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_title(entry.first);
 		for (int i=0; i<entry.second; ++i) {
-			feed->add_item(std::make_shared<RssItem>(&rsscache));
+			feed->add_item(std::make_shared<RssItem>(rsscache.get()));
 		}
 		feeds.push_back(feed);
 	}
@@ -551,7 +549,7 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by last updated ite
 	"[FeedContainer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const std::map<std::string, int> name_to_date = {
 		{"a", 3}, {"b", 2}, {"c", 1}, {"d", 1}, {"e", 1}
@@ -559,9 +557,9 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by last updated ite
 
 	std::vector<std::shared_ptr<RssFeed>> feeds;
 	for (const auto& entry : name_to_date) {
-		const auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		const auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_title(entry.first);
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_pubDate(entry.second);
 		feed->add_item(item);
 		feeds.push_back(feed);
@@ -606,7 +604,7 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by title",
 	"[FeedContainer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const std::map<std::string, std::string> url_to_title = {
 		{"1", "c"}, {"2", "b"}, {"3", "a"}, {"4", "a"}, {"5", "a"}
@@ -614,7 +612,7 @@ TEST_CASE("sort_feeds() and keep in-group order when sorting by title",
 
 	std::vector<std::shared_ptr<RssFeed>> feeds;
 	for (const auto& entry : url_to_title) {
-		const auto feed = std::make_shared<RssFeed>(&rsscache, entry.first);
+		const auto feed = std::make_shared<RssFeed>(rsscache.get(), entry.first);
 		feed->set_title(entry.second);
 		feeds.push_back(feed);
 	}
@@ -660,26 +658,26 @@ TEST_CASE("sort_feeds() sorts by number of unread articles if `feed-sort-order`
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
-	feeds[0]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[0]->add_item(std::make_shared<RssItem>(&rsscache));
+	feeds[0]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[0]->add_item(std::make_shared<RssItem>(rsscache.get()));
 
-	auto item = std::make_shared<RssItem>(&rsscache);
+	auto item = std::make_shared<RssItem>(rsscache.get());
 	item->set_unread_nowrite(false);
 	feeds[1]->add_item(item);
-	feeds[1]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[1]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[1]->add_item(std::make_shared<RssItem>(&rsscache));
+	feeds[1]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[1]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[1]->add_item(std::make_shared<RssItem>(rsscache.get()));
 
-	feeds[2]->add_item(std::make_shared<RssItem>(&rsscache));
-	feeds[2]->add_item(std::make_shared<RssItem>(&rsscache));
+	feeds[2]->add_item(std::make_shared<RssItem>(rsscache.get()));
+	feeds[2]->add_item(std::make_shared<RssItem>(rsscache.get()));
 
-	feeds[3]->add_item(std::make_shared<RssItem>(&rsscache));
+	feeds[3]->add_item(std::make_shared<RssItem>(rsscache.get()));
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_unread_nowrite(false);
 	feeds[4]->add_item(item);
 
@@ -714,27 +712,27 @@ TEST_CASE("sort_feeds() sorts by publish date of newest item "
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
-	auto item = std::make_shared<RssItem>(&rsscache);
+	auto item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(93);
 	feeds[0]->add_item(item);
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(42);
 	feeds[1]->add_item(item);
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(69);
 	feeds[2]->add_item(item);
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(23);
 	feeds[3]->add_item(item);
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(1);
 	feeds[4]->add_item(item);
 
@@ -765,8 +763,8 @@ TEST_CASE("Sorting by firsttag-asc puts empty tags on top", "[FeedContainer]")
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
 	feeds[0]->set_tags({""});
@@ -803,23 +801,23 @@ TEST_CASE("Sorting by lastupdated-asc puts empty feeds on top",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
-	auto item = std::make_shared<RssItem>(&rsscache);
+	auto item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(93);
 	feeds[0]->add_item(item);
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(42);
 	feeds[1]->add_item(item);
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(69);
 	feeds[2]->add_item(item);
 
-	item = std::make_shared<RssItem>(&rsscache);
+	item = std::make_shared<RssItem>(rsscache.get());
 	item->set_pubDate(23);
 	feeds[3]->add_item(item);
 
@@ -853,8 +851,8 @@ TEST_CASE("Sorting by firsttag-asc reverses the order of feeds with the same fir
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feedcontainer.set_feeds(feeds);
 
 	feeds[0]->set_tags({""});
@@ -891,11 +889,11 @@ TEST_CASE("mark_all_feed_items_read() marks all of feed's items as read",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	const auto feed = feeds.at(0);
 	for (int j = 0; j < 5; ++j) {
-		const auto item = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread_nowrite(true);
 		feed->add_item(item);
 	}
@@ -913,12 +911,12 @@ TEST_CASE("mark_all_feeds_read() marks all items in all feeds as read",
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 
 	for (const auto& feed : feeds) {
 		for (int j = 0; j < 3; ++j) {
-			const auto item = std::make_shared<RssItem>(&rsscache);
+			const auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_unread_nowrite(true);
 			feed->add_item(item);
 		}
@@ -941,8 +939,8 @@ TEST_CASE(
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	feeds[0]->set_status(DlStatus::SUCCESS);
 	feeds[1]->set_status(DlStatus::TO_BE_DOWNLOADED);
 	feeds[2]->set_status(DlStatus::DURING_DOWNLOAD);
@@ -963,12 +961,12 @@ TEST_CASE(
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 	for (int j = 0; j < 5; ++j) {
 		// Make sure that number of unread items in feed doesn't matter
-		const auto item = std::make_shared<RssItem>(&rsscache);
-		const auto item2 = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
+		const auto item2 = std::make_shared<RssItem>(rsscache.get());
 		if ((j % 2) == 0) {
 			item->set_unread_nowrite(false);
 			item2->set_unread_nowrite(false);
@@ -987,14 +985,14 @@ TEST_CASE("unread_item_count() returns number of distinct unread items "
 {
 	FeedContainer feedcontainer;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	SECTION("No query feeds") {
-		const auto feeds = get_five_empty_feeds(&rsscache);
+		const auto feeds = get_five_empty_feeds(rsscache.get());
 		for (int j = 0; j < 5; ++j) {
-			const auto item = std::make_shared<RssItem>(&rsscache);
+			const auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_guid(std::to_string(j) + "item1");
-			const auto item2 = std::make_shared<RssItem>(&rsscache);
+			const auto item2 = std::make_shared<RssItem>(rsscache.get());
 			item2->set_guid(std::to_string(j) + "item2");
 			if ((j % 2) == 0) {
 				item->set_unread_nowrite(false);
@@ -1011,22 +1009,22 @@ TEST_CASE("unread_item_count() returns number of distinct unread items "
 	SECTION("Query feeds do not affect the total count") {
 		// This is a regression test for https://github.com/newsboat/newsboat/issues/1120
 
-		auto feeds = get_five_empty_feeds(&rsscache);
+		auto feeds = get_five_empty_feeds(rsscache.get());
 
-		auto query1 = std::make_shared<RssFeed>(&rsscache,
+		auto query1 = std::make_shared<RssFeed>(rsscache.get(),
 				"query:Title contains word:title # \"word\"");
-		auto query2 = std::make_shared<RssFeed>(&rsscache,
+		auto query2 = std::make_shared<RssFeed>(rsscache.get(),
 				"query:Posts by John Doe:author = \"John Doe\"");
 
 		feeds.push_back(query1);
 		feeds.push_back(query2);
 
 		for (int j = 0; j < 5; ++j) {
-			const auto item = std::make_shared<RssItem>(&rsscache);
+			const auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_title("All titles contain word");
 			item->set_author("John Doe");
 			item->set_guid(std::to_string(j) + "item1");
-			const auto item2 = std::make_shared<RssItem>(&rsscache);
+			const auto item2 = std::make_shared<RssItem>(rsscache.get());
 			item2->set_title("All titles contain word");
 			item2->set_author("John Doe");
 			item2->set_guid(std::to_string(j) + "item2");
@@ -1047,12 +1045,12 @@ TEST_CASE("unread_item_count() returns number of distinct unread items "
 	SECTION("Items in hidden feeds are not counted") {
 		// This is a regression test for https://github.com/newsboat/newsboat/issues/444
 
-		auto feeds = get_five_empty_feeds(&rsscache);
+		auto feeds = get_five_empty_feeds(rsscache.get());
 
 		// First feed is hidden and contains five unread items
 		feeds[0]->set_tags({"!hidden"});
 		for (int i = 0; i < 5; ++i) {
-			const auto item = std::make_shared<RssItem>(&rsscache);
+			const auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_guid(std::to_string(i) + "feed1");
 			item->set_unread(true);
 			feeds[0]->add_item(item);
@@ -1060,7 +1058,7 @@ TEST_CASE("unread_item_count() returns number of distinct unread items "
 
 		// Second feed is **not** hidden and contains two unread items
 		for (int i = 0; i < 2; ++i) {
-			const auto item = std::make_shared<RssItem>(&rsscache);
+			const auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_guid(std::to_string(i) + "feed2");
 			item->set_unread(true);
 			feeds[1]->add_item(item);
@@ -1068,7 +1066,7 @@ TEST_CASE("unread_item_count() returns number of distinct unread items "
 
 		// Third feed contains three read items -- they shouldn't affect the count
 		for (int i = 0; i < 3; ++i) {
-			const auto item = std::make_shared<RssItem>(&rsscache);
+			const auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_guid(std::to_string(i) + "feed3");
 			item->set_unread(false);
 			feeds[2]->add_item(item);
@@ -1080,7 +1078,7 @@ TEST_CASE("unread_item_count() returns number of distinct unread items "
 		REQUIRE(feedcontainer.unread_item_count() == 2);
 
 		SECTION("...unless they are also in some query feed(s)") {
-			const auto query_feed = std::make_shared<RssFeed>(&rsscache,
+			const auto query_feed = std::make_shared<RssFeed>(rsscache.get(),
 					"query:Posts from the hidden feed:guid =~ \".*feed1\"");
 			feeds.push_back(query_feed);
 			feedcontainer.set_feeds(feeds);
@@ -1106,11 +1104,11 @@ TEST_CASE("get_unread_feed_count_per_tag returns 0 if there are no feeds "
 
 	SECTION("Non-empty FeedContainer, but no feeds are tagged") {
 		ConfigContainer cfg;
-		Cache rsscache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		feedcontainer.add_feed(std::make_shared<RssFeed>(&rsscache, ""));
-		feedcontainer.add_feed(std::make_shared<RssFeed>(&rsscache, ""));
-		feedcontainer.add_feed(std::make_shared<RssFeed>(&rsscache, ""));
+		feedcontainer.add_feed(std::make_shared<RssFeed>(rsscache.get(), ""));
+		feedcontainer.add_feed(std::make_shared<RssFeed>(rsscache.get(), ""));
+		feedcontainer.add_feed(std::make_shared<RssFeed>(rsscache.get(), ""));
 
 		REQUIRE(feedcontainer.get_unread_feed_count_per_tag("unknown") == 0);
 		REQUIRE(feedcontainer.get_unread_feed_count_per_tag("test") == 0);
@@ -1119,17 +1117,17 @@ TEST_CASE("get_unread_feed_count_per_tag returns 0 if there are no feeds "
 
 	SECTION("Non-empty FeedContainer, no feeds are tagged with our desired tag") {
 		ConfigContainer cfg;
-		Cache rsscache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_tags({"one", "two", "three"});
 		feedcontainer.add_feed(feed);
 
-		feed = std::make_shared<RssFeed>(&rsscache, "");
+		feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_tags({"some", "different", "tags"});
 		feedcontainer.add_feed(feed);
 
-		feed = std::make_shared<RssFeed>(&rsscache, "");
+		feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_tags({"here's one with spaces"});
 		feedcontainer.add_feed(feed);
 
@@ -1146,29 +1144,29 @@ TEST_CASE("get_unread_feed_count_per_tag returns 0 if feeds with given tag "
 	FeedContainer feedcontainer;
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const auto desired_tag = std::string("target");
 	const auto different_tag = std::string("something else entirely");
 
-	auto feed = std::make_shared<RssFeed>(&rsscache, "");
+	auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	feed->set_tags({desired_tag});
 	for (int i = 0; i < 10; ++i) {
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread(false);
 		feed->add_item(item);
 	}
 	feedcontainer.add_feed(feed);
 
-	feed = std::make_shared<RssFeed>(&rsscache, "");
+	feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	feed->set_tags({different_tag});
 	for (int i = 0; i < 5; ++i) {
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread(true);
 		feed->add_item(item);
 	}
 	for (int i = 0; i < 5; ++i) {
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread(false);
 		feed->add_item(item);
 	}
@@ -1184,7 +1182,7 @@ TEST_CASE("get_unread_feed_count_per_tag returns the number of feeds that have "
 	FeedContainer feedcontainer;
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const auto desired_tag = std::string("target");
 	const auto different_tag = std::string("something else entirely");
@@ -1192,17 +1190,17 @@ TEST_CASE("get_unread_feed_count_per_tag returns the number of feeds that have "
 	const auto add_feed_with_tag_and_unreads =
 		[&feedcontainer, &rsscache]
 	(std::string tag, unsigned int unreads) {
-		auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
 		feed->set_tags({tag});
 
 		for (unsigned int i = 0; i < unreads; ++i) {
-			auto item = std::make_shared<RssItem>(&rsscache);
+			auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_unread(true);
 			feed->add_item(item);
 		}
 		for (int i = 0; i < 10; ++i) {
-			auto item = std::make_shared<RssItem>(&rsscache);
+			auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_unread(false);
 			feed->add_item(item);
 		}
@@ -1253,11 +1251,11 @@ TEST_CASE("get_unread_item_count_per_tag returns 0 if there are no feeds "
 
 	SECTION("Non-empty FeedContainer, but no feeds are tagged") {
 		ConfigContainer cfg;
-		Cache rsscache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		feedcontainer.add_feed(std::make_shared<RssFeed>(&rsscache, ""));
-		feedcontainer.add_feed(std::make_shared<RssFeed>(&rsscache, ""));
-		feedcontainer.add_feed(std::make_shared<RssFeed>(&rsscache, ""));
+		feedcontainer.add_feed(std::make_shared<RssFeed>(rsscache.get(), ""));
+		feedcontainer.add_feed(std::make_shared<RssFeed>(rsscache.get(), ""));
+		feedcontainer.add_feed(std::make_shared<RssFeed>(rsscache.get(), ""));
 
 		REQUIRE(feedcontainer.get_unread_item_count_per_tag("unknown") == 0);
 		REQUIRE(feedcontainer.get_unread_item_count_per_tag("test") == 0);
@@ -1266,17 +1264,17 @@ TEST_CASE("get_unread_item_count_per_tag returns 0 if there are no feeds "
 
 	SECTION("Non-empty FeedContainer, no feeds are tagged with our desired tag") {
 		ConfigContainer cfg;
-		Cache rsscache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_tags({"one", "two", "three"});
 		feedcontainer.add_feed(feed);
 
-		feed = std::make_shared<RssFeed>(&rsscache, "");
+		feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_tags({"some", "different", "tags"});
 		feedcontainer.add_feed(feed);
 
-		feed = std::make_shared<RssFeed>(&rsscache, "");
+		feed = std::make_shared<RssFeed>(rsscache.get(), "");
 		feed->set_tags({"here's one with spaces"});
 		feedcontainer.add_feed(feed);
 
@@ -1293,29 +1291,29 @@ TEST_CASE("get_unread_item_count_per_tag returns 0 if feeds with given tag "
 	FeedContainer feedcontainer;
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const auto desired_tag = std::string("target");
 	const auto different_tag = std::string("something else entirely");
 
-	auto feed = std::make_shared<RssFeed>(&rsscache, "");
+	auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	feed->set_tags({desired_tag});
 	for (int i = 0; i < 10; ++i) {
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread(false);
 		feed->add_item(item);
 	}
 	feedcontainer.add_feed(feed);
 
-	feed = std::make_shared<RssFeed>(&rsscache, "");
+	feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	feed->set_tags({different_tag});
 	for (int i = 0; i < 5; ++i) {
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread(true);
 		feed->add_item(item);
 	}
 	for (int i = 0; i < 5; ++i) {
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_unread(false);
 		feed->add_item(item);
 	}
@@ -1331,7 +1329,7 @@ TEST_CASE("get_unread_item_count_per_tag returns the number of unread items "
 	FeedContainer feedcontainer;
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const auto desired_tag = std::string("target");
 	const auto different_tag = std::string("something else entirely");
@@ -1339,17 +1337,17 @@ TEST_CASE("get_unread_item_count_per_tag returns the number of unread items "
 	const auto add_feed_with_tag_and_unreads =
 		[&feedcontainer, &rsscache]
 	(std::string tag, unsigned int unreads) {
-		auto feed = std::make_shared<RssFeed>(&rsscache, "");
+		auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
 		feed->set_tags({tag});
 
 		for (unsigned int i = 0; i < unreads; ++i) {
-			auto item = std::make_shared<RssItem>(&rsscache);
+			auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_unread(true);
 			feed->add_item(item);
 		}
 		for (int i = 0; i < 10; ++i) {
-			auto item = std::make_shared<RssItem>(&rsscache);
+			auto item = std::make_shared<RssItem>(rsscache.get());
 			item->set_unread(false);
 			feed->add_item(item);
 		}
@@ -1392,8 +1390,8 @@ TEST_CASE("replace_feed() puts given feed into the specified position",
 	FeedContainer feedcontainer;
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	const auto feeds = get_five_empty_feeds(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	const auto feeds = get_five_empty_feeds(rsscache.get());
 
 	const auto first_feed = *feeds.begin();
 	const auto four_feeds = std::vector<std::shared_ptr<RssFeed>>(feeds.begin() + 1,
diff --git a/test/feedretriever.cpp b/test/feedretriever.cpp
index fcda39fc..0cbd1af9 100644
--- a/test/feedretriever.cpp
+++ b/test/feedretriever.cpp
@@ -1,5 +1,3 @@
-#define ENABLE_IMPLICIT_FILEPATH_CONVERSIONS
-
 #include "feedretriever.h"
 
 #include "3rd-party/catch.hpp"
@@ -21,9 +19,9 @@ TEST_CASE("Feed retriever retrieves feed successfully", "[FeedRetriever]")
 	auto feed_xml = test_helpers::read_binary_file("data/atom10_1.xml");
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	CurlHandle easyHandle;
-	FeedRetriever feedRetriever(cfg, rsscache, easyHandle);
+	FeedRetriever feedRetriever(cfg, *rsscache, easyHandle);
 
 	auto& testServer = test_helpers::HttpTestServer::get_instance();
 	auto mockRegistration = testServer.add_endpoint("/feed", {}, 200, {
@@ -41,17 +39,17 @@ TEST_CASE("Feed retriever retrieves feed successfully", "[FeedRetriever]")
 TEST_CASE("Feed retriever adds header with etag info if available", "[FeedRetriever]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	CurlHandle easyHandle;
-	FeedRetriever feedRetriever(cfg, rsscache, easyHandle);
+	FeedRetriever feedRetriever(cfg, *rsscache, easyHandle);
 
 	auto& testServer = test_helpers::HttpTestServer::get_instance();
 	const auto address = testServer.get_address();
 	const auto url = strprintf::fmt("http://%s/feed", address);
 
-	RssFeed feed_with_etag(&rsscache, url);
-	rsscache.externalize_rssfeed(feed_with_etag, false);
-	rsscache.update_lastmodified(url, {}, "some-random-etag");
+	RssFeed feed_with_etag(rsscache.get(), url);
+	rsscache->externalize_rssfeed(feed_with_etag, false);
+	rsscache->update_lastmodified(url, {}, "some-random-etag");
 
 	auto mockRegistration = testServer.add_endpoint("/feed", {
 		{"If-None-Match", "some-random-etag"},
@@ -67,9 +65,9 @@ TEST_CASE("Feed retriever retries download if no data is received",
 	"[FeedRetriever]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	CurlHandle easyHandle;
-	FeedRetriever feedRetriever(cfg, rsscache, easyHandle);
+	FeedRetriever feedRetriever(cfg, *rsscache, easyHandle);
 
 	auto& testServer = test_helpers::HttpTestServer::get_instance();
 	const auto address = testServer.get_address();
@@ -90,17 +88,17 @@ TEST_CASE("Feed retriever does not retry download on HTTP 304 (Not Modified), 42
 {
 	auto http_status = GENERATE(as<std::uint16_t> {}, 304, 429);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	CurlHandle easyHandle;
-	FeedRetriever feedRetriever(cfg, rsscache, easyHandle);
+	FeedRetriever feedRetriever(cfg, *rsscache, easyHandle);
 
 	auto& testServer = test_helpers::HttpTestServer::get_instance();
 	const auto address = testServer.get_address();
 	const auto url = strprintf::fmt("http://%s/feed", address);
 
-	RssFeed feed_with_etag(&rsscache, url);
-	rsscache.externalize_rssfeed(feed_with_etag, false);
-	rsscache.update_lastmodified(url, {}, "some-random-etag");
+	RssFeed feed_with_etag(rsscache.get(), url);
+	rsscache->externalize_rssfeed(feed_with_etag, false);
+	rsscache->update_lastmodified(url, {}, "some-random-etag");
 
 	auto mockRegistration = testServer.add_endpoint("/feed", {
 		{"If-None-Match", "some-random-etag"},
@@ -121,9 +119,9 @@ TEST_CASE("Feed retriever does not retry download on HTTP 304 (Not Modified), 42
 TEST_CASE("Feed retriever throws on HTTP error status codes", "[FeedRetriever]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	CurlHandle easyHandle;
-	FeedRetriever feedRetriever(cfg, rsscache, easyHandle);
+	FeedRetriever feedRetriever(cfg, *rsscache, easyHandle);
 
 	auto& testServer = test_helpers::HttpTestServer::get_instance();
 	const auto address = testServer.get_address();
diff --git a/test/itemlistformaction.cpp b/test/itemlistformaction.cpp
index 9f3e6aa9..2605075d 100644
--- a/test/itemlistformaction.cpp
+++ b/test/itemlistformaction.cpp
@@ -42,12 +42,12 @@ TEST_CASE("OP_OPEN displays article using an external pager",
 	FilterContainer filters;
 	RegexManager rxman;
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	cfg.set_configvalue("pager", "cat %f > " + pagerfile.get_path());
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	item->set_title(test_title);
 	item->set_author(test_author);
@@ -59,7 +59,7 @@ TEST_CASE("OP_OPEN displays article using an external pager",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 
 	const std::vector<std::string> args;
@@ -80,17 +80,17 @@ TEST_CASE("OP_PURGE_DELETED purges previously deleted items",
 	Controller c(paths);
 	newsboat::View v(&c);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	feed->add_item(item);
 
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 
 	SECTION("No items to purge") {
@@ -122,12 +122,12 @@ TEST_CASE(
 	ConfigContainer cfg;
 	cfg.set_configvalue("browser", "echo %u >> " + browserfile.get_path());
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	item->set_unread(true);
 	feed->add_item(item);
@@ -135,7 +135,7 @@ TEST_CASE(
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 	const std::vector<std::string> args;
 	itemlist.process_op(OP_OPENBROWSER_AND_MARK, args);
@@ -160,12 +160,12 @@ TEST_CASE(
 	ConfigContainer cfg;
 	cfg.set_configvalue("browser", "false %u");
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	item->set_unread(true);
 	feed->add_item(item);
@@ -173,7 +173,7 @@ TEST_CASE(
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 	const std::vector<std::string> args;
 	itemlist.process_op(OP_OPENBROWSER_AND_MARK, args);
@@ -194,19 +194,19 @@ TEST_CASE("OP_OPENINBROWSER passes the url to the browser",
 	ConfigContainer cfg;
 	cfg.set_configvalue("browser", "echo %u >> " + browserfile.get_path());
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	feed->add_item(item);
 
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 	const std::vector<std::string> args;
 	itemlist.process_op(OP_OPENINBROWSER, args);
@@ -229,19 +229,19 @@ TEST_CASE("OP_OPENINBROWSER_NONINTERACTIVE passes the url to the browser",
 	ConfigContainer cfg;
 	cfg.set_configvalue("browser", "echo %u >> " + browserfile.get_path());
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	feed->add_item(item);
 
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 	const std::vector<std::string> args;
 	itemlist.process_op(newsboat::OP_OPENINBROWSER_NONINTERACTIVE, args);
@@ -266,15 +266,15 @@ TEST_CASE("OP_OPENALLUNREADINBROWSER passes the url list to the browser",
 	ConfigContainer cfg;
 	cfg.set_configvalue("browser", "echo %u >> " + browserfile.get_path());
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
 	for (int i = 0; i < itemCount; i++) {
 		std::shared_ptr<RssItem> item =
-			std::make_shared<RssItem>(&rsscache);
+			std::make_shared<RssItem>(rsscache.get());
 		item->set_link(test_url + std::to_string(i));
 		url_set.insert(test_url + std::to_string(i));
 		item->set_unread(true);
@@ -284,7 +284,7 @@ TEST_CASE("OP_OPENALLUNREADINBROWSER passes the url list to the browser",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 
 	SECTION("unread >= max-browser-tabs") {
@@ -352,15 +352,15 @@ TEST_CASE(
 	ConfigContainer cfg;
 	cfg.set_configvalue("browser", "echo %u >> " + browserfile.get_path());
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
 	for (unsigned int i = 0; i < itemCount; i++) {
 		std::shared_ptr<RssItem> item =
-			std::make_shared<RssItem>(&rsscache);
+			std::make_shared<RssItem>(rsscache.get());
 		item->set_link(test_url + std::to_string(i));
 		url_set.insert(test_url + std::to_string(i));
 		item->set_unread(true);
@@ -370,7 +370,7 @@ TEST_CASE(
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 
 	SECTION("unread >= max-browser-tabs") {
@@ -429,7 +429,7 @@ TEST_CASE("OP_SHOWURLS shows the article's properties", "[ItemListFormAction]")
 	Controller c(paths);
 	newsboat::View v(&c);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 	test_helpers::TempFile urlFile;
@@ -448,15 +448,15 @@ TEST_CASE("OP_SHOWURLS shows the article's properties", "[ItemListFormAction]")
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 
 	item->set_link(test_url);
 	item->set_title(test_title);
 	item->set_author(test_author);
 	item->set_description(test_description, "text/plain");
 	item->set_pubDate(test_pubDate);
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 
 	SECTION("with external-url-viewer") {
 		feed->add_item(item);
@@ -495,7 +495,7 @@ TEST_CASE("OP_BOOKMARK pipes articles url and title to bookmark-command",
 	Controller c(paths);
 	newsboat::View v(&c);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 	test_helpers::TempFile bookmarkFile;
@@ -511,14 +511,14 @@ TEST_CASE("OP_BOOKMARK pipes articles url and title to bookmark-command",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	feed->set_title(feed_title);
 
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	item->set_title(test_title);
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 
 	feed->add_item(item);
 	itemlist.set_feed(feed);
@@ -558,7 +558,7 @@ TEST_CASE("OP_EDITFLAGS arguments are added to an item's flags",
 	Controller c(paths);
 	newsboat::View v(&c);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
@@ -567,10 +567,10 @@ TEST_CASE("OP_EDITFLAGS arguments are added to an item's flags",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 
 	feed->add_item(item);
 	itemlist.set_feed(feed);
@@ -617,7 +617,7 @@ TEST_CASE("OP_SAVE writes an article's attributes to the specified file",
 	newsboat::View v(&c);
 	test_helpers::TempFile saveFile;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
@@ -638,16 +638,16 @@ TEST_CASE("OP_SAVE writes an article's attributes to the specified file",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	item->set_title(test_title);
 	item->set_author(test_author);
 	item->set_pubDate(test_pubDate);
 	item->set_description(test_description, "text/plain");
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 
 	feed->add_item(item);
 	itemlist.set_feed(feed);
@@ -679,7 +679,7 @@ TEST_CASE("OP_HELP command is processed", "[ItemListFormAction]")
 	Controller c(paths);
 	newsboat::View v(&c);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	KeyMap k(KM_NEWSBOAT);
 	v.set_keymap(&k);
@@ -687,8 +687,8 @@ TEST_CASE("OP_HELP command is processed", "[ItemListFormAction]")
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 
 	feed->add_item(item);
 
@@ -704,7 +704,7 @@ TEST_CASE("OP_HARDQUIT command is processed", "[ItemListFormAction]")
 	Controller c(paths);
 	newsboat::View v(&c);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
@@ -714,9 +714,9 @@ TEST_CASE("OP_HARDQUIT command is processed", "[ItemListFormAction]")
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 	itemlist.set_feed(feed);
 
 	const std::vector<std::string> args;
@@ -736,7 +736,7 @@ TEST_CASE("Navigate back and forth using OP_NEXT and OP_PREV",
 	ConfigContainer cfg;
 	cfg.set_configvalue(
 		"external-url-viewer", "tee > " + articleFile.get_path());
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	std::string line;
 
 	std::string first_article_title = "First_Article";
@@ -749,13 +749,13 @@ TEST_CASE("Navigate back and forth using OP_NEXT and OP_PREV",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_title(first_article_title);
 	feed->add_item(item);
 
-	std::shared_ptr<RssItem> item2 = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item2 = std::make_shared<RssItem>(rsscache.get());
 	item2->set_title(second_article_title);
 	feed->add_item(item2);
 
@@ -784,7 +784,7 @@ TEST_CASE("OP_TOGGLESHOWREAD switches the value of show-read-articles",
 	Controller c(paths);
 	newsboat::View v(&c);
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	KeyMap k(KM_NEWSBOAT);
 	v.set_keymap(&k);
@@ -792,9 +792,9 @@ TEST_CASE("OP_TOGGLESHOWREAD switches the value of show-read-articles",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	feed->add_item(item);
 
 	std::shared_ptr<ItemListFormAction> itemlist = v.push_itemlist(feed);
@@ -823,7 +823,7 @@ TEST_CASE("OP_PIPE_TO pipes an article's content to an external command",
 	newsboat::View v(&c);
 	test_helpers::TempFile articleFile;
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
@@ -844,16 +844,16 @@ TEST_CASE("OP_PIPE_TO pipes an article's content to an external command",
 	v.set_config_container(&cfg);
 	c.set_view(&v);
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 
-	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item = std::make_shared<RssItem>(rsscache.get());
 	item->set_link(test_url);
 	item->set_title(test_title);
 	item->set_author(test_author);
 	item->set_pubDate(test_pubDate);
 	item->set_description(test_description, "text/plain");
 
-	ItemListFormAction itemlist(v, itemlist_str, &rsscache, filters, &cfg, rxman);
+	ItemListFormAction itemlist(v, itemlist_str, rsscache.get(), filters, &cfg, rxman);
 
 	feed->add_item(item);
 	itemlist.set_feed(feed);
@@ -888,18 +888,18 @@ TEST_CASE("OP_OPENINBROWSER does not result in itemlist invalidation",
 	newsboat::View v(&c);
 	v.set_config_container(&cfg);
 	v.set_keymap(&k);
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	FilterContainer filters;
 	RegexManager rxman;
 
-	std::shared_ptr<RssItem> item1 = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item1 = std::make_shared<RssItem>(rsscache.get());
 	item1->set_link("https://example.com/1");
-	std::shared_ptr<RssItem> item2 = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item2 = std::make_shared<RssItem>(rsscache.get());
 	item2->set_link("https://example.com/2");
-	std::shared_ptr<RssItem> item3 = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssItem> item3 = std::make_shared<RssItem>(rsscache.get());
 	item3->set_link("https://example.com/3");
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, "");
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), "");
 	feed->add_item(item1);
 	feed->add_item(item2);
 	feed->add_item(item3);
diff --git a/test/itemrenderer.cpp b/test/itemrenderer.cpp
index bc09ca20..29efd4c8 100644
--- a/test/itemrenderer.cpp
+++ b/test/itemrenderer.cpp
@@ -1,5 +1,3 @@
-#define ENABLE_IMPLICIT_FILEPATH_CONVERSIONS
-
 #include "itemrenderer.h"
 
 #include "3rd-party/catch.hpp"
@@ -70,11 +68,11 @@ TEST_CASE("item_renderer::to_plain_text() produces a rendered representation "
 	// reproducible
 	cfg.set_configvalue("text-width", "80");
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	SECTION("Item without an enclosure") {
 		item->set_description(ITEM_DESCRIPTON, "text/html");
@@ -221,11 +219,11 @@ TEST_CASE("item_renderer::to_plain_text() renders text to the width specified "
 
 	ConfigContainer cfg;
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	item->set_description(
 		"Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
@@ -328,11 +326,11 @@ TEST_CASE("to_plain_text() does not escape '<' and '>' in header and body",
 
 	ConfigContainer cfg;
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	feed->set_title("<" + FEED_TITLE + ">");
 	item->set_title("<" + ITEM_TITLE + ">");
@@ -363,11 +361,11 @@ TEST_CASE("Empty fields are not rendered", "[item_renderer]")
 	// reproducible
 	cfg.set_configvalue("text-width", "80");
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	SECTION("Item without a feed title") {
 		item->get_feedptr()->set_title("");
@@ -477,11 +475,11 @@ TEST_CASE("item_renderer::to_plain_text honours `html-renderer` setting",
 	ConfigContainer cfg;
 	cfg.set_configvalue("text-width", "80");
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	SECTION("Single-paragraph description") {
 		const auto description = std::string() +
@@ -590,11 +588,11 @@ TEST_CASE("item_renderer::get_feedtitle() returns item's feed title without "
 	"[item_renderer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	const auto check = [&]() {
 		const auto result = item_renderer::get_feedtitle(*item);
@@ -617,11 +615,11 @@ TEST_CASE("item_renderer::get_feedtitle() returns item's feed self-link "
 	"[item_renderer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	const auto feedlink = std::string("https://rss.example.com/~joe/");
 
@@ -637,12 +635,12 @@ TEST_CASE("item_renderer::get_feedtitle() returns item's feed URL "
 	"[item_renderer]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const auto feedurl = std::string("https://example.com/~joe/entries.rss");
 
-	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(&rsscache, feedurl);
-	auto item = std::make_shared<RssItem>(&rsscache);
+	std::shared_ptr<RssFeed> feed = std::make_shared<RssFeed>(rsscache.get(), feedurl);
+	auto item = std::make_shared<RssItem>(rsscache.get());
 	item->set_feedptr(feed);
 
 
@@ -662,11 +660,11 @@ TEST_CASE("Functions used for rendering articles escape '<' into `<>` for use wi
 	ConfigContainer cfg;
 	RegexManager rxman;
 
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	std::shared_ptr<RssItem> item;
 	std::shared_ptr<RssFeed> feed;
-	std::tie(item, feed) = create_test_item(&rsscache);
+	std::tie(item, feed) = create_test_item(rsscache.get());
 
 	feed->set_title("<" + FEED_TITLE + ">");
 	item->set_title("<" + ITEM_TITLE + ">");
diff --git a/test/opml.cpp b/test/opml.cpp
index bcf6fd8c..e85a0e8e 100644
--- a/test/opml.cpp
+++ b/test/opml.cpp
@@ -54,16 +54,16 @@ TEST_CASE("opml::generate creates an XML document with feed URLs in OPML format"
 
 	SECTION("A few feeds") {
 		ConfigContainer cfg;
-		Cache rsscache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 		FeedContainer feeds;
 
 		std::shared_ptr<RssFeed> feed =
-			std::make_shared<RssFeed>(&rsscache, "https://example.com/feed1.xml");
+			std::make_shared<RssFeed>(rsscache.get(), "https://example.com/feed1.xml");
 		feed->set_title("Feed 1");
 		feed->set_link("https://example.com/feed1/");
 		feeds.add_feed(std::move(feed));
 
-		feed = std::make_shared<RssFeed>(&rsscache, "https://example.com/feed2.xml");
+		feed = std::make_shared<RssFeed>(rsscache.get(), "https://example.com/feed2.xml");
 		feed->set_title("Feed 2");
 		feed->set_link("https://example.com/feed2/");
 		feed->set_tags({"tag", "tag,with,commas", "tag/with/slashes", "tag with spaces"});
diff --git a/test/queuemanager.cpp b/test/queuemanager.cpp
index 5baffb0c..83a02f5d 100644
--- a/test/queuemanager.cpp
+++ b/test/queuemanager.cpp
@@ -20,14 +20,14 @@ SCENARIO("Smoke test for QueueManager", "[QueueManager]")
 	GIVEN("A fresh instance of QueueManager") {
 		ConfigContainer cfg;
 
-		Cache cache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		RssItem item(&cache);
+		RssItem item(rsscache.get());
 		const std::string enclosure_url("https://example.com/podcast.mp3");
 		item.set_enclosure_url(enclosure_url);
 		item.set_enclosure_type("audio/mpeg");
 
-		RssFeed feed(&cache, "https://example.com/news.atom");
+		RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
 		test_helpers::TempFile queue_file;
 		QueueManager manager(&cfg, queue_file.get_path());
@@ -88,12 +88,12 @@ SCENARIO("Smoke test for QueueManager", "[QueueManager]")
 		WHEN("enqueue_url() is called for multiple different items") {
 			const auto result = manager.enqueue_url(item, feed);
 
-			RssItem item2(&cache);
+			RssItem item2(rsscache.get());
 			item2.set_enclosure_url("https://www.example.com/another.mp3");
 			item2.set_enclosure_type("audio/mpeg");
 			const auto result2 = manager.enqueue_url(item2, feed);
 
-			RssItem item3(&cache);
+			RssItem item3(rsscache.get());
 			item3.set_enclosure_url("https://joe.example.com/vacation.jpg");
 			item3.set_enclosure_type("image/jpeg");
 			const auto result3 = manager.enqueue_url(item3, feed);
@@ -134,19 +134,19 @@ SCENARIO("enqueue_url() errors if the filename is already used", "[QueueManager]
 	GIVEN("Pristine QueueManager and two RssItems") {
 		ConfigContainer cfg;
 
-		Cache cache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		RssItem item1(&cache);
+		RssItem item1(rsscache.get());
 		const std::string enclosure_url1("https://example.com/podcast.mp3");
 		item1.set_enclosure_url(enclosure_url1);
 		item1.set_enclosure_type("audio/mpeg");
 
-		RssItem item2(&cache);
+		RssItem item2(rsscache.get());
 		const std::string enclosure_url2("https://example.com/~joe/podcast.mp3");
 		item2.set_enclosure_url(enclosure_url2);
 		item2.set_enclosure_type("audio/mpeg");
 
-		RssFeed feed(&cache, "https://example.com/news.atom");
+		RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
 		test_helpers::TempFile queue_file;
 		QueueManager manager(&cfg, queue_file.get_path());
@@ -210,13 +210,13 @@ SCENARIO("enqueue_url() errors if the queue file can't be opened for writing",
 	GIVEN("Pristine QueueManager, an RssItem, and an uneditable queue file") {
 		ConfigContainer cfg;
 
-		Cache cache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		RssItem item(&cache);
+		RssItem item(rsscache.get());
 		item.set_enclosure_url("https://example.com/podcast.mp3");
 		item.set_enclosure_type("audio/mpeg");
 
-		RssFeed feed(&cache, "https://example.com/news.atom");
+		RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
 		test_helpers::TempFile queue_file;
 		QueueManager manager(&cfg, queue_file.get_path());
@@ -251,19 +251,19 @@ TEST_CASE("QueueManager puts files into a location configured by `download-path`
 		cfg.set_configvalue("download-path", "/tmp/nonexistent-newsboat");
 	}
 
-	Cache cache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
-	RssItem item1(&cache);
+	RssItem item1(rsscache.get());
 	const std::string enclosure_url1("https://example.com/podcast.mp3");
 	item1.set_enclosure_url(enclosure_url1);
 	item1.set_enclosure_type("audio/mpeg");
 
-	RssItem item2(&cache);
+	RssItem item2(rsscache.get());
 	const std::string enclosure_url2("https://example.com/~joe/podcast.ogg");
 	item2.set_enclosure_url(enclosure_url2);
 	item2.set_enclosure_type("audio/vorbis");
 
-	RssFeed feed(&cache, "https://example.com/podcasts.atom");
+	RssFeed feed(rsscache.get(), "https://example.com/podcasts.atom");
 
 	test_helpers::TempFile queue_file;
 	QueueManager manager(&cfg, queue_file.get_path());
@@ -299,13 +299,13 @@ TEST_CASE("QueueManager names files according to the `download-filename-format`
 	// *exactly* how the result should look.
 	cfg.set_configvalue("download-path", "/example/");
 
-	Cache cache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
-	RssItem item(&cache);
+	RssItem item(rsscache.get());
 	item.set_enclosure_url("https://example.com/~adam/podcast.mp3");
 	item.set_enclosure_type("audio/mpeg");
 
-	auto feed = std::make_shared<RssFeed>(&cache, "https://example.com/podcasts.atom");
+	auto feed = std::make_shared<RssFeed>(rsscache.get(), "https://example.com/podcasts.atom");
 
 	test_helpers::TempFile queue_file;
 	QueueManager manager(&cfg, queue_file.get_path());
@@ -396,7 +396,7 @@ TEST_CASE("QueueManager names files according to the `download-filename-format`
 
 			item.set_feedptr(feed);
 
-			RssFeed irrelevant_feed(&cache, "https://example.com/podcasts.atom");
+			RssFeed irrelevant_feed(rsscache.get(), "https://example.com/podcasts.atom");
 			irrelevant_feed.set_title("Irrelevant");
 
 			manager.enqueue_url(item, irrelevant_feed);
@@ -428,21 +428,21 @@ TEST_CASE("autoenqueue() adds all enclosures of all items to the queue", "[Queue
 	GIVEN("Pristine QueueManager and a feed of three items") {
 		ConfigContainer cfg;
 
-		Cache cache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		RssFeed feed(&cache, "https://example.com/podcasts.atom");
+		RssFeed feed(rsscache.get(), "https://example.com/podcasts.atom");
 
-		auto item1 = std::make_shared<RssItem>(&cache);
+		auto item1 = std::make_shared<RssItem>(rsscache.get());
 		item1->set_enclosure_url("https://example.com/~adam/podcast.mp3");
 		item1->set_enclosure_type("audio/mpeg");
 		feed.add_item(item1);
 
-		auto item2 = std::make_shared<RssItem>(&cache);
+		auto item2 = std::make_shared<RssItem>(rsscache.get());
 		item2->set_enclosure_url("https://example.com/episode.ogg");
 		item2->set_enclosure_type("audio/vorbis");
 		feed.add_item(item2);
 
-		auto item3 = std::make_shared<RssItem>(&cache);
+		auto item3 = std::make_shared<RssItem>(rsscache.get());
 		item3->set_enclosure_url("https://example.com/~fae/painting.jpg");
 		item3->set_enclosure_type("");
 		feed.add_item(item3);
@@ -483,17 +483,17 @@ SCENARIO("autoenqueue() errors if the filename is already used", "[QueueManager]
 	GIVEN("Pristine QueueManager and a feed of two items") {
 		ConfigContainer cfg;
 
-		Cache cache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		RssFeed feed(&cache, "https://example.com/news.atom");
+		RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
-		auto item1 = std::make_shared<RssItem>(&cache);
+		auto item1 = std::make_shared<RssItem>(rsscache.get());
 		const std::string enclosure_url1("https://example.com/podcast.mp3");
 		item1->set_enclosure_url(enclosure_url1);
 		item1->set_enclosure_type("audio/mpeg");
 		feed.add_item(item1);
 
-		auto item2 = std::make_shared<RssItem>(&cache);
+		auto item2 = std::make_shared<RssItem>(rsscache.get());
 		const std::string enclosure_url2("https://example.com/~joe/podcast.mp3");
 		item2->set_enclosure_url(enclosure_url2);
 		item2->set_enclosure_type("audio/mpeg");
@@ -537,11 +537,11 @@ SCENARIO("autoenqueue() errors if the queue file can't be opened for writing",
 	GIVEN("Pristine QueueManager, a single-item feed, and an uneditable queue file") {
 		ConfigContainer cfg;
 
-		Cache cache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		RssFeed feed(&cache, "https://example.com/news.atom");
+		RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
-		auto item = std::make_shared<RssItem>(&cache);
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_enclosure_url("https://example.com/podcast.mp3");
 		item->set_enclosure_type("audio/mpeg");
 		feed.add_item(item);
@@ -575,22 +575,22 @@ TEST_CASE("autoenqueue() skips already-enqueued items", "[QueueManager]")
 	// *exactly* how the result should look.
 	cfg.set_configvalue("download-path", "/example/");
 
-	Cache cache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
-	RssFeed feed(&cache, "https://example.com/news.atom");
+	RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
-	auto item1 = std::make_shared<RssItem>(&cache);
+	auto item1 = std::make_shared<RssItem>(rsscache.get());
 	item1->set_enclosure_url("https://example.com/podcast.mp3");
 	item1->set_enclosure_type("audio/mpeg");
 	feed.add_item(item1);
 
-	auto item2 = std::make_shared<RssItem>(&cache);
+	auto item2 = std::make_shared<RssItem>(rsscache.get());
 	item2->set_enclosure_url("https://example.com/podcast2.mp3");
 	item2->set_enclosure_type("audio/mpeg");
 	item2->set_enqueued(true);
 	feed.add_item(item2);
 
-	auto item3 = std::make_shared<RssItem>(&cache);
+	auto item3 = std::make_shared<RssItem>(rsscache.get());
 	item3->set_enclosure_url("https://example.com/podcast3.mp3");
 	item3->set_enclosure_type("audio/mpeg");
 	feed.add_item(item3);
@@ -618,21 +618,21 @@ TEST_CASE("autoenqueue() only enqueues HTTP and HTTPS URLs", "[QueueManager]")
 	// *exactly* how the result should look.
 	cfg.set_configvalue("download-path", "/example/");
 
-	Cache cache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
-	RssFeed feed(&cache, "https://example.com/news.atom");
+	RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
-	auto item1 = std::make_shared<RssItem>(&cache);
+	auto item1 = std::make_shared<RssItem>(rsscache.get());
 	item1->set_enclosure_url("https://example.com/podcast.mp3");
 	item1->set_enclosure_type("audio/mpeg");
 	feed.add_item(item1);
 
-	auto item2 = std::make_shared<RssItem>(&cache);
+	auto item2 = std::make_shared<RssItem>(rsscache.get());
 	item2->set_enclosure_url("http://example.com/podcast2.mp3");
 	item2->set_enclosure_type("audio/mpeg");
 	feed.add_item(item2);
 
-	auto item3 = std::make_shared<RssItem>(&cache);
+	auto item3 = std::make_shared<RssItem>(rsscache.get());
 	item3->set_enclosure_url("ftp://user@example.com/podcast3.mp3");
 	item3->set_enclosure_type("audio/mpeg");
 	feed.add_item(item3);
@@ -658,26 +658,26 @@ TEST_CASE("autoenqueue() does not enqueue items with an invalid podcast type",
 {
 	GIVEN("Pristine QueueManager and a feed of three items with one of them having an image enclosure") {
 		ConfigContainer cfg;
-		Cache cache(":memory:", cfg);
+		auto rsscache = Cache::in_memory(cfg);
 
-		RssFeed feed(&cache, "https://example.com/news.atom");
+		RssFeed feed(rsscache.get(), "https://example.com/news.atom");
 
-		auto item1 = std::make_shared<RssItem>(&cache);
+		auto item1 = std::make_shared<RssItem>(rsscache.get());
 		item1->set_enclosure_url("https://example.com/podcast1.mp3");
 		item1->set_enclosure_type("audio/mpeg");
 		feed.add_item(item1);
 
-		auto item2 = std::make_shared<RssItem>(&cache);
+		auto item2 = std::make_shared<RssItem>(rsscache.get());
 		item2->set_enclosure_url("http://example.com/not-a-podcast.jpg");
 		item2->set_enclosure_type("image/jpeg");
 		feed.add_item(item2);
 
-		auto item3 = std::make_shared<RssItem>(&cache);
+		auto item3 = std::make_shared<RssItem>(rsscache.get());
 		item3->set_enclosure_url("https://example.com/podcast2.mp3");
 		item3->set_enclosure_type("audio/mpeg");
 		feed.add_item(item3);
 
-		auto item4 = std::make_shared<RssItem>(&cache);
+		auto item4 = std::make_shared<RssItem>(rsscache.get());
 		item4->set_enclosure_url("https://example.com/podcast3.mp3");
 		item4->set_enclosure_type("");
 		feed.add_item(item4);
diff --git a/test/rssfeed.cpp b/test/rssfeed.cpp
index 8cb8cb58..4577dc9e 100644
--- a/test/rssfeed.cpp
+++ b/test/rssfeed.cpp
@@ -18,29 +18,29 @@ TEST_CASE("RssFeed constructor checks if query feed has a valid query",
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	SECTION("invalid query results in exception") {
-		REQUIRE_THROWS(RssFeed(&rsscache, "query:a title:unread ="));
-		REQUIRE_THROWS(RssFeed(&rsscache, "query:a title:between 1:3"));
+		REQUIRE_THROWS(RssFeed(rsscache.get(), "query:a title:unread ="));
+		REQUIRE_THROWS(RssFeed(rsscache.get(), "query:a title:between 1:3"));
 	}
 
 	SECTION("valid query doesn't throw an exception") {
-		REQUIRE_NOTHROW(RssFeed(&rsscache, "query:a title:unread = \"yes\""));
-		REQUIRE_NOTHROW(RssFeed(&rsscache,
+		REQUIRE_NOTHROW(RssFeed(rsscache.get(), "query:a title:unread = \"yes\""));
+		REQUIRE_NOTHROW(RssFeed(rsscache.get(),
 				"query:Title:unread = \"yes\" and age between 0:7"));
 
-		REQUIRE_NOTHROW(RssFeed(&rsscache, R"_(query:a title:title =~ "media:")_"));
+		REQUIRE_NOTHROW(RssFeed(rsscache.get(), R"_(query:a title:title =~ "media:")_"));
 	}
 }
 
 TEST_CASE("RssFeed::sort() correctly sorts articles", "[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 	for (int i = 0; i < 5; ++i) {
-		const auto item = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_guid(std::to_string(i));
 		f.add_item(item);
 	}
@@ -217,10 +217,10 @@ TEST_CASE("RssFeed::unread_item_count() returns number of unread articles",
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 	for (int i = 0; i < 5; ++i) {
-		const auto item = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
 		item->set_guid(std::to_string(i));
 		f.add_item(item);
 	}
@@ -247,8 +247,8 @@ TEST_CASE("RssFeed::matches_tag() returns true if article has a specified tag",
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 	const std::vector<std::string> tags = {"One", "Two", "Three", "Four"};
 	f.set_tags(tags);
 
@@ -263,8 +263,8 @@ TEST_CASE("RssFeed::matches_tag() returns true if article has a specified tag",
 TEST_CASE("RssFeed::get_firsttag() returns first tag", "[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 
 	SECTION("Empty tag array") {
 		REQUIRE(f.get_firsttag() == "");
@@ -296,8 +296,8 @@ TEST_CASE(
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 
 	REQUIRE_FALSE(f.hidden());
 
@@ -319,10 +319,10 @@ TEST_CASE(
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 	for (int i = 0; i < 5; ++i) {
-		const auto item = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
 		REQUIRE(item->unread());
 		f.add_item(item);
 	}
@@ -337,8 +337,8 @@ TEST_CASE(
 TEST_CASE("RssFeed::set_tags() sets tags for a feed", "[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 
 	std::vector<std::string> tags = {"One", "Two"};
 	f.set_tags(tags);
@@ -354,10 +354,10 @@ TEST_CASE(
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 	for (int i = 0; i < 5; ++i) {
-		const auto item = std::make_shared<RssItem>(&rsscache);
+		const auto item = std::make_shared<RssItem>(rsscache.get());
 		if (i % 2) {
 			item->set_deleted(true);
 		}
@@ -372,12 +372,12 @@ TEST_CASE("If item's <title> is empty, try to deduce it from the URL",
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	CurlHandle easyHandle;
-	FeedRetriever feed_retriever(cfg, rsscache, easyHandle);
+	FeedRetriever feed_retriever(cfg, *rsscache, easyHandle);
 	const std::string uri = "file://data/items_without_titles.xml";
 	RssParser p(uri,
-		rsscache,
+		*rsscache,
 		cfg,
 		nullptr);
 	auto feed = p.parse(feed_retriever.retrieve(uri));
@@ -396,10 +396,10 @@ TEST_CASE(
 	"[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 
 	const auto check_if_query_feed = [&](const std::string& rssurl) {
-		RssFeed f(&rsscache, rssurl);
+		RssFeed f(rsscache.get(), rssurl);
 		return f.is_query_feed();
 	};
 
@@ -413,8 +413,8 @@ TEST_CASE(
 TEST_CASE("RssFeed contains a number of matchable attributes", "[RssFeed]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssFeed f(&rsscache, "");
+	auto rsscache = Cache::in_memory(cfg);
+	RssFeed f(rsscache.get(), "");
 
 	SECTION("`feedtitle`, containing feed's title") {
 		const auto title = std::string("Example feed");
@@ -480,7 +480,7 @@ TEST_CASE("RssFeed contains a number of matchable attributes", "[RssFeed]")
 
 	SECTION("rssurl, the URL by which this feed is fetched (specified in the urls file)") {
 		const auto url = std::string("https://example.com/news.atom");
-		RssFeed f2(&rsscache, url);
+		RssFeed f2(rsscache.get(), url);
 
 		const auto attr = "rssurl";
 		REQUIRE(f2.attribute_value(attr) == url);
@@ -494,8 +494,8 @@ TEST_CASE("RssFeed contains a number of matchable attributes", "[RssFeed]")
 		}
 
 		SECTION("feed with two items") {
-			auto item1 = std::make_shared<RssItem>(&rsscache);
-			auto item2 = std::make_shared<RssItem>(&rsscache);
+			auto item1 = std::make_shared<RssItem>(rsscache.get());
+			auto item2 = std::make_shared<RssItem>(rsscache.get());
 
 			f.add_item(item1);
 			f.add_item(item2);
@@ -530,8 +530,8 @@ TEST_CASE("RssFeed contains a number of matchable attributes", "[RssFeed]")
 		}
 
 		SECTION("feed with two items => total_count == 2") {
-			auto item1 = std::make_shared<RssItem>(&rsscache);
-			auto item2 = std::make_shared<RssItem>(&rsscache);
+			auto item1 = std::make_shared<RssItem>(rsscache.get());
+			auto item2 = std::make_shared<RssItem>(rsscache.get());
 
 			f.add_item(item1);
 			f.add_item(item2);
@@ -585,8 +585,8 @@ TEST_CASE("RssFeed contains a number of matchable attributes", "[RssFeed]")
 		}
 
 		SECTION("feed with two items => latest_article_age == <days since most recent publish date>") {
-			auto item1 = std::make_shared<RssItem>(&rsscache);
-			auto item2 = std::make_shared<RssItem>(&rsscache);
+			auto item1 = std::make_shared<RssItem>(rsscache.get());
+			auto item2 = std::make_shared<RssItem>(rsscache.get());
 
 			item1->set_pubDate(current_time - 3 * seconds_per_day);
 			item2->set_pubDate(current_time - 5 * seconds_per_day);
diff --git a/test/rssignores.cpp b/test/rssignores.cpp
index e6b0a838..e0187f5d 100644
--- a/test/rssignores.cpp
+++ b/test/rssignores.cpp
@@ -1,5 +1,3 @@
-#define ENABLE_IMPLICIT_FILEPATH_CONVERSIONS
-
 #include "rssignores.h"
 
 #include <set>
@@ -244,8 +242,8 @@ TEST_CASE("RssIgnores::matches() returns true if given RssItem matches any "
 	RssIgnores ignores;
 
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssItem item(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	RssItem item(rsscache.get());
 
 	const auto feedurl = "https://example.com/feed.xml";
 
diff --git a/test/rssitem.cpp b/test/rssitem.cpp
index db39b72a..fbce2b4e 100644
--- a/test/rssitem.cpp
+++ b/test/rssitem.cpp
@@ -1,5 +1,3 @@
-#define ENABLE_IMPLICIT_FILEPATH_CONVERSIONS
-
 #include "rssitem.h"
 
 #include <unistd.h>
@@ -17,8 +15,8 @@ using namespace newsboat;
 TEST_CASE("RssItem::sort_flags() cleans up flags", "[RssItem]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssItem item(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	RssItem item(rsscache.get());
 
 	SECTION("Repeated letters do not erase other letters") {
 		std::string inputflags = "Abcdecf";
@@ -37,8 +35,8 @@ TEST_CASE("RssItem::sort_flags() cleans up flags", "[RssItem]")
 TEST_CASE("RssItem contains a number of matchable attributes", "[RssItem]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssItem item(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	RssItem item(rsscache.get());
 
 	SECTION("title") {
 		const auto attr = "title";
@@ -232,8 +230,8 @@ TEST_CASE("RssItem contains a number of matchable attributes", "[RssItem]")
 	}
 
 	SECTION("unknown attributes are forwarded to parent feed") {
-		auto feed = std::make_shared<RssFeed>(&rsscache, "");
-		auto item = std::make_shared<RssItem>(&rsscache);
+		auto feed = std::make_shared<RssFeed>(rsscache.get(), "");
+		auto item = std::make_shared<RssItem>(rsscache.get());
 		feed->add_item(item);
 
 		const auto feedindex = 42;
@@ -256,8 +254,8 @@ TEST_CASE("RssItem contains a number of matchable attributes", "[RssItem]")
 TEST_CASE("set_title() removes superfluous whitespace", "[RssItem]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
-	RssItem item(&rsscache);
+	auto rsscache = Cache::in_memory(cfg);
+	RssItem item(rsscache.get());
 
 	SECTION("duplicate whitespace") {
 		item.set_title("lorem        ipsum");
diff --git a/test/rssparser.cpp b/test/rssparser.cpp
index ca68518b..418586f2 100644
--- a/test/rssparser.cpp
+++ b/test/rssparser.cpp
@@ -1,5 +1,3 @@
-#define ENABLE_IMPLICIT_FILEPATH_CONVERSIONS
-
 #include "rssparser.h"
 
 #include "3rd-party/catch.hpp"
@@ -15,9 +13,9 @@ using namespace newsboat;
 TEST_CASE("parse() ignores uninitialized upstream feed", "[RssParser]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	RssIgnores ignores;
-	RssParser parser("http://example.com", rsscache, cfg, &ignores);
+	RssParser parser("http://example.com", *rsscache, cfg, &ignores);
 
 	rsspp::Feed upstream_feed;
 	const auto feed = parser.parse(upstream_feed);
@@ -28,9 +26,9 @@ TEST_CASE("parse() with no item GUID falls back to link+pubdate, link, and title
 	"[RssParser]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	RssIgnores ignores;
-	RssParser parser("http://example.com", rsscache, cfg, &ignores);
+	RssParser parser("http://example.com", *rsscache, cfg, &ignores);
 
 	rsspp::Feed upstream_feed;
 	upstream_feed.rss_version = rsspp::Feed::ATOM_1_0;
@@ -83,9 +81,9 @@ TEST_CASE("parse() renders html titles into plaintext if type indicates html",
 	"[RssParser]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	RssIgnores ignores;
-	RssParser parser("http://example.com", rsscache, cfg, &ignores);
+	RssParser parser("http://example.com", *rsscache, cfg, &ignores);
 
 	rsspp::Feed upstream_feed;
 	upstream_feed.rss_version = rsspp::Feed::ATOM_1_0;
@@ -128,9 +126,9 @@ TEST_CASE("parse() generates a title when title element is missing",
 	"[RssParser]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	RssIgnores ignores;
-	RssParser parser("http://example.com", rsscache, cfg, &ignores);
+	RssParser parser("http://example.com", *rsscache, cfg, &ignores);
 
 	rsspp::Feed upstream_feed;
 	upstream_feed.rss_version = rsspp::Feed::ATOM_1_0;
@@ -167,9 +165,9 @@ TEST_CASE("parse() generates a title when title element is missing",
 TEST_CASE("parse() extracts best enclosure", "[RssParser]")
 {
 	ConfigContainer cfg;
-	Cache rsscache(":memory:", cfg);
+	auto rsscache = Cache::in_memory(cfg);
 	RssIgnores ignores;
-	RssParser parser("http://example.com", rsscache, cfg, &ignores);
+	RssParser parser("http://example.com", *rsscache, cfg, &ignores);
 
 	rsspp::Feed upstream_feed;
 	upstream_feed.rss_version = rsspp::Feed::ATOM_1_0;
diff --git a/test/view.cpp b/test/view.cpp
index 04653656..1b79f254 100644
--- a/test/view.cpp
+++ b/test/view.cpp
@@ -1,5 +1,3 @@
-#define ENABLE_IMPLICIT_FILEPATH_CONVERSIONS
-
 #include "view.h"
 
 #include <string>
@@ -25,7 +23,6 @@ TEST_CASE("get_filename_suggestion() normalizes filenames for saving articles",
 	newsboat::View v(&c);
 
 	ConfigContainer cfg{};
-	Cache rsscache(":memory:", cfg);
 
 	v.set_config_container(&cfg);
 	c.set_view(&v);