Combine tests from both local and samba

Most the tests test the Tree implementation and thus should work
on all such implementations. Current exception is symlinks which
Samba backend doesn't (currently?) support.

Improve the Samba remove methods to better match the expected behavior.

1 files changed, 3 insertions, 306 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
index a7d0afa..e2d4264 100644
--- 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
@@ -1,326 +1,23 @@
 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
+import org.the_jk.cleversync.TreeAbstractTest
 
 @Config(manifest=Config.NONE)
 @RunWith(RobolectricTestRunner::class)
-class LocalTreeTest {
+class LocalTreeTest : TreeAbstractTest() {
     @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(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()
-    }
+    override fun supportSymlinks() = true
 }