diff --git a/src/storage.rs b/src/storage.rs
index a1ab246..03f90d8 100644
--- a/src/storage.rs
+++ b/src/storage.rs
@@ -40,6 +40,10 @@ mod rng {
     }
 }
 
+/// A newtype over [String] to represent a single quote.
+/// [Quote] does not implement [PartialEq] or [Eq] as, on principle, two
+/// quotes may be comprised of the same contents whilst still
+/// representing distinct quotes in practice (e.g. two different lines of dialogue which happen to be the same).
 #[derive(Debug, Clone)]
 pub struct Quote(String);
 
@@ -62,7 +66,47 @@ impl Quote {
 }
 
 pub mod source {
-    struct SourceQuotes;
+    use super::*;
+
+    // TODO: Should the quote source filters be
+    // generic over the exact manager implementation being used?
+    /// Message to request that a SourceManager source its quotes once again.
+    pub struct SourceQuotes;
+
+    /// Subtrait of Actor which specifically
+    /// denotes actors that can handle all relevant source messages.
+    pub trait SourceManager: Actor {}
+
+    impl<T> SourceManager for T where T: Message<SourceQuotes, Reply = Result<Vec<Quote>, ()>> {}
+
+    /// Implementation of [`SourceManager`] which sources quotes from a Vec
+    /// that it holds in memory, without accessing external services.
+    /// Its main purpose is to be used for testing.
+    #[derive(Actor)]
+    pub struct MemorySourceManager {
+        quotes: Vec<Quote>,
+    }
+
+    impl MemorySourceManager {
+        pub fn new(quotes: impl IntoIterator<Item = impl Into<Quote>>) -> Self {
+            Self {
+                quotes: quotes.into_iter().map(Into::into).collect(),
+            }
+        }
+    }
+
+    impl Message<SourceQuotes> for MemorySourceManager {
+        type Reply = Result<Vec<Quote>, ()>;
+
+        async fn handle(
+            &mut self,
+            _msg: SourceQuotes,
+            _ctx: &mut Context<Self, Self::Reply>,
+        ) -> Self::Reply {
+            // We just clone the quotes we've been holding onto since startup
+            Ok(self.quotes.clone())
+        }
+    }
 }
 
 pub mod queue {
@@ -128,14 +172,18 @@ pub mod queue {
     }
 }
 
-struct QuoteCycle<Q: queue::QueueManager> {
+struct QuoteCycle<S: source::SourceManager, Q: queue::QueueManager> {
     rng: rng::PrngState,
-    source_manager: (),
+    source_manager: ActorRef<S>,
     queue_manager: ActorRef<Q>,
 }
 
-impl<Q: queue::QueueManager> QuoteCycle<Q> {
-    pub fn new(rng: rng::PrngState, source_manager: (), queue_manager: ActorRef<Q>) -> Self {
+impl<S: source::SourceManager, Q: queue::QueueManager> QuoteCycle<S, Q> {
+    pub fn new(
+        rng: rng::PrngState,
+        source_manager: ActorRef<S>,
+        queue_manager: ActorRef<Q>,
+    ) -> Self {
         Self {
             rng,
             source_manager,
@@ -143,7 +191,7 @@ impl<Q: queue::QueueManager> QuoteCycle<Q> {
         }
     }
 
-    pub fn with_thread_rng(source_manager: (), queue_manager: ActorRef<Q>) -> Self {
+    pub fn with_thread_rng(source_manager: ActorRef<S>, queue_manager: ActorRef<Q>) -> Self {
         Self {
             rng: rng::PrngState::from_thread_rng(),
             source_manager,
@@ -153,6 +201,8 @@ impl<Q: queue::QueueManager> QuoteCycle<Q> {
 }
 
 mod test {
+    use crate::storage::QuoteCycle;
+
     #[tokio::test]
     async fn memory_queue() {
         use super::Quote;
@@ -182,4 +232,30 @@ mod test {
             );
         }
     }
+
+    #[tokio::test]
+    async fn memory_source() {
+        use super::source::*;
+        use kameo::prelude::*;
+
+        let sample_quotes = ["Minie", "Miney", "Moe", "and", "some", "more"];
+
+        let source_manager = MemorySourceManager::spawn(MemorySourceManager::new(&sample_quotes));
+
+        let quotes = source_manager
+            .ask(SourceQuotes)
+            .await
+            .expect("In-memory quote queue storage should be valid for insertion");
+
+        assert_eq!(
+            sample_quotes.as_slice(),
+            quotes
+                .into_iter()
+                // Since [Quote] doesn't implement any Equality trait,
+                // we map the strings into quotes instead
+                .map(String::from)
+                .collect::<Vec<_>>()
+                .as_slice(),
+        );
+    }
 }