Break out io code in libs

Preparing for adding more io implementations.

Really tried writing the convention plugins in kotlin dsl but could
not find the exact right hacks to get it to work.

1 files changed, 327 insertions, 0 deletions

diff --git a/libs/local/src/test/java/org/the_jk/cleversync/local/LocalTreeTest.kt b/libs/local/src/test/java/org/the_jk/cleversync/local/LocalTreeTest.kt
new file mode 100644
index 0000000..21002e3
--- /dev/null
+++ b/libs/local/src/test/java/org/the_jk/cleversync/local/LocalTreeTest.kt
@@ -0,0 +1,327 @@
+package org.the_jk.cleversync.local
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.shadows.ShadowLooper
+import org.the_jk.cleversync.io.Directory
+import org.the_jk.cleversync.io.Link
+import org.the_jk.cleversync.io.ModifiableLink
+import org.the_jk.cleversync.io.ModifiableTree
+import org.the_jk.cleversync.safeValue
+
+@Config(manifest=Config.NONE)
+@RunWith(RobolectricTestRunner::class)
+class LocalTreeTest {
+    @get:Rule
+    val folder = TemporaryFolder()
+
+    private lateinit var tree: ModifiableTree
+
+    @Before
+    fun setUp() {
+        tree = LocalTreeFactory.modifiableTree(folder.root.toPath())
+    }
+
+    @Test
+    fun empty() {
+        val content = tree.list()
+        assertThat(content.directories).isEmpty()
+        assertThat(content.files).isEmpty()
+        assertThat(content.links).isEmpty()
+    }
+
+    @Test
+    fun emptyLive() {
+        val content = tree.liveList().safeValue()
+        assertThat(content?.directories).isEmpty()
+        assertThat(content?.files).isEmpty()
+        assertThat(content?.links).isEmpty()
+    }
+
+    @Test
+    fun createDirectory() {
+        val foo = tree.createDirectory("foo")
+        assertThat(foo.name).isEqualTo("foo")
+        val fooContent = foo.list()
+        assertThat(fooContent.directories).isEmpty()
+        assertThat(fooContent.files).isEmpty()
+        assertThat(fooContent.links).isEmpty()
+        val content = tree.list()
+        assertThat(content.directories).contains(foo)
+        assertThat(content.files).isEmpty()
+        assertThat(content.links).isEmpty()
+    }
+
+    @Test
+    fun observeCreateDirectory() {
+        val content = tree.liveList()
+        var dir: Directory? = null
+        content.observeForever {
+            if (it.directories.size == 1) dir = it.directories[0]
+        }
+        tree.createDirectory("foo")
+        while (dir == null) {
+            ShadowLooper.idleMainLooper()
+        }
+        assertThat(dir?.name).isEqualTo("foo")
+    }
+
+    @Test
+    fun createFile() {
+        val foo = tree.createFile("foo")
+        // Files are not created until you write to them.
+        assertThat(tree.list().files).isEmpty()
+        foo.write().use { os ->
+            os.write(byteArrayOf(1, 2, 3, 4))
+        }
+        assertThat(tree.list().files).contains(foo)
+        assertThat(foo.size).isEqualTo(4.toULong())
+        foo.read().use {
+            assertThat(it.readBytes()).isEqualTo(byteArrayOf(1, 2, 3, 4))
+        }
+    }
+
+    @Test
+    fun overwriteFile() {
+        val foo = tree.createFile("foo")
+        foo.write().use { os ->
+            os.write(byteArrayOf(1, 2, 3, 4))
+        }
+        foo.write().use { os ->
+            os.write(127)
+            os.write(byteArrayOf(1))
+            os.write(byteArrayOf(2), 0, 0)
+            assertThat(foo.size).isEqualTo(4.toULong())
+        }
+        assertThat(foo.size).isEqualTo(2.toULong())
+        assertThat(tree.list().files).hasSize(1)
+        foo.read().use {
+            assertThat(it.readBytes()).isEqualTo(byteArrayOf(127, 1))
+        }
+    }
+
+    @Test
+    fun removeDir() {
+        tree.createDirectory("foo")
+        tree.removeDirectory("foo")
+        assertThat(tree.list().directories).isEmpty()
+    }
+
+    @Test
+    fun removeDirLive() {
+        tree.createDirectory("foo")
+        val content = tree.liveList()
+        var done = false
+        content.observeForever {
+            if (it.directories.isEmpty()) done = true
+        }
+        tree.removeDirectory("foo")
+        while (!done) {
+            ShadowLooper.idleMainLooper()
+        }
+    }
+
+    @Test
+    fun createLink() {
+        val dir = tree.createDirectory("dir")
+        val file = tree.createFile("file")
+        val link = tree.createLink("link", dir.name)
+        var target = link.resolve()
+        when (target) {
+            is Link.DirectoryTarget -> assertThat(target.directory).isEqualTo(
+                dir
+            )
+            is Link.FileTarget -> Assert.fail()
+            is Link.NoTarget -> Assert.fail()
+        }
+        assertThat(tree.openDir("link")).isEqualTo(dir)
+
+        link.target(file)
+        target = link.resolve()
+        when (target) {
+            is Link.DirectoryTarget -> Assert.fail()
+            is Link.FileTarget -> Assert.fail()
+            is Link.NoTarget -> Unit
+        }
+        file.write().use { it.write(1) }
+        target = link.resolve()
+        when (target) {
+            is Link.DirectoryTarget -> Assert.fail()
+            is Link.FileTarget -> assertThat(target.file).isEqualTo(file)
+            is Link.NoTarget -> Assert.fail()
+        }
+
+        assertThat(tree.openFile("link")).isEqualTo(file)
+    }
+
+    @Test
+    fun createLinkSubdir() {
+        val foo = tree.createDirectory("foo")
+        val bar = foo.createDirectory("bar")
+        val link1 = tree.createLink("link1", "foo/bar")
+        val link2 = tree.createLink("link2", bar)
+        assertThat(link1.resolve()).isEqualTo(link2.resolve())
+        assertThat((link1.resolve() as Link.DirectoryTarget).directory).isEqualTo(bar)
+        val link3 = foo.createLink("link3", "../link1")
+        assertThat((link3.resolve() as Link.DirectoryTarget).directory).isEqualTo(bar)
+    }
+
+    @Test
+    fun createLiveLink() {
+        val content = tree.liveList()
+        var link: Link? = null
+        content.observeForever {
+            if (it.links.size == 1) link = it.links[0]
+        }
+        val dir = tree.createDirectory("dir")
+        tree.createLink("link", "dir")
+        while (link == null) {
+            ShadowLooper.idleMainLooper()
+        }
+        assertThat((link?.resolve() as Link.DirectoryTarget).directory).isEqualTo(dir)
+    }
+
+    @Test
+    fun sameDir() {
+        val dir1 = tree.createDirectory("dir")
+        val dir2 = tree.openDir("dir")
+        assertThat(dir1).isEqualTo(dir2)
+        assertThat(dir1.hashCode()).isEqualTo(dir2.hashCode())
+        assertThat(dir1.toString()).isEqualTo(dir2.toString())
+    }
+
+    @Test
+    fun sameFile() {
+        val file1 = tree.createFile("file")
+        file1.write().use { it.write(127) }
+        val file2 = tree.openFile("file")
+        assertThat(file1).isEqualTo(file2)
+        assertThat(file1.hashCode()).isEqualTo(file2.hashCode())
+        assertThat(file1.toString()).isEqualTo(file2.toString())
+    }
+
+    @Test
+    fun sameLink() {
+        val link1 = tree.createLink("link", "foo")
+        val link2 = tree.openLink("link")
+        assertThat(link1).isEqualTo(link2)
+        assertThat(link1.hashCode()).isEqualTo(link2.hashCode())
+        assertThat(link1.toString()).isEqualTo(link2.toString())
+    }
+
+    @Test
+    fun removeDirWithContent() {
+        val foo = tree.createDirectory("foo")
+        foo.createDirectory("dir")
+        foo.createFile("file").write().use { it.write(byteArrayOf(1, 2, 3, 4)) }
+        foo.createLink("link", "file")
+        assertThat(tree.list().directories).hasSize(1)
+        assertThat(tree.removeDirectory("foo")).isTrue()
+        assertThat(tree.list().directories).isEmpty()
+    }
+
+    @Test
+    fun removeWrongType() {
+        tree.createDirectory("dir")
+        assertThat(tree.removeFile("dir")).isFalse()
+        assertThat(tree.removeLink("dir")).isFalse()
+        tree.createFile("file").write().use { it.write(byteArrayOf(1, 2, 3, 4)) }
+        assertThat(tree.removeDirectory("file")).isFalse()
+        assertThat(tree.removeLink("file")).isFalse()
+        tree.createLink("link", "doesn't exist")
+        assertThat(tree.removeDirectory("link")).isFalse()
+        assertThat(tree.removeFile("link")).isFalse()
+        val content = tree.list()
+        assertThat(content.directories).hasSize(1)
+        assertThat(content.files).hasSize(1)
+        assertThat(content.links).hasSize(1)
+    }
+
+    @Test
+    fun removeFile() {
+        tree.createFile("file").write().use { it.write(byteArrayOf(1, 2, 3, 4)) }
+        assertThat(tree.list().files).hasSize(1)
+        tree.removeFile("file")
+        assertThat(tree.list().files).isEmpty()
+    }
+
+    @Test
+    fun removeLink() {
+        val dir = tree.createDirectory("dir")
+        val file = tree.createFile("file")
+        file.write().use { it.write(127) }
+        tree.createLink("link1", dir)
+        tree.createLink("link2", file)
+        assertThat(tree.list().links).hasSize(2)
+        tree.removeLink("link1")
+        tree.removeLink("link2")
+        assertThat(tree.list().links).isEmpty()
+    }
+
+    @Test
+    fun changeLink() {
+        val dir = tree.createDirectory("dir")
+        val file = tree.createFile("file")
+        file.write().use { it.write(127) }
+        val link = tree.createLink("link", "doesn't exist")
+        assertThat(link.resolve() is Link.NoTarget).isTrue()
+        link.target(file)
+        assertThat((link.resolve() as Link.FileTarget).file).isEqualTo(file)
+        link.target(dir)
+        assertThat((link.resolve() as Link.DirectoryTarget).directory).isEqualTo(dir)
+        link.target("bad")
+        assertThat(link.resolve() is Link.NoTarget).isTrue()
+    }
+
+    @Test
+    fun changeModifiableLink() {
+        val dir = tree.createDirectory("dir")
+        val file = tree.createFile("file")
+        file.write().use { it.write(127) }
+        val link = tree.createLink("link", "doesn't exist")
+        assertThat(link.modifiableResolve() is ModifiableLink.NoTarget).isTrue()
+        link.target(file)
+        assertThat((link.modifiableResolve() as ModifiableLink.ModifiableFileTarget).file).isEqualTo(file)
+        link.target(dir)
+        assertThat((link.modifiableResolve() as ModifiableLink.ModifiableDirectoryTarget).directory).isEqualTo(dir)
+        link.target("bad")
+        assertThat(link.modifiableResolve() is ModifiableLink.NoTarget).isTrue()
+    }
+
+    @Test
+    fun recursiveLink() {
+        val link = tree.createLink("link", "link")
+        assertThat(link.resolve() is Link.NoTarget).isTrue()
+    }
+
+    @Test
+    fun names() {
+        assertThat(tree.createDirectory("dir").name).isEqualTo("dir")
+        assertThat(tree.createFile("file").name).isEqualTo("file")
+        assertThat(tree.createLink("link", "file").name).isEqualTo("link")
+    }
+
+    @Test
+    fun openNonExistent() {
+        assertThat(tree.openDir("dir")).isNull()
+        assertThat(tree.openFile("file")).isNull()
+        assertThat(tree.openLink("link")).isNull()
+    }
+
+    @Test
+    fun lastModified() {
+        val file = tree.createFile("foo")
+        file.write().use { it.write(1) }
+        val old = file.lastModified
+        file.write().use { it.write(2); it.flush() }
+        val new = file.lastModified
+        assertThat(old.isBefore(new) || old == new).isTrue()
+    }
+}