Merge branch 'test-custom-dns-ios-437'

3 files changed, 103 insertions, 1 deletions

diff --git a/.github/workflows/ios-end-to-end-tests.yml b/.github/workflows/ios-end-to-end-tests.yml
index b44665649f..d9907295f0 100644
--- a/.github/workflows/ios-end-to-end-tests.yml
+++ b/.github/workflows/ios-end-to-end-tests.yml
@@ -33,7 +33,6 @@ jobs:
           toolchain: stable
           override: true
           target: aarch64-apple-ios
-
       - name: Checkout repository
         uses: actions/checkout@v4
 
diff --git a/ios/MullvadVPNUITests/Networking/Networking.swift b/ios/MullvadVPNUITests/Networking/Networking.swift
index 67e2156603..4af87b5523 100644
--- a/ios/MullvadVPNUITests/Networking/Networking.swift
+++ b/ios/MullvadVPNUITests/Networking/Networking.swift
@@ -15,6 +15,11 @@ enum NetworkingError: Error {
     case internalError(reason: String)
 }
 
+struct DNSServerEntry: Decodable {
+    let organization: String
+    let mullvad_dns: Bool
+}
+
 /// Class with methods for verifying network connectivity
 class Networking {
     /// Get IP address of the iOS device under test
@@ -63,6 +68,18 @@ class Networking {
         throw NetworkingError.internalError(reason: "Failed to determine device's IP address")
     }
 
+    /// Get configured ad serving domain as URL object
+    private static func getAdServingDomainURL() -> URL? {
+        guard let adServingDomain = Bundle(for: BaseUITestCase.self)
+            .infoDictionary?["AdServingDomain"] as? String,
+            let adServingDomainURL = URL(string: adServingDomain) else {
+            XCTFail("Ad serving domain not configured")
+            return nil
+        }
+
+        return adServingDomainURL
+    }
+
     /// Get configured ad serving domain
     private static func getAdServingDomain() throws -> String {
         guard let adServingDomain = Bundle(for: Networking.self)
@@ -153,4 +170,60 @@ class Networking {
     public static func verifyCannotReachAdServingDomain() throws {
         XCTAssertFalse(try Self.canConnectSocket(host: try Self.getAdServingDomain(), port: "80"))
     }
+
+    /// Verify that the expected DNS server is used by verifying provider name and whether it is a Mullvad DNS server or not
+    public static func verifyDNSServerProvider(_ providerName: String, isMullvad: Bool) throws {
+        guard let mullvadDNSLeakURL = URL(string: "https://am.i.mullvad.net/dnsleak") else {
+            throw NetworkingError.internalError(reason: "Failed to create URL object")
+        }
+
+        var request = URLRequest(url: mullvadDNSLeakURL)
+        request.setValue("application/json", forHTTPHeaderField: "accept")
+
+        var requestData: Data?
+        var requestResponse: URLResponse?
+        var requestError: Error?
+        let completionHandlerInvokedExpectation = XCTestExpectation(
+            description: "Completion handler for the request is invoked"
+        )
+
+        do {
+            let dataTask = URLSession.shared.dataTask(with: request) { data, response, error in
+                requestData = data
+                requestResponse = response
+                requestError = error
+                completionHandlerInvokedExpectation.fulfill()
+            }
+
+            dataTask.resume()
+
+            let waitResult = XCTWaiter.wait(for: [completionHandlerInvokedExpectation], timeout: 30)
+
+            if waitResult != .completed {
+                XCTFail("Failed to verify DNS server provider - timeout")
+            } else {
+                if let response = requestResponse as? HTTPURLResponse {
+                    if response.statusCode != 200 {
+                        XCTFail("Failed to verify DNS server provider - unexpected server response")
+                    }
+                }
+
+                if let error = requestError {
+                    XCTFail("Failed to verify DNS server provider - encountered error \(error.localizedDescription)")
+                }
+
+                if let requestData = requestData {
+                    let dnsServerEntries = try JSONDecoder().decode([DNSServerEntry].self, from: requestData)
+                    XCTAssertGreaterThanOrEqual(dnsServerEntries.count, 1)
+
+                    for dnsServerEntry in dnsServerEntries {
+                        XCTAssertEqual(dnsServerEntry.organization, providerName)
+                        XCTAssertEqual(dnsServerEntry.mullvad_dns, isMullvad)
+                    }
+                }
+            }
+        } catch {
+            XCTFail("Failed to verify DNS server provider - couldn't serialize JSON")
+        }
+    }
 }
diff --git a/ios/MullvadVPNUITests/RelayTests.swift b/ios/MullvadVPNUITests/RelayTests.swift
index 5df5b05a06..d0f8ea2037 100644
--- a/ios/MullvadVPNUITests/RelayTests.swift
+++ b/ios/MullvadVPNUITests/RelayTests.swift
@@ -197,4 +197,34 @@ class RelayTests: LoggedInWithTimeUITestCase {
 
         return relayIPAddress
     }
+
+    func testCustomDNS() throws {
+        let dnsServerIPAddress = "8.8.8.8"
+        let dnsServerProviderName = "GOOGLE"
+
+        TunnelControlPage(app)
+            .tapSecureConnectionButton()
+
+        allowAddVPNConfigurations()
+
+        HeaderBar(app)
+            .tapSettingsButton()
+
+        SettingsPage(app)
+            .tapVPNSettingsCell()
+
+        VPNSettingsPage(app)
+            .tapDNSSettingsCell()
+
+        DNSSettingsPage(app)
+            .tapEditButton()
+            .tapAddAServer()
+            .tapEnterIPAddressTextField()
+            .enterText(dnsServerIPAddress)
+            .dismissKeyboard()
+            .tapUseCustomDNSSwitch()
+            .tapDoneButton()
+
+        try Networking.verifyDNSServerProvider(dnsServerProviderName, isMullvad: false)
+    }
 }