query-orchestration/internal/test/runner.go

package test

import (
	"context"
	"testing"

	clientsyncrunner "queryorchestration/api/clientSyncRunner"
	doccleanrunner "queryorchestration/api/docCleanRunner"
	docinitrunner "queryorchestration/api/docInitRunner"
	docsyncrunner "queryorchestration/api/docSyncRunner"
	doctextrunner "queryorchestration/api/docTextRunner"
	queryrunner "queryorchestration/api/queryRunner"
	querysyncrunner "queryorchestration/api/querySyncRunner"
	queryversionsyncrunner "queryorchestration/api/queryVersionSyncRunner"

	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/serviceconfig/queue/clientsync"
	"queryorchestration/internal/serviceconfig/queue/documentclean"
	"queryorchestration/internal/serviceconfig/queue/documentinit"
	"queryorchestration/internal/serviceconfig/queue/documentsync"
	"queryorchestration/internal/serviceconfig/queue/documenttext"
	"queryorchestration/internal/serviceconfig/queue/query"
	"queryorchestration/internal/serviceconfig/queue/querysync"
	"queryorchestration/internal/serviceconfig/queue/queryversionsync"

	"github.com/testcontainers/testcontainers-go"
)

type RunnerName = string

const (
	DocInitRunnerName          RunnerName = docinitrunner.Name
	DocSyncRunnerName          RunnerName = docsyncrunner.Name
	DocCleanRunnerName         RunnerName = doccleanrunner.Name
	DocTextRunnerName          RunnerName = doctextrunner.Name
	QuerySyncRunnerName        RunnerName = querysyncrunner.Name
	QueryRunnerName            RunnerName = queryrunner.Name
	ClientSyncRunnerName       RunnerName = clientsyncrunner.Name
	QueryVersionSyncRunnerName RunnerName = queryversionsyncrunner.Name
)

type RunnerEnv = string

const (
	DocInitRunnerEnv          RunnerEnv = documentinit.EnvName
	DocSyncRunnerEnv          RunnerEnv = documentsync.EnvName
	DocCleanRunnerEnv         RunnerEnv = documentclean.EnvName
	DocTextRunnerEnv          RunnerEnv = documenttext.EnvName
	QuerySyncRunnerEnv        RunnerEnv = querysync.EnvName
	QueryRunnerEnv            RunnerEnv = query.EnvName
	ClientSyncRunnerEnv       RunnerEnv = clientsync.EnvName
	QueryVersionSyncRunnerEnv RunnerEnv = queryversionsync.EnvName
)

type Runner struct {
	Name             RunnerName
	DownstreamQueues []RunnerName
}

func GetRunnerEnvFromName(name RunnerName) RunnerEnv {
	switch name {
	case DocSyncRunnerName:
		return DocSyncRunnerEnv
	case DocCleanRunnerName:
		return DocCleanRunnerEnv
	case DocTextRunnerName:
		return DocTextRunnerEnv
	case QuerySyncRunnerName:
		return QuerySyncRunnerEnv
	case QueryRunnerName:
		return QueryRunnerEnv
	case ClientSyncRunnerName:
		return ClientSyncRunnerEnv
	case QueryVersionSyncRunnerName:
		return QueryVersionSyncRunnerEnv
	}
	return DocInitRunnerEnv
}

type RunnerConfig struct {
	Runner  Runner
	Cfg     serviceconfig.ConfigProvider
	Network *testcontainers.DockerNetwork
}

func CreateRunner(t testing.TB, ctx context.Context, config *RunnerConfig) (*Container, func()) {
	env := map[string]string{}
	url := GetQueueURL(config.Cfg, config.Runner.Name)
	env["QUEUE_URL"] = url

	c, cleanup := createContainer(t, ctx, &containerConfig{
		Network:          config.Network,
		Name:             config.Runner.Name,
		DownstreamQueues: config.Runner.DownstreamQueues,
		Cfg:              config.Cfg,
		Env:              env,
		WaitForMsg:       "Listening to queue",
	})

	return &Container{
		Container: c,
		URI:       url,
	}, cleanup
}

var DocInitRunner = Runner{
	Name:             DocInitRunnerName,
	DownstreamQueues: []RunnerName{DocSyncRunnerName},
}
var DocSyncRunner = Runner{
	Name:             DocSyncRunnerName,
	DownstreamQueues: []RunnerName{DocCleanRunnerName},
}
var DocCleanRunner = Runner{
	Name:             DocCleanRunnerName,
	DownstreamQueues: []RunnerName{DocTextRunnerName},
}
var DocTextRunner = Runner{
	Name:             DocTextRunnerName,
	DownstreamQueues: []RunnerName{QuerySyncRunnerName},
}
var QuerySyncRunner = Runner{
	Name:             QuerySyncRunnerName,
	DownstreamQueues: []RunnerName{QueryRunnerName},
}
var QueryRunner = Runner{
	Name:             QueryRunnerName,
	DownstreamQueues: []RunnerName{QueryRunnerName},
}
var ClientSyncRunner = Runner{
	Name:             ClientSyncRunnerName,
	DownstreamQueues: []RunnerName{DocSyncRunnerName},
}
var QueryVersionSyncRunner = Runner{
	Name:             QueryVersionSyncRunnerName,
	DownstreamQueues: []RunnerName{ClientSyncRunnerName},
}

var runners = []Runner{
	DocInitRunner,
	DocSyncRunner,
	DocCleanRunner,
	DocTextRunner,
	QuerySyncRunner,
	QueryRunner,
	ClientSyncRunner,
	QueryVersionSyncRunner,
}