cyclane
/
teamcity-build-step-extension-test-task
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 2 Activity

Compare commits

base: cyclane:main
Branches Tags
cyclane:main
cyclane:v0.1.1
cyclane:v0.1.0
..
compare: cyclane:v0.1.0
Branches Tags
cyclane:main
cyclane:v0.1.1
cyclane:v0.1.0

No commits in common. "main" and "v0.1.0" have entirely different histories.
main ... v0.1.0

4 changed files with 37 additions and 289 deletions
Show Stats Expand all files Collapse all files

41
src/main/kotlin/filesystem/FSCreator.kt
View File

@ -1,57 +1,36 @@
package filesystem
import java.nio.file.FileAlreadyExistsException
import kotlin.io.path.Path
import kotlin.io.path.createDirectory
import kotlin.io.path.createFile
import kotlin.io.path.writeText
import java.nio.file.FileSystemException
import java.nio.file.Files
import java.nio.file.Path
class FSCreator {
/**
* Create entry, leaving existing folders' contents, but overwriting existing files.
* @throws CyclicFolderException Cyclic folders cannot be created.
* @throws DuplicateEntryNameException A folder or sub-folder contains entries with duplicate names.
*/
@Throws(CyclicFolderException::class, DuplicateEntryNameException::class)
@Throws(FileSystemException::class)
fun create(
entryToCreate: FSEntry,
destination: String,
) {
// No point in running anything if we know the input is invalid.
if (entryToCreate is FSFolder) {
if (entryToCreate.isCyclic()) {
throw CyclicFolderException()
}
if (entryToCreate.deepHasDuplicateNames()) {
throw DuplicateEntryNameException()
}
}
val queue =
ArrayDeque(
listOf(
entryToCreate to Path(destination),
),
)
val queue = ArrayDeque<Pair<FSEntry, Path>>()
queue.add(entryToCreate to Path.of(destination))
while (queue.isNotEmpty()) {
val (entry, dest) = queue.removeFirst()
val path = dest.resolve(entry.name)
try {
when (entry) {
is FSFile -> path.createFile()
is FSFolder -> path.createDirectory()
is FSFile -> Files.createFile(path)
is FSFolder -> Files.createDirectory(path)
}
} catch (_: FileAlreadyExistsException) {
} // Allow files/folders to already exist.
when (entry) {
is FSFile -> path.writeText(entry.content)
is FSFile -> Files.write(path, entry.content.toByteArray())
is FSFolder -> queue.addAll(entry.entries.map { it to path })
}
}
}
}
class CyclicFolderException : Exception("Cyclic FSFolders are not supported")
class DuplicateEntryNameException : Exception("Folder contains entries with duplicate names")
}

54
src/main/kotlin/filesystem/FSEntry.kt
View File

@ -1,59 +1,9 @@
package filesystem
import kotlin.io.path.Path
// Note sealed allows for simpler logic in FSCreator by guaranteeing FSFile and FSFolder are the only possible FSEntries
// (as we expect), and it also implicitly makes the class abstract as required.
sealed class FSEntry(val name: String) {
init {
val p = Path(name)
// Only allow single filenames (no paths or relative references (e.g. ".."))
if (p.toList().size != 1 || p.fileName != p.toFile().canonicalFile.toPath().fileName) {
throw InvalidEntryNameException(name)
}
}
}
sealed class FSEntry(val name: String)
class FSFile(name: String, val content: String) : FSEntry(name)
class FSFolder(name: String, val entries: List<FSEntry>) : FSEntry(name) {
/**
* Check whether a folder is cyclic.
*/
fun isCyclic(): Boolean {
val seen = listOf(this).toHashSet<FSEntry>()
val queue = ArrayDeque(entries)
while (queue.isNotEmpty()) {
val entry = queue.removeFirst()
if (!seen.add(entry)) {
return true
}
if (entry is FSFolder) {
queue.addAll(entry.entries)
}
}
return false
}
/**
* Check whether a folder contains multiple entries with the same name.
*/
fun hasDuplicateNames(): Boolean {
val seen = HashSet<String>()
return entries.any { !seen.add(it.name) }
}
internal fun deepHasDuplicateNames(): Boolean {
val queue = ArrayDeque(listOf(this))
while (queue.isNotEmpty()) {
val entry = queue.removeFirst()
if (entry.hasDuplicateNames()) {
return true
}
queue.addAll(entry.entries.mapNotNull { it as? FSFolder })
}
return false
}
}
class InvalidEntryNameException(name: String) : Exception("Invalid FSEntry name: '$name'")
class FSFolder(name: String, val entries: List<FSEntry>) : FSEntry(name)

95
src/test/kotlin/filesystem/FSCreatorTest.kt
View File

@ -1,10 +1,10 @@
package filesystem
import org.junit.jupiter.api.*
import java.io.File
import java.nio.file.FileSystemException
import java.nio.file.Files
import java.nio.file.Path
import java.util.concurrent.TimeUnit
import kotlin.io.path.Path
import kotlin.io.path.createDirectory
import kotlin.test.Test
import kotlin.test.assertEquals
@ -14,26 +14,17 @@ class FSCreatorTest {
@BeforeEach
fun `before each`() {
assertDoesNotThrow("should create _tmp directory") {
Path("_tmp").createDirectory()
Files.createDirectory(Path.of("_tmp"))
}
}
@AfterEach
fun `after each`() {
assertDoesNotThrow("should delete _tmp directory") {
File("_tmp").deleteRecursively()
deleteRecursive(Path.of("_tmp"))
}
}
@Test
fun `create file`() {
val file = FSFile("test.txt", "This is a file")
assertDoesNotThrow("should create file") {
creator.create(file, "_tmp")
}
assertEquals(file.content, File("_tmp/", file.name).readText())
}
@Test
fun `create entries`() {
val readme = FSFile("README", "Hello World!")
@ -71,10 +62,10 @@ class FSCreatorTest {
}
// If objects don't exist, these functions will throw anyway, so don't explicitly check for existence.
// Similarly, don't explicitly check if an object is a directory.
assertEquals(readme.content, File("_tmp/folder", readme.name).readText())
assertEquals(gomod.content, File("_tmp/folder", gomod.name).readText())
assertEquals(maingo.content, File("_tmp/folder", maingo.name).readText())
assertEquals(helloworldgo.content, File("_tmp/folder/utils", helloworldgo.name).readText())
assertEquals(readme.content, Files.readString(Path.of("_tmp/folder", readme.name)))
assertEquals(gomod.content, Files.readString(Path.of("_tmp/folder", gomod.name)))
assertEquals(maingo.content, Files.readString(Path.of("_tmp/folder", maingo.name)))
assertEquals(helloworldgo.content, Files.readString(Path.of("_tmp/folder/utils", helloworldgo.name)))
}
@Test
@ -90,7 +81,7 @@ class FSCreatorTest {
FSFile("hi", "hi"),
),
),
FSFolder("folder", listOf()),
FSFolder("another-folder", listOf()),
FSFile("1.txt", "One!"),
FSFile("2.txt", "Two!"),
),
@ -104,8 +95,7 @@ class FSCreatorTest {
"folder",
listOf(
FSFolder(
// Repeated name should be fine here (not throw)
"folder",
"another-folder",
listOf(
FSFolder(
"secrets",
@ -122,65 +112,30 @@ class FSCreatorTest {
"_tmp",
)
}
assertEquals("hi", File("_tmp/folder/sub-folder/hi").readText())
assertEquals("P4ssW0rd", File("_tmp/folder/folder/secrets/secret").readText())
assertEquals("One is a good number", File("_tmp/folder/1.txt").readText())
assertEquals("Two!", File("_tmp/folder/2.txt").readText())
assertEquals("Three!", File("_tmp/folder/3.txt").readText())
assertEquals("hi", Files.readString(Path.of("_tmp/folder/sub-folder/hi")))
assertEquals("P4ssW0rd", Files.readString(Path.of("_tmp/folder/another-folder/secrets/secret")))
assertEquals("One is a good number", Files.readString(Path.of("_tmp/folder/1.txt")))
assertEquals("Two!", Files.readString(Path.of("_tmp/folder/2.txt")))
assertEquals("Three!", Files.readString(Path.of("_tmp/folder/3.txt")))
}
@Test
@Timeout(500, unit = TimeUnit.MILLISECONDS) // in case implementation starts trying to handle cyclic folders
fun `create throws on cyclic folder`() {
@Timeout(500, unit = TimeUnit.MILLISECONDS) // in case implementation starts trying to handle recursion
fun `create throws on recursive folder`() {
val files = mutableListOf<FSEntry>()
val folder = FSFolder("folder", files)
files.add(folder)
assertThrows<CyclicFolderException> {
assertThrows<FileSystemException> {
creator.create(folder, "_tmp")
}
}
}
@Test
@Timeout(500, unit = TimeUnit.MILLISECONDS)
fun `create throws on long cyclic folder`() {
val files = mutableListOf<FSEntry>()
val folder1 = FSFolder("folder", files)
val folder2 = FSFolder("folder2", listOf(folder1))
val folder3 = FSFolder("folder3", listOf(folder2))
val folder4 = FSFolder("folder4", listOf(folder3))
files.add(folder4)
assertThrows<CyclicFolderException> {
creator.create(folder4, "_tmp")
}
}
@Test
fun `create throws on folder with duplicate names`() {
val folder =
FSFolder(
"folder",
listOf(
FSFile("README.md", "# Test File"),
FSFile("hello-world.txt", "Hello World!"),
FSFolder(
"src",
listOf(
FSFile("README.md", "# Source files"),
FSFolder(
"solution",
listOf(
FSFile("solution.py", "print('1 + 1 = 1')"),
FSFile("tmp", "A temporary file"),
FSFolder("tmp", listOf()),
),
),
),
),
FSFolder("tmp", listOf()),
),
)
assertThrows<DuplicateEntryNameException> {
creator.create(folder, "_tmp")
fun deleteRecursive(path: Path) {
if (Files.isDirectory(path)) {
for (child in Files.list(path)) {
deleteRecursive(child)
}
}
Files.delete(path)
}

136
src/test/kotlin/filesystem/FSEntryTest.kt
View File

@ -1,136 +0,0 @@
package filesystem
import org.junit.jupiter.api.*
import kotlin.test.assertFalse
import kotlin.test.assertTrue
class FSEntryTest {
@Test
fun `valid name entries`() {
assertDoesNotThrow("should construct FSFile and FSFolder without throwing") {
FSFile("A file with a name.tar.xz", "Contents")
FSFolder(".a folder with a name", listOf())
}
}
@Test
fun `invalid name entries`() {
assertThrows<InvalidEntryNameException> {
FSFile("File/here", "Contents")
}
assertThrows<InvalidEntryNameException> {
FSFolder("Folder/here", listOf())
}
assertThrows<InvalidEntryNameException> {
FSFolder(".", listOf())
}
assertThrows<InvalidEntryNameException> {
FSFolder("/", listOf())
}
}
@Test
fun `non-cyclic folder`() {
val folder =
FSFolder(
"folder",
listOf(
FSFolder("folder", listOf()),
FSFile("text.txt", "Hello!"),
),
)
assertFalse(folder.isCyclic())
}
@Test
fun `cyclic folder`() {
val files = mutableListOf<FSEntry>()
val folder = FSFolder("folder", files)
files.add(folder)
assertTrue(folder.isCyclic())
}
@Test
fun `long cyclic folder`() {
val files = mutableListOf<FSEntry>()
val folder1 = FSFolder("folder", files)
val folder2 = FSFolder("folder2", listOf(folder1))
val folder3 = FSFolder("folder3", listOf(folder2))
val folder4 = FSFolder("folder4", listOf(folder3))
files.add(folder4)
assertTrue(folder1.isCyclic())
assertTrue(folder2.isCyclic())
assertTrue(folder3.isCyclic())
assertTrue(folder4.isCyclic())
}
@Test
fun `no duplicate names folder`() {
val folder =
FSFolder(
"folder",
listOf(
FSFile("README.md", "# Test File"),
FSFile("hello-world.txt", "Hello World!"),
FSFolder(
"src",
listOf(
FSFile("README.md", "# Source files"),
FSFile("solution-1.py", "print('1 + 1 = 1')"),
FSFile("solution-2.py", "print('1 + 1 = 1')"),
),
),
FSFolder("tmp", listOf()),
),
)
assertFalse(folder.hasDuplicateNames())
assertFalse(folder.deepHasDuplicateNames())
}
@Test
fun `shallow duplicate names folder`() {
val folder =
FSFolder(
"folder",
listOf(
FSFile("README.md", "# Test File"),
FSFile("hello-world.txt", "Hello World!"),
FSFolder(
"src",
listOf(
FSFile("README.md", "# Source files"),
FSFile("solution-1.py", "print('1 + 1 = 1')"),
FSFile("solution-2.py", "print('1 + 1 = 1')"),
),
),
FSFolder("tmp", listOf()),
FSFile("tmp", "A temporary file"),
),
)
assertTrue(folder.hasDuplicateNames())
assertTrue(folder.deepHasDuplicateNames())
}
@Test
fun `deep duplicate names folder`() {
val folder =
FSFolder(
"folder",
listOf(
FSFile("README.md", "# Test File"),
FSFile("hello-world.txt", "Hello World!"),
FSFolder(
"src",
listOf(
FSFile("README.md", "# Source files"),
FSFile("solution-1.py", "print('1 + 1 = 1')"),
FSFile("solution-1.py", "print('1 + 1 = 1')"),
),
),
FSFolder("tmp", listOf()),
),
)
assertFalse(folder.hasDuplicateNames())
assertTrue(folder.deepHasDuplicateNames())
}
}