Implement UnitTests

- `RequestParametersEncoderTests`
- `RequestBuilderTests`
- `RequestBodyEncoderTests`

Author: ns-vasilev

Sources/NetworkLayer/Classes/Core/Authentification/AuthenticatorInterceptor.swift

@@ -7,7 +7,8 @@ import Atomic
 import Foundation
 import NetworkLayerInterfaces
 
-/// <#Description#>
+/// A custom AuthenticatorInterceptor implementation that works with a specific type
+/// of Authenticator conforming to the IAuthenticator protocol.
 public final class AuthenticatorInterceptor<Authenticator: IAuthenticator>: IAuthenticatorInterceptor {
     // MARK: Types
 

Sources/NetworkLayer/Classes/Core/Builders/RequestBuilder/RequestBuilder.swift

@@ -24,8 +24,11 @@ final class RequestBuilder: IRequestBuilder {
 
     // MARK: IRequestBuilder
 
-    func build(_ request: NetworkLayerInterfaces.IRequest, _: ((inout URLRequest) throws -> Void)?) throws -> URLRequest? {
-        guard let url = URL(string: request.fullPath) else {
+    func build(
+        _ request: NetworkLayerInterfaces.IRequest,
+        _ configure: ((inout URLRequest) throws -> Void)?
+    ) throws -> URLRequest? {
+        guard let fullPath = request.fullPath, let url = URL(string: fullPath) else {
             throw URLError(.badURL)
         }
 
@@ -45,6 +48,8 @@ final class RequestBuilder: IRequestBuilder {
             try requestBodyEncoder.encode(body: httpBody, to: &urlRequest)
         }
 
+        try configure?(&urlRequest)
+
         return urlRequest
     }
 

Sources/NetworkLayer/Classes/Extensions/IRequest+.swift

@@ -7,7 +7,10 @@ import Foundation
 import NetworkLayerInterfaces
 
 extension IRequest {
-    var fullPath: String {
-        [domainName, path].joined(separator: "/")
+    var fullPath: String? {
+        if !domainName.isEmpty {
+            return [domainName, path].joined(separator: "/")
+        }
+        return nil
     }
 }

Tests/NetworkLayerTests/Fakes/URLRequest+Fake.swift

@@ -6,7 +6,7 @@
 import Foundation
 
 extension URLRequest {
-    static func fake() -> URLRequest {
-        URLRequest(url: URL(string: "https://google.com/")!)
+    static func fake(string: String = "https://google.com/") -> URLRequest {
+        URLRequest(url: URL(string: string)!)
     }
 }

Tests/NetworkLayerTests/Mocks/RequestBodyEncoderMock.swift

@@ -0,0 +1,26 @@
+//
+// network-layer
+// Copyright © 2023 Space Code. All rights reserved.
+//
+
+import Foundation
+@testable import NetworkLayer
+import NetworkLayerInterfaces
+
+final class RequestBodyEncoderMock: IRequestBodyEncoder {
+    var invokedEncode = false
+    var invokedEncodeCount = 0
+    var invokedEncodeParameters: (body: RequestBody, request: URLRequest)?
+    var invokedEncodeParametersList = [(body: RequestBody, request: URLRequest)]()
+    var stubbedEncodeError: Error?
+
+    func encode(body: RequestBody, to request: inout URLRequest) throws {
+        invokedEncode = true
+        invokedEncodeCount += 1
+        invokedEncodeParameters = (body, request)
+        invokedEncodeParametersList.append((body, request))
+        if let error = stubbedEncodeError {
+            throw error
+        }
+    }
+}

Tests/NetworkLayerTests/Mocks/RequestParametersEncoderMock.swift

@@ -0,0 +1,25 @@
+//
+// network-layer
+// Copyright © 2023 Space Code. All rights reserved.
+//
+
+import Foundation
+@testable import NetworkLayer
+
+final class RequestParametersEncoderMock: IRequestParametersEncoder {
+    var invokedEncode = false
+    var invokedEncodeCount = 0
+    var invokedEncodeParameters: (parameters: [String: String], request: URLRequest)?
+    var invokedEncodeParametersList = [(parameters: [String: String], request: URLRequest)]()
+    var stubbedEncodeError: Error?
+
+    func encode(parameters: [String: String], to request: inout URLRequest) throws {
+        invokedEncode = true
+        invokedEncodeCount += 1
+        invokedEncodeParameters = (parameters, request)
+        invokedEncodeParametersList.append((parameters, request))
+        if let error = stubbedEncodeError {
+            throw error
+        }
+    }
+}

Tests/NetworkLayerTests/Stubs/RequestStub.swift

@@ -0,0 +1,63 @@
+//
+// network-layer
+// Copyright © 2023 Space Code. All rights reserved.
+//
+
+import Foundation
+import NetworkLayerInterfaces
+
+final class RequestStub: IRequest {
+    var stubbedDomainName: String! = ""
+
+    var domainName: String {
+        stubbedDomainName
+    }
+
+    var stubbedPath: String! = ""
+
+    var path: String {
+        stubbedPath
+    }
+
+    var stubbedHeaders: [String: String]!
+
+    var headers: [String: String]? {
+        stubbedHeaders
+    }
+
+    var stubbedParameters: [String: String]!
+
+    var parameters: [String: String]? {
+        stubbedParameters
+    }
+
+    var stubbedRequiresAuthentication: Bool! = false
+
+    var requiresAuthentication: Bool {
+        stubbedRequiresAuthentication
+    }
+
+    var stubbedTimeoutInterval: TimeInterval = 60
+
+    var timeoutInterval: TimeInterval {
+        stubbedTimeoutInterval
+    }
+
+    var stubbedHttpMethod: HTTPMethod = .get
+
+    var httpMethod: HTTPMethod {
+        stubbedHttpMethod
+    }
+
+    var stubbedHttpBody: RequestBody? = nil
+
+    var httpBody: RequestBody? {
+        stubbedHttpBody
+    }
+
+    var stubbedCachePolicy: URLRequest.CachePolicy = .useProtocolCachePolicy
+
+    var cachePolicy: URLRequest.CachePolicy {
+        stubbedCachePolicy
+    }
+}

Tests/NetworkLayerTests/UnitTests/RequestBodyEncoderTests.swift

@@ -0,0 +1,73 @@
+//
+// network-layer
+// Copyright © 2023 Space Code. All rights reserved.
+//
+
+@testable import NetworkLayer
+import XCTest
+
+// MARK: - RequestBodyEncoderTests
+
+final class RequestBodyEncoderTests: XCTestCase {
+    // MARK: Properties
+
+    private var sut: RequestBodyEncoder!
+
+    // MARK: XCTestCase
+
+    override func setUp() {
+        super.setUp()
+        sut = RequestBodyEncoder(jsonEncoder: JSONEncoder())
+    }
+
+    override func tearDown() {
+        sut = nil
+        super.tearDown()
+    }
+
+    // MARK: Tests
+
+    func test_thatRequestBodyEncoderEncodesBodyIntoRequest_whenTypeIsData() throws {
+        // given
+        var requestFake = URLRequest.fake()
+        let data = Data()
+
+        // when
+        try sut.encode(body: .data(data), to: &requestFake)
+
+        // then
+        XCTAssertEqual(requestFake.httpBody, data)
+    }
+
+    func test_thatRequestBodyEncoderEncodesBodyIntoRequest_whenTypeIsDictonary() throws {
+        // given
+        var requestFake = URLRequest.fake()
+        let dictonary = ["test": "test"]
+
+        // when
+        try sut.encode(body: .dictonary(dictonary), to: &requestFake)
+
+        // then
+        let data = try JSONSerialization.data(withJSONObject: dictonary)
+        XCTAssertEqual(requestFake.httpBody, data)
+    }
+
+    func test_thatRequestBodyEncoderEncodesBodyIntoRequest_whenTypeIsEncodable() throws {
+        // given
+        var requestFake = URLRequest.fake()
+        let object = DummyObject()
+
+        // when
+        try sut.encode(body: .encodable(object), to: &requestFake)
+
+        // then
+        let data = try JSONEncoder().encode(object)
+        XCTAssertEqual(requestFake.httpBody, data)
+    }
+}
+
+// MARK: RequestBodyEncoderTests.DummyObject
+
+private extension RequestBodyEncoderTests {
+    struct DummyObject: Encodable {}
+}

Tests/NetworkLayerTests/UnitTests/RequestBuilderTests.swift

@@ -0,0 +1,95 @@
+//
+// network-layer
+// Copyright © 2023 Space Code. All rights reserved.
+//
+
+@testable import NetworkLayer
+import XCTest
+
+// MARK: - RequestBuilderTests
+
+final class RequestBuilderTests: XCTestCase {
+    // MARK: Properties
+
+    private var parametersEncoderMock: RequestParametersEncoderMock!
+    private var requestBodyEncoderMock: RequestBodyEncoderMock!
+
+    private var sut: RequestBuilder!
+
+    // MARK: XCTestCase
+
+    override func setUp() {
+        super.setUp()
+        parametersEncoderMock = RequestParametersEncoderMock()
+        requestBodyEncoderMock = RequestBodyEncoderMock()
+        sut = RequestBuilder(
+            parametersEncoder: parametersEncoderMock,
+            requestBodyEncoder: requestBodyEncoderMock
+        )
+    }
+
+    override func tearDown() {
+        parametersEncoderMock = nil
+        requestBodyEncoderMock = nil
+        sut = nil
+        super.tearDown()
+    }
+
+    // MARK: Tests
+
+    func test_thatRequestBuilderThrowsAnError_whenRequestIsNotValid() {
+        // given
+        let request = RequestStub()
+
+        // when
+        var receivedError: NSError?
+        do {
+            _ = try sut.build(request, nil)
+        } catch {
+            receivedError = error as NSError
+        }
+
+        // then
+        XCTAssertEqual(receivedError, URLError(.badURL) as NSError)
+    }
+
+    func test_thatRequestBuilderBuildsARequest() throws {
+        // given
+        let requestStub = RequestStub()
+        requestStub.stubbedDomainName = .domainName
+        requestStub.stubbedHeaders = .contentType
+        requestStub.stubbedHttpMethod = .post
+        requestStub.stubbedHttpBody = .dictonary(.item)
+        requestStub.stubbedParameters = .contentType
+
+        // when
+        var invokedConfigure = false
+        let request = try sut.build(requestStub) { _ in invokedConfigure = true }
+
+        // then
+        XCTAssertTrue(invokedConfigure)
+        XCTAssertEqual(request?.allHTTPHeaderFields, .contentType)
+        XCTAssertEqual(request?.httpMethod, "POST")
+        XCTAssertEqual(parametersEncoderMock.invokedEncodeParameters?.parameters, .contentType)
+
+        if case let .dictonary(dict) = requestBodyEncoderMock.invokedEncodeParameters?.body {
+            XCTAssertTrue(NSDictionary(dictionary: dict).isEqual(to: Dictionary.item))
+        } else {
+            XCTFail("body should be equal to a dictionary")
+        }
+    }
+}
+
+// MARK: - Constants
+
+private extension String {
+    static let domainName = "https://google.com"
+}
+
+private extension Dictionary where Self.Key == String, Self.Value == String {
+    static let contentType = ["Content-Type": "application/json"]
+}
+
+private extension Dictionary where Self.Key == String, Self.Value == Any {
+    static let item = ["Content-Type": "application/json"]
+}