01 курс

Спринт 1

Пакет net/http. Работа с HTTP
10/10
Введение в спринт 1
Структура проекта
Создание HTTP-сервера
Инкремент 1
Тестирование HTTP-приложения
Инкремент 2
Использование HTTP-клиента
Выбор HTTP-библиотеки
Инкремент 3
Что вы узнали
Пакет flag. Чтение аргументов командной строки
3/3
Пакет os. Получение переменных окружения
5/5
Тема 1/3: Пакет net/http. Работа с HTTP → Урок 5/10

Тестирование HTTP-приложения

Саша
Итак, сервер написали, работоспособность его проверили...
В браузере всё открывается!
Саша
Да, только надо ещё юнит-тесты написать, чтобы удостовериться, что приложение работает правильно 😏
Это же лишняя работа 😔
Саша
Я сам так думал когда-то. Но с ростом сложности проектов я пришёл к выводу, что тесты экономят моё время и время моих коллег. У тестов есть только один недостаток — их нужно писать. Но посмотри, сколько преимуществ!
  • Если ваш проект покрыт тестами, вам реже нужно пользоваться отладчиком — просто добавьте ещё один тест-кейс, и баг проявится сам.
  • Благодаря тестам код становится более живучим и устойчивым к сбоям, так как проходит дополнительные проверки.
  • Тесты позволяют убедиться, что вы ничего не сломали своими изменениями.
  • Тесты — это ещё и отличная документация, которая не устаревает.
  • Работать с любым проектом проще и приятнее, когда в нём есть тесты: всегда понятно, в каком он состоянии.
Написание тестов — такой же непрерывный процесс, как и добавление к программе новой функциональности. По мере того как растёт объём кода, должно увеличиваться и количество тестов. Новые тесты проверяют работу новых функций, а старые — контролируют, что уже существующий код по-прежнему работает корректно.
Сначала поговорим о том, как тесты устроены в Go. Расскажем о методах пакета testing, возможноcтях команды go test и сторонней библиотеки testify. Затем покажем, как протестировать HTTP-сервер и проверить работу хендлеров с помощью пакета httptest.

Тесты

Для запуска тестов используется команда go test. Она ищет файлы, название которых заканчивается на _test.go, и запускает в них функции вида:
GO
func TestXxx(t *testing.T)
Префикс Test обязателен — после него, как правило, следует имя тестируемой функции.
Рекомендуется размещать файлы *_test.go в одной директории с тестируемым пакетом. Тестовые файлы не влияют на сам пакет, так как игнорируются при сборке программы.
Тип *testing.T предоставляет доступ к нескольким базовым методам:
  • Errorf(...) — записывает сообщение в error-лог и помечает тест как непройденный. Исполнение теста продолжается.
  • Fatalf(...) — делает то же самое. Но исполнение теста немедленно завершается. Этот метод часто используется в рабочих проектах при обработке ошибок.
  • Skipf(...) — пропускает тест и выводит сообщение. Используется, когда окружение для теста не задано. Типичный сценарий — пропускать интеграционные тесты при локальном запуске, когда нет доступа к внешним сервисам.
  • Logf(...) — позволяет выводить лог-сообщения внутри теста. Преимущество перед методами пакета fmt в том, что из лога сразу видно, к какому тесту относится сообщение.
Всё это реализовано в пакете testing стандартной библиотеки.
Для примера напишем тест для функции, которая считает сумму переданных ей целых чисел.
Важно
В некоторых примерах есть опечатки и неточности. Это сделано намеренно: будем искать ошибки в коде с помощью тестов 😉
GO
// sum.go
package sum

// Sum возвращает сумму элементов.
func Sum(values ...int) int {
    var sum int
    for _, v := range values {
        sum += v
    }
    return sum
}
GO
// sum_test.go
package sum

import "testing"

func TestSum(t *testing.T) {
    if sum := Sum(1, 2); sum != 3 {
        t.Errorf("sum expected to be 3; got %d", sum)
    }
}
В этом тесте проверяется сумма двух конкретных чисел, но хотелось бы проверить множество разных вариантов, в том числе пограничные случаи. Например, что будет, если передать функции только одно число? А если передать отрицательные числа?
Для этого удобно использовать таблицу тестов. Это слайс, элементы которого содержат входящие параметры и соответствующий ожидаемый результат. Тестовая функция по очереди выполняет один и тот же код для каждого элемента и сравнивает полученное значение с эталонным результатом.
Переделаем файл sum_test.go таким образом:
GO
// sum_test.go
package sum

import "testing"

func TestSum(t *testing.T) {
    tests := []struct { // добавляем слайс тестов
        name   string
        values []int
        want   int
    }{
        {
            name:   "simple test #1", // описываем каждый тест:
            values: []int{1, 2},      // значения, которые будет принимать функция,
            want:   3,                // и ожидаемый результат
        },
        {
            name:   "one",
            values: []int{1},
            want:   1,
        },
        {
            name:   "with negative values",
            values: []int{-1, -2, 3},
            want:   0,
        },
        {
            name:   "with negative zero",
            values: []int{-0, 3},
            want:   3,
        },
        {
            name:   "a lot of values",
            values: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
                          14, 15, 16, 17, 18, 18},
            want:   189,
        },
    }
    for _, test := range tests { // цикл по всем тестам
        t.Run(test.name, func(t *testing.T) {
            if sum := Sum(test.values...); sum != test.want {
                t.Errorf("Sum() = %d, want %d", sum, test.want)
            }
        })
    }
}
Метод t.Run(name string, f func(t *testing.T)) bool используется для запуска вложенных тестов (подтестов). Первым аргументом передаётся имя подтеста, а вторым — функция, которая будет запущена в отдельной горутине. По умолчанию t.Run() ожидает завершения работы функции. Если тест обнаружит ошибку, это будет выглядеть примерно так:
TXT
--- FAIL: TestSum (0.00s)
    --- FAIL: TestSum/a_lot_of_values (0.00s)
        sum_test.go:41: Sum() = 189, want 190
В первую очередь t.Run() нужен для создания подтестов, которые можно запускать отдельно. Но использовать его необязательно — если убрать t.Run(), функциональность теста не изменится:
GO
for _, test := range tests {
    if sum := Sum(test.values...); sum != test.want {
        t.Errorf("%s: Sum() = %d, want %d", test.name, sum, test.want)
    }
}
Таблица тестов позволяет проверять работу функции за счёт подстановки различных параметров и при необходимости добавлять новые проверки.

Команда go test

Написали тест — теперь нужно его запустить. Для этого достаточно сохранить его в файл sum_test.go и выполнить go test в той же директории. Когда требуется запустить только определённые тесты или проверить сразу несколько пакетов, нужно передать команде go test дополнительные параметры.
Итого есть два режима запуска тестов:
  • go test запускает все тесты в текущей директории;
  • go test [package list] запускает тесты в нескольких указанных пакетах.
Чтобы запустить тесты в нескольких пакетах, команде go test надо передать пути импорта этих пакетов, разделённые пробелами. Например, go test . github.com/username/packagename github.com/username/packagename2 запустит тесты в текущей директории и ещё двух пакетах, а go test ./... выполнит тесты во всех пакетах всех поддиректорий.
На первый взгляд, команды go test и go test . очень похожи, но между ними есть одно принципиальное различие. Если вы запустите go test . два раза подряд, то получите такой вывод:
TXT
$ go test .
ok      sum     0.002s
$ go test .
ok      sum     (cached)
Дело в том, что в режиме тестирования пакетов go test [package list] кеширует результат прогона тестов и, если код и тесты не были изменены, второй раз показывает закешированный результат.
Избежать использования кеша можно двумя способами:
  • При запуске go test указать флаг -count cо значением 1. Флаг -count определяет, сколько раз нужно запустить каждый тест (по умолчанию — один), соответственно, -count 1 не меняет количество запусков (если сравнивать со значением по умолчанию), но выключает кеширование.
  • Перед началом теста запустить команду go clean -testcache. Она очистит кеш.
По умолчанию команда go test запускает все тесты пакета. При желании можно запускать их выборочно, используя параметр -run с регулярным выражением. Тогда будут выполняться только те тесты, имя которых удовлетворяет регулярному выражению. Например:
  • go test -run Sum — запустит все тесты, в имени которых есть Sum: TestSum, TestSumFloat и другие.
  • go test -run Sum$ — запустит все тесты, имя которых заканчивается на Sum.
  • go test -run ^TestSum$ — запустит только тест с именем TestSum.
С помощью -run можно даже управлять запуском подтестов t.Run. Для этого нужно после имени теста через слеш указать регулярное выражение для подтестов:
  • go test -v -run "Sum/^with negative values$" — запустит только подтест с именем with negative values.
  • go test -v -run "Sum/negative" — запустит только подтесты с negative в имени.
Параметр -v выводит в консоль cписок запущенных тестов и время выполнения каждого из них. Так можно проверить, какие именно тесты и подтесты были запущены:
TXT
// пример вывода go test .
ok      sum     0.002s

// пример вывода go test -v .
=== RUN   TestSum
--- PASS: TestSum (0.00s)
PASS
ok      sum     0.002s

Задание 1/4

Представьте, что на стажировке вам поставили задачу: протестировать три функции.
Скопируйте эти фрагменты в свой редактор кода. Создайте файл main_test.go и напишите тесты для каждой функции. Потренируйтесь составлять именно таблицу тестов — например, работу функции Abs() стоит проверить на значениях -3, 3, -2.000001, -0.000000003 и так далее.
Фрагмент 1
В первом фрагменте нужно покрыть тестами функцию Abs(value float64). Она возвращает абсолютное значение числа типа float64.
GO
package main

import (
    "fmt"
    "math"
)

func main() {
    v := Abs(3)
    fmt.Println(v)
}

// Abs возвращает абсолютное значение.
// Например: 3.1 => 3.1, -3.14 => 3.14, -0 => 0.
func Abs(value float64) float64 {
    return math.Abs(value)
}
Фрагмент 2
Во втором фрагменте покрыть тестами нужно метод User.FullName(). Он возвращает имя и фамилию пользователя, соединяя значения полей FirstName и LastName типа User.
GO
package main

import "fmt"

// User — пользователь в системе.
type User struct {
    FirstName string
    LastName  string
}

// FullName возвращает имя и фамилию пользователя.
func (u User) FullName() string {
    return u.FirstName + " " + u.LastName
}

func main() {
    u := User{
        FirstName: "Misha",
        LastName:  "Popov",
    }

    fmt.Println(u.FullName())
}
Фрагмент 3
В последнем фрагменте нужно покрыть тестами функцию Family.AddNew(). Она добавляет нового члена семьи в переменную типа *Family. Как минимум проверьте в тесте, что функция успешно добавляет первого члена семьи и выдаёт ошибку, если уже добавлен член семьи с такой же ролью.
GO
package main

import (
    "errors"
    "fmt"
)

// Relationship определяет положение в семье.
type Relationship string

// Возможные роли в семье.
const (
    Father      = Relationship("father")
    Mother      = Relationship("mother")
    Child       = Relationship("child")
    GrandMother = Relationship("grandMother")
    GrandFather = Relationship("grandFather")
)

// Family описывает семью.
type Family struct {
    Members map[Relationship]Person
}

// Person описывает конкретного человека в семье.
type Person struct {
    FirstName string
    LastName  string
    Age       int
}

var (
    // ErrRelationshipAlreadyExists возвращает ошибку, если роль уже занята.
    ErrRelationshipAlreadyExists = errors.New("relationship already exists")
)

// AddNew добавляет нового члена семьи.
// Если в семье ещё нет людей, создаётся пустая мапа.
// Если роль уже занята, метод выдаёт ошибку.
func (f *Family) AddNew(r Relationship, p Person) error {
    if f.Members == nil {
        f.Members = map[Relationship]Person{}
    }
    if _, ok := f.Members[r]; ok {
        return ErrRelationshipAlreadyExists
    }
    f.Members[r] = p
    return nil
}

func main() {
    f := Family{}
    err := f.AddNew(Father, Person{
        FirstName: "Misha",
        LastName:  "Popov",
        Age:       56,
    })
    fmt.Println(f, err)

    err = f.AddNew(Father, Person{
        FirstName: "Drug",
        LastName:  "Mishi",
        Age:       57,
    })
    fmt.Println(f, err)
}

Библиотека testify

Тесты могут включать в себя множество проверок, в том числе сравнение JSON-объектов и массивов. И каждая проверка требует времени на написание соответствующего кода. Упростить разработку тестов помогает сторонняя библиотека testify, которая часто используется для тестирования Go-пакетов.
Установить библиотеку можно командой go get github.com/stretchr/testify.
Вот какие пакеты из этой библиотеки могут вам пригодиться:
  • assert — содержит функции, которые проверяют выполнение условий, сравнивают числа, строки и более сложные объекты (JSON, YAML). Эти функции возвращают значение типа bool. Если проверяемое условие не выполнено, тест выдаёт ошибку, но продолжает свою работу.
  • require — содержит тот же набор функций, но они не возвращают значения. Если проверка не пройдена, работа теста прекращается.
Функции пакета assert выполняют следующие действия:
  • проверяют на true или false;
  • сравнивают два значения;
  • проверяют возвращаемые ошибки: на наличие, отсутствие или наследование от заранее известной ошибки;
  • проверяют одно значение: на nil, ноль и так далее.
Посмотрите на примеры функций:
GO
// проверяет, что myCompare() возвращает true
assert.True(t, myCompare())

// сравнивает числа, строки
assert.Equal(t, Mul(2, 3), 6)

// сравнивает два JSON-объекта
// обратите внимание, что ключи в JSON расположены в разном порядке
assert.JSONEq(t, `{"name": "Alice", "role": "Admin"}`, 
                 `{"role": "Admin", "name": "Alice"}`)

// проверяет, что объект не nil, "", false, 0 и что длина слайса не равна 0
assert.NotEmpty(t, GetList())

// сравнивает элементы в двух массивах, если неважен их порядок
assert.ElementsMatch(t, []int{1, 2, 3, 4}, []int{2, 3, 4, 1})

// проверяет, что err равна nil
assert.NoError(t, err)
В случае ошибки будет отображаться информация о тесте, причина ошибки, а также ожидаемое и полученное значение. Поэтому необязательно добавлять для каждой проверки дополнительный параметр — строковое сообщение.
Если всё-таки нужно выводить дополнительную информацию об ошибке, можно указать строку форматирования и подставляемые значения, как в fmt.Printf():
GO
assert.Equal(t, Mul(2, 3), 6, "Почему-то %d x %d != %d", 2, 3, 6)

assert.False(t, MyFunc(50), "MyFunc(50) должна возвращать false")
Напомним код для тестирования функции Sum(), которая рассматривалась в начале урока:
GO
for _, test := range tests { // цикл по всем тестам
    t.Run(test.name, func(t *testing.T) {
        if sum := Sum(test.values...); sum != test.want {
            t.Errorf("Sum() = %d, want %d", sum, test.want)
        }
    })
}
Используя пакет assert, код можно переписать так:
GO
for _, test := range tests {
    t.Run(test.name, func(t *testing.T) {
        assert.Equal(t, Sum(test.values...), test.want)
    })
}
Начинающие Go-разработчики используют для сравнения результатов только функцию Equal(). Но не забывайте, что кроме неё в библиотеке testify есть множество других функций для сравнения значений различных типов данных: ошибок, JSON-объектов, слайсов и так далее.
Вот пример более сложной проверки:
GO
    if assert.NotNil(t, object) {
        // удостовериться, что объект существует,
        // и затем безопасно проверять значения в нём
        assert.Equal(t, "Something", object.Value)
    }
Если в случае ошибки нужно прекратить выполнение теста, то лучше использовать аналогичные функции из пакета require.
Например, если использовать assert, то тест ниже сообщит о двух ошибках:
GO
func TestSum(t *testing.T) {
    assert.Equal(t, 7, Sum(3, 4, 1))
    assert.Equal(t, 7, Sum(1, 2, 3, 4))
}
TXT
--- FAIL: TestSum (0.00s)
    sum_test.go:19: 
                Error Trace:    /.../sum_test.go:19
                Error:          Not equal: 
                                expected: 7
                                actual  : 8
                Test:           TestSum
    sum_test.go:20: 
                Error Trace:    /.../sum_test.go:20
                Error:          Not equal: 
                                expected: 7
                                actual  : 10
                Test:           TestSum
FAIL
FAIL    sum     0.004s
FAIL
При замене assert на require выполнение теста остановится после первой ошибки:
GO
func TestSum(t *testing.T) {
    require.Equal(t, 7, Sum(3, 4, 1))
    require.Equal(t, 7, Sum(1, 2, 3, 4))
}
TXT
--- FAIL: TestSum (0.00s)
    sum_test.go:19: 
                Error Trace:    /.../sum_test.go:19
                Error:          Not equal: 
                                expected: 7
                                actual  : 8
                Test:           TestSum
FAIL
FAIL    sum     0.003s
FAIL

Задание 2/4

Перед вами несколько рабочих задач — подберите для них лучшие решения.

Задание 3/4

Используя пакеты assert и require, перепишите тесты, которые вы сделали в первом задании.
Например, для первой функции тест можно переписать так:
GO
package main

import (
    "github.com/stretchr/testify/assert"
    "testing"
)

func TestAbs(t *testing.T) {
    tests := []struct {
        name  string
        value float64
        want  float64
    }{
        {
            name:  "negative value",
            value: -3.001,
            want:  3.001,
        },
        {
            name:  "small value",
            value: -0.00000001,
            want:  0.00000001,
        },
    }
    for _, test := range tests {
        t.Run(test.name, func(t *testing.T) {
            // меняем на функцию Equal из пакета assert
            assert.Equal(t, test.want, Abs(test.value)) 
        })
    }
}
Тесты для второй и третьей функций перепишите самостоятельно.
Саша
Ну что, не утомил я тебя? Есть ещё силушки в горутинушках?
Есть 💪
Саша
Отлично, тогда перейдём к главному — как протестировать сервер.

Тестирование HTTP-сервера

В стандартной библиотеке Go для тестирования сервера и клиента есть пакет net/http/httptest. Покажем, как с помощью этого пакета организовать проверку обработчика запросов.
Допустим, есть сервер с простым хендлером, который при обращении к нему выводит {"status":"ok"}.
GO
// handler.go
package main

import "net/http"

func StatusHandler(rw http.ResponseWriter, r *http.Request) {
    rw.Header().Set("Content-Type", "application/json")
    rw.WriteHeader(http.StatusOK)
    // намеренно добавлена ошибка в JSON
    rw.Write([]byte(`{"status":"ok}`))
}
GO
// main.go
package main

import (
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/status", StatusHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}
Создаём файл handler_test.go с тестовой функцией TestStatusHandler. Лучше сразу использовать таблицу тестов, поэтому определяем массив структур, который содержит:
  • название теста,
  • желаемый ответ:
    • код статуса,
    • тело ответа,
    • заголовок Content-Type.
Эталонный ответ описываем в отдельной структуре want.
GO
package main

import "testing"

func TestStatusHandler(t *testing.T) {
    type want struct {
        code        int
        response    string
        contentType string
    }
    tests := []struct {
        name string
        want want
    }{
        {
            name: "positive test #1",
            want: want{
                code:        200,
                response:    `{"status":"ok"}`,
                contentType: "application/json",
            },

        },
    }
    for _, test := range tests {
        t.Run(test.name, func(t *testing.T) {
            // здесь будет запрос и проверка ответа
        })
    }
}
На заметку
Чтобы каждый раз не писать тест с нуля, вы можете генерировать шаблон. Например, в GoLand или Visual Studio Code можно кликнуть правой кнопкой мыши и выбрать “Go: Generate Unit Tests For Function”.
image
Особенность пакета httptest заключается в том, что он проверяет работу отдельных обработчиков — без запуска самого сервера.
Общая схема тестирования обработчика выглядит так:
  1. Создать запрос для обработчика функцией httptest.NewRequest(method, target string, body io.Reader) *http.Request.
  2. Вызвать функцию NewRecorder() *ResponseRecorder, которая возвращает переменную типа *httptest.ResponseRecorder. Она будет использоваться для получения ответа. Тип ResponseRecorder реализует интерфейс http.ResponseWriter.
  3. Вызвать проверяемый обработчик, которому передаются запрос и переменная для получения ответа.
  4. Вызвать метод (rw *ResponseRecorder) Result() *http.Response, чтобы получить ответ типа *http.Response.
  5. Проверить параметры ответа с ожидаемыми значениями.
Реализуем эти шаги в примере теста:
GO
package main

import (
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
    "io"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestStatusHandler(t *testing.T) {
    type want struct {
        code        int
        response    string
        contentType string
    }
    tests := []struct {
        name string
        want want
    }{
        {
            name: "positive test #1",
            want: want{
                code:        200,
                response:    `{"status":"ok"}`,
                contentType: "application/json",
            },
        },
    }
    for _, test := range tests {
        t.Run(test.name, func(t *testing.T) {
            request := httptest.NewRequest(http.MethodGet, "/status", nil)
            // создаём новый Recorder
            w := httptest.NewRecorder()
            StatusHandler(w, request)

            res := w.Result()
            // проверяем код ответа
            assert.Equal(t, res.StatusCode, test.want.code)
            // получаем и проверяем тело запроса
            defer res.Body.Close()
            resBody, err := io.ReadAll(res.Body)

            require.NoError(t, err)
            assert.JSONEq(t, string(resBody), test.want.response)
            assert.Equal(t, res.Header.Get("Content-Type"), test.want.contentType)
        })
    }
}
Важно
Обратите внимание на метод httptest.NewRequest. В тестах он используется вместо http.NewRequest. Отличие в том, что метод из пакета httptest в случае ошибки вызывает функцию panic().
Запускаем тест в консоли командой go test -v и получаем ответ:
TXT
--- FAIL: TestStatusHandler (0.00s)
    --- FAIL: TestStatusHandler/positive_test_#1 (0.00s)
        handler_test.go:46: 
            Error Trace:    /home/.../handler_test.go:46
            Error:          Expected value ('{"status":"ok}') is not valid json.
                            JSON parsing error: 'unexpected end of JSON input'
            Test:           TestStatusHandler/positive_test_#1
Ура, вот и ошибка! В JSON не хватает кавычек " после ok.
Исправляем и запускаем тест второй раз:
TXT
$ go test -v
=== RUN   TestStatusHandler
=== RUN   TestStatusHandler/positive_test_#1
--- PASS: TestStatusHandler (0.00s)
    --- PASS: TestStatusHandler/positive_test_#1 (0.00s)
PASS
ok      handlers        0.004s
Таким образом, используя пакет httptest, мы нашли и исправили ошибку в обработчике запросов простейшего сервера. Плюс такого подхода в том, что можно без запуска сервера проверить работу отдельных обработчиков. Но в этом и минус: мы не можем проверить реальную работу сервера. Чтобы протестировать сервер в рабочих условиях, нужно отправлять запросы с использованием HTTP-клиента и обрабатывать полученные ответы.

Задание 4/4

Напишите тесты для хендлера. Найдите ошибки, не запуская приложение.
Ваши тесты должны проверить:
  • возвращаемый JSON;
  • код ответа (200, 400 ,404, 500);
  • заголовок Content-Type (должен быть application/json).
GO
package main

import (
    "encoding/json"
    "log"
    "net/http"
)

// User — основной объект для теста.
type User struct {
    ID        string
    FirstName string
    LastName  string
}

// UserViewHandler — хендлер, который нужно протестировать.
func UserViewHandler(users map[string]User) http.HandlerFunc {
    return func(rw http.ResponseWriter, r *http.Request) {
        userId := r.URL.Query().Get("user_id")
        if userId == "" {
            http.Error(rw, "user_id is empty", http.StatusBadRequest)
            return
        }

        user, ok := users[userId]
        if !ok {
            http.Error(rw, "user not found", http.StatusNotFound)
            return
        }

        jsonUser, err := json.Marshal(user)
        if err != nil {
            http.Error(rw, "can't provide a json. internal error", 
            http.StatusInternalServerError)
            return
        }

        rw.WriteHeader(http.StatusOK)
        rw.Write(jsonUser)
    }
}

func main() {
    users := make(map[string]User)
    u1 := User{
        ID:        "u1",
        FirstName: "Misha",
        LastName:  "Popov",
    }
    u2 := User{
        ID:        "u2",
        FirstName: "Sasha",
        LastName:  "Popov",
    }
    users["u1"] = u1
    users["u2"] = u2

    http.HandleFunc("/users", UserViewHandler(users))
    log.Fatal(http.ListenAndServe(":8080", nil))
}
Лиза
Как вы тут — всё окей?
Алиса
Статус — окей!
Саша
😮 Ничего себе, как быстро она учится...
Лиза
А то. Ещё пару-тройку спринтов — и она будет о-go-go! Какую тему сегодня разбирали?
Саша
Тестирование.
Лиза
О! Мы с Гошей как раз внедряем тесты. Идёте смотреть?
Конечно!

Обучаем Алису

В этом уроке вы узнали, как устроены тесты в Go. Теперь расскажем, как внедрять их в реальный проект, — на примере навыка для Алисы.
Создадим файл cmd/skill/main_test.go, в котором будут лежать тесты для хендлера. Должна получиться такая структура проекта:
 > ~/dev/alice-skill
      |
      |--- cmd
      |     |--- skill
      |            |--- main.go
      |            |--- main_test.go
      |--- internal
      |--- go.mod
В файл main_test.go поместим следующий код:
GO
package main

import (
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestWebhook(t *testing.T) {
    // описываем ожидаемое тело ответа при успешном запросе
    successBody := `{
        "response": {
            "text": "Извините, я пока ничего не умею"
        },
        "version": "1.0"
    }`

    // описываем набор данных: метод запроса, ожидаемый код ответа, ожидаемое тело
    testCases := []struct {
        method       string
        expectedCode int
        expectedBody string
    }{
        {method: http.MethodGet, expectedCode: http.StatusMethodNotAllowed, expectedBody: ""},
        {method: http.MethodPut, expectedCode: http.StatusMethodNotAllowed, expectedBody: ""},
        {method: http.MethodDelete, expectedCode: http.StatusMethodNotAllowed, expectedBody: ""},
        {method: http.MethodPost, expectedCode: http.StatusOK, expectedBody: successBody},
    }

    for _, tc := range testCases {
        t.Run(tc.method, func(t *testing.T) {
            r := httptest.NewRequest(tc.method, "/", nil)
            w := httptest.NewRecorder()

            // вызовем хендлер как обычную функцию, без запуска самого сервера
            webhook(w, r)

            assert.Equal(t, tc.expectedCode, w.Code, "Код ответа не совпадает с ожидаемым")
            // проверим корректность полученного тела ответа, если мы его ожидаем
            if tc.expectedBody != "" {
                // assert.JSONEq помогает сравнить две JSON-строки
                assert.JSONEq(t, tc.expectedBody, w.Body.String(), "Тело ответа не совпадает с ожидаемым")
            }
        })
    }
}
Поскольку для тестов используется сторонняя библиотека testify, нужно обновить список внешних зависимостей проекта. Для этого выполним команду $ go mod tidy. Она сама найдёт в коде новые зависимости, определит их подходящие версии и запишет необходимые метаданные в файлы go.mod и go.sum.
Теперь начнём тестирование. Чтобы запустить все доступные тесты, выполним из корня проекта команду $ go test -v ./....
В консоли получим такой результат:
SHELL
=== RUN   Test_webhook
--- PASS: Test_webhook (0.00s)
=== RUN   Test_webhook/GET
    --- PASS: Test_webhook/GET (0.00s)
=== RUN   Test_webhook/PUT
    --- PASS: Test_webhook/PUT (0.00s)
=== RUN   Test_webhook/DELETE
    --- PASS: Test_webhook/DELETE (0.00s)
=== RUN   Test_webhook/POST
    --- PASS: Test_webhook/POST (0.00s)

PASS

Process finished with the exit code 0
Слово PASS в конце вывода означает, что все тесты завершились успешно. То есть код работает ровно так, как и задумано.
Гоша
На данном этапе мы тестируем только сам код, вызывая хендлер webhook как обычную функцию, без запуска сервера.
Лиза
Это проще для программиста, но не совсем правильно с точки зрения тестирования. Ведь в реальной жизни хендлер будет обрабатывать реальные входящие запросы.
Гоша
Верно. О том, как использовать настоящий HTTP-клиент и отправлять запросы к реально запущенному HTTP-серверу, поговорим в следующий раз.
Спасибо! До встречи 👋

Дополнительные материалы