unbreakable domain models - froscon 2013

UnbreakableDomain Models

Mathias Verraes

FrOSConSankt-Augustin, DE

August 24, 2013

@mathiasverraeshttp://verraes.net

I'm an independent consultant.

I build enterprise web applications.

I help teams escape from

survival mode.

Cofounder of theBelgian

Domain-Driven Design community

http://domaindriven.be@DDDBE

Modellathon on September 3rd, 2013

Ghent

DomainProblem Space

Domain ModelSolution Space

(Data ModelThe model’s state)

Protect your invariants

The domain expert says

“A customer must always have an email address.”

* Could be different for your domain** All examples are simplified

class CustomerTest extends PHPUnit_Framework_TestCase{ /** @test */ public function should_always_have_an_email() {

$customer = new Customer();

assertThat( $customer->getEmail(), equalTo('jim@example.com') );

}}

Test fails

class CustomerTest extends PHPUnit_Framework_TestCase{ /** @test */ public function should_always_have_an_email() {

$customer = new Customer(); $customer->setEmail('jim@example.com'); assertThat( $customer->getEmail(), equalTo('jim@example.com') ); }}

Test passes

class CustomerTest extends PHPUnit_Framework_TestCase{ /** @test */ public function should_always_have_an_email() {

$customer = new Customer(); assertThat( $customer->getEmail(), equalTo(‘jim@example.com') ); $customer->setEmail(‘jim@example.com’);

}}

Test fails

class Customer{ private $email;

public function __construct($email) { $this->email = $email; }

public function getEmail() { return $this->email; }}

Test passes

class CustomerTest extends PHPUnit_Framework_TestCase{ /** @test */ public function should_always_have_an_email() {

$customer = new Customer(‘jim@example.com’);

assertThat( $customer->getEmail(), equalTo(‘jim@example.com') ); }}

Test passes

Use objects asconsistency boundaries

class ProspectiveCustomer { //...

/** @return PayingCustomer */ public function convertToPayingCustomer(){ }}

class PayingCustomer { ... }

Make the implicitexplicit

The domain expert meant

“A customer must always have a valid

email address.”

$customerValidator = new CustomerValidator;if($customerValidator->isValid($customer)){ // ...}

class CustomerTest extends PHPUnit_Framework_TestCase{ /** @test */ public function should_always_have_a_valid_email() {

$this->setExpectedException( '\InvalidArgumentException' );

new Customer('malformed@email');

}}

Test fails

class Customer { public function __construct($email) { if( /* ugly regex here */) { throw new \InvalidArgumentException(); } $this->email = $email; }}

Test passes

ViolatesSingle Responsibility

Principle

class Email{ private $email;

public function __construct($email) { if( /* ugly regex here */) { throw new \InvalidArgumentException(); } $this->email = $email; }

public function __toString() { return $this->email; } }

Test passes

class Customer{ /** @var Email */ private $email;

public function __construct(Email $email) { $this->email = $email; }}

Test passes

class CustomerTest extends PHPUnit_Framework_TestCase{ /** @test */ public function should_always_have_a_valid_email() {

$this->setExpectedException( ‘\InvalidArgumentException’ );

new Customer(new Email(‘malformed@email’));

}}

Test passes

Encapsulate state and behaviorwith Value Objects

The domain expert says

“A customer orders products

and pays for them.”

$order = new Order;$order->setCustomer($customer);$order->setProducts($products);$order->setStatus(Order::UNPAID);

// ...

$order->setPaidAmount(500);$order->setPaidCurrency(‘EUR’);

$order->setStatus(Order::PAID);

$order = new Order;$order->setCustomer($customer);$order->setProducts($products);$order->setStatus( new PaymentStatus(PaymentStatus::UNPAID));

$order->setPaidAmount(500);$order->setPaidCurrency(‘EUR’);

$order->setStatus( new PaymentStatus(PaymentStatus::PAID));

$order = new Order;$order->setCustomer($customer);$order->setProducts($products);$order->setStatus( new PaymentStatus(PaymentStatus::UNPAID));

$order->setPaidMonetary( new Money(500, new Currency(‘EUR’)));$order->setStatus( new PaymentStatus(PaymentStatus::PAID));

$order = new Order($customer, $products);// set PaymentStatus in Order::__construct()

$order->setPaidMonetary( new Money(500, new Currency(‘EUR’)));$order->setStatus( new PaymentStatus(PaymentStatus::PAID));

$order = new Order($customer, $products);

$order->pay( new Money(500, new Currency(‘EUR’)));// set PaymentStatus in Order#pay()

Encapsulate operations

$order = $customer->order($products);

$customer->pay( $order, new Money(500, new Currency(‘EUR’)));

The domain expert says

“Premium customers get special offers.”

if($customer->isPremium()) { // send special offer}

The domain expert says

“Order 3 times to become a

premium customer.”

interface CustomerSpecification { /** @return bool */ public function isSatisfiedBy(Customer $customer); }

class CustomerIsPremium implements CustomerSpecification { private $orderRepository; public function __construct( OrderRepository $orderRepository ) {...}

/** @return bool */ public function isSatisfiedBy(Customer $customer) { $count = $this->orderRepository->countFor($customer); return $count >= 3; }}

$customerIsPremium = new CustomerIsPremium($orderRepository)if($customerIsPremium->isSatisfiedBy($customer)) { // send special offer}

$customerIsPremium = new CustomerIsPremium;

$aCustomerWith2Orders = ...$aCustomerWith3Orders = ...

assertFalse( $customerIsPremium->isSatisfiedBy($aCustomerWith2Orders));

assertTrue( $customerIsPremium->isSatisfiedBy($aCustomerWith3Orders));

The domain expert says

“Different rules apply for different tenants.”

interface CustomerIsPremium extends CustomerSpecification

class CustomerWith3OrdersIsPremium implements CustomerIsPremium

class CustomerWith500EuroTotalIsPremium implements CustomerIsPremium

class CustomerWhoBoughtLuxuryProductsIsPremium implements CustomerIsPremium

...

class SpecialOfferSender{ private $customerIsPremium;

public function __construct( CustomerIsPremium $customerIsPremium) {...}

public function sendOffersTo(Customer $customer) { if($this->customerIsPremium->isSatisfiedBy( $customer )) { // send offers... } }}

<!-- if you load services_amazon.xml: --><service id="customer.is.premium" class="CustomerWith500EuroTotalIsPremium">

<!-- if you load services_ebay.xml: --><service id="customer.is.premium" class="CustomerWith3OrdersIsPremium">

<!-- elsewhere --><service id=”special.offer.sender” class=”SpecialOfferSender”> <argument type=”service” id=”customer.is.premium”/></service>

Use specifications to encapsulate rules

about object selection

The domain expert says

“Get a list of all premium customers.”

interface CustomerRepository{ public function add(Customer $customer);

public function remove(Customer $customer); /** @return Customer */ public function find(CustomerId $customerId);

/** @return Customer[] */ public function findAll();

/** @return Customer[] */ public function findRegisteredIn(Year $year);}

interface CustomerRepository{

/** @return Customer[] */ public function findSatisfying( CustomerSpecification $customerSpecification );

}

// generalized:$objects = $repository->findSatisfying($specification);

class DbCustomerRepository implements CustomerRepository{ /** @return Customer[] */ public function findSatisfying( CustomerSpecification $customerSpecification) { // filter Customers (see next slide) }}

// class DbCustomerRepository

public function findSatisfying($specification) { $foundCustomers = array(); foreach($this->findAll() as $customer) { if($specification->isSatisfiedBy($customer)) { $foundCustomers[] = $customer; } } return $foundCustomers;}

class CustomerWith3OrdersIsPremium implements CustomerSpecification{ public function asSql() { return ‘SELECT * FROM Customer...’; }}

// class DbCustomerRepository public function findSatisfying($specification) { return $this->db->query($specification->asSql()); }

Use double dispatchto preserve encapsulation

$expectedCustomers = // filtered using isSatisfiedBy$actualCustomers = $repository->findSatisfying($specification);

assertThat($expectedCustomers, equalTo($actualCustomers));

Test by comparing different representations

Protect your invariants

Objects as consistency boundaries

Encapsulate state and behavior

More? google for:Eric Evans

Vaugh VernonMartin Fowler

Greg YoungUdi Dahan

Sandro MarcusoYves Reynhout

Szymon PobiegaAlberto Brandolini

...

Thanks! Questions?

@mathiasverraeshttp://verraes.net

https://joind.in/9020