Go Interface Tutorial: Creating and Utilizing Interfaces with Unit Test Example

Welcome to this Go programming tutorial where we’ll delve into the concept of interfaces in Go. Interfaces are a powerful feature that promotes code flexibility, extensibility, and testability. In this tutorial, we’ll explore how to create interfaces, why they are crucial, and demonstrate their use with a practical example – a simple banking application. Additionally, we’ll write unit tests to validate our implementation.

Table of Contents

1. Introduction to Interfaces in Go

In Go, an interface is a collection of method signatures. A type implements an interface by providing definitions for these methods. Unlike some other languages, Go interfaces are satisfied implicitly, and a type doesn’t explicitly state that it implements an interface. This promotes loose coupling and flexibility in your code.

2. Creating a Basic Interface

Let’s start by defining a simple interface named Account for our banking application. It will include methods for deposit, withdrawal, and checking the account balance.

// banking.go

package main

import "errors"

// Account represents a basic banking account.
type Account interface {
    Deposit(amount float64) error
    Withdraw(amount float64) error
    Balance() float64
}

3. Implementing Interface Methods

Next, we’ll implement two types, SavingsAccount and CheckingAccount, that satisfy the Account interface. These types will have their own implementations of deposit, withdrawal, and balance methods.

// banking.go

package main

import "errors"

// SavingsAccount represents a savings account.
type SavingsAccount struct {
    balance float64
}

func (s *SavingsAccount) Deposit(amount float64) error {
    s.balance += amount
    return nil
}

func (s *SavingsAccount) Withdraw(amount float64) error {
    if amount > s.balance {
        return errors.New("Insufficient funds")
    }
    s.balance -= amount
    return nil
}

func (s *SavingsAccount) Balance() float64 {
    return s.balance
}

// CheckingAccount represents a checking account.
type CheckingAccount struct {
    balance float64
}

func (c *CheckingAccount) Deposit(amount float64) error {
    c.balance += amount
    return nil
}

func (c *CheckingAccount) Withdraw(amount float64) error {
    if amount > c.balance {
        return errors.New("Insufficient funds")
    }
    c.balance -= amount
    return nil
}

func (c *CheckingAccount) Balance() float64 {
    return c.balance
}

4. Polymorphism and Interface Types

Now, let’s explore polymorphism using the Account interface. We’ll create a function, printAccountInfo, that can accept any type implementing the Account interface.

// banking.go

package main

import "fmt"

// printAccountInfo prints account information.
func printAccountInfo(acc Account) {
    fmt.Printf("Balance: $%.2f\n", acc.Balance())
}

5. Writing Unit Tests

To ensure the correctness of our implementation, we’ll write unit tests. Create a file named banking_test.go to test various functionalities of the banking application.

// banking_test.go

package main

import (
    "testing"
)

func TestBankingApplication(t *testing.T) {
    // Create Savings Account
    savingsAcc := &SavingsAccount{}
    savingsAcc.Deposit(1000)

    // Create Checking Account
    checkingAcc := &CheckingAccount{}
    checkingAcc.Deposit(500)

    // Print account info using the interface
    printAccountInfo(savingsAcc)
    printAccountInfo(checkingAcc)

    // Test Withdrawal
    err := savingsAcc.Withdraw(200)
    if err != nil {
        t.Errorf("Error withdrawing from savings account: %v", err)
    }

    err = checkingAcc.Withdraw(700)
    if err != nil {
        t.Errorf("Error withdrawing from checking account: %v", err)
    }

    // Print updated account info
    printAccountInfo(savingsAcc)
    printAccountInfo(checkingAcc)
}

Execute the tests using the go test command:

go test

6. Conclusion

Congratulations! You’ve successfully learned how to create and utilize interfaces in Go, enhancing your code’s modularity and flexibility. The banking application example demonstrated how different types can implement a common interface, allowing for polymorphic behavior. Unit tests ensure that our code functions as expected, providing confidence in the correctness of our implementation.

Interfaces are a fundamental part of Go’s design philosophy, enabling clean and scalable code. As you continue to explore Go, remember that interfaces play a key role in crafting maintainable and extensible applications. Happy coding!