Work with real files

Author: SimplyDanny

Tests/FileSystemAccessTests/ConfigurationTests+Mock.swift

@@ -33,6 +33,10 @@ internal extension ConfigurationTests {
             static var remoteConfigLocalRef: String { level0.stringByAppendingPathComponent("RemoteConfig/LocalRef") }
             static var remoteConfigCycle: String { level0.stringByAppendingPathComponent("RemoteConfig/Cycle") }
             static var emptyFolder: String { level0.stringByAppendingPathComponent("EmptyFolder") }
+
+            static var exclusionTests: String { testResourcesPath.stringByAppendingPathComponent("ExclusionTests") }
+            static var directory: String { exclusionTests.stringByAppendingPathComponent("directory") }
+            static var directoryExcluded: String { directory.stringByAppendingPathComponent("excluded") }
         }
 
         // MARK: YAML File Paths

Tests/FileSystemAccessTests/ConfigurationTests.swift

@@ -281,85 +281,75 @@ final class ConfigurationTests: SwiftLintTestCase {
         XCTAssertEqual(actualExcludedPath, desiredExcludedPath)
     }
 
-    private class TestFileManager: LintableFileManager {
-        func filesToLint(inPath path: String, rootDirectory _: String? = nil) -> [String] {
-            var filesToLint: [String] = []
-            switch path {
-            case "directory": filesToLint = [
-                "directory/File1.swift",
-                "directory/File2.swift",
-                "directory/excluded/Excluded.swift",
-                "directory/ExcludedFile.swift",
-            ]
-            case "directory/excluded": filesToLint = ["directory/excluded/Excluded.swift"]
-            case "directory/ExcludedFile.swift": filesToLint = ["directory/ExcludedFile.swift"]
-            default: XCTFail("Should not be called with path \(path)")
-            }
-            return filesToLint.absolutePathsStandardized()
-        }
-
-        func modificationDate(forFileAtPath _: String) -> Date? {
-            nil
-        }
-
-        func isFile(atPath path: String) -> Bool {
-            path.hasSuffix(".swift")
-        }
-    }
-
     func testExcludedPaths() {
-        let fileManager = TestFileManager()
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
         let configuration = Configuration(
             includedPaths: ["directory"],
             excludedPaths: ["directory/excluded", "directory/ExcludedFile.swift"]
         )
 
-        let paths = configuration.lintablePaths(inPath: "",
-                                                forceExclude: false,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        let paths = configuration.lintablePaths(
+            inPath: "",
+            forceExclude: false,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift"], paths)
     }
 
     func testForceExcludesFile() {
-        let fileManager = TestFileManager()
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
         let configuration = Configuration(excludedPaths: ["directory/ExcludedFile.swift"])
-        let paths = configuration.lintablePaths(inPath: "directory/ExcludedFile.swift",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual([], paths)
+
+        let paths = configuration.lintablePaths(
+            inPath: "directory/ExcludedFile.swift",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        XCTAssert(paths.isEmpty)
     }
 
     func testForceExcludesFileNotPresentInExcluded() {
-        let fileManager = TestFileManager()
-        let configuration = Configuration(includedPaths: ["directory"],
-                                          excludedPaths: ["directory/ExcludedFile.swift", "directory/excluded"])
-        let paths = configuration.lintablePaths(inPath: "",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
+        let configuration = Configuration(
+            includedPaths: ["directory"],
+            excludedPaths: ["directory/ExcludedFile.swift", "directory/excluded"]
+        )
+
+        let paths = configuration.lintablePaths(
+            inPath: "",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift"], paths)
     }
 
     func testForceExcludesDirectory() {
-        let fileManager = TestFileManager()
-        let configuration = Configuration(excludedPaths: ["directory/excluded", "directory/ExcludedFile.swift"])
-        let paths = configuration.lintablePaths(inPath: "directory",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
+        let configuration = Configuration(excludedPaths: ["directory/excluded"])
+
+        let paths = configuration.lintablePaths(
+            inPath: "directory",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift", "directory/ExcludedFile.swift"], paths)
     }
 
     func testForceExcludesDirectoryThatIsNotInExcludedButHasChildrenThatAre() {
-        let fileManager = TestFileManager()
-        let configuration = Configuration(excludedPaths: ["directory/excluded", "directory/ExcludedFile.swift"])
-        let paths = configuration.lintablePaths(inPath: "directory",
-                                                forceExclude: true,
-                                                excludeByPrefix: false,
-                                                fileManager: fileManager)
-        XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"].absolutePathsStandardized(), paths)
+        XCTAssert(FileManager.default.changeCurrentDirectoryPath(Mock.Dir.exclusionTests))
+        let configuration = Configuration(excludedPaths: ["directory/ExcludedFile.swift"])
+
+        let paths = configuration.lintablePaths(
+            inPath: "directory",
+            forceExclude: true,
+            excludeByPrefix: false
+        )
+
+        assertEqual(["directory/File1.swift", "directory/File2.swift", "directory/excluded/Excluded.swift"], paths)
     }
 
     func testLintablePaths() {
@@ -621,6 +611,18 @@ extension ConfigurationTests {
         XCTAssertEqual(configuration1.cachePath, "cache/path/1")
         XCTAssertEqual(configuration2.cachePath, "cache/path/1")
     }
+
+    private func assertEqual(_ relativeExpectedPaths: [String],
+                             _ actualPaths: [String],
+                             file: StaticString = #filePath,
+                             line: UInt = #line) {
+        XCTAssertEqual(
+            relativeExpectedPaths.absolutePathsStandardized().sorted(),
+            actualPaths.sorted(),
+            file: file,
+            line: line
+        )
+    }
 }
 
 private extension Sequence where Element == String {

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/ExcludedFile.swift

@@ -0,0 +1,4 @@
+// Excluded test file
+func excludedFunction() {
+    print("Excluded File")
+}

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/File1.swift

@@ -0,0 +1,4 @@
+// Test file 1
+func testFunction1() {
+    print("File 1")
+}

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/File2.swift

@@ -0,0 +1,4 @@
+// Test file 2
+func testFunction2() {
+    print("File 2")
+}

Tests/FileSystemAccessTests/Resources/ExclusionTests/directory/excluded/Excluded.swift

@@ -0,0 +1,4 @@
+// Excluded directory test file
+func excludedDirectoryFunction() {
+    print("Excluded in directory")
+}