aftermath/render_test.go at main · Cufee/aftermath · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package main

import (
	"bytes"
	"context"
	"io"
	"os"
	"slices"
	"testing"

	"github.com/cufee/aftermath/internal/localization"
	rc "github.com/cufee/aftermath/internal/render/common"

	"github.com/cufee/aftermath/internal/stats/fetch/v1"
	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"

	prepare "github.com/cufee/aftermath/internal/stats/prepare/replay/v1"
	render "github.com/cufee/aftermath/internal/stats/render/replay/v1"

	"github.com/cufee/aftermath/tests"
	"github.com/cufee/aftermath/tests/env"
	"github.com/matryer/is"
	"github.com/nao1215/imaging"
	"github.com/rs/zerolog"
	"github.com/stretchr/testify/assert"
	"golang.org/x/text/language"

	_ "github.com/joho/godotenv/autoload"
)

var bgImage = "static://bg-default"
var bgIsCustom = false

func init() {
	loadStaticAssets(static)
	level, _ := zerolog.ParseLevel(os.Getenv("LOG_LEVEL"))
	zerolog.SetGlobalLevel(level)
}

func saveTestImage(t *testing.T, dir, filename string, encode func(io.Writer) error) {
	t.Helper()
	assert.NoError(t, os.MkdirAll("tmp/"+dir, 0o755), "failed to create directory")
	f, err := os.Create("tmp/" + dir + "/" + filename)
	assert.NoError(t, err, "failed to create a file")
	defer f.Close()
	assert.NoError(t, encode(f), "failed to encode image")
}

func TestRenderReplay(t *testing.T) {
	is := is.New(t)

	env.LoadTestEnv(t)
	db := tests.StaticTestingDatabase()
	wg, _ := wargamingClientsFromEnv(tests.NewNoopObserver())

	printer, err := localization.NewPrinter("stats", language.English)
	is.NoErr(err)

	fetch, err := fetch.NewMultiSourceClient(wg, tests.StaticTestingFetch(), db)
	is.NoErr(err)

	replayFiles := []string{"replay_defeat.wotbreplay", "replay_victory.wotbreplay", "replay_draw.wotbreplay", "replay_rating.wotbreplay"}
	for _, name := range replayFiles {
		t.Run("render replay image from "+name, func(t *testing.T) {
			is := is.New(t)

			file, err := os.ReadFile("tests/" + name)
			is.NoErr(err)

			replay, err := fetch.Replay(context.Background(), bytes.NewReader(file), int64(len(file)))
			is.NoErr(err)

			var vehicles []string
			for _, player := range append(replay.Teams.Allies, replay.Teams.Enemies...) {
				if id := player.VehicleID; !slices.Contains(vehicles, id) {
					vehicles = append(vehicles, id)
				}
			}

			glossary, err := db.GetVehicles(context.Background(), vehicles)
			is.NoErr(err)

			gameModeNames, err := db.GetGameModeNames(context.Background(), replay.GameMode.String())
			is.NoErr(err)

			{
				cards, err := prepare.NewCards(replay, glossary, gameModeNames, common.WithPrinter(printer, language.English))
				is.NoErr(err)

				image, err := render.CardsToImage(replay, cards, rc.WithBackgroundURL(bgImage, bgIsCustom), rc.WithPrinter(printer))
				assert.NoError(t, err, "failed to render a replay image")
				assert.NotNil(t, image, "image is nil")

				out := "tmp/replay/" + name + ".png"
				assert.NoError(t, os.MkdirAll("tmp/replay", 0o755), "failed to create directory")
				f, err := os.Create(out)
				assert.NoError(t, err, "failed to create a file")
				defer f.Close()

				err = imaging.Save(image, out)
				assert.NoError(t, err, "failed to encode a png image")
			}
		})
	}
}