Introduction to Dependencies in Testing with Swift

Introduction to Dependencies in Testing

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Example of Using Dummies

Let's see dummies in action by setting up tests for an EmailService application. Here's how you can create a test file with dummies using the XCTest framework:

Swift

import XCTest

class DummyLogger {
    func log(_ message: String) {
        // No operation
    }
}

class DummyEmailSender {
    func send(to: String, subject: String, body: String) {
        // No operation
    }
}

class EmailServiceTests: XCTestCase {
    var emailService: EmailService!

    override func setUp() {
        super.setUp()
        emailService = EmailService(logger: DummyLogger(), emailSender: DummyEmailSender())
    }

    func testShouldAcceptValidEmailParameters() {
        let result = emailService.sendEmail(to: "test@example.com", subject: "Hello", body: "This is a test")
        XCTAssertTrue(result)
    }

    // Additional tests for other cases...
}

import XCTest

class DummyLogger {
    func log(_ message: String) {
        // No operation
    }
}

class DummyEmailSender {
    func send(to: String, subject: String, body: String) {
        // No operation
    }
}

class EmailServiceTests: XCTestCase {
    var emailService: EmailService!

    override func setUp() {
        super.setUp()
        emailService = EmailService(logger: DummyLogger(), emailSender: DummyEmailSender())
    }

    func testShouldAcceptValidEmailParameters() {
        let result = emailService.sendEmail(to: "test@example.com", subject: "Hello", body: "This is a test")
        XCTAssertTrue(result)
    }

    // Additional tests for other cases...
}

In this example:

DummyLogger and DummyEmailSender act as stand-ins for real implementations. They don't have any behavior; they just satisfy the interface requirements of EmailService.
By using dummies, you reduce complexity and ensure that the tests are focusing solely on the logic within EmailService.

This method provides an introduction to isolating dependencies with minimal effort, setting the stage for learning about more advanced test doubles like stubs, mocks, and fakes.

To fully understand how dummies integrate into your testing workflow, let's look at the implementation of the EmailService that the tests are targeting. Here's how you can set up the EmailService.swift file:

EmailService.swift

Swift

class EmailService {
    private let logger: DummyLogger
    private let emailSender: DummyEmailSender

    init(logger: DummyLogger, emailSender: DummyEmailSender) {
        self.logger = logger
        self.emailSender = emailSender
    }

    func sendEmail(to: String, subject: String, body: String) -> Bool {
        guard !to.isEmpty, to.contains("@"), !subject.isEmpty, !body.isEmpty, body.count <= 1000 else {
            return false
        }

        logger.log("Sending email to \(to)")
        emailSender.send(to: to, subject: subject, body: body)
        return true
    }
}

class EmailService {
    private let logger: DummyLogger
    private let emailSender: DummyEmailSender

    init(logger: DummyLogger, emailSender: DummyEmailSender) {
        self.logger = logger
        self.emailSender = emailSender
    }

    func sendEmail(to: String, subject: String, body: String) -> Bool {
        guard !to.isEmpty, to.contains("@"), !subject.isEmpty, !body.isEmpty, body.count <= 1000 else {
            return false
        }

        logger.log("Sending email to \(to)")
        emailSender.send(to: to, subject: subject, body: body)
        return true
    }
}

This implementation outlines a basic EmailService class, using a logger and an email sender as dependencies. The method sendEmail performs basic validation checks on the email parameters and, if they're valid, logs and sends the email using the dependencies provided. By using dummies to stand in for Logger and EmailSender, you can isolate this email-sending logic from the complexities of actual logging and email-sending functionalities, ensuring a focused test environment.

In this lesson, you were introduced to the concept of dependencies in testing and how test doubles, specifically dummies, can help isolate these dependencies. Dummies serve as simple placeholders without behavior, allowing you to concentrate on testing the core logic of your application without external complexities. By using dummies, you can simplify test setups and focus more effectively on the behavior of the code under test. As you progress, try to identify which parts of your code rely on external systems or services. These are great candidates for introducing test doubles. Starting with dummies helps you build the habit of isolating dependencies, which will become crucial when dealing with more complex or asynchronous behavior in tests. This foundational understanding sets the stage for exploring more advanced test doubles in future lessons.