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

The last feature that we have to implement is the FizzBuzz feature. Let’s recap the scenarios we’ve managed so far
- Return `Fizz` if the number is divisible by `3`.
- Return `Buzz` if the number is divisible by `5`.
- Return the string representation of the number if not divisible neither by `3` nor by `5`.  
  
Now, let's focus on what we missed to complete the kata.
# `FizzBuzz` scenario
We have to manage the numbers that are divisible by `3` and also by `5`. When we receive one of these numbers, we need to return the `FizzBuzz` string to the caller.

## The Red phase
Let's write one test to jump into the Red phase:

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

We've added the test `ShouldReturnFizzBuzz_WhenFifteenIsPassed` to the `TestFizzBuzz` function. The latter expects that if we provide `15` to the function, it should reply with the `FizzBuzz` string. However, the `FizzBuzz` function isn't ready to manage this scenario so, it replies with `Buzz` because `15` is divisible by `5` (and this is the first check it encounters).
## The Green phase
At this point, we have to apply the smallest possible fix to our function which is the one presented below:

Finish the kata by building the FizzBuzz feature.

FizzBuzz: FizzBuzz Requirement

Introduction

Go: Fundamentals

Assessment: Basics of Go

Tests & TDD

Go & Tests

Assessment: Tests in Go

TDD Katas

A Simple TODO Application

Conclusion

FizzBuzz: "FizzBuzz" Requirement

`FizzBuzz` scenario

Assessment: Basics of Go

Assessment: Tests in Go

A Simple TODO Application

FizzBuzz: "FizzBuzz" Requirement

FizzBuzz scenario

`FizzBuzz` scenario