{"id":3846,"date":"2025-12-24T10:01:18","date_gmt":"2025-12-24T15:01:18","guid":{"rendered":"https:\/\/www.mymiller.name\/wordpress\/?p=3846"},"modified":"2025-12-24T10:01:18","modified_gmt":"2025-12-24T15:01:18","slug":"speed-and-reliability-unit-testing-with-mongodb-memory-server-in-spring-boot","status":"publish","type":"post","link":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/speed-and-reliability-unit-testing-with-mongodb-memory-server-in-spring-boot\/","title":{"rendered":"Speed and Reliability: Unit Testing with MongoDB Memory Server in Spring Boot"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><p>When you\u2019re building Spring Boot applications that interact with MongoDB, ensuring the reliability of your data access layer is crucial. Unit tests play a vital role, but setting up and tearing down a real MongoDB instance for each test can be slow and cumbersome. This is where MongoDB Memory Server comes to the rescue, providing a fast and efficient in-memory alternative.<\/p>\n<p><strong>What is MongoDB Memory Server?<\/strong><\/p>\n<p>MongoDB Memory Server is a tool that spins up an actual MongoDB server process in memory. This gives you several key advantages:<\/p>\n<ul>\n<li><strong>Real MongoDB Behavior:<\/strong> Unlike mocking, you\u2019re interacting with a real MongoDB instance, which significantly reduces the risk of tests passing but failing in production due to subtle differences in behavior.<\/li>\n<li><strong>Speed:<\/strong> In-memory operations are incredibly fast, leading to quicker test execution and faster development cycles.<\/li>\n<li><strong>Isolation:<\/strong> Each test can have its own isolated MongoDB instance, preventing data contamination and ensuring reliable results.<\/li>\n<\/ul>\n<p><strong>How to Use MongoDB Memory Server in Your Spring Boot Tests<\/strong><\/p>\n<p>Here\u2019s a step-by-step guide to integrating MongoDB Memory Server into your Spring Boot unit testing workflow:<\/p>\n<p><strong>1.   Dependencies<\/strong><\/p>\n<ul>\n<li>You\u2019ll need the <code>de.flapdoodle.embed.mongo<\/code> dependency to manage the embedded MongoDB server. Add this to your <code>pom.xml<\/code> (Maven) or <code>build.gradle<\/code> (Gradle):<\/li>\n<\/ul>\n<pre><code class=\"language-xml\">&lt;dependency&gt;\n    &lt;groupId&gt;de.flapdoodle.embed&lt;\/groupId&gt;\n    &lt;artifactId&gt;de.flapdoodle.embed.mongo&lt;\/artifactId&gt;\n    &lt;scope&gt;test&lt;\/scope&gt;\n&lt;\/dependency&gt;\n<\/code><\/pre>\n<pre><code class=\"language-gradle\">\/\/ Gradle\ntestImplementation 'de.flapdoodle.embed:de.flapdoodle.embed.mongo'\n<\/code><\/pre>\n<p><strong>2.   Configuration (Spring Boot)<\/strong><\/p>\n<ul>\n<li>\n<p>While MongoDB Memory Server handles the server itself, Spring Boot still needs database connection details. You can configure this in your <code>application.properties<\/code> or <code>application.yml<\/code> within <code>src\/test\/resources<\/code>.<\/p>\n<\/li>\n<li>\n<p><strong>Important:<\/strong> You won\u2019t specify a fixed host and port here, as MongoDB Memory Server provides a dynamic connection URI.<\/p>\n<\/li>\n<li>\n<p>Example (<code>application.properties<\/code>):<\/p>\n<\/li>\n<\/ul>\n<pre><code class=\"language-properties\">spring.data.mongodb.uri=${spring.mongodb.embedded.connection-string}\nspring.data.mongodb.database=testdb\n<\/code><\/pre>\n<ul>\n<li>Example (<code>application.yml<\/code>):<\/li>\n<\/ul>\n<pre><code class=\"language-yaml\">spring:\n  data:\n    mongodb:\n      uri: ${spring.mongodb.embedded.connection-string}\n      database: testdb\n<\/code><\/pre>\n<p><strong>3.   Setting Up and Tearing Down the Embedded MongoDB<\/strong><\/p>\n<ul>\n<li>Here\u2019s how you\u2019d typically manage the MongoDB Memory Server lifecycle within your tests (using JUnit 5):<\/li>\n<\/ul>\n<pre><code class=\"language-java\">import com.mongodb.client.MongoClient;\nimport com.mongodb.client.MongoCollection;\nimport com.mongodb.client.MongoDatabase;\nimport de.flapdoodle.embed.mongo.MongodExecutable;\nimport de.flapdoodle.embed.mongo.MongodStarter;\nimport de.flapdoodle.embed.mongo.config.ImmutableMongodConfig;\nimport de.flapdoodle.embed.mongo.config.Net;\nimport org.bson.Document;\nimport org.junit.jupiter.api.AfterEach;\nimport org.junit.jupiter.api.BeforeEach;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.beans.factory.annotation.Value;\nimport org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;\nimport org.springframework.context.annotation.Import;\nimport org.springframework.data.mongodb.core.MongoTemplate;\nimport org.springframework.test.context.DynamicPropertyRegistry;\nimport org.springframework.test.context.DynamicPropertySource;\n\nimport java.io.IOException;\n\nimport static org.junit.jupiter.api.Assertions.assertEquals;\n\n@DataMongoTest\npublic class MyMongoDbTest {\n\n    private static MongodExecutable mongodExecutable;\n    private MongoClient mongoClient;\n    private MongoCollection&lt;Document&gt; collection;\n\n    @Autowired\n    private MongoTemplate mongoTemplate;\n\n    @Value(&quot;${spring.data.mongodb.database}&quot;)\n    private String databaseName;\n\n    @DynamicPropertySource\n    static void setProperties(DynamicPropertyRegistry registry) throws IOException {\n        MongodStarter starter = MongodStarter.getDefaultInstance();\n        int port = 27018; \/\/ Choose a free port\n        ImmutableMongodConfig mongodConfig = ImmutableMongodConfig.builder()\n                .net(new Net(&quot;localhost&quot;, port, false))\n                .build();\n        mongodExecutable = starter.prepare(mongodConfig);\n        mongodExecutable.start();\n        registry.add(&quot;spring.mongodb.embedded.connection-string&quot;, () -&gt; &quot;mongodb:\/\/localhost:&quot; + port);\n    }\n\n    @BeforeEach\n    void setUp() {\n        mongoClient = mongoTemplate.getMongoDatabaseFactory().getMongoClient();\n        MongoDatabase database = mongoClient.getDatabase(databaseName);\n        collection = database.getCollection(&quot;mycollection&quot;);\n        collection.insertOne(new Document(&quot;name&quot;, &quot;Test&quot;));\n    }\n\n    @AfterEach\n    void tearDown() {\n        collection.deleteMany(new Document());\n        mongoClient.close();\n        mongodExecutable.stop();\n    }\n\n    @Test\n    void myTest() {\n        assertEquals(1, collection.countDocuments());\n    }\n}\n<\/code><\/pre>\n<ul>\n<li><strong>Explanation<\/strong>\n<ul>\n<li><code>@DataMongoTest<\/code>: This Spring Boot annotation sets up a test context focused on MongoDB, similar to <code>@DataJpaTest<\/code> for JPA.<\/li>\n<li><code>@DynamicPropertySource<\/code>: This annotation is used to dynamically set the <code>spring.mongodb.embedded.connection-string<\/code> property. The <code>setProperties<\/code> method starts the embedded MongoDB server and registers the connection string with Spring\u2019s environment.<\/li>\n<li><code>MongodStarter<\/code>: This class from Flapdoodle is used to configure and start the MongoDB Memory Server.<\/li>\n<li><code>@BeforeEach<\/code>: This JUnit 5 annotation ensures that the <code>setUp<\/code> method is executed before each test method. Here, we get the <code>MongoClient<\/code> from Spring\u2019s <code>MongoTemplate<\/code>, get the database and collection and insert a test document.<\/li>\n<li><code>@AfterEach<\/code>: This JUnit 5 annotation ensures that the <code>tearDown<\/code> method is executed after each test method. Here, we delete all documents from the collection, close the <code>MongoClient<\/code> and stop the embedded MongoDB server.<\/li>\n<li><code>mongoTemplate<\/code>: Spring Data MongoDB\u2019s <code>MongoTemplate<\/code> is used to interact with the database.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p><strong>4.   Writing Your Tests<\/strong><\/p>\n<ul>\n<li>Now you can write your unit tests as you normally would, using Spring Data MongoDB\u2019s repositories or the <code>MongoTemplate<\/code> to interact with the database.<\/li>\n<\/ul>\n<pre><code class=\"language-java\">import org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;\nimport org.springframework.data.mongodb.core.MongoTemplate;\n\nimport static org.junit.jupiter.api.Assertions.assertEquals;\n\n@DataMongoTest\npublic class MyServiceTest {\n\n    @Autowired\n    private MongoTemplate mongoTemplate;\n\n    @Test\n    void testMyServiceLogic() {\n        \/\/ Arrange\n        mongoTemplate.save(new MyDocument(&quot;testId&quot;, &quot;testValue&quot;), &quot;mycollection&quot;);\n\n        \/\/ Act\n        MyService service = new MyService(mongoTemplate);\n        MyDocument result = service.getDocument(&quot;testId&quot;);\n\n        \/\/ Assert\n        assertEquals(&quot;testValue&quot;, result.getValue());\n    }\n}\n<\/code><\/pre>\n<p><strong>Benefits of Using MongoDB Memory Server<\/strong><\/p>\n<ul>\n<li><strong>Fast and Reliable Tests:<\/strong> Significantly speeds up test execution and provides consistent results.<\/li>\n<li><strong>Reduced Setup Complexity:<\/strong> Automates the management of MongoDB instances for testing.<\/li>\n<li><strong>Improved Code Quality:<\/strong> Encourages more thorough testing of your data access logic.<\/li>\n<li><strong>Seamless Spring Boot Integration:<\/strong> Works well with Spring Data MongoDB and Spring Boot\u2019s testing features.<\/li>\n<\/ul>\n<p><strong>Important Considerations<\/strong><\/p>\n<ul>\n<li><strong>Resource Consumption:<\/strong> Running a MongoDB process in memory can consume significant RAM, especially for large datasets.<\/li>\n<li><strong>Platform Compatibility:<\/strong> Ensure that the embedded MongoDB binaries are available for your target platforms.<\/li>\n<li><strong>Test Isolation:<\/strong> While MongoDB Memory Server provides good isolation, always clean up your test data properly to avoid any potential side effects.<\/li>\n<\/ul>\n<p><strong>Conclusion<\/strong><\/p>\n<p>MongoDB Memory Server is a valuable tool for any Spring Boot developer working with MongoDB. By providing a fast, reliable, and in-memory database for unit testing, it helps you write more effective tests and build higher-quality applications. Remember to carefully manage the lifecycle of the embedded MongoDB instance and consider the potential resource consumption in your test environment.<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":3857,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_coblocks_attr":"","_coblocks_dimensions":"","_coblocks_responsive_height":"","_coblocks_accordion_ie_support":"","jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[435],"tags":[],"series":[],"class_list":["post-3846","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-spring_databases"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/scientist-9234951_1280-png.avif","jetpack-related-posts":[{"id":3840,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/speedy-testing-with-h3-your-in-memory-powerhouse-for-spring-boot-unit-tests\/","url_meta":{"origin":3846,"position":0},"title":"Speedy Testing with H3: Your In-Memory Powerhouse for Spring Boot Unit Tests","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Unit testing is the bedrock of robust software. When it comes to testing your Spring Boot applications that interact with a database, spinning up a full-fledged database instance for every test can be time-consuming and resource-intensive. This is where in-memory databases like H3 (HyperSQL Database Engine) shine. H3 is a\u2026","rel":"","context":"In &quot;Spring Databases&quot;","block_context":{"text":"Spring Databases","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_databases\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/big-data-7216839_1280-png.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/big-data-7216839_1280-png.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/big-data-7216839_1280-png.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/big-data-7216839_1280-png.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/big-data-7216839_1280-png.avif 3x"},"classes":[]},{"id":3548,"url":"https:\/\/www.mymiller.name\/wordpress\/spring\/beyond-the-basics-optimizing-your-spring-boot-applications-for-performance-fine-tune-your-application-for-speed-and-efficiency\/","url_meta":{"origin":3846,"position":1},"title":"Beyond the Basics: Optimizing Your Spring Boot Applications for Performance &#8211; Fine-tune your application for speed and efficiency.","author":"Jeffery Miller","date":"November 25, 2025","format":false,"excerpt":"Absolutely! Here\u2019s a blog article on optimizing Spring Boot applications, aimed at those who already have some experience with the framework: Beyond the Basics: Optimizing Your Spring Boot Applications for Performance Spring Boot is a fantastic framework for rapidly building production-ready applications. However, as your application grows and handles more\u2026","rel":"","context":"In &quot;Spring&quot;","block_context":{"text":"Spring","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=1050%2C600 3x"},"classes":[]},{"id":3757,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/connecting-to-multiple-mongodb-databases-with-spring-data\/","url_meta":{"origin":3846,"position":2},"title":"Connecting to Multiple MongoDB Databases with Spring Data","author":"Jeffery Miller","date":"December 23, 2025","format":false,"excerpt":"Modern applications, especially in a microservices architecture, often require interaction with multiple databases. This is particularly common with NoSQL databases like MongoDB, where different services might have their own dedicated databases. Spring Data MongoDB simplifies the management of multiple MongoDB datasources within your application. This article provides a comprehensive guide\u2026","rel":"","context":"In &quot;Spring Databases&quot;","block_context":{"text":"Spring Databases","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_databases\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8180209_1280-jpg.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8180209_1280-jpg.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8180209_1280-jpg.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8180209_1280-jpg.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8180209_1280-jpg.avif 3x"},"classes":[]},{"id":3836,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_rest\/testing-the-waters-writing-effective-unit-tests-for-spring-data-rest-apis\/","url_meta":{"origin":3846,"position":3},"title":"Testing the Waters: Writing Effective Unit Tests for Spring Data REST APIs","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Spring Data REST is a powerful tool for rapidly exposing your JPA entities as RESTful APIs with minimal code. However, the \u201cminimal code\u201d aspect doesn\u2019t absolve you from the crucial responsibility of writing unit tests. While Spring Data REST handles much of the underlying API infrastructure, your business logic, entity\u2026","rel":"","context":"In &quot;Spring Rest&quot;","block_context":{"text":"Spring Rest","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_rest\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 3x"},"classes":[]},{"id":3842,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_messaging\/taming-the-stream-effective-unit-testing-with-kafka-in-spring-boot\/","url_meta":{"origin":3846,"position":4},"title":"Taming the Stream: Effective Unit Testing with Kafka in Spring Boot","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Kafka\u2019s asynchronous, distributed nature introduces unique challenges to testing. Unlike traditional synchronous systems, testing Kafka interactions requires verifying message production, consumption, and handling potential asynchronous delays. This article explores strategies for robust unit testing of Kafka components within a Spring Boot application. Understanding the Testing Landscape Before diving into specifics,\u2026","rel":"","context":"In &quot;Spring Messaging&quot;","block_context":{"text":"Spring Messaging","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_messaging\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/intro-7400243_640.jpg?fit=640%2C334&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/intro-7400243_640.jpg?fit=640%2C334&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/intro-7400243_640.jpg?fit=640%2C334&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3844,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_messaging\/the-power-of-kafka-connect\/","url_meta":{"origin":3846,"position":5},"title":"The Power of Kafka Connect","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Kafka Connect is a powerful framework for streaming data between Kafka and other systems in a scalable and reliable way. Connectors handle the complexities of data integration, allowing you to focus on your core application logic. Sink Connectors are used to export data from Kafka to other systems, and in\u2026","rel":"","context":"In &quot;Spring Messaging&quot;","block_context":{"text":"Spring Messaging","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_messaging\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/ai-generated-8131434_1280-png.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/ai-generated-8131434_1280-png.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/ai-generated-8131434_1280-png.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/ai-generated-8131434_1280-png.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/ai-generated-8131434_1280-png.avif 3x"},"classes":[]}],"jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3846","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/comments?post=3846"}],"version-history":[{"count":1,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3846\/revisions"}],"predecessor-version":[{"id":3847,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3846\/revisions\/3847"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media\/3857"}],"wp:attachment":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media?parent=3846"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/categories?post=3846"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/tags?post=3846"},{"taxonomy":"series","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/series?post=3846"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}