Dependency Injection: The Key to Writing Testable and Flexible Code
Tags: webdev, javascript, typescript, designpatterns
Published: 2023-10-26 07:40:39

#Introduction
Web development demands scalable and maintainable code, and Dependency Injection is a crucial pattern that can help you achieve this goal. 
In this article, we'll delve into dependency injection, common bad practices to avoid, how to use it, its benefits for unit testing, and when to apply or skip it.

The code examples presented above are written in TypeScript. Whether you're a front-end or back-end developer, you'll find these examples easy to grasp 😉

#Dependency Injection (DI) vs Dependency Inversion (IOC)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dts0cawgx2g33ejfho9s.jpg)
**Dependency Injection (DI)** is one of the techniques that's used to implement **Dependency Inversion** also called **inversion of control (IOC)**, which represents the **D** of[SOLID principles](https://en.wikipedia.org/wiki/SOLID). focuses on decoupling high-level and low-level components by depending on abstractions rather than concrete implementations. DI, specifically, is the method of injecting dependencies into a component rather than having the component create them. In simpler terms, DI is how we achieve Dependency Inversion in practice, making our code more modular and flexible


#Common Bad Practices (problem)
##1. Hard-Coding Dependencies

```ts
function getOrderService() {
    const paymentService = getPaymentService();
    // ... Order logic
}
```
Hard-coding dependencies, like the direct invocation of **getPaymentService()**, tightly couples your code, making it challenging to switch implementations or mock dependencies for testing.
##2. Direct dependency calls

```ts
import { fetchData } from './api';

async function fetchProductData() {
    return await fetchData('/api/products');
}
```
This code directly calls fetchData, making it difficult to substitute with a mock for testing purposes.

#Using Dependency Injection (solution)
To apply dependency injection, define Interfaces Types or even JsDoc to abstract your dependencies:

```ts
// Interfaces
interface PaymentService {
    processPayment(amount: number): Promise<void>;
}

interface OrderService {
    placeOrder(): Promise<void>;
}

// Implementations
function createPaymentService(): PaymentService {
    async function processPayment(amount: number): Promise<void> {
        // Payment logic here
    }

    return { processPayment };
}

function createOrderService(paymentService: PaymentService): OrderService {
    async function placeOrder(): Promise<void> {
        // Order logic here
        await paymentService.processPayment(100);
    }

    return { placeOrder };
}
```

This approach allows you to easily switch out implementations:

```ts
const fakePaymentService: PaymentService = {
    processPayment: async (amount) => {
        // Fake payment logic for testing
    },
};

const orderService = createOrderService(fakePaymentService);
```
you can also use a container to manage the dependencies with tools like [inversify](https://inversify.io) (if you would like an article about it, let me know in the comments) which makes the experience even better, but it's more conventional tu use it with classes than functions 
#Benefits of Dependency Injection
##1. Flexibility and Maintainability
Dependency Injection provides flexibility when swapping implementations. Here's how it maintains code flexibility:

```ts
// Interfaces for various data sources
interface DataSource {
    fetchData(): Promise<any>;
}

// Concrete implementations for different data sources
const apiDataSource: DataSource = {
    fetchData: async () => {
        // Fetch data from an API
    },
};

const localDataSource: DataSource = {
    fetchData: async () => {
        // Fetch data locally
    },
};

// Function that depends on a data source
async function fetchDataFromSource(dataSource: DataSource): Promise<void> {
    const data = await dataSource.fetchData();
    // Process the data
}

// Switching data sources without changing the calling code
await fetchDataFromSource(apiDataSource); // Fetch from API
await fetchDataFromSource(localDataSource); // Fetch locally
```
By using the following pattern, we can easily switch between data sources without modifying the **fetchDataFromSource** function.

##2. Enhanced Unit Testing
Dependency Injection makes unit testing easier by allowing you to swap out real implementations with mocks or fakes. Let's see this in action

```ts
//--payment.contract.ts
  // Interface PaymentService
interface PaymentService {
    processPayment(amount: number): Promise<void>;
}
//--

//--payment.fake.ts
const fakePaymentService: PaymentService = {
    processPayment: async (amount) => {
        // Fake payment logic for testing
    },
};
//--

//--processOrder.ts
  // Function that depends on PaymentService
async function processOrder(paymentService: PaymentService, amount: number): Promise<void> {
    await paymentService.processPayment(amount);
    // Additional order processing logic
}
//--

//--processOrder.test.ts
import {fakePaymentService} from "./payment.fake.ts"
  // Unit test using the fake PaymentService
it('should process an order', async () => {
    await processOrder(fakePaymentService, 100);
    // Assert the desired behavior
});
//--
```
In this example, we can easily replace the real **PaymentService** with the **fakePaymentService** for testing purposes.

#When to Use Dependency Injection
##1. Complex Systems 
Dependency Injection excels in complex systems with various external dependencies, helping maintain code organisation and manageability like DDD based architecture
##2. Testing Priority
 If comprehensive unit testing is a priority, dependency injection is a valuable technique. It streamlines test setup and promotes testability (and believe me, you don't want to skip tests, you will regret it)

#When Not to Use Dependency injection
##1. Simpler Projects 
For smaller, straightforward projects with minimal external dependencies, the overhead of implementing dependency injection may not be justified.
##2. Third-Party Libraries
When working with third-party libraries or APIs that can't be modified, applying dependency injection might not be feasible. In such cases, adapt your code to the library's constraints.

#Conclusion
Dependency injection is a powerful technique . By decoupling implementation details and external dependencies, you can enhance code maintainability and testability. However, consider the complexity of your project before deciding to use it. When applied judiciously, dependency injection can significantly improve code quality.