El patrón del dinero: La forma correcta de representar pares de unidades de valor

Spanish (Español) translation by Steven (you can also view the original English article)

El patrón del dinero o "Money Pattern", definido por Martin Fowler y publicado en "Patterns of Enterprise Application Architecture", es una excelente manera de representar pares de unidades de valor. Se llama Money Pattern porque surgió en un contexto financiero y vamos a ilustrar su uso principalmente en este contexto usando PHP.

Una cuenta similar a PayPal

No tengo idea de cómo se implementa PayPal, pero creo que es una buena idea tomar su funcionalidad como ejemplo. Permítanme mostrarles lo que quiero decir, mi cuenta de PayPal tiene dos monedas: dólares estadounidenses y euros. Mantiene los dos valores separados, pero puedo recibir dinero en cualquier moneda, puedo ver mi monto total en cualquiera de las dos monedas y puedo extraer en cualquiera de las dos. Por el bien de este ejemplo, imagina que extraemos en cualquiera de las monedas y se realiza la conversión automática si el saldo de esa moneda específica es menor de lo que queremos transferir pero aún hay suficiente dinero en la otra moneda. Además, limitaremos el ejemplo a solo dos monedas.

Obtener una cuenta

Si tuviera que crear y usar un objeto "Account", me gustaría inicializarlo con un número de cuenta.

1	function testItCanCrateANewAccount() {
2	$this->assertInstanceOf("Account", new Account(123));
3	}

Obviamente, esto fallará porque todavía no tenemos una clase "Account".

1	class Account {
2
3	}

Bueno, escribir eso en un nuevo archivo "Account.php" y requerirlo en la prueba, lo hizo pasar. Sin embargo, todo esto se está haciendo solo para sentirnos cómodos con la idea. A continuación, estoy pensando en obtener la identificación (id) de la cuenta.

1	function testItCanCrateANewAccountWithId() {
2	$this->assertEquals(123, (new Account(123))->getId());
3	}

De hecho, cambié la prueba anterior por esta. No hay razón para quedarse con el primero. Vivió su vida, lo que significa que me obligó a pensar en la clase Account y crearla. Ahora podemos continuar.

class Account {

	private $id;

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

	public function getId() {
		return $this->id;
	}

}

La prueba está pasando y Account empieza a parecer una clase real.

Monedas

Según nuestra analogía con PayPal, es posible que queramos definir una moneda principal y una secundaria para nuestra cuenta.

private $account;

protected function setUp() {
	$this->account = new Account(123);
}

[...]

function testItCanHavePrimaryAndSecondaryCurrencies() {
	$this->account->setPrimaryCurrency("EUR");
	$this->account->setSecondaryCurrency('USD');

	$this->assertEquals(array('primary' => 'EUR', 'secondary' => 'USD'), $this->account->getCurrencies());
}

Ahora la prueba anterior nos obligará a escribir el siguiente código.

class Account {

	private $id;
	private $primaryCurrency;
	private $secondaryCurrency;

[...]

	function setPrimaryCurrency($currency) {
		$this->primaryCurrency = $currency;
	}

	function setSecondaryCurrency($currency) {
		$this->secondaryCurrency = $currency;
	}

	function getCurrencies() {
		return array('primary' => $this->primaryCurrency, 'secondary' => $this->secondaryCurrency);
	}

}

Por el momento, mantenemos la moneda como un simple "string". Esto puede cambiar en el futuro, pero todavía no lo hemos logrado.

Dame el dinero

Hay un sinfín de razones por las que no se debe representar el dinero como un valor simple. ¿Cálculos de coma flotante? ¿Alguien? ¿Qué pasa con las fracciones de moneda? ¿Deberíamos tener 10, 100 o 1000 centavos en alguna moneda exótica? Bueno, este es otro problema que tendremos que evitar. ¿Qué pasa con la asignación de centavos indivisibles?

Hay demasiados problemas exóticos cuando se trabaja con dinero para escribirlos en código, así que pasaremos directamente a la solución, el "Patrón del dinero". Este es un patrón bastante simple, con grandes ventajas y muchos casos de uso, lejos del dominio financiero. Siempre que tengas que representar un par de unidades de valor, probablemente deberías usar este patrón.

El patrón de dinero es básicamente una clase que encapsula una cantidad y una moneda. Luego define todas las operaciones matemáticas sobre el valor con respecto a la moneda. "allocate()" es una función especial para distribuir una cantidad específica de dinero entre dos o más destinatarios.

Entonces, como usuario de Money, me gustaría poder hacer esto en una prueba:

class MoneyTest extends PHPUnit_Framework_TestCase {

	function testWeCanCreateAMoneyObject() {
		$money = new Money(100, Currency::USD());
	}

}

Pero eso todavía no funcionará. Necesitamos tanto dinero (Money) como moneda (Currency). Aún más, necesitamos Currency antes que Money. Esta será una clase simple, por lo que omitiré probarla por ahora. Estoy bastante seguro de que el IDE puede generar la mayor parte del código por mí.

class Currency {

	private $centFactor;
	private $stringRepresentation;

	private function __construct($centFactor, $stringRepresentation) {
		$this->centFactor = $centFactor;
		$this->stringRepresentation = $stringRepresentation;
	}

	public function getCentFactor() {
		return $this->centFactor;
	}

	function getStringRepresentation() {
		return $this->stringRepresentation;
	}

	static function USD() {
		return new self(100, 'USD');
	}

	static function EUR() {
		return new self(100, 'EUR');
	}

}

Eso es suficiente para nuestro ejemplo. Tenemos dos funciones estáticas para las monedas USD y EUR. En una aplicación real, probablemente tendríamos un constructor general con un parámetro y cargaríamos todas las monedas desde una tabla de base de datos o, mejor aún, desde un archivo de texto.

A continuación, incluye los dos archivos nuevos en la prueba:

require_once '../Currency.php';
require_once '../Money.php';

class MoneyTest extends PHPUnit_Framework_TestCase {

	function testWeCanCreateAMoneyObject() {
		$money = new Money(100, Currency::USD());
	}

}

Esta prueba aún falla, pero al menos ahora esto puede encontrar Currency. Seguimos con una implementación mínima de Money. Un poco más de lo que esta prueba requiere estrictamente ya que, nuevamente, es principalmente código generado automáticamente.

class Money {

	private $amount;
	private $currency;

	function __construct($amount, Currency $currency) {
		$this->amount = $amount;
		$this->currency = $currency;
	}

}

Ten en cuenta que aplicamos el tipo Currency para el segundo parámetro en nuestro constructor. Esta es una buena manera de evitar que nuestros clientes envíen basura como moneda.

Comparando el dinero

Lo primero que me vino a la mente después de tener el objeto mínimo en funcionamiento fue que tendré que comparar los objetos monetarios de alguna manera. Entonces recordé que PHP es bastante inteligente cuando se trata de comparar objetos, así que escribí esta prueba.

function testItCanTellTwoMoneyObjectAreEqual() {
	$m1 = new Money(100, Currency::USD());
	$m2 = new Money(100, Currency::USD());

	$this->assertEquals($m1,$m2);
	$this->assertTrue($m1 == $m2);
}

Bueno, eso realmente pasa. La función "assertEquals" puede comparar los dos objetos e incluso la condición de igualdad incorporada de PHP "==" me dice lo que espero. Genial.

Pero, ¿qué pasa si nos interesa que uno sea más grande que el otro? Para mi sorpresa aún mayor, la siguiente prueba también pasa sin problemas.

function testOneMoneyIsBiggerThanTheOther() {
	$m1 = new Money(200, Currency::USD());
	$m2 = new Money(100, Currency::USD());

	$this->assertGreaterThan($m2, $m1);
	$this->assertTrue($m1 > $m2);
}

Lo que nos lleva a...

function testOneMoneyIsLessThanTheOther() {
	$m1 = new Money(100, Currency::USD());
	$m2 = new Money(200, Currency::USD());

	$this->assertLessThan($m2, $m1);
	$this->assertTrue($m1 < $m2);
}

...una prueba que pasa de inmediato.

Más, Menos, Multiplicar

Al ver tanta magia de PHP funcionando realmente con las comparaciones, no pude resistirme a probar esta.

function testTwoMoneyObjectsCanBeAdded() {
	$m1 = new Money(100, Currency::USD());
	$m2 = new Money(200, Currency::USD());
	$sum = new Money(300, Currency::USD());

	$this->assertEquals($sum, $m1 + $m2);
}

Que falla y dice:

1	Object of class Money could not be converted to int

Mmm. Eso suena bastante obvio. En este punto tenemos que tomar una decisión. Es posible continuar este ejercicio con aún más magia PHP, pero este enfoque, en algún momento, transformará este tutorial en una hoja de referencia PHP en lugar de un patrón de diseño. Entonces, tomemos la decisión de implementar los métodos reales para sumar, restar y multiplicar objetos de dinero.

function testTwoMoneyObjectsCanBeAdded() {
	$m1 = new Money(100, Currency::USD());
	$m2 = new Money(200, Currency::USD());
	$sum = new Money(300, Currency::USD());

	$this->assertEquals($sum, $m1->add($m2));
}

Esta prueba también falla, pero con un error que nos indica que no hay un método "add" en Money.

public function getAmount() {
	return $this->amount;
}

function add($other) {
	return new Money($this->amount + $other->getAmount(), $this->currency);
}

Para resumir dos objetos Money, necesitamos una forma de obtener la cantidad del objeto que pasamos como argumento. Prefiero escribir un captador, pero configurar la variable de clase para que sea pública también sería una solución aceptable. Pero, ¿y si queremos agregar dólares a euros?

/**
 * @expectedException Exception
 * @expectedExceptionMessage Both Moneys must be of same currency
 */
function testItThrowsExceptionIfWeTryToAddTwoMoneysWithDifferentCurrency() {
	$m1 = new Money(100, Currency::USD());
	$m2 = new Money(100, Currency::EUR());

	$m1->add($m2);
}

Hay varias formas de realizar operaciones en objetos Money con diferentes monedas. Lanzaremos una excepción y la esperaremos en la prueba. Alternativamente, podríamos implementar un mecanismo de conversión de moneda en nuestra aplicación, llamarlo, convertir ambos objetos Money en alguna moneda predeterminada y compararlos. O, si tuviéramos un algoritmo de conversión de moneda más sofisticado, siempre podríamos convertir de una a otra y comparar en esa moneda convertida. La cuestión es que cuando se produce la conversión, se deben considerar las tarifas de conversión y las cosas se pondrán bastante complicadas. Así que arrojemos esa excepción y continuemos.

public function getCurrency() {
	return $this->currency;
}

function add(Money $other) {
	$this->ensureSameCurrencyWith($other);
	return new Money($this->amount + $other->getAmount(), $this->currency);
}

private function ensureSameCurrencyWith(Money $other) {
	if ($this->currency != $other->getCurrency())
		throw new Exception("Both Moneys must be of same currency");
}

Eso es mejor. Hacemos una verificación para ver si las monedas son diferentes y lanzamos una excepción. Ya lo escribí como un método privado separado, porque sé que también lo necesitaremos en las otras operaciones matemáticas.

La resta y la multiplicación son muy similares a la suma, así que aquí está el código y puedes encontrar las pruebas en el código fuente adjunto.

function subtract(Money $other) {
	$this->ensureSameCurrencyWith($other);
	if ($other > $this)
		throw new Exception("Subtracted money is more than what we have");
	return new Money($this->amount - $other->getAmount(), $this->currency);
}

function multiplyBy($multiplier, $roundMethod = PHP_ROUND_HALF_UP) {
	$product = round($this->amount * $multiplier, 0, $roundMethod);
	return new Money($product, $this->currency);
}

Con la resta, tenemos que asegurarnos de tener suficiente dinero y con la multiplicación, debemos tomar acciones para redondear las cosas hacia arriba o hacia abajo para que la división (multiplicación con números menores a uno) no produzca "medio centavo". Mantenemos nuestra cantidad en centavos, el factor más bajo posible de la moneda. No podemos dividirlo más.

Introducción de moneda a nuestra cuenta

Tenemos Money y Currency casi completo. Es hora de presentar estos objetos a Account. Comenzaremos con Currency y cambiaremos nuestras pruebas en consecuencia.

function testItCanHavePrimaryAndSecondaryCurrencies() {
	$this->account->setPrimaryCurrency(Currency::EUR());
	$this->account->setSecondaryCurrency(Currency::USD());

	$this->assertEquals(array('primary' => Currency::EUR(), 'secondary' => Currency::USD()), $this->account->getCurrencies());
}

Debido a la naturaleza de escritura dinámica de PHP, esta prueba pasa sin problemas. Sin embargo, me gustaría forzar a los métodos en Account para usar objetos Currency y no acepto nada más. Esto no es obligatorio, pero encuentro este tipo de bisagras de tipo extremadamente útiles cuando alguien más necesita entender nuestro código.

function setPrimaryCurrency(Currency $currency) {
	$this->primaryCurrency = $currency;
}

function setSecondaryCurrency(Currency $currency) {
	$this->secondaryCurrency = $currency;
}

Ahora es obvio para cualquiera que lea este código por primera vez que Account funciona con Currency.

Introducción de dinero a nuestra cuenta

Las dos acciones básicas que debe proporcionar cualquier cuenta son: depositar, es decir, agregar dinero a una cuenta, y retirar, es decir, eliminar dinero de una cuenta. El depósito tiene una fuente y el retiro tiene un destino diferente a nuestra cuenta corriente. No entraremos en detalles sobre cómo implementar estas transacciones, solo nos concentraremos en implementar los efectos que tienen en nuestra cuenta. Entonces, podemos imaginar una prueba como esta para depositar.

function testAccountCanDepositMoney() {
	$this->account->setPrimaryCurrency(Currency::EUR());
	$money = new Money(100, Currency::EUR()); //That's 1 EURO
	$this->account->deposit($money);

	$this->assertEquals($money, $this->account->getPrimaryBalance());
}

Esto nos obligará a escribir bastante código de implementación.

class Account {

	private $id;
	private $primaryCurrency;
	private $secondaryCurrency;
	private $secondaryBalance;
	private $primaryBalance;

	function getSecondaryBalance() {
		return $this->secondaryBalance;
	}

	function getPrimaryBalance() {
		return $this->primaryBalance;
	}

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

	[...]

	function deposit(Money $money) {
		$this->primaryCurrency == $money->getCurrency() ? $this->primaryBalance = $money : $this->secondaryBalance = $money;
	}

}

BIEN BIEN. Lo sé, escribí más de lo absolutamente necesario para producción. Pero no quiero aburrirte hasta la muerte con pequeños pasos y también estoy bastante seguro de que el código de balance secundario (secondaryBalance) funcionará correctamente. Fue generado casi en su totalidad por el IDE. Incluso me saltaré la prueba. Si bien este código hace que nuestra prueba pase, tenemos que preguntarnos qué sucede cuando hacemos depósitos posteriores. Queremos que nuestro dinero se sume al saldo anterior.

function testSubsequentDepositsAddUpTheMoney() {
	$this->account->setPrimaryCurrency(Currency::EUR());
	$money = new Money(100, Currency::EUR()); //That's 1 EURO
	$this->account->deposit($money); //One euro in the account
	$this->account->deposit($money); //Two euros in the account

	$this->assertEquals($money->multiplyBy(2), $this->account->getPrimaryBalance());
}

Bueno, eso falla. Entonces tenemos que actualizar nuestro código de producción.

function deposit(Money $money) {
	if ($this->primaryCurrency == $money->getCurrency()){
		$this->primaryBalance = $this->primaryBalance ? : new Money(0, $this->primaryCurrency);
		$this->primaryBalance = $this->primaryBalance->add($money);
	}else {
		$this->secondaryBalance = $this->secondaryBalance ? : new Money(0, $this->secondaryCurrency);
		$this->secondaryBalance = $this->secondaryBalance->add($money);
	}
}

Esto es mucho mejor. Probablemente hayamos terminado con el método de depósito (deposit) y podemos continuar con el de retiro (withdraw).

function testAccountCanWithdrawMoneyOfSameCurrency() {
	$this->account->setPrimaryCurrency(Currency::EUR());
	$money = new Money(100, Currency::EUR()); //That's 1 EURO
	$this->account->deposit($money);
	$this->account->withdraw(new Money(70, Currency::EUR()));

	$this->assertEquals(new Money(30, Currency::EUR()), $this->account->getPrimaryBalance());

}

Esta es solo una prueba simple. La solución también es simple.

function withdraw(Money $money) {
	$this->primaryCurrency == $money->getCurrency() ?
		$this->primaryBalance = $this->primaryBalance->subtract($money) :
		$this->secondaryBalance = $this->secondaryBalance->subtract($money);
}

Bueno, eso funciona, pero ¿qué pasa si queremos usar una moneda que no está en tu cuenta? Deberíamos lanzar una excepción para eso.

/**
 * @expectedException Exception
 * @expectedExceptionMessage This account has no currency USD
 */

function testThrowsExceptionForInexistentCurrencyOnWithdraw() {
	$this->account->setPrimaryCurrency(Currency::EUR());
	$money = new Money(100, Currency::EUR()); //That's 1 EURO
	$this->account->deposit($money);
	$this->account->withdraw(new Money(70, Currency::USD()));
}

Eso también nos obligará a revisar nuestras monedas.

function withdraw(Money $money) {
	$this->validateCurrencyFor($money);
	$this->primaryCurrency == $money->getCurrency() ?
		$this->primaryBalance = $this->primaryBalance->subtract($money) :
		$this->secondaryBalance = $this->secondaryBalance->subtract($money);
}

private function validateCurrencyFor(Money $money) {
	if (!in_array($money->getCurrency(), $this->getCurrencies()))
			throw new Exception(
				sprintf(
					'This account has no currency %s',
					$money->getCurrency()->getStringRepresentation()
				)
			);
}

Pero, ¿y si queremos retirar más de lo que tenemos? Ese caso ya se abordó cuando implementamos la resta en Money. Aquí está la prueba que lo prueba.

/**
 * @expectedException Exception
 * @expectedExceptionMessage Subtracted money is more than what we have
 */
function testItThrowsExceptionIfWeTryToSubtractMoreMoneyThanWeHave() {
	$this->account->setPrimaryCurrency(Currency::EUR());
	$money = new Money(100, Currency::EUR()); //That's 1 EURO
	$this->account->deposit($money);
	$this->account->withdraw(new Money(150, Currency::EUR()));
}

Lidiar con el Retiro e Intercambio

Una de las cosas más difíciles de afrontar cuando trabajamos con varias divisas es el intercambio entre ellas. La belleza de este patrón de diseño es que nos permite simplificar un poco este problema aislándolo y encapsulándolo en su propia clase. Si bien la lógica en una clase de Exchange puede ser muy sofisticada, su uso se vuelve mucho más fácil. Por el bien de este tutorial, imaginemos que solo tenemos una lógica de Exchange muy básica. 1 EUR = 1,5 USD.

class Exchange {

	function convert(Money $money, Currency $toCurrency) {
		if ($toCurrency == Currency::EUR() && $money->getCurrency() == Currency::USD())
			return new Money($money->multiplyBy(0.67)->getAmount(), $toCurrency);
		if ($toCurrency == Currency::USD() && $money->getCurrency() == Currency::EUR())
			return new Money($money->multiplyBy(1.5)->getAmount(), $toCurrency);
		return $money;
	}

}

Si convertimos de EUR a USD multiplicamos el valor por 1,5, si convertimos de USD a EUR dividimos el valor por 1,5, de lo contrario suponemos que estamos convirtiendo dos divisas del mismo tipo, así que no hacemos nada y solo devolvemos el dinero. Por supuesto, en realidad esta sería una clase mucho más complicada.

Ahora, al tener una clase Exchange, la cuenta puede tomar diferentes decisiones cuando queremos retirar dinero en una moneda, pero no tenemos suficiente dinero en esa moneda específica. Aquí hay una prueba que lo ejemplifica mejor.

function testItConvertsMoneyFromTheOtherCurrencyWhenWeDoNotHaveEnoughInTheCurrentOne() {
	$this->account->setPrimaryCurrency(Currency::USD());
	$money = new Money(100, Currency::USD()); //That's 1 USD
	$this->account->deposit($money);

	$this->account->setSecondaryCurrency(Currency::EUR());
	$money = new Money(100, Currency::EUR()); //That's 1 EURO = 1.5 USD
	$this->account->deposit($money);

	$this->account->withdraw(new Money(200, Currency::USD())); //That's 2 USD

	$this->assertEquals(new Money(0, Currency::USD()), $this->account->getPrimaryBalance());
	$this->assertEquals(new Money(34, Currency::EUR()), $this->account->getSecondaryBalance());
}

Establecemos la moneda principal de nuestra cuenta en USD y depositamos un dólar. Luego, establecemos la moneda secundaria en EUR y depositamos un euro. Luego retiramos dos dólares. Finalmente, esperamos quedarnos con cero dólares y 0,34 euros. Por supuesto, esta prueba arroja una excepción, por lo que tenemos que implementar una solución a este dilema.

function withdraw(Money $money) {
	$this->validateCurrencyFor($money);
	if ($this->primaryCurrency == $money->getCurrency()) {
		if( $this->primaryBalance >= $money ) {
			$this->primaryBalance = $this->primaryBalance->subtract($money);
		}else{
			$ourMoney = $this->primaryBalance->add($this->secondaryToPrimary());
			$remainingMoney = $ourMoney->subtract($money);
			$this->primaryBalance = new Money(0, $this->primaryCurrency);
			$this->secondaryBalance = (new Exchange())->convert($remainingMoney, $this->secondaryCurrency);
		}

	} else {
		$this->secondaryBalance = $this->secondaryBalance->subtract($money);
	}
}

private function secondaryToPrimary() {
	return (new Exchange())->convert($this->secondaryBalance, $this->primaryCurrency);
}

Vaya, se tuvieron que hacer muchos cambios para admitir esta conversión automática. Lo que está sucediendo es que si estamos en el caso de extraer de nuestra moneda principal y no tenemos suficiente dinero, convertimos nuestro saldo de la moneda secundaria a primaria y volvemos a intentar la resta. Si aún no tenemos suficiente dinero, el objeto $ourMoney lanzará la excepción apropiada. De lo contrario, estableceremos nuestro saldo primario en cero y convertiremos el dinero restante a la moneda secundaria y estableceremos nuestro saldo secundario en ese valor.

Depende de la lógica de nuestra cuenta implementar una conversión automática similar para la moneda secundaria. No implementaremos una lógica tan simétrica. Si te gusta la idea, considérala como un ejercicio para ti. Además, piensa en un método privado más genérico que haría la magia de las conversiones automáticas en ambos casos.

Este complejo cambio en nuestra lógica también nos obliga a actualizar otra de nuestras pruebas. Siempre que queramos convertir automáticamente debemos tener un saldo, incluso si es solo cero.

/**
 * @expectedException Exception
 * @expectedExceptionMessage Subtracted money is more than what we have
 */
function testItThrowsExceptionIfWeTryToSubtractMoreMoneyThanWeHave() {
	$this->account->setPrimaryCurrency(Currency::EUR());
	$money = new Money(100, Currency::EUR()); //That's 1 EURO
	$this->account->deposit($money);

	$this->account->setSecondaryCurrency(Currency::USD());
	$money = new Money(0, Currency::USD());
	$this->account->deposit($money);


	$this->account->withdraw(new Money(150, Currency::EUR()));
}

Asignación de dinero entre cuentas

El último método que necesitamos implementar en Money es allocate. Esta es la lógica que decide qué hacer al dividir dinero entre diferentes cuentas que no se pueden hacer exactamente. Por ejemplo, si tenemos 0,10 centavos y queremos distribuirlos entre dos cuentas en una proporción de 30 a 70 por ciento, es fácil. Una cuenta obtendrá tres centavos y la otra siete. Sin embargo, si queremos hacer la misma asignación de razón de 30-70 de cinco centavos, tenemos un problema. La asignación exacta sería de 1,5 centavos en una cuenta y 3,5 en la otra. Pero no podemos dividir centavos, por lo que tenemos que implementar nuestro propio algoritmo para asignar el dinero.

Puede haber varias soluciones a este problema, un algoritmo común es agregar un centavo secuencialmente a cada cuenta. Si una cuenta tiene más centavos que su valor matemático exacto, debe eliminarse de la lista de asignación y no recibir más dinero. Aquí hay una representación gráfica.

Y una prueba para demostrar nuestro punto está a continuación.

function testItCanAllocateMoneyBetween2Accounts() {
	$a1 = $this->anAccount();
	$a2 = $this->anAccount();
	$money = new Money(5, Currency::USD());
	$money->allocate($a1, $a2, 30, 70);

	$this->assertEquals(new Money(2, Currency::USD()), $a1->getPrimaryBalance());
	$this->assertEquals(new Money(3, Currency::USD()), $a2->getPrimaryBalance());
}

private function anAccount() {
	$account = new Account(1);
	$account->setPrimaryCurrency(Currency::USD());
	$account->deposit(new Money(0, Currency::USD()));
	return $account;
}

Simplemente creamos un objeto Money con cinco centavos y dos cuentas. Llamamos a allocate y esperamos que los dos o tres valores estén en las dos cuentas. También creamos un método auxiliar para crear cuentas rápidamente. La prueba falla, como se esperaba, pero podemos hacerla pasar con bastante facilidad.

function allocate(Account $a1, Account $a2, $a1Percent, $a2Percent) {
	$exactA1Balance = $this->amount * $a1Percent / 100;
	$exactA2Balance = $this->amount * $a2Percent / 100;

	$oneCent = new Money(1, $this->currency);
	while ($this->amount > 0) {
		if ($a1->getPrimaryBalance()->getAmount() < $exactA1Balance) {
			$a1->deposit($oneCent);
			$this->amount--;
		}
		if ($this->amount <= 0)
			break;
		if ($a2->getPrimaryBalance()->getAmount() < $exactA2Balance) {
			$a2->deposit($oneCent);
			$this->amount--;
		}
	}
}

Bueno, no es el código más simple, pero está funcionando correctamente, como lo demuestra la aprobación de nuestra prueba. Lo único que todavía podemos hacer con este código es reducir la pequeña duplicación dentro del ciclo while.

function allocate(Account $a1, Account $a2, $a1Percent, $a2Percent) {
	$exactA1Balance = $this->amount * $a1Percent / 100;
	$exactA2Balance = $this->amount * $a2Percent / 100;

	while ($this->amount > 0) {
		$this->allocateTo($a1, $exactA1Balance);
		if ($this->amount <= 0)
			break;
		$this->allocateTo($a2, $exactA2Balance);
	}
}

private function allocateTo($account, $exactBalance) {
	if ($account->getPrimaryBalance()->getAmount() < $exactBalance) {
		$account->deposit(new Money(1, $this->currency));
		$this->amount--;
	}
}

Reflexiones finales

Lo que encuentro asombroso con este pequeño patrón es la gran variedad de casos en los que podemos aplicarlo.

Hemos terminado con nuestro patrón de dinero. Vimos que es un patrón bastante simple, que encapsula los detalles del concepto de dinero. También vimos que esta encapsulación alivia la carga de los cálculos de "Account". La cuenta puede concentrarse en representar el concepto desde un nivel superior, desde el punto de vista del banco. La cuenta puede implementar métodos como la conexión con los titulares de la cuenta, identificaciones, transacciones y dinero. Será un orquestador, no una calculadora. El dinero se encargará de los cálculos.

Lo que encuentro asombroso con este pequeño patrón es la gran variedad de casos en los que podemos aplicarlo. Básicamente, cada vez que tengas un par de unidad de valor, puedes usarlo. Imagina que tienes una aplicación meteorológica y deseas implementar una representación para la temperatura. Ese sería el equivalente de nuestro objeto Money. Puedes usar Fahrenheit o Celsius en vez de las monedas.

Otro caso de uso es cuando tienes una aplicación de mapeo y deseas representar distancias entre puntos. Puedes utilizar fácilmente este patrón para cambiar entre medidas métricas o imperiales. Cuando trabajas con unidades simples, puedes soltar el objeto "Exchange" e implementar la lógica de conversión simple dentro de tu objeto "Money".

Por lo tanto, espero que hayas disfrutado de este tutorial y estoy ansioso por conocer las diferentes formas en que puedes usar este concepto. Gracias por leer.