🚛 Moved tests around, added Feature, UI tests

tests/unit/Parsers/HomebrewPackageTest.swift

@@ -0,0 +1,88 @@
+//
+//  BrewJsonParserTest.swift
+//  phpmon-tests
+//
+//  Created by Nico Verbruggen on 14/02/2021.
+//  Copyright © 2022 Nico Verbruggen. All rights reserved.
+//
+
+import XCTest
+
+class HomebrewPackageTest: XCTestCase {
+
+    // - MARK: SYNTHETIC TESTS
+
+    static var jsonBrewFile: URL {
+        return Bundle(for: Self.self)
+            .url(forResource: "brew-formula", withExtension: "json")!
+    }
+
+    func testCanLoadExtensionJson() throws {
+        let json = try! String(contentsOf: Self.jsonBrewFile, encoding: .utf8)
+        let package = try! JSONDecoder().decode(
+            [HomebrewPackage].self, from: json.data(using: .utf8)!
+        ).first!
+
+        XCTAssertEqual(package.name, "php")
+        XCTAssertEqual(package.full_name, "php")
+        XCTAssertEqual(package.aliases.first!, "php@8.1")
+        XCTAssertEqual(package.installed.contains(where: { installed in
+            installed.version.starts(with: "8.1")
+        }), true)
+    }
+
+    static var jsonBrewServicesFile: URL {
+        return Bundle(for: Self.self)
+            .url(forResource: "brew-services", withExtension: "json")!
+    }
+
+    func testCanParseServicesJson() throws {
+        let json = try! String(contentsOf: Self.jsonBrewServicesFile, encoding: .utf8)
+        let services = try! JSONDecoder().decode(
+            [HomebrewService].self, from: json.data(using: .utf8)!
+        )
+
+        XCTAssertGreaterThan(services.count, 0)
+        XCTAssertEqual(services.first?.name, "dnsmasq")
+        XCTAssertEqual(services.first?.service_name, "homebrew.mxcl.dnsmasq")
+    }
+
+    // - MARK: LIVE TESTS
+
+    /// This test requires that you have a valid Homebrew installation set up,
+    /// and requires the Valet services to be installed: php, nginx and dnsmasq.
+    /// If this test fails, there is an issue with your Homebrew installation
+    /// or the JSON API of the Homebrew output may have changed.
+    func testCanParseServicesJsonFromCliOutput() async throws {
+        ActiveShell.useSystem()
+
+        let services = try! JSONDecoder().decode(
+            [HomebrewService].self,
+            from: await Shell.pipe(
+                "sudo \(Paths.brew) services info --all --json"
+            ).out.data(using: .utf8)!
+        ).filter({ service in
+            return ["php", "nginx", "dnsmasq"].contains(service.name)
+        })
+
+        XCTAssertTrue(services.contains(where: {$0.name == "php"}))
+        XCTAssertTrue(services.contains(where: {$0.name == "nginx"}))
+        XCTAssertTrue(services.contains(where: {$0.name == "dnsmasq"}))
+        XCTAssertEqual(services.count, 3)
+    }
+
+    /// This test requires that you have a valid Homebrew installation set up,
+    /// and requires the `php` formula to be installed.
+    /// If this test fails, there is an issue with your Homebrew installation
+    /// or the JSON API of the Homebrew output may have changed.
+    func testCanLoadExtensionJsonFromCliOutput() async throws {
+        ActiveShell.useSystem()
+
+        let package = try! JSONDecoder().decode(
+            [HomebrewPackage].self,
+            from: await Shell.pipe("\(Paths.brew) info php --json").out.data(using: .utf8)!
+        ).first!
+
+        XCTAssertTrue(package.name == "php")
+    }
+}

tests/unit/Parsers/NginxConfigurationTest.swift

@@ -0,0 +1,81 @@
+//
+//  NginxConfigurationTest.swift
+//  phpmon-tests
+//
+//  Created by Nico Verbruggen on 29/11/2021.
+//  Copyright © 2022 Nico Verbruggen. All rights reserved.
+//
+
+import XCTest
+
+class NginxConfigurationTest: XCTestCase {
+
+    // MARK: - Test Files
+
+    static var regularUrl: URL {
+        return Bundle(for: Self.self).url(forResource: "nginx-site", withExtension: "test")!
+    }
+
+    static var isolatedUrl: URL {
+        return Bundle(for: Self.self).url(forResource: "nginx-site-isolated", withExtension: "test")!
+    }
+
+    static var proxyUrl: URL {
+        return Bundle(for: Self.self).url(forResource: "nginx-proxy", withExtension: "test")!
+    }
+
+    static var secureProxyUrl: URL {
+        return Bundle(for: Self.self).url(forResource: "nginx-secure-proxy", withExtension: "test")!
+    }
+
+    static var customTldProxyUrl: URL {
+        return Bundle(for: Self.self).url(forResource: "nginx-secure-proxy-custom-tld", withExtension: "test")!
+    }
+
+    // MARK: - Tests
+
+    func testCanDetermineSiteNameAndTld() throws {
+        XCTAssertEqual(
+            "nginx-site",
+            NginxConfigurationFile.from(filePath: NginxConfigurationTest.regularUrl.path)?.domain
+        )
+        XCTAssertEqual(
+            "test",
+            NginxConfigurationFile.from(filePath: NginxConfigurationTest.regularUrl.path)?.tld
+        )
+    }
+
+    func testCanDetermineIsolation() throws {
+        XCTAssertNil(
+            NginxConfigurationFile.from(filePath: NginxConfigurationTest.regularUrl.path)?.isolatedVersion
+        )
+
+        XCTAssertEqual(
+            "8.1",
+            NginxConfigurationFile.from(filePath: NginxConfigurationTest.isolatedUrl.path)?.isolatedVersion
+        )
+    }
+
+    func testCanDetermineProxy() throws {
+        let proxied = NginxConfigurationFile.from(filePath: NginxConfigurationTest.proxyUrl.path)!
+        XCTAssertTrue(proxied.contents.contains("# valet stub: proxy.valet.conf"))
+        XCTAssertEqual("http://127.0.0.1:90", proxied.proxy)
+
+        let normal = NginxConfigurationFile.from(filePath: NginxConfigurationTest.regularUrl.path)!
+        XCTAssertFalse(normal.contents.contains("# valet stub: proxy.valet.conf"))
+        XCTAssertEqual(nil, normal.proxy)
+    }
+
+    func testCanDetermineSecuredProxy() throws {
+        let proxied = NginxConfigurationFile.from(filePath: NginxConfigurationTest.secureProxyUrl.path)!
+        XCTAssertTrue(proxied.contents.contains("# valet stub: secure.proxy.valet.conf"))
+        XCTAssertEqual("http://127.0.0.1:90", proxied.proxy)
+    }
+
+    func testCanDetermineProxyWithCustomTld() throws {
+        let proxied = NginxConfigurationFile.from(filePath: NginxConfigurationTest.customTldProxyUrl.path)!
+        XCTAssertTrue(proxied.contents.contains("# valet stub: secure.proxy.valet.conf"))
+        XCTAssertEqual("http://localhost:8080", proxied.proxy)
+    }
+
+}

tests/unit/Parsers/PhpConfigurationTest.swift

@@ -0,0 +1,84 @@
+//
+//  PhpConfigurationTest.swift
+//  PHP Monitor
+//
+//  Created by Nico Verbruggen on 04/05/2022.
+//  Copyright © 2022 Nico Verbruggen. All rights reserved.
+//
+
+import XCTest
+
+class PhpConfigurationTest: XCTestCase {
+
+    static var phpIniFileUrl: URL {
+        return Bundle(for: Self.self).url(forResource: "php", withExtension: "ini")!
+    }
+
+    func testCanLoadExtension() throws {
+        let iniFile = PhpConfigurationFile.from(filePath: Self.phpIniFileUrl.path)!
+
+        XCTAssertNotNil(iniFile)
+
+        XCTAssertGreaterThan(iniFile.extensions.count, 0)
+    }
+
+    func testCanCheckKeyExistence() throws {
+        let iniFile = PhpConfigurationFile.from(filePath: Self.phpIniFileUrl.path)!
+
+        XCTAssertTrue(iniFile.has(key: "error_reporting"))
+        XCTAssertTrue(iniFile.has(key: "display_errors"))
+        XCTAssertFalse(iniFile.has(key: "my_unknown_key"))
+    }
+
+    func testCanCheckKeyValue() throws {
+        let iniFile = PhpConfigurationFile.from(filePath: Self.phpIniFileUrl.path)!
+
+        XCTAssertNotNil(iniFile.get(for: "error_reporting"))
+        XCTAssert(iniFile.get(for: "error_reporting") == "E_ALL")
+
+        XCTAssertNotNil(iniFile.get(for: "display_errors"))
+        XCTAssert(iniFile.get(for: "display_errors") == "On")
+    }
+
+    func testCanCustomizeConfigurationValue() throws {
+        let destination = Utility
+            .copyToTemporaryFile(resourceName: "php", fileExtension: "ini")!
+
+        let configurationFile = PhpConfigurationFile
+            .from(filePath: destination.path)!
+
+        // 0. Verify the original value
+        XCTAssertEqual(configurationFile.get(for: "error_reporting"), "E_ALL")
+
+        // 1. Change the value
+        try! configurationFile.replace(
+            key: "error_reporting",
+            value: "E_ALL & ~E_DEPRECATED & ~E_STRICT"
+        )
+        XCTAssertEqual(
+            configurationFile.get(for: "error_reporting"),
+            "E_ALL & ~E_DEPRECATED & ~E_STRICT"
+        )
+
+        // 2. Ensure that same key and value doesn't break subsequent saves
+        try! configurationFile.replace(
+            key: "error_reporting",
+            value: "error_reporting"
+        )
+        XCTAssertEqual(
+            configurationFile.get(for: "error_reporting"),
+            "error_reporting"
+        )
+
+        // 3. Verify subsequent saves weren't broken
+        try! configurationFile.replace(
+            key: "error_reporting",
+            value: "E_ALL"
+        )
+        XCTAssertEqual(
+            configurationFile.get(for: "error_reporting"),
+            "E_ALL"
+        )
+    }
+
+}

tests/unit/Parsers/PhpExtensionTest.swift

@@ -0,0 +1,72 @@
+//
+//  ExtensionParserTest.swift
+//  phpmon-tests
+//
+//  Created by Nico Verbruggen on 13/02/2021.
+//  Copyright © 2022 Nico Verbruggen. All rights reserved.
+//
+
+import XCTest
+
+class PhpExtensionTest: XCTestCase {
+
+    static var phpIniFileUrl: URL {
+        return Bundle(for: Self.self).url(forResource: "php", withExtension: "ini")!
+    }
+
+    func testCanLoadExtension() throws {
+        let extensions = PhpExtension.from(filePath: Self.phpIniFileUrl.path)
+
+        XCTAssertGreaterThan(extensions.count, 0)
+    }
+
+    func testExtensionNameIsCorrect() throws {
+        let extensions = PhpExtension.from(filePath: Self.phpIniFileUrl.path)
+
+        let extensionNames = extensions.map { (ext) -> String in
+            return ext.name
+        }
+
+        // These 6 should be found
+        XCTAssertTrue(extensionNames.contains("xdebug"))
+        XCTAssertTrue(extensionNames.contains("imagick"))
+        XCTAssertTrue(extensionNames.contains("sodium-next"))
+        XCTAssertTrue(extensionNames.contains("opcache"))
+        XCTAssertTrue(extensionNames.contains("yaml"))
+        XCTAssertTrue(extensionNames.contains("custom"))
+
+        XCTAssertFalse(extensionNames.contains("fake"))
+        XCTAssertFalse(extensionNames.contains("nice"))
+    }
+
+    func testExtensionStatusIsCorrect() throws {
+        let extensions = PhpExtension.from(filePath: Self.phpIniFileUrl.path)
+
+        // xdebug should be enabled
+        XCTAssertEqual(extensions[0].enabled, true)
+
+        // imagick should be disabled
+        XCTAssertEqual(extensions[1].enabled, false)
+    }
+
+    func testToggleWorksAsExpected() async throws {
+        let destination = Utility.copyToTemporaryFile(resourceName: "php", fileExtension: "ini")!
+        let extensions = PhpExtension.from(filePath: destination.path)
+        XCTAssertEqual(extensions.count, 6)
+
+        // Try to disable xdebug (should be detected first)!
+        let xdebug = extensions.first!
+        XCTAssertTrue(xdebug.name == "xdebug")
+        XCTAssertEqual(xdebug.enabled, true)
+        await xdebug.toggle()
+        XCTAssertEqual(xdebug.enabled, false)
+
+        // Check if the file contains the appropriate data
+        let file = try! String(contentsOf: destination, encoding: .utf8)
+        XCTAssertTrue(file.contains("; zend_extension=\"xdebug.so\""))
+
+        // Make sure if we load the data again, it's disabled
+        XCTAssertEqual(PhpExtension.from(filePath: destination.path).first!.enabled, false)
+    }
+
+}

tests/unit/Parsers/ValetConfigurationTest.swift

@@ -0,0 +1,39 @@
+//
+//  ValetConfigParserTest.swift
+//  phpmon-tests
+//
+//  Created by Nico Verbruggen on 29/11/2021.
+//  Copyright © 2022 Nico Verbruggen. All rights reserved.
+//
+
+import XCTest
+
+class ValetConfigurationTest: XCTestCase {
+
+    static var jsonConfigFileUrl: URL {
+        return Bundle(for: Self.self).url(
+            forResource: "valet-config",
+            withExtension: "json"
+        )!
+    }
+
+    func testCanLoadConfigFile() throws {
+        let json = try? String(
+            contentsOf: Self.jsonConfigFileUrl,
+            encoding: .utf8
+        )
+        let config = try! JSONDecoder().decode(
+            Valet.Configuration.self,
+            from: json!.data(using: .utf8)!
+        )
+
+        XCTAssertEqual(config.tld, "test")
+        XCTAssertEqual(config.paths, [
+            "/Users/username/.config/valet/Sites",
+            "/Users/username/Sites"
+        ])
+        XCTAssertEqual(config.defaultSite, "/Users/username/default-site")
+        XCTAssertEqual(config.loopback, "127.0.0.1")
+    }
+
+}