Python

Let’s write a new test in test_money.py that validates adding Dollars to Euros:

    def testAdditionOfDollarsAndEuros(self):
        fiveDollars = Money(5, "USD")
        tenEuros = Money(10, "EUR")
        portfolio = Portfolio()
        portfolio.add(fiveDollars, tenEuros)
        expectedValue = Money(17, "USD") 
        actualValue = portfolio.evaluate("USD")
        self.assertEqual(expectedValue, actualValue)

The expected value of 17 USD assumes that we get 1.2 dollars for every euro we convert

The test creates two Money objects representing 5 USD and 10 EUR, respectively. They are added to a pristine Portfolio object. The actualValue from evaluating the Portfolio in dollars is compared with a newly minted expectedValue of 17 USD.

We expect the test to fail, of course, because we are in the RED phase of our of RGR cycle. However, the error message from the assertion failure is rather cryptic:

AssertionError: <money.Money object at 0x10f3c3280> != <money.Money object at 0x10f3c33a0>

Who on earth knows what mysterious goblins reside at those obscure memory addresses!

This is one of those times where we must slow down and write a better failing test before we attempt to get to GREEN. Can we make the assertion statement print a more helpful error message?

The assertEqual method — like most other assertion methods in the unittest package — takes an optional third parameter, which is a custom error message. Let’s provide a formatted string showing the stringified representation of expectedValue and actualValue:

self.assertEqual(expectedValue, actualValue,
                "%s != %s"%(expectedValue, actualValue)) 

Last line of testAdditionOfDollarsAndEuros test method

Nope! That simply prints the obscure memory addresses twice:

AssertionError:
    <money.Money object at 0x1081111f0> != <money.Money object at 0x108111310> :
    <money.Money object at 0x1081111f0> != <money.Money object at 0x108111310>

What we need to do is to override the __str__ method in the Money class and make it return a more human-readable representation. Something like “USD 17.00”.

    def __str__(self): 
        return f"{self.currency} {self.amount:0.2f}"

In Money class

We format Money’s currency and amount fields, printing the latter up to two decimal places.

After adding the __str__ method, let’s run our test suite again:

AssertionError: ... USD 17.00 != USD 15.00

Ah, much better! Seventeen dollars certainly aren’t the same thing as 15 dollars!

This validates our belief that the evaluate method, as currently implemented, mindlessly adds the amounts of all Money objects (5 and 10 in our test) to get the result, with no regard to the currencies (USD and EUR, respectively, in our test).

A closer examination of the evaluate method shows that the mindlessness is in the lambda expression. It maps every Money object to its amount, regardless of its currency. These amounts are then added up by the reduce function using the add operator.

What if the lambda expression mapped every Money object to its converted value? The target currency for the conversion would be the currency in which the Portfolio is being evaluated.

        total = functools.reduce(operator.add,
          map(lambda m: self.__convert(m, currency), self.moneys), 0) 

In Money class

How should we implement the __convert method? Converting to the same currency as that of the Money is trivial: the Money’s amount doesn’t change in this case. When converting to a different currency, we’ll multiply Money’s amount with the (for now) hard-coded exchange rate between USD and EUR:

    def __convert(self, aMoney, aCurrency): 
        if aMoney.currency == aCurrency:
            return aMoney.amount
        else:
            return aMoney.amount * 1.2 

New method in Portfolio class

Hard-coded exchange rate

The test is green. Yay … and hmm! We should do the refactoring to remove the ugliness of this code. Here are some problems with it:

1. The exchange rate is hard-coded. It should be declared as a variable.

2. The exchange rate isn’t dependent on the currency. It should be looked up based on the two currencies involved.

3. The exchange rate should be modifiable.

Let’s address the first of these three items in the REFACTOR phase and add the remaining two to our feature list.

We define a private variable named _eur_to_usd in the __init__ method and use it instead of the hard-coded value in the __convert method:

class Portfolio:
    def __init__(self):
        self.moneys = []
        self._eur_to_usd = 1.2 
...
    def __convert(self, aMoney, aCurrency):
        if aMoney.currency == aCurrency:
            return aMoney.amount
        else:
            return aMoney.amount * self._eur_to_usd 

Exchange rate is defined as an appropriately named variable

The exchange rate variable is used to convert currency

All tests are green.