Gain insights into TDD with Go. Learn Go fundamentals, write test cases, explore TDD katas, and build a TODO app to master reliable application development practices.

Test-Driven Development Made Easy Through Golang.png

hello_world_go.tar.gz

hello_world_test

assert_demo

code_smells

no_code_smells

magic_numbers

no_magic_numbers

roman_numerals

roman_numerals_improved

subtests

table_driven_tests

skip_by_flag

skip_by_condition

benchmarking

benchmarking_multiple_times

benchmarking_different_values

fuzz_error

fuzz_fixed

acme_start

acme_mock

blog

blog_mock

ping_webapi

product_webapi

product_webapi_w

ping_test

product_test

fizzbuzz

passvalidator

clean_tests

Test-driven development (TDD) is a software design technique based on tests that promotes an iterative way of writing software. This course will teach you to use TDD using Go—one of the most popular languages.

In this course, you will first learn about the fundamentals of Go, including packages, standard library, and error handling. Then, you will go through a comprehensive guide on writing test cases using Go, including subtests, table-driven tests, skipping, benchmarking, fuzzing, dependency injection, and mocking in unit tests. Next, you will look at multiple TDD katas and learn about the best practices for making most of the TDD approach. Finally, you will build a TODO application by following the test-driven development approach. This application will be a REST API that exposes actions getting TODOs. 

After completing this course, you will have the skills needed to build reliable applications using the test-driven development approach.

Learning Test-Driven Development with Go

# Hello, World!
As a warmup, let’s start with a basic application: “Hello, World!” The code sample for this application is below.



package main
import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

If we run the code above, we should see the `Hello, World!` string in the output section.

## In a nutshell
Now, let's walk through the creation process for this application.
### Coding
We need to create an empty folder that contains our project. Inside it, we add a `main.go` that will be the entry point for our application. This file is part of the main package, which is the executable package invoked during program startup. Just below the package definition, we can see the import section. In this section, we can see which packages are used by our Go program. In our program, we rely only on the `fmt` package. The `fmt.Println` function writes the characters passed in, plus a trailing new-line character. 
### Setup and running
The setup for this simple program can also be applied to more complex programs.
#### Initialize a Go module
We need to initialize a module with the command-line interface `go mod init hello-world` command. This creates a Go module that is rooted in the current directory. The phrase `hello-world` is the module path, but it’s not mandatory for the command to be executed. If we successfully run this command, a new `go.mod` file will appear within our source project directory. This file holds the references to other packages. 
#### Run it
One way of running our program is by issuing the `go run .` command in the terminal. This will prompt Go to compile and run the main package of our program.
>  Note: To make this command work, we need to be with our terminal in the same location as the `go.mod` file.  
  
As soon as we launch this program, we can see the output printed onto the console.
## Try it yourself
Now, it’s time to run the “Hello World” application through the terminal below. The commands that we need to run are:
- The `go mod init hello-world` command for initializing the Go module
- The `go run .` command for both compiling and running the program



Get familiar with the basics of Go with some practical examples.

Hello, World

Introduction

Go: Fundamentals

Assessment: Basics of Go

Tests & TDD

Go & Tests

Assessment: Tests in Go

TDD Katas

A Simple TODO Application

Conclusion

Hello, World

Hello, World!