File assertions: exists, isDir, isFile; updated Gradle to 4.0

gradle/wrapper/gradle-wrapper.properties

@@ -1,4 +1,4 @@
-#Fri Mar 17 11:18:59 CET 2017
+#Fri Jun 23 18:28:02 CEST 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME

src/main/kotlin/org/amshove/kluent/File.kt

@@ -0,0 +1,28 @@
+package org.amshove.kluent
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import java.io.File
+
+fun File.shouldExist() = assertTrue("The file does not exist", this.exists())
+fun File.shouldNotExist() = assertFalse("The file exists", this.exists())
+
+
+fun File.shouldBeDir() = assertTrue("The file is not a directory", this.isDirectory)
+fun File.shouldNotBeDir() = assertFalse("The file is a directory", this.isDirectory)
+
+
+fun File.shouldBeFile() = assertTrue("The file is not a file", this.isFile)
+fun File.shouldNotBeFile() = assertFalse("The file is a file", this.isFile)
+
+
+infix fun File.shouldHaveExtension(other: String) = this.extension shouldEqualTo other
+infix fun File.shouldNotHaveExtension(other: String) = this.extension shouldNotEqualTo other
+infix fun File.`should have extension`(other: String) = this shouldHaveExtension other
+infix fun File.`should not have extension`(other: String) = this shouldNotHaveExtension other
+
+infix fun File.shouldHaveName(other: String) = this.name shouldEqualTo other
+infix fun File.shouldNotHaveName(other: String) = this.name shouldNotEqualTo other
+infix fun File.`should have name`(other: String) = this shouldHaveName other
+infix fun File.`should not have name`(other: String) = this shouldNotHaveName other
+

src/test/kotlin/org/amshove/kluent/tests/assertions/file/FileTestHelper.kt

@@ -0,0 +1,15 @@
+package org.amshove.kluent.tests.assertions.file
+
+import java.io.File
+
+/**
+ * Constructs a directory or a plain file with no content and deletes it after the body has run
+ */
+fun File.useFile(isDir: Boolean = false, body: (file: File) -> Unit) = try {
+    if (isDir) this.mkdir() else this.writeText("")
+    body(this)
+} finally {
+    if (!this.delete()) throw Exception("Could not delete file")
+}
+
+fun File.useDir(body: (file: File) -> Unit) = this.useFile(true, body)

src/test/kotlin/org/amshove/kluent/tests/assertions/file/ShouldBeDirTests.kt

@@ -0,0 +1,39 @@
+package org.amshove.kluent.tests.assertions.file
+
+import org.amshove.kluent.shouldBeDir
+import org.amshove.kluent.shouldNotBeDir
+import org.jetbrains.spek.api.Spek
+import java.io.File
+import kotlin.test.assertFails
+
+class ShouldBeDirTests : Spek({
+    val dir = File("testDir")
+    val file = File("test")
+    given("the shouldBeDir method") {
+        on("passing a File that is a directory") {
+            it("should pass") {
+                dir.useDir { it.shouldBeDir() }
+            }
+        }
+
+        on("passing a File that is not a directory") {
+            it("should fail") {
+                file.useFile { assertFails { it.shouldBeDir() } }
+            }
+        }
+    }
+
+    given("the shouldNotBeDir method") {
+        on("passing a File that is a directory") {
+            it("should fail") {
+                dir.useDir { assertFails { it.shouldNotBeDir() } }
+            }
+        }
+        on("passing a File that is not a directory") {
+            it("should pass") {
+                file.useFile { it.shouldNotBeDir() }
+            }
+        }
+    }
+
+})

src/test/kotlin/org/amshove/kluent/tests/assertions/file/ShouldBeFileTests.kt

@@ -0,0 +1,38 @@
+package org.amshove.kluent.tests.assertions.file
+
+import org.amshove.kluent.shouldBeFile
+import org.amshove.kluent.shouldNotBeFile
+import org.jetbrains.spek.api.Spek
+import java.io.File
+import kotlin.test.assertFails
+
+class ShouldBeFileTests : Spek({
+    val file = File("isFile")
+    val dir = File("isDir")
+    given("the shouldBeFile method") {
+        on("passing a File that is a file") {
+            it("should pass") {
+                file.useFile { it.shouldBeFile() }
+            }
+        }
+        on("passing a File that is a directory") {
+            it("should fail") {
+                dir.useDir { assertFails { it.shouldBeFile() } }
+            }
+        }
+    }
+
+    given("the shouldNotBeFile method") {
+        on("passing a File that is a file") {
+            it("should fail") {
+                file.useFile { assertFails { it.shouldNotBeFile() } }
+            }
+        }
+        on("passing a File that is a directory") {
+            it("should pass") {
+                dir.useDir { it.shouldNotBeFile() }
+            }
+        }
+    }
+
+})

src/test/kotlin/org/amshove/kluent/tests/assertions/file/ShouldExistTests.kt

@@ -0,0 +1,36 @@
+package org.amshove.kluent.tests.assertions.file
+
+import org.amshove.kluent.shouldExist
+import org.amshove.kluent.shouldNotExist
+import org.jetbrains.spek.api.Spek
+import java.io.File
+import kotlin.test.assertFails
+
+class ShouldExistTests : Spek({
+    val file = File("test")
+    given("the shouldExist method") {
+        on("passing a File that exists") {
+            it("should pass") {
+                file.useFile { it.shouldExist() }
+            }
+        }
+        on("passing a File that doesn't exist") {
+            it("should fail") {
+                assertFails { file.shouldExist() }
+            }
+        }
+    }
+
+    given("the shouldNotExist method") {
+        on("passing a File that exists") {
+            it("should fail") {
+                file.useFile { assertFails { it.shouldNotExist() } }
+            }
+        }
+        on("passing a File that doesn't exist") {
+            it("should pass") {
+                file.shouldNotExist()
+            }
+        }
+    }
+})

src/test/kotlin/org/amshove/kluent/tests/assertions/file/ShouldHaveExtensionTests.kt

@@ -0,0 +1,41 @@
+package org.amshove.kluent.tests.assertions.file
+
+import org.amshove.kluent.shouldHaveExtension
+import org.amshove.kluent.shouldNotHaveExtension
+import org.jetbrains.spek.api.Spek
+import java.io.File
+import kotlin.test.assertFails
+
+class ShouldHaveExtensionTests : Spek({
+    val txtFile = File("test.txt")
+    val wavFile = File("test.wav")
+    given("the shouldHaveExtension method") {
+
+        on("passing txt on a .txt File") {
+            it("should pass") {
+                txtFile.useFile { it shouldHaveExtension "txt" }
+            }
+        }
+
+        on("passing txt on a File that is not .txt") {
+            it("should fail") {
+                wavFile.useFile { assertFails { it shouldHaveExtension "txt" } }
+            }
+        }
+
+    }
+
+    given("the shouldNotHaveExtension method") {
+        on("passing txt on a .txt File") {
+            it("should fail") {
+                txtFile.useFile { assertFails { it shouldNotHaveExtension "txt" } }
+            }
+        }
+        on("passing txt on a File that is not .txt") {
+            it("should pass") {
+                wavFile.useFile { it shouldNotHaveExtension "txt" }
+            }
+        }
+    }
+
+})

src/test/kotlin/org/amshove/kluent/tests/assertions/file/ShouldHaveNameTests.kt

@@ -0,0 +1,39 @@
+package org.amshove.kluent.tests.assertions.file
+
+import org.amshove.kluent.shouldHaveName
+import org.amshove.kluent.shouldNotHaveName
+import org.jetbrains.spek.api.Spek
+import java.io.File
+import kotlin.test.assertFails
+
+class ShouldHaveNameTests : Spek({
+    val name = "thisfilenameisweird.csv"
+    val file = File(name)
+    given("the shouldHaveName method") {
+        on("passing the correct name of the File") {
+            it("should pass") {
+                file.useFile { it shouldHaveName name }
+            }
+        }
+        on("passing the incorrect name of the File") {
+            it("should fail") {
+                file.useFile { assertFails { it shouldHaveName "someothername" } }
+            }
+        }
+    }
+
+    given("the shouldNotHaveName method") {
+        on("passing the correct name of the File") {
+            it("should fail") {
+                file.useFile { assertFails { it shouldNotHaveName name } }
+            }
+        }
+        on("passing the incorrect name of the File") {
+            it("should pass") {
+                file.useFile { it shouldNotHaveName "someothername" }
+            }
+        }
+    }
+
+
+})

src/test/kotlin/org/amshove/kluent/tests/backtickassertions/file/ShouldHaveExtensionTests.kt

@@ -0,0 +1,42 @@
+package org.amshove.kluent.tests.backtickassertions.file
+
+import org.amshove.kluent.`should have extension`
+import org.amshove.kluent.`should not have extension`
+import org.amshove.kluent.tests.assertions.file.useFile
+import org.jetbrains.spek.api.Spek
+import java.io.File
+import kotlin.test.assertFails
+
+class ShouldHaveExtensionTests : Spek({
+    val txtFile = File("test.txt")
+    val wavFile = File("test.wav")
+    given("the shouldHaveExtension method") {
+
+        on("passing txt on a .txt File") {
+            it("should pass") {
+                txtFile.useFile { it `should have extension` "txt" }
+            }
+        }
+
+        on("passing txt on a File that is not .txt") {
+            it("should fail") {
+                wavFile.useFile { assertFails { it `should have extension` "txt" } }
+            }
+        }
+
+    }
+
+    given("the shouldNotHaveExtension method") {
+        on("passing txt on a .txt File") {
+            it("should fail") {
+                txtFile.useFile { assertFails { it `should not have extension` "txt" } }
+            }
+        }
+        on("passing txt on a File that is not .txt") {
+            it("should pass") {
+                wavFile.useFile { it `should not have extension` "txt" }
+            }
+        }
+    }
+
+})

src/test/kotlin/org/amshove/kluent/tests/backtickassertions/file/ShouldHaveNameTests.kt

@@ -0,0 +1,39 @@
+package org.amshove.kluent.tests.backtickassertions.file
+
+import org.amshove.kluent.`should have name`
+import org.amshove.kluent.`should not have name`
+import org.amshove.kluent.tests.assertions.file.useFile
+import org.jetbrains.spek.api.Spek
+import java.io.File
+import kotlin.test.assertFails
+
+class ShouldHaveNameTests : Spek({
+    val name = "thisfilenameisweird.csv"
+    val file = File(name)
+    given("the shouldHaveName method") {
+        on("passing the correct name of the File") {
+            it("should pass") {
+                file.useFile { it `should have name` name }
+            }
+        }
+        on("passing the incorrect name of the File") {
+            it("should fail") {
+                file.useFile { assertFails { it `should have name` "someothername" } }
+            }
+        }
+    }
+
+    given("the shouldNotHaveName method") {
+        on("passing the correct name of the File") {
+            it("should fail") {
+                file.useFile { assertFails { it `should not have name` name } }
+            }
+        }
+        on("passing the incorrect name of the File") {
+            it("should pass") {
+                file.useFile { it `should not have name` "someothername" }
+            }
+        }
+    }
+
+})