Go

Let’s write a new test in money_test.go. This test requires that when a struct representing “10 Euros” is multiplied by 2, we get “20 Euros”:

func TestMultiplicationInEuros(t *testing.T) {
    tenEuros := Money{amount: 10, currency: "EUR"}
    twentyEuros := tenEuros.Times(2)
    if twentyEuros.amount != 20 {
        t.Errorf("Expected 20, got: [%d]", twentyEuros.amount)
    }
    if twentyEuros.currency != "EUR" {
        t.Errorf("Expected EUR, got: [%s]", twentyEuros.currency)
    }
}

The test expresses the concepts of “10 Euros” and “20 Euros” with struct instances containing a currency as well as amount.

By now, we know that when we run this test, we’ll get an error notifying us of undefined: Money. We can eliminate this by introducing a new struct:

type Money struct {
    amount   int
    currency string
}

We now get the error type Money has no field or method Times, which we know how to get around. We define a Times method for Money:

func (m Money) Times(multiplier int) Money {
    return Money{amount: m.amount * multiplier, currency: m.currency}
}

Yay! Green tests again.

Go

We realize that the Money struct can do everything that the Dollar struct can, and more. Money has currency, which Dollar does not.

Let’s delete the Dollar struct and its Times method.

When we do this, the TestMultiplication test predictably breaks with an undefined: Dollar error. Let’s refactor that test to use Money instead:

func TestMultiplicationInDollars(t *testing.T) {
    fiver := Money{amount: 5, currency: "USD"}
    tenner := fiver.Times(2)
    if tenner.amount != 10 {
        t.Errorf("Expected 10, got: [%d]", tenner.amount)
    }
    if tenner.currency != "USD" {
        t.Errorf("Expected USD, got: [%s]", tenner.currency)
    }
}

Both tests now pass. Notice that we renamed the test to be more descriptive: TestMultiplicationInDollars.

Go

Let’s write our new test for division.

func TestDivision(t *testing.T) {
    originalMoney := Money{amount: 4002, currency: "KRW"}
    actualMoneyAfterDivision := originalMoney.Divide(4)
    expectedMoneyAfterDivision := Money{amount: 1000.5, currency: "KRW"}
    if expectedMoneyAfterDivision != actualMoneyAfterDivision {
        t.Errorf("Expected  [%+v] Got: [%+v]",
            expectedMoneyAfterDivision, actualMoneyAfterDivision)
    }
}

Notice that we wrote this test a bit differently. We define variables for the two structs: actualMoneyAfterDivision and expectedMoneyAfterDivision. And instead of comparing amount and currency separately, we compare the two structs as a whole. If the structs don’t match, we print them both.

We anticipate the type Money has no field or method Divide error we get when we run this test. Let’s define this missing method, taking our cue from the existing Times method:

func (m Money) Divide(divisor int) Money {
    return Money{amount: m.amount / divisor, currency: m.currency}
}

Ah! The test fails with a new error: constant 1000.5 truncated to integer.

It’s clear that we need to change the amount field in the Money struct so that it can hold fractional values. The float64 data type is appropriate for this purpose:

type Money struct {
    amount   float64
    currency string
}

This gives us new errors when we run our test:

... invalid operation: m.amount * multiplier (mismatched types float64 and int)
... invalid operation: m.amount / divisor (mismatched types float64 and int)

We need to modify our arithmetic operations (multiplication and division) to use the same data type for all operands. We know from our domain that the multipliers and divisors are likely to be integers (number of shares of a stock) whereas the amount can be a fractional number (trading price of a particular stock). Let’s use this knowledge to convert the multiplier and divisor to float64 before using them in our arithmetic operations. We can do this by calling the float64() function:

func (m Money) Times(multiplier int) Money {
    return Money{amount: m.amount * float64(multiplier), currency: m.currency}
}

func (m Money) Divide(divisor int) Money {
    return Money{amount: m.amount / float64(divisor), currency: m.currency}
}

Now we get different wrong type failures

... Errorf format %d has arg tenner.amount of wrong type float64
... Errorf format %d has arg twentyEuros.amount of wrong type float64

A careful reading of the error messages reveals that we are using the wrong format “verb” in our earlier tests to print the amount field. Since our newest test — TestDivision — successfully compares entire struct`s, we can refactor our earlier two multiplication tests to do something similar. This way, we'll side-step the whole issue of having used the incorrect formatting "verb" for `float64 type.

Here’s how TestMultiplicationInDollars looks after changing its assertion statement. (The other test, TestMultiplicationInEuros, needs similar changes.)

func TestMultiplicationInDollars(t *testing.T) {
    fiver := Money{amount: 5, currency: "USD"}
    actualResult := fiver.Times(2)
    expectedResult := Money{amount: 10, currency: "USD"}
    if actualResult != actualResult {
        t.Errorf("Expected [%+v], got: [%+v]", expectedResult, actualResult)
    }
}

After these changes, all our tests are green.

Go

We now have three tests with three assertion blocks, each of which is a 3-line if block. Except for the variable names in each test, the if blocks are identical. This duplication is ripe for removal via extracted into a helper function, which we can call assertEqual.

func assertEqual(t *testing.T, expected Money, actual Money) {
    if expected != actual {
        t.Errorf("Expected  [%+v] Got: [%+v]", expected, actual)
    }
}

The function’s body is identical to any of the three existing if blocks. We can now call this function from each of the three tests. The TestDivision function is shown below:

func TestDivision(t *testing.T) {
    originalMoney := Money{amount: 4002, currency: "KRW"}
    actualResult := originalMoney.Divide(4)
    expectedResult := Money{amount: 1000.5, currency: "KRW"}
    assertEqual(t, expectedResult, actualResult)
}

We can modify the TestMultiplicationInEuros and TestMultiplicationInDollars tests similarly.

Go

Here’s how the file money_test.go looks right now:

package main

import (
    "testing"
)

func TestMultiplicationInDollars(t *testing.T) {
    fiver := Money{amount: 5, currency: "USD"}
    actualResult := fiver.Times(2)
    expectedResult := Money{amount: 10, currency: "USD"}
    assertEqual(t, expectedResult, actualResult)
}

func TestMultiplicationInEuros(t *testing.T) {
    tenEuros := Money{amount: 10, currency: "EUR"}
    actualResult := tenEuros.Times(2)
    expectedResult := Money{amount: 20, currency: "EUR"}
    assertEqual(t, expectedResult, actualResult)
}

func TestDivision(t *testing.T) {
    originalMoney := Money{amount: 4002, currency: "KRW"}
    actualResult := originalMoney.Divide(4)
    expectedResult := Money{amount: 1000.5, currency: "KRW"}
    assertEqual(t, expectedResult, actualResult)
}

func assertEqual(t *testing.T, expected Money, actual Money) {
    if expected != actual {
        t.Errorf("Expected  [%+v] Got: [%+v]", expected, actual)
    }
}

type Money struct {
    amount   float64
    currency string
}

func (m Money) Times(multiplier int) Money {
    return Money{amount: m.amount * float64(multiplier), currency: m.currency}
}

func (m Money) Divide(divisor int) Money {
    return Money{amount: m.amount / float64(divisor), currency: m.currency}
}