Add in-memory repositories for testing user and article data

Author: gunkim

core/src/test/kotlin/io/github/gunkim/realworld/share/InMemoryDatabase.kt

@@ -0,0 +1,20 @@
+package io.github.gunkim.realworld.share
+
+import io.github.gunkim.realworld.domain.article.model.ArticleId
+import io.github.gunkim.realworld.domain.user.model.UserId
+
+object InMemoryDatabase {
+    val users: MutableMap<UserId, Any> = mutableMapOf() // User 저장소
+    val articles: MutableMap<ArticleId, Any> = mutableMapOf() // Article 저장소
+
+    val followings: MutableMap<UserId, MutableSet<UserId>> = mutableMapOf()
+    val favorites: MutableMap<ArticleId, MutableSet<UserId>> = mutableMapOf()
+
+    // 테스트 실행 전후 데이터를 초기화하기 위한 메서드
+    fun clear() {
+        users.clear()
+        articles.clear()
+        followings.clear()
+        favorites.clear()
+    }
+}

core/src/test/kotlin/io/github/gunkim/realworld/share/MockArticleRepository.kt

@@ -0,0 +1,106 @@
+package io.github.gunkim.realworld.share
+
+import io.github.gunkim.realworld.domain.article.model.Article
+import io.github.gunkim.realworld.domain.article.model.ArticleId
+import io.github.gunkim.realworld.domain.article.model.Slug
+import io.github.gunkim.realworld.domain.article.repository.ArticleCountProjection
+import io.github.gunkim.realworld.domain.article.repository.ArticleRepository
+import io.github.gunkim.realworld.domain.user.model.User
+import io.github.gunkim.realworld.domain.user.model.UserId
+
+data class ArticleCountProjectionImpl(
+    override val articleId: ArticleId,
+    override val count: Int,
+) : ArticleCountProjection
+
+class MockArticleRepository : ArticleRepository {
+    override fun save(article: Article): Article {
+        val updatedAuthor: User = InMemoryDatabase.users[article.author.id] as? User ?: article.author
+        val updatedArticle = if (article is Article.Companion.Model) {
+            article.copy(author = updatedAuthor)
+        } else {
+            article
+        }
+        InMemoryDatabase.articles[updatedArticle.id] = updatedArticle
+        return updatedArticle
+    }
+
+    override fun delete(article: Article) {
+        InMemoryDatabase.articles.remove(article.id)
+        InMemoryDatabase.favorites.remove(article.id)
+    }
+
+    override fun favorite(article: Article, user: User) {
+        val favoritesSet = InMemoryDatabase.favorites.getOrPut(article.id) { mutableSetOf() }
+        favoritesSet.add(user.id)
+    }
+
+    override fun unFavorite(article: Article, user: User) {
+        InMemoryDatabase.favorites[article.id]?.remove(user.id)
+    }
+
+    override fun find(
+        tag: String?,
+        author: String?,
+        favoritedUsername: String?,
+        limit: Int,
+        offset: Int,
+    ): List<Article> {
+        var filtered = InMemoryDatabase.articles.values.toList().mapNotNull { it as? Article }
+
+        if (tag != null) {
+            filtered = filtered.filter { article ->
+                article.tags.any { it.name == tag }
+            }
+        }
+
+        if (author != null) {
+            filtered = filtered.filter { article ->
+                article.author.name == author
+            }
+        }
+
+        if (favoritedUsername != null) {
+            val favoriter = InMemoryDatabase.users.values
+                .mapNotNull { it as? User }
+                .find { it.name == favoritedUsername }
+            filtered = if (favoriter != null) {
+                filtered.filter { article ->
+                    InMemoryDatabase.favorites[article.id]?.contains(favoriter.id) ?: false
+                }
+            } else {
+                emptyList()
+            }
+        }
+
+        return filtered.drop(offset).take(limit)
+    }
+
+    override fun findFeedArticles(userId: UserId, limit: Int, offset: Int): List<Article> {
+        val followedUserIds = InMemoryDatabase.followings[userId] ?: emptySet()
+        val feedArticles = InMemoryDatabase.articles.values.toList().mapNotNull { it as? Article }
+            .filter { article ->
+                followedUserIds.contains(article.author.id)
+            }
+        return feedArticles.drop(offset).take(limit)
+    }
+
+    override fun getCountAllByArticleIds(articleIds: List<ArticleId>): List<ArticleCountProjection> {
+        return articleIds.map { articleId ->
+            val count = InMemoryDatabase.favorites[articleId]?.size ?: 0
+            ArticleCountProjectionImpl(articleId, count)
+        }
+    }
+
+    override fun getFavoritesArticleIds(userId: UserId): List<ArticleId> {
+        return InMemoryDatabase.favorites.filter { (_, userIds) ->
+            userIds.contains(userId)
+        }.keys.toList()
+    }
+
+    override fun findBySlug(slug: Slug): Article? {
+        return InMemoryDatabase.articles.values
+            .mapNotNull { it as? Article }
+            .find { it.slug == slug }
+    }
+}

core/src/test/kotlin/io/github/gunkim/realworld/share/MockUserRepository.kt

@@ -0,0 +1,54 @@
+package io.github.gunkim.realworld.share
+
+import io.github.gunkim.realworld.domain.article.model.Article
+import io.github.gunkim.realworld.domain.user.model.User
+import io.github.gunkim.realworld.domain.user.model.UserId
+import io.github.gunkim.realworld.domain.user.repository.UserRepository
+
+class MockUserRepository : UserRepository {
+    override fun save(user: User): User {
+        val existingUser = InMemoryDatabase.users[user.id]
+        InMemoryDatabase.users[user.id] = user
+
+        if (existingUser != null) {
+            InMemoryDatabase.articles.replaceAll { articleId, article ->
+                if (article.author.id == user.id) {
+                    if (article is Article.Companion.Model) {
+                        article.copy(author = user)
+                    } else {
+                        article
+                    }
+                } else {
+                    article
+                }
+            }
+        }
+        return user
+    }
+
+    override fun follow(followerId: UserId, followeeId: UserId) {
+        // followerId가 followeeId를 팔로우하도록 followings 맵을 업데이트합니다.
+        val followingSet = InMemoryDatabase.followings.getOrPut(followerId) { mutableSetOf() }
+        followingSet.add(followeeId)
+    }
+
+    override fun unfollow(followerId: UserId, followeeId: UserId) {
+        InMemoryDatabase.followings[followerId]?.remove(followeeId)
+    }
+
+    override fun findByEmail(email: String): User? {
+        return InMemoryDatabase.users.values.find { it.email == email }
+    }
+
+    override fun findById(userId: UserId): User? {
+        return InMemoryDatabase.users[userId]
+    }
+
+    override fun findByUserName(name: String): User? {
+        return InMemoryDatabase.users.values.find { it.name == name }
+    }
+
+    override fun findFollowedUserIdsFor(userId: UserId): List<UserId> {
+        return InMemoryDatabase.followings[userId]?.toList() ?: emptyList()
+    }
+}