Introduction to API Testing with Go

Welcome to the first lesson of the course Automating API Tests with Go . In this course, we will focus on validating API behavior by writing automated tests in Go. APIs play a crucial role in modern software systems, acting as the communication layer between services. Ensuring that an API is reliable, returns expected responses, and handles errors correctly is critical for maintaining system stability. API testing helps detect issues early by verifying that the API behaves correctly from the consumer's perspective.

What You’ll Learn in This Lesson

By the end of this lesson, you will be able to: Understand the basics of API testing and its importance. Write and run basic API tests using Go’s testing package. Follow the Arrange-Act-Assert (AAA) pattern for structuring test cases. Validate API responses to ensure correctness.

What is API Testing?

API testing is the process of verifying that an API: Returns the correct status codes . Responds with the expected data . Handles errors properly (e.g., missing parameters, invalid inputs). Performs within an acceptable time limit . Unlike unit testing, which isolates functions or methods, API testing verifies the behavior of an API as a whole, ensuring that it functions correctly when integrated with other services.

Types of API Testing

API testing can take different forms, including: Functional Testing : Ensuring that the API returns the expected output for given inputs. Performance Testing : Checking response times and API stability under load. Security Testing : Verifying authentication and access control mechanisms. Contract Testing : Ensuring API responses follow the expected data structure. This lesson will focus on functional testing by writing tests that validate an API’s behavior using Go’s standard testing package.

The Arrange-Act-Assert (AAA) Pattern

The Arrange-Act-Assert (AAA) pattern provides a structured way to write test cases: Arrange : Set up the test environment, including inputs and expected results. Act : In this phase, you perform the action that triggers the behavior you want to test. In this case, it executes the actual API request. Assert : Verify the response meets expectations. This is done using assertions to check the response from the API, ensuring it behaves as expected. This pattern improves readability and maintainability by clearly separating test phases. We’ll now write a test for an API endpoint that retrieves all todo items.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

func TestFunction(t *testing.T) {
    result, err := SomeFunction()
    if err != nil {
        t.Fatalf("Unexpected error: %v", err)
    }
    
    if result != expectedValue {
        t.Errorf("Expected %v, got %v", expectedValue, result)
    }
}

func TestFunction(t *testing.T) {
    result, err := SomeFunction()
    if err != nil {
        t.Fatalf("Unexpected error: %v", err)
    }
    
    if result != expectedValue {
        t.Errorf("Expected %v, got %v", expectedValue, result)
    }
}

package main_test

import (
    "net/http"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"
}

package main_test

import (
    "net/http"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"
}

package main_test

import (
    "net/http"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"
    // Act
    response, err := http.Get(url)
    if err != nil {
        t.Fatalf("Failed to make GET request: %v", err)
    }
    defer response.Body.Close()
}

package main_test

import (
    "net/http"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"
    // Act
    response, err := http.Get(url)
    if err != nil {
        t.Fatalf("Failed to make GET request: %v", err)
    }
    defer response.Body.Close()
}

package main_test

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"

    // Act
    response, err := http.Get(url)
    if err != nil {
        t.Fatalf("Failed to make GET request: %v", err)
    }
    defer response.Body.Close()

    // Assert
    if response.StatusCode != http.StatusOK {
        t.Errorf("Expected status code 200, got %d", response.StatusCode)
    }

    var todos []map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&todos); err != nil {
        t.Fatalf("Failed to decode response body: %v", err)
    }

    if len(todos) == 0 {
        t.Error("Expected non-empty list of todos.")
    }

    // Basic contract validation: Check required fields
    if _, ok := todos[0]["id"]; !ok {
        t.Error("Expected field 'id' in response")
    }
    if _, ok := todos[0]["title"]; !ok {
        t.Error("Expected field 'title' in response")
    }
}

package main_test

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"

    // Act
    response, err := http.Get(url)
    if err != nil {
        t.Fatalf("Failed to make GET request: %v", err)
    }
    defer response.Body.Close()

    // Assert
    if response.StatusCode != http.StatusOK {
        t.Errorf("Expected status code 200, got %d", response.StatusCode)
    }

    var todos []map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&todos); err != nil {
        t.Fatalf("Failed to decode response body: %v", err)
    }

    if len(todos) == 0 {
        t.Error("Expected non-empty list of todos.")
    }

    // Basic contract validation: Check required fields
    if _, ok := todos[0]["id"]; !ok {
        t.Error("Expected field 'id' in response")
    }
    if _, ok := todos[0]["title"]; !ok {
        t.Error("Expected field 'title' in response")
    }
}

func TestFunction(t *testing.T) {
    result, err := SomeFunction()
    if err != nil {
        t.Fatalf("Unexpected error: %v", err)
    }
    
    if result != expectedValue {
        t.Errorf("Expected %v, got %v", expectedValue, result)
    }
}

package main_test

import (
    "net/http"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"
}

package main_test

import (
    "net/http"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"
    // Act
    response, err := http.Get(url)
    if err != nil {
        t.Fatalf("Failed to make GET request: %v", err)
    }
    defer response.Body.Close()
}

package main_test

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

const baseURL = "http://localhost:8000"

func TestGetAllTodos(t *testing.T) {
    // Arrange
    url := baseURL + "/todos"

    // Act
    response, err := http.Get(url)
    if err != nil {
        t.Fatalf("Failed to make GET request: %v", err)
    }
    defer response.Body.Close()

    // Assert
    if response.StatusCode != http.StatusOK {
        t.Errorf("Expected status code 200, got %d", response.StatusCode)
    }

    var todos []map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&todos); err != nil {
        t.Fatalf("Failed to decode response body: %v", err)
    }

    if len(todos) == 0 {
        t.Error("Expected non-empty list of todos.")
    }

    // Basic contract validation: Check required fields
    if _, ok := todos[0]["id"]; !ok {
        t.Error("Expected field 'id' in response")
    }
    if _, ok := todos[0]["title"]; !ok {
        t.Error("Expected field 'title' in response")
    }
}

Introduction to API Testing with Go

What You’ll Learn in This Lesson

What is API Testing?

Types of API Testing

The Arrange-Act-Assert (AAA) Pattern

Join the 1M+ learners on CodeSignal

Go’s Testing Approach and the Fail-on-Error Pattern

Why Use the Fail-on-Error Pattern?

Step 1: Arranging the Test

Step 2: Acting on the Test Case

Step 3: Asserting the Expected Outcomes

Summary and Practice Preparation