ProjectsFileSystemDatasourceTest implemented

server/src/main/kotlin/com/darkrockstudios/apps/hammer/projects/ProjectsDatasource.kt

@@ -14,4 +14,5 @@ interface ProjectsDatasource {
 	): ProjectsSyncData
 
 	fun deleteProject(userId: Long, projectName: String): Result<Unit>
+	fun createProject(userId: Long, projectName: String)
 }

server/src/main/kotlin/com/darkrockstudios/apps/hammer/projects/ProjectsFileSystemDatasource.kt

@@ -15,12 +15,6 @@ class ProjectsFileSystemDatasource(
 	private val json: Json,
 ) : ProjectsDatasource {
 
-	private fun getUserDirectory(userId: Long): Path {
-		return getUserDirectory(userId, fileSystem)
-	}
-
-	private fun getSyncDataPath(userId: Long): Path = getUserDirectory(userId) / DATA_FILE
-
 	override fun createUserData(userId: Long) {
 		val userDir = getUserDirectory(userId)
 
@@ -48,6 +42,12 @@ class ProjectsFileSystemDatasource(
 		*/
 	}
 
+	override fun createProject(userId: Long, projectName: String) {
+		val projectDef = ProjectDefinition(projectName)
+		val projectDir = ProjectRepository.getProjectDirectory(userId, projectDef, fileSystem)
+		fileSystem.createDirectories(projectDir)
+	}
+
 	override fun deleteProject(userId: Long, projectName: String): Result<Unit> {
 		val projectDef = ProjectDefinition(projectName)
 		val projectDir = ProjectRepository.getProjectDirectory(userId, projectDef, fileSystem)
@@ -103,6 +103,12 @@ class ProjectsFileSystemDatasource(
 		}
 	}
 
+	private fun getUserDirectory(userId: Long): Path {
+		return getUserDirectory(userId, fileSystem)
+	}
+
+	private fun getSyncDataPath(userId: Long): Path = getUserDirectory(userId) / DATA_FILE
+
 	companion object {
 		private const val DATA_DIRECTORY = "user_data"
 		private const val DATA_FILE = "syncData.json"

server/src/main/kotlin/com/darkrockstudios/apps/hammer/projects/ProjectsRepository.kt

@@ -88,6 +88,8 @@ class ProjectsRepository(
 				.not()
 		) return Result.failure(InvalidSyncIdException())
 
+		projectsDatasource.createProject(userId, projectName)
+
 		projectsDatasource.updateSyncData(userId) { data ->
 			data.copy(
 				deletedProjects = data.deletedProjects - projectName

server/src/test/kotlin/com/darkrockstudios/apps/hammer/projects/ProjectsFileSystemDatasourceTest.kt

@@ -1,12 +1,18 @@
 package com.darkrockstudios.apps.hammer.projects
 
 import com.darkrockstudios.apps.hammer.base.http.createJsonSerializer
+import com.darkrockstudios.apps.hammer.base.http.readJson
+import com.darkrockstudios.apps.hammer.base.http.writeJson
+import com.darkrockstudios.apps.hammer.project.ProjectDefinition
+import com.darkrockstudios.apps.hammer.project.ProjectsSyncData
 import com.darkrockstudios.apps.hammer.utils.BaseTest
+import kotlinx.datetime.Instant
 import kotlinx.serialization.json.Json
 import okio.FileSystem
 import okio.fakefilesystem.FakeFileSystem
 import org.junit.Before
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
@@ -15,12 +21,6 @@ class ProjectsFileSystemDatasourceTest : BaseTest() {
 	private lateinit var fileSystem: FileSystem
 	private lateinit var json: Json
 
-//	private fun createProjectDir() {
-//		val userDir = ProjectsRepository.getUserDirectory(userId, fileSystem)
-//		val projectDir = userDir / projectDefinition.name
-//		fileSystem.createDirectories(projectDir)
-//	}
-
 	@Before
 	override fun setup() {
 		super.setup()
@@ -44,4 +44,154 @@ class ProjectsFileSystemDatasourceTest : BaseTest() {
 		val dataFile = ProjectsFileSystemDatasource.getSyncDataPath(userId, fileSystem)
 		assertTrue { fileSystem.exists(dataFile) }
 	}
+
+	@Test
+	fun `Create Project`() {
+		val userId = 1L
+		val projectName = "Test Project"
+
+		val userDir = ProjectsFileSystemDatasource.getUserDirectory(userId, fileSystem)
+		assertFalse(userDir.toString()) { fileSystem.exists(userDir) }
+
+		val datasource = ProjectsFileSystemDatasource(fileSystem, json)
+		datasource.createProject(userId, projectName)
+
+		val projectDir = userDir / projectName
+		assertTrue { fileSystem.exists(projectDir) }
+	}
+
+	@Test
+	fun `Delete Project`() {
+		val userId = 1L
+		val projectName = "Test Project"
+
+		val userDir = ProjectsFileSystemDatasource.getUserDirectory(userId, fileSystem)
+		val projectDir = userDir / projectName
+		val testFile1 = projectDir / "test1.txt"
+		val testFile2 = projectDir / "test2.txt"
+
+		fileSystem.createDirectories(projectDir)
+		fileSystem.write(testFile1) {
+			writeUtf8("test1")
+		}
+		fileSystem.write(testFile2) {
+			writeUtf8("test2")
+		}
+
+		assertTrue { fileSystem.exists(testFile1) }
+		assertTrue { fileSystem.exists(testFile2) }
+		assertTrue { fileSystem.exists(projectDir) }
+
+		val datasource = ProjectsFileSystemDatasource(fileSystem, json)
+		datasource.deleteProject(userId, projectName)
+
+		assertFalse { fileSystem.exists(testFile1) }
+		assertFalse { fileSystem.exists(testFile2) }
+		assertFalse { fileSystem.exists(projectDir) }
+	}
+
+	@Test
+	fun `Get Projects`() {
+		val userId = 1L
+		val projectName1 = "Test Project 1"
+		val projectName2 = "Test Project 2"
+
+		val userDir = ProjectsFileSystemDatasource.getUserDirectory(userId, fileSystem)
+		val project1Dir = userDir / projectName1
+		val project2Dir = userDir / projectName2
+
+		fileSystem.createDirectories(project1Dir)
+		fileSystem.createDirectories(project2Dir)
+		fileSystem.createDirectories(userDir / ".hidden")
+
+		val datasource = ProjectsFileSystemDatasource(fileSystem, json)
+		val projects = datasource.getProjects(userId)
+
+		assertEquals(
+			setOf(
+				ProjectDefinition("Test Project 1"),
+				ProjectDefinition("Test Project 2"),
+			),
+			projects
+		)
+	}
+
+	@Test
+	fun `Save SyncData`() {
+		val userId = 1L
+		val syncDataPath = ProjectsFileSystemDatasource.getSyncDataPath(userId, fileSystem)
+		fileSystem.createDirectories(syncDataPath.parent!!)
+
+		val syncData = ProjectsSyncData(
+			lastSync = Instant.fromEpochSeconds(123),
+			deletedProjects = setOf(
+				"Test Project 1",
+				"Test Project 2",
+			)
+		)
+
+		val datasource = ProjectsFileSystemDatasource(fileSystem, json)
+		datasource.saveSyncData(userId, syncData)
+
+		val data: ProjectsSyncData? = fileSystem.readJson(syncDataPath, json)
+		assertEquals(syncData, data)
+	}
+
+	@Test
+	fun `Load SyncData`() {
+		val userId = 1L
+		val syncDataPath = ProjectsFileSystemDatasource.getSyncDataPath(userId, fileSystem)
+		fileSystem.createDirectories(syncDataPath.parent!!)
+
+		val syncData = ProjectsSyncData(
+			lastSync = Instant.fromEpochSeconds(123),
+			deletedProjects = setOf(
+				"Test Project 1",
+				"Test Project 2",
+			)
+		)
+
+		fileSystem.writeJson(syncDataPath, json, syncData)
+
+		val datasource = ProjectsFileSystemDatasource(fileSystem, json)
+		val loadedSyncData = datasource.loadSyncData(userId)
+
+		assertEquals(syncData, loadedSyncData)
+	}
+
+	@Test
+	fun `Update SyncData`() {
+		val userId = 1L
+		val syncDataPath = ProjectsFileSystemDatasource.getSyncDataPath(userId, fileSystem)
+		fileSystem.createDirectories(syncDataPath.parent!!)
+
+		val syncData = ProjectsSyncData(
+			lastSync = Instant.fromEpochSeconds(123),
+			deletedProjects = setOf(
+				"Test Project 1",
+				"Test Project 2",
+			)
+		)
+
+		fileSystem.writeJson(syncDataPath, json, syncData)
+
+		val datasource = ProjectsFileSystemDatasource(fileSystem, json)
+		val loadedSyncData = datasource.updateSyncData(userId) { data ->
+			data.copy(
+				lastSync = Instant.fromEpochSeconds(456),
+				deletedProjects = data.deletedProjects + "Test Project 3"
+			)
+		}
+
+		val updatedSyncData = ProjectsSyncData(
+			lastSync = Instant.fromEpochSeconds(456),
+			deletedProjects = setOf(
+				"Test Project 1",
+				"Test Project 2",
+				"Test Project 3",
+			)
+		)
+
+		assertEquals(updatedSyncData, loadedSyncData)
+	}
 }