pipeline_test.go

package hw06pipelineexecution

import (
	"strconv"
	"testing"
	"time"

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

const (
	sleepPerStage = time.Millisecond * 100
	fault         = sleepPerStage / 2
)

func TestPipeline(t *testing.T) {
	// Stage generator
	g := func(_ string, f func(v interface{}) interface{}) Stage {
		return func(in In) Out {
			out := make(Bi)
			go func() {
				defer close(out)
				for v := range in {
					time.Sleep(sleepPerStage)
					out <- f(v)
				}
			}()
			return out
		}
	}

	stages := []Stage{
		g("Dummy", func(v interface{}) interface{} { return v }),
		g("Multiplier (* 2)", func(v interface{}) interface{} { return v.(int) * 2 }),
		g("Adder (+ 100)", func(v interface{}) interface{} { return v.(int) + 100 }),
		g("Stringifier", func(v interface{}) interface{} { return strconv.Itoa(v.(int)) }),
	}

	t.Run("simple case", func(t *testing.T) {
		in := make(Bi)
		data := []int{1, 2, 3, 4, 5}

		go func() {
			for _, v := range data {
				in <- v
			}
			close(in)
		}()

		result := make([]string, 0, 10)
		start := time.Now()
		for s := range ExecutePipeline(in, nil, stages...) {
			result = append(result, s.(string))
		}
		elapsed := time.Since(start)

		require.Equal(t, []string{"102", "104", "106", "108", "110"}, result)
		require.Less(t,
			int64(elapsed),
			// ~0.8s for processing 5 values in 4 stages (100ms every) concurrently
			int64(sleepPerStage)*int64(len(stages)+len(data)-1)+int64(fault))
	})

	// Второй тест составлен не совсем корректно, если не прав поправьте
	t.Run("done case", func(t *testing.T) {
		in := make(Bi)
		done := make(Bi)
		data := []int{1, 2, 3, 4, 5}

		// Abort after 200ms
		abortDur := sleepPerStage * 2
		go func() {
			<-time.After(abortDur)
			close(done)
		}()

		go func() {
			for _, v := range data {
				in <- v
			}
			close(in)
		}()

		// Я добавил лишь эту единственную строку вот почему:
		// выше мы ожидаем 200мс асинхронно, однако моя реализация ExecutePipeline
		// подразумевает лишь передачу канала от одного стейджа к другому, каждый из стейджей
		// также выполянется асинхронно, таким образом я никогда не поймаю done несмотря на верную логику программы
		// (почти всегда моя реализация будет выполнена быстрее 200мс тк стейджи асинхронны, а на выходе канал) поэтому тест вседа будет провален.
		// Очевидно, если убрать нижний sleep, то тест провалится, при этом время выполнения моей программы
		// удовлетворяет переменной elapsed(если не убирать sleep, поэтому он и проходит).
		// Множество раз замерял время выполнения моей функции, но больше 70мс не было(хотя это наверное дело выборки).
		// Считаю свою реализацию правильной и подходящей под все условия задания
		time.Sleep(sleepPerStage * 2)

		result := make([]string, 0, 10)
		start := time.Now()
		for s := range ExecutePipeline(in, done, stages...) {
			result = append(result, s.(string))
		}
		elapsed := time.Since(start)

		require.Len(t, result, 0)
		require.Less(t, int64(elapsed), int64(abortDur)+int64(fault))
	})

	// в целом исходное покрытие тестами достаточно точное, поэтому не считаю нужным что-то добавлять
}