Create Coordinates & Rating Value Objects With TDD

Dec 6, 2025 by Alex Johnson 51 views

Create Coordinates and Rating Value Objects in Domain Layer

Introduction to Value Objects and Domain-Driven Design

In the realm of software development, particularly within the context of Domain-Driven Design (DDD), Value Objects are fundamental building blocks. This article delves into the creation of two crucial Value Objects: Coordinates and Rating. These objects encapsulate specific data and behavior, ensuring data integrity and promoting a more robust and maintainable codebase. We'll explore how these Value Objects are implemented, validated, and utilized, along with a focus on Test-Driven Development (TDD) to guarantee their reliability. This implementation is crucial for any application that deals with geographical locations or user ratings. The use of Value Objects enhances the domain layer, making it more expressive and preventing accidental modifications of data. By implementing these Value Objects, we're not just creating data structures; we're establishing a clear, concise, and dependable representation of essential concepts within the application's domain. The advantages of using Value Objects are numerous, including increased code readability, reduced errors, and a more focused domain model. They contribute significantly to the overall quality and maintainability of the software. Each Value Object is designed to be immutable, meaning its state cannot be changed after creation. This characteristic simplifies reasoning about the object and makes it easier to test. Let's start with the Coordinates Value Object.

Implementing the Coordinates Value Object

The Coordinates Value Object is designed to represent a geographical location using latitude and longitude. The core of its functionality lies in its create static method, which takes latitude and longitude as input, validates these values to ensure they fall within acceptable ranges (-90 to 90 for latitude, and -180 to 180 for longitude), and then constructs a new Coordinates instance if the input is valid. This validation is critical for maintaining data integrity. The Coordinates class also includes methods for calculating the distance to another set of coordinates using the Haversine formula. This formula accurately computes the distance between two points on a sphere given their latitudes and longitudes, an essential feature for any application that needs to measure distances between geographical locations. In addition to these methods, Coordinates provides getter methods (lat and lng) for accessing the latitude and longitude values, ensuring that the internal state is only accessible through defined interfaces. Furthermore, it incorporates an equals method for comparing two Coordinates objects and a toArray method for converting the coordinates to an array of numbers, offering versatility in how the data can be used within the application. Finally, the toString method provides a simple way to represent the coordinates as a string, useful for debugging and logging. The immutability of the Coordinates ensures that once created, its state is fixed, which prevents unintended modifications and simplifies concurrent access, making the code more predictable and easier to reason about. This design approach significantly contributes to building a more reliable and maintainable application.

Code Snippet for Coordinates

import { DomainError } from '../errors/domain-error';

export class Coordinates {
  private readonly _lat: number;
  private readonly _lng: number;

  private constructor(lat: number, lng: number) {
    this._lat = lat;
    this._lng = lng;
  }

  static create(lat: number, lng: number): Coordinates {
    if (lat < -90 || lat > 90) {
      throw new DomainError('Latitude must be between -90 and 90');
    }
    if (lng < -180 || lng > 180) {
      throw new DomainError('Longitude must be between -180 and 180');
    }
    return new Coordinates(lat, lng);
  }

  get lat(): number { return this._lat; }
  get lng(): number { return this._lng; }

  // Haversine formula para calcular distancia en km
  distanceTo(other: Coordinates): number {
    const R = 6371; // Radio de la Tierra en km
    const dLat = this.toRad(other.lat - this.lat);
    const dLng = this.toRad(other.lng - this.lng);
    const a = 
      Math.sin(dLat / 2) * Math.sin(dLat / 2) +
      Math.cos(this.toRad(this.lat)) * Math.cos(this.toRad(other.lat)) *
      Math.sin(dLng / 2) * Math.sin(dLng / 2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    return R * c;
  }

  private toRad(deg: number): number {
    return deg * (Math.PI / 180);
  }

  equals(other: Coordinates): boolean {
    return this._lat === other._lat && this._lng === other._lng;
  }

  toArray(): [number, number] {
    return [this._lat, this._lng];
  }

  toString(): string {
    return \`
  }
}

Building the Rating Value Object

Next, we'll create the Rating Value Object to represent a rating value, typically used to rate items on a scale of 0 to 5 stars. The Rating Value Object's create method validates that the rating value falls within the acceptable range (0 to 5) and rounds the value to one decimal place. This validation ensures that all rating values are within the allowed bounds. The class also includes a static method, fromAverage, which calculates the average rating from a list of ratings, providing a way to compute an average rating from multiple user inputs. The getter methods (value, fullStars, hasHalfStar, emptyStars) are provided to easily access and interpret the rating data in a user-friendly format, such as displaying full stars, half stars, and empty stars. Furthermore, the Rating Value Object features helper methods to categorize the rating (isExcellent, isGood, isAverage, isPoor), allowing for straightforward evaluation and classification of ratings. The immutability of Rating guarantees that once a rating is created, it cannot be altered, which aids in data integrity and simplifies testing. This approach makes the code more predictable and easier to understand. The helper methods, like isExcellent, isGood, isAverage, and isPoor, offer a clear and concise way to classify ratings, making it easier to use this value object in user interfaces and business logic.

Code Snippet for Rating

export class Rating {
  private readonly _value: number;

  private constructor(value: number) {
    this._value = value;
  }

  static create(value: number): Rating {
    if (value < 0 || value > 5) {
      throw new DomainError('Rating must be between 0 and 5');
    }
    return new Rating(Math.round(value * 10) / 10); // 1 decimal
  }

  static fromAverage(ratings: number[]): Rating {
    if (ratings.length === 0) return new Rating(0);
    const avg = ratings.reduce((a, b) => a + b, 0) / ratings.length;
    return Rating.create(avg);
  }

  get value(): number { return this._value; }
  
  get fullStars(): number { return Math.floor(this._value); }
  get hasHalfStar(): boolean { return this._value % 1 >= 0.5; }
  get emptyStars(): number { return 5 - this.fullStars - (this.hasHalfStar ? 1 : 0); }

  isExcellent(): boolean { return this._value >= 4.5; }
  isGood(): boolean { return this._value >= 3.5 && this._value < 4.5; }
  isAverage(): boolean { return this._value >= 2.5 && this._value < 3.5; }
  isPoor(): boolean { return this._value < 2.5; }
}

The Power of TDD in Value Object Development

Test-Driven Development (TDD) is an essential practice when creating Value Objects. Before writing any implementation code, the process starts with defining the tests. For both Coordinates and Rating, we would first write tests that specify the expected behavior, such as validating the range of latitude and longitude in Coordinates and validating the rating range in Rating. These tests guide the development process, ensuring that the Value Objects function as expected and that any changes don't break existing functionality. The tests are written to fail initially, confirming that the test setup is correct. Then, the implementation code is written to make the tests pass. This iterative approach helps clarify the requirements and design, leading to more robust and reliable code. Furthermore, TDD fosters a clear understanding of the desired behavior of each Value Object. By writing tests first, developers gain a deeper understanding of the requirements and constraints, leading to better-designed and more effective code. The tests for Coordinates would include validations for valid and invalid latitude and longitude values, checking the distanceTo method with various coordinate pairs, and verifying the equals, toArray, and toString methods. The tests for Rating would validate the rating values within the specified range, verify the fromAverage method, and ensure the correct behavior of helper methods, such as isExcellent, isGood, isAverage, and isPoor. This rigorous testing approach is critical in developing high-quality, maintainable code.

Conclusion: Benefits and Best Practices

The implementation of Coordinates and Rating Value Objects is a cornerstone of good software design, particularly when applying DDD principles. These Value Objects enhance the clarity, correctness, and maintainability of the codebase. By adhering to TDD principles, developers can ensure that these Value Objects meet the defined requirements and that any modifications do not introduce regressions. Key takeaways include the importance of validation, immutability, and the use of helper methods to encapsulate domain logic. The examples provided can be adapted and extended to various scenarios in your projects. Implementing Value Objects like Coordinates and Rating provides numerous advantages, including: Improved Code Readability: Value Objects make the code easier to understand by providing clear and concise representations of domain concepts. Data Integrity: Validation within the Value Objects ensures that the data is always in a consistent and valid state. Reduced Errors: By encapsulating data and behavior, Value Objects minimize the risk of errors related to data manipulation. Enhanced Maintainability: Immutability simplifies reasoning about the objects and makes it easier to change the code. Following TDD principles guarantees a high level of code quality, promoting a more robust and adaptable application. This results in a codebase that is easier to reason about, test, and maintain over time. Implementing these value objects is a strong step towards a cleaner, more efficient, and robust software architecture.

For further reading on Domain-Driven Design and related topics, I recommend visiting the official DDD website:

Domain-Driven Design