Makefile

PROJECT := go-driver
SCRIPTDIR := $(shell pwd)

CURR=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
ROOTDIR:=$(CURR)

GOVERSION ?= 1.25.12
GOTOOLCHAIN ?= auto
GOIMAGE ?= golang:$(GOVERSION)
GOV2IMAGE ?= $(GOIMAGE)
ALPINE_IMAGE ?= alpine:3.23
TMPDIR := ${SCRIPTDIR}/.tmp

DOCKER_CMD:=docker run
DOCKER_PLATFORM ?=
DOCKER_BUILD_PLATFORM ?= $(DOCKER_PLATFORM)
DOCKER_CMD:=docker run $(DOCKER_PLATFORM)

GOBUILDTAGS:=$(TAGS)
GOBUILDTAGSOPT=-tags "$(GOBUILDTAGS)"

ARANGODB ?= arangodb/enterprise:latest
STARTER ?= arangodb/arangodb-starter:latest
K8S_DRIVER_TEST_RUNNER ?= $(ROOTDIR)/deploy/kubernetes/run-driver-tests.sh
K8S_NAMESPACE ?= default
K8S_DEPLOYMENT ?= arangodb-driver-tests

ifeq ($(origin K8S_RESILIENCY_TEST_VERBOSE),undefined)
K8S_RESILIENCY_TEST_VERBOSE := -v
endif

ifdef VERBOSE
	TESTVERBOSEOPTIONS := -v
endif

# Toxiproxy sits between the driver and ArangoDB for network fault injection.
TOXIPROXY_LISTEN_PORT ?= 17001
TOXIPROXY_ADMIN_PORT ?= 8474
TOXIPROXY_UPSTREAM ?= 127.0.0.1:7001
TOXIPROXY_PROXY_NAME ?= arangodb
TOXIPROXY_TEST_ENDPOINTS ?= http://127.0.0.1:$(TOXIPROXY_LISTEN_PORT)

CGO_ENABLED=0
ifdef RACE
	TESTVERBOSEOPTIONS += -race
	CGO_ENABLED=1
endif

ifndef AF_ENABLED
	AF_ENABLED := "false"
endif

ifndef VST_ENABLED
	VST_ENABLED := "false"
endif

ifndef ENABLE_VECTOR_INDEX
	ENABLE_VECTOR_INDEX := "false"
endif

TESTV2PARALLEL ?= 4

ORGPATH := github.com/arangodb
REPONAME := $(PROJECT)
REPODIR := $(ORGDIR)/$(REPONAME)
REPOPATH := $(ORGPATH)/$(REPONAME)

SOURCES_EXCLUDE:=vendor
SOURCES := $(shell find "$(ROOTDIR)" $(foreach SOURCE,$(SOURCES_EXCLUDE),-not -path '$(ROOTDIR)/$(SOURCE)/*') -name '*.go')

# Test variables

ifndef TESTCONTAINER
	TESTCONTAINER := $(PROJECT)-test
endif
ifndef DBCONTAINER
	DBCONTAINER := $(TESTCONTAINER)-db
endif 

ifeq ("$(TEST_AUTH)", "none")
	ARANGOENV := -e ARANGO_NO_AUTH=1
	TEST_AUTHENTICATION :=
	TESTS := $(REPOPATH) $(REPOPATH)/test
else ifeq ("$(TEST_AUTH)", "rootpw")
	ARANGOENV := -e ARANGO_ROOT_PASSWORD=rootpw
	TEST_AUTHENTICATION := basic:root:rootpw
	GOBUILDTAGS += auth
	TESTS := $(REPOPATH)/test
else ifeq ("$(TEST_AUTH)", "jwt")
	ARANGOENV := -e ARANGO_ROOT_PASSWORD=rootpw 
	TEST_AUTHENTICATION := jwt:root:rootpw
	GOBUILDTAGS += auth
	TESTS := $(REPOPATH)/test
	JWTSECRET := testing
	JWTSECRETFILE := "${TMPDIR}/${TESTCONTAINER}-jwtsecret"
	ARANGOVOL := -v "$(JWTSECRETFILE):/jwtsecret"
	ARANGOARGS := --server.jwt-secret=/jwtsecret
endif

TEST_NET := --net=host

# By default we run tests against single endpoint to avoid problems with data propagation in Cluster mode
# e.g. when we create a document in one endpoint, it may not be visible in another endpoint for a while
# Use 127.0.0.1 (not localhost): many systems resolve localhost to IPv6 [::1] first while arangod listens on IPv4 only.
TEST_ENDPOINTS := http://127.0.0.1:7001

TESTS := $(REPOPATH)/test
ifeq ("$(TEST_AUTH)", "rootpw")
	CLUSTERENV := JWTSECRET=testing
	TEST_JWTSECRET := testing
	TEST_AUTHENTICATION := basic:root:
endif
ifeq ("$(TEST_AUTH)", "jwt")
	CLUSTERENV := JWTSECRET=testing
	TEST_JWTSECRET := testing
	TEST_AUTHENTICATION := jwt:root:
endif
ifeq ("$(TEST_AUTH)", "jwtsuper")
	CLUSTERENV := JWTSECRET=testing
	TEST_JWTSECRET := testing
	TEST_AUTHENTICATION := super:testing
endif
ifeq ("$(TEST_SSL)", "auto")
	CLUSTERENV := SSL=auto $(CLUSTERENV)
	TEST_ENDPOINTS = https://127.0.0.1:7001
endif

ifeq ("$(TEST_CONNECTION)", "vst")
	TESTS := $(REPOPATH)/test
ifndef TEST_CONTENT_TYPE
	TEST_CONTENT_TYPE := vpack
endif
endif

ifeq ("$(TEST_BENCHMARK)", "true")
	TAGS := -bench=. -benchmem -run=notests -cpu=1,2,4
	TESTS := $(REPOPATH)/test
ifndef TESTOPTIONS
	TESTOPTIONS := $(TAGS)
endif
endif

ifdef TEST_ENDPOINTS_OVERRIDE
	TEST_ENDPOINTS := $(TEST_ENDPOINTS_OVERRIDE)
endif

ifdef TEST_AUTHENTICATION_OVERRIDE
	TEST_AUTHENTICATION := $(TEST_AUTHENTICATION_OVERRIDE)
endif

ifdef TEST_NET_OVERRIDE
	TEST_NET := $(TEST_NET_OVERRIDE)
endif

ifdef ENABLE_VST11
	VST11_SINGLE_TESTS := run-tests-single-vst-1.1
	VST11_RESILIENTSINGLE_TESTS := run-tests-resilientsingle-vst-1.1
	VST11_CLUSTER_TESTS := run-tests-cluster-vst-1.1
endif

TEST_RESOURCES_VOLUME :=
ifdef TEST_RESOURCES
	TEST_RESOURCES_VOLUME := -v ${TEST_RESOURCES}:/tmp/resources
endif

ifeq ("$(DEBUG)", "true")
	GOIMAGE := go-driver-tests:debug
	DOCKER_DEBUG_ARGS := --security-opt=seccomp:unconfined -e GOTOOLCHAIN=$(GOTOOLCHAIN)
	DEBUG_PORT := 2345

	DOCKER_RUN_CMD := $(DOCKER_DEBUG_ARGS) $(GOIMAGE) /go/bin/dlv --listen=:$(DEBUG_PORT) --headless=true --api-version=2 --accept-multiclient exec /test_debug.test -- $(TESTOPTIONS)
	DOCKER_V2_RUN_CMD := $(DOCKER_RUN_CMD)
else
    DOCKER_RUN_CMD := $(GOIMAGE) go test -timeout 120m $(GOBUILDTAGSOPT) $(TESTOPTIONS) $(TESTVERBOSEOPTIONS) $(TESTS)
    DOCKER_V2_RUN_CMD := $(GOV2IMAGE) go test -timeout 120m $(GOBUILDTAGSOPT) $(TESTOPTIONS) $(TESTVERBOSEOPTIONS) -parallel $(TESTV2PARALLEL) ./tests
endif

ifeq ("$(ADD_TIMESTAMP)", "true")
	ADD_TIMESTAMP :=| go run ./test/timestamp_output/timestamp_output.go 
endif

.PHONY: all build clean linter run-tests run-k8s-v2-tests run-k8s-v2-single run-k8s-v2-cluster run-k8s-v2-resiliency run-k8s-v2-resiliency-tls run-k8s-v2-resiliency-e2e-tls run-k8s-v2-toxiproxy run-k8s-v2-toxiproxy-tls run-k8s-v2-toxiproxy-e2e-tls run-v2-tests-toxiproxy vulncheck

all: build

build: __dir_setup $(SOURCES)
	go build -v $(REPOPATH) $(REPOPATH)/http $(REPOPATH)/vst $(REPOPATH)/agency $(REPOPATH)/jwt

clean: 
	@rm -rf "${TMPDIR}"

.PHONY: changelog
changelog:
	@$(DOCKER_CMD) --rm \
		-e CHANGELOG_GITHUB_TOKEN=$(shell cat ~/.arangodb/github-token) \
		-v "${ROOTDIR}":/usr/local/src/your-app \
		ferrarimarco/github-changelog-generator \
		--user arangodb \
		--project go-driver \
		--no-author \
		--unreleased-label "Master"

run-tests: run-unit-tests run-tests-single run-tests-cluster
ifeq ("$(AF_ENABLED)", "true")
	make run-tests-resilientsingle
endif

# Kubernetes integration tests (v2). Local kind: run setup-kind once first — see deploy/kubernetes/README.md.
run-k8s-v2-tests: run-k8s-v2-single run-k8s-v2-cluster

run-k8s-v2-single: run-k8s-v2-single-without-auth run-k8s-v2-single-basic-auth run-k8s-v2-single-tls-basic-auth

run-k8s-v2-cluster: run-k8s-v2-cluster-basic-auth run-k8s-v2-cluster-tls-basic-auth

run-k8s-v2-single-without-auth:
	@echo "Kubernetes single server, without authentication, v2"
	@K8S_MODE=Single K8S_AUTHENTICATION=false K8S_TEST_AUTHENTICATION=none K8S_TLS=false K8S_INGRESS_TLS=false bash "$(K8S_DRIVER_TEST_RUNNER)" run make run-v2-tests-single-without-auth

run-k8s-v2-single-basic-auth:
	@echo "Kubernetes single server, with basic authentication, v2"
	@K8S_MODE=Single K8S_TEST_AUTHENTICATION=basic K8S_TLS=false K8S_INGRESS_TLS=false bash "$(K8S_DRIVER_TEST_RUNNER)" run make run-v2-tests-single-with-auth

run-k8s-v2-single-tls-basic-auth:
	@echo "Kubernetes single server, with TLS and basic authentication, v2"
	@K8S_MODE=Single K8S_TEST_AUTHENTICATION=basic K8S_TLS=false K8S_INGRESS_TLS=true bash "$(K8S_DRIVER_TEST_RUNNER)" run make run-v2-tests-single-with-auth

run-k8s-v2-cluster-basic-auth:
	@echo "Kubernetes cluster, with basic authentication, v2"
	@K8S_MODE=Cluster K8S_TEST_AUTHENTICATION=basic K8S_TLS=false K8S_INGRESS_TLS=false bash "$(K8S_DRIVER_TEST_RUNNER)" run env TESTV2PARALLEL=1 make run-v2-tests-cluster-with-basic-auth

run-k8s-v2-cluster-tls-basic-auth:
	@echo "Kubernetes cluster, with TLS and basic authentication, v2"
	@K8S_MODE=Cluster K8S_TEST_AUTHENTICATION=basic K8S_TLS=false K8S_INGRESS_TLS=true bash "$(K8S_DRIVER_TEST_RUNNER)" run env TESTV2PARALLEL=1 make run-v2-tests-cluster-with-basic-auth

run-k8s-v2-resiliency:
	@echo "Kubernetes cluster resiliency tests, v2"
	@K8S_MODE=Cluster K8S_COORDINATORS_COUNT=3 K8S_TEST_AUTHENTICATION=basic \
		K8S_TLS=false K8S_INGRESS_TLS=false bash "$(K8S_DRIVER_TEST_RUNNER)" \
		run make run-v2-tests-resiliency-k8s

run-k8s-v2-resiliency-tls:
	@echo "Kubernetes cluster resiliency tests, HTTPS ingress, v2"
	@K8S_MODE=Cluster K8S_COORDINATORS_COUNT=3 K8S_TEST_AUTHENTICATION=basic \
		K8S_TLS=false K8S_INGRESS_TLS=true bash "$(K8S_DRIVER_TEST_RUNNER)" \
		run make run-v2-tests-resiliency-k8s

# End-to-end TLS: HTTPS Driver↔Ingress and HTTPS Ingress↔ArangoDB (K8S_TLS=true).
run-k8s-v2-resiliency-e2e-tls:
	@echo "Kubernetes cluster resiliency tests, end-to-end TLS (ingress + ArangoDB), v2"
	@K8S_MODE=Cluster K8S_COORDINATORS_COUNT=3 K8S_TEST_AUTHENTICATION=basic \
		K8S_TLS=true K8S_INGRESS_TLS=true bash "$(K8S_DRIVER_TEST_RUNNER)" \
		run make run-v2-tests-resiliency-k8s

run-k8s-v2-toxiproxy:
	@echo "Kubernetes Toxiproxy network fault tests, v2"
	@K8S_MODE=Cluster K8S_COORDINATORS_COUNT=1 K8S_TEST_AUTHENTICATION=basic \
		K8S_TLS=false K8S_INGRESS_TLS=false bash "$(K8S_DRIVER_TEST_RUNNER)" \
		run-toxiproxy make run-v2-tests-toxiproxy-k8s

run-k8s-v2-toxiproxy-tls:
	@echo "Kubernetes Toxiproxy network fault tests, HTTPS ingress, v2"
	@K8S_MODE=Cluster K8S_COORDINATORS_COUNT=1 K8S_TEST_AUTHENTICATION=basic \
		K8S_TLS=false K8S_INGRESS_TLS=true bash "$(K8S_DRIVER_TEST_RUNNER)" \
		run-toxiproxy make run-v2-tests-toxiproxy-k8s

# End-to-end TLS: HTTPS through Toxiproxy→Ingress and HTTPS Ingress↔ArangoDB (K8S_TLS=true).
run-k8s-v2-toxiproxy-e2e-tls:
	@echo "Kubernetes Toxiproxy network fault tests, end-to-end TLS (ingress + ArangoDB), v2"
	@K8S_MODE=Cluster K8S_COORDINATORS_COUNT=1 K8S_TEST_AUTHENTICATION=basic \
		K8S_TLS=true K8S_INGRESS_TLS=true bash "$(K8S_DRIVER_TEST_RUNNER)" \
		run-toxiproxy make run-v2-tests-toxiproxy-k8s

# The below rule exists only for backward compatibility.
run-tests-http: run-unit-tests

run-unit-tests: run-v2-unit-tests
	@$(DOCKER_CMD) \
		--rm \
		-v "${ROOTDIR}":/usr/code \
		-e CGO_ENABLED=$(CGO_ENABLED) \
		-e GOTOOLCHAIN=$(GOTOOLCHAIN) \
		-w /usr/code/ \
		$(GOIMAGE) \
		go test $(TESTOPTIONS) $(REPOPATH) $(REPOPATH)/http $(REPOPATH)/agency $(REPOPATH)/vst/protocol

run-v2-unit-tests:
	@$(DOCKER_CMD) \
		--rm \
		-v "${ROOTDIR}"/v2:/usr/code \
		-e CGO_ENABLED=$(CGO_ENABLED) \
		-e GOTOOLCHAIN=$(GOTOOLCHAIN) \
		-w /usr/code/ \
		$(GOIMAGE) \
		go test $(TESTOPTIONS) $(REPOPATH)/v2/connection $(REPOPATH)/v2/arangodb/...

# Single server tests 
run-tests-single: run-tests-single-json run-tests-single-vpack
ifeq ("$(VST_ENABLED)", "true")
	make run-tests-single-vst-1.0 $(VST11_SINGLE_TESTS)
endif

run-tests-single-json: run-tests-single-json-with-auth run-tests-single-json-no-auth run-tests-single-json-jwt-super run-tests-single-json-ssl

run-tests-single-vpack: run-tests-single-vpack-with-auth run-tests-single-vpack-no-auth run-tests-single-vpack-ssl

run-tests-single-vst-1.0: run-tests-single-vst-1.0-with-auth run-tests-single-vst-1.0-no-auth run-tests-single-vst-1.0-ssl

run-tests-single-vst-1.1: run-tests-single-vst-1.1-with-auth run-tests-single-vst-1.1-jwt-auth run-tests-single-vst-1.1-no-auth run-tests-single-vst-1.1-ssl run-tests-single-vst-1.1-jwt-ssl

run-tests-single-json-no-auth:
	@echo "Single server, HTTP+JSON, no authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" TEST_CONTENT_TYPE="json" __run_tests

run-tests-single-vpack-no-auth:
	@echo "Single server, HTTP+Velocypack, no authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-single-vst-1.0-no-auth:
	@echo "Single server, Velocystream 1.0, no authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-single-vst-1.1-no-auth:
	@echo "Single server, Velocystream 1.1, no authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-single-json-with-auth:
	@echo "Single server, HTTP+JSON, with authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_CONTENT_TYPE="json" __run_tests

run-tests-single-json-http2-with-auth:
	@echo "Single server, HTTP+JSON, with authentication"
	@${MAKE} TEST_MODE="single" TAGS="http2" TEST_AUTH="rootpw" TEST_CONTENT_TYPE="json" __run_tests

run-tests-single-vpack-with-auth:
	@echo "Single server, HTTP+Velocypack, with authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-single-vst-1.0-with-auth:
	@echo "Single server, Velocystream 1.0, with authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-single-vst-1.1-with-auth:
	@echo "Single server, Velocystream 1.1, with authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-single-vst-1.1-jwt-auth:
	@echo "Single server, Velocystream 1.1, JWT authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="jwt" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-single-json-jwt-super:
	@echo "Single server, HTTP+JSON, JWT super authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="jwtsuper" TEST_CONTENT_TYPE="json" __run_tests

run-tests-single-json-ssl:
	@echo "Single server, HTTP+JSON, with authentication, SSL"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONTENT_TYPE="json" __run_tests

run-tests-single-vpack-ssl:
	@echo "Single server, HTTP+Velocypack, with authentication, SSL"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-single-vst-1.0-ssl:
	@echo "Single server, Velocystream 1.0, with authentication, SSL"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-single-vst-1.1-ssl:
	@echo "Single server, Velocystream 1.1, with authentication, SSL"
	@${MAKE} TEST_MODE="single" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-single-vst-1.1-jwt-ssl:
	@echo "Single server, Velocystream 1.1, JWT authentication, SSL"
	@${MAKE} TEST_MODE="single" TEST_AUTH="jwt" TEST_SSL="auto" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

# ResilientSingle server tests 
run-tests-resilientsingle: run-tests-resilientsingle-json run-tests-resilientsingle-vpack
ifeq ("$(VST_ENABLED)", "true")
	make run-tests-resilientsingle-vst-1.0 $(VST11_RESILIENTSINGLE_TESTS)
endif

run-tests-resilientsingle-json: run-tests-resilientsingle-json-with-auth run-tests-resilientsingle-json-no-auth

run-tests-resilientsingle-vpack: run-tests-resilientsingle-vpack-with-auth run-tests-resilientsingle-vpack-no-auth

run-tests-resilientsingle-vst-1.0: run-tests-resilientsingle-vst-1.0-with-auth run-tests-resilientsingle-vst-1.0-no-auth

run-tests-resilientsingle-vst-1.1: run-tests-resilientsingle-vst-1.1-with-auth run-tests-resilientsingle-vst-1.1-jwt-auth run-tests-resilientsingle-vst-1.1-no-auth

run-tests-resilientsingle-json-no-auth:
	@echo "Resilient Single server, HTTP+JSON, no authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="none" TEST_CONTENT_TYPE="json" __run_tests

run-tests-resilientsingle-vpack-no-auth:
	@echo "Resilient Single server, HTTP+Velocypack, no authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="none" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-resilientsingle-vst-1.0-no-auth:
	@echo "Resilient Single server, Velocystream 1.0, no authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="none" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-resilientsingle-vst-1.1-no-auth:
	@echo "Resilient Single server, Velocystream 1.1, no authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="none" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-resilientsingle-json-with-auth:
	@echo "Resilient Single server, HTTP+JSON, with authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="rootpw" TEST_CONTENT_TYPE="json" __run_tests

run-tests-resilientsingle-vpack-with-auth:
	@echo "Resilient Single server, HTTP+Velocypack, with authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="rootpw" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-resilientsingle-vst-1.0-with-auth:
	@echo "Resilient Single server, Velocystream 1.0, with authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="rootpw" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-resilientsingle-vst-1.1-with-auth:
	@echo "Resilient Single server, Velocystream 1.1, with authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="rootpw" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-resilientsingle-vst-1.1-jwt-auth:
	@echo "Resilient Single server, Velocystream 1.1, JWT authentication"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="jwt" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

# Cluster mode tests
run-tests-cluster: run-tests-cluster-json run-tests-cluster-vpack
ifeq ("$(VST_ENABLED)", "true")
	make run-tests-cluster-vst-1.0 $(VST11_CLUSTER_TESTS)
endif


run-tests-cluster-json: run-tests-cluster-json-no-auth run-tests-cluster-json-with-auth run-tests-cluster-json-ssl

run-tests-cluster-vpack: run-tests-cluster-vpack-no-auth run-tests-cluster-vpack-with-auth run-tests-cluster-vpack-ssl

run-tests-cluster-vst-1.0: run-tests-cluster-vst-1.0-no-auth run-tests-cluster-vst-1.0-with-auth run-tests-cluster-vst-1.0-ssl

run-tests-cluster-vst-1.1: run-tests-cluster-vst-1.1-no-auth run-tests-cluster-vst-1.1-with-auth run-tests-cluster-vst-1.1-ssl

run-tests-cluster-json-no-auth: 
	@echo "Cluster server, JSON, no authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" TEST_CONTENT_TYPE="json" __run_tests

run-tests-cluster-vpack-no-auth:
	@echo "Cluster server, Velocypack, no authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-cluster-vst-1.0-no-auth: 
	@echo "Cluster server, Velocystream 1.0, no authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-cluster-vst-1.1-no-auth:
	@echo "Cluster server, Velocystream 1.1, no authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-cluster-json-with-auth:
	@echo "Cluster server, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_CONTENT_TYPE="json" __run_tests

run-tests-cluster-json-jwt-super:
	@echo "Cluster server, HTTP+JSON, JWT super authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="jwtsuper" TEST_CONTENT_TYPE="json" __run_tests

run-tests-cluster-vpack-with-auth:
	@echo "Cluster server, Velocypack, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-cluster-vst-1.0-with-auth: 
	@echo "Cluster server, Velocystream 1.0, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-cluster-vst-1.1-with-auth: 
	@echo "Cluster server, Velocystream 1.1, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

run-tests-cluster-json-ssl: 
	@echo "Cluster server, SSL, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONTENT_TYPE="json" __run_tests

run-tests-cluster-vpack-ssl: 
	@echo "Cluster server, Velocypack, SSL, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONTENT_TYPE="vpack" __run_tests

run-tests-cluster-vst-1.0-ssl:
	@echo "Cluster server, Velocystream 1.0, SSL, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONNECTION="vst" TEST_CVERSION="1.0" __run_tests

run-tests-cluster-vst-1.1-ssl: 
	@echo "Cluster server, Velocystream 1.1, SSL, with authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_SSL="auto" TEST_CONNECTION="vst" TEST_CVERSION="1.1" __run_tests

ON_FAILURE_PARAMS = \
	TESTCONTAINER=$(TESTCONTAINER) \
	TEST_MODE=$(TEST_MODE) \
	TEST_SSL=$(TEST_SSL) \
	TEST_AUTH=$(TEST_AUTH) \
	TEST_CONNECTION=$(TEST_CONNECTION) \
	TEST_CONTENT_TYPE=$(TEST_CONTENT_TYPE) \
	TEST_CVERSION=$(TEST_CVERSION) \
	TEST_JWTSECRET=$(TEST_JWTSECRET) \
	DUMP_AGENCY_ON_FAILURE=$(DUMP_AGENCY_ON_FAILURE)


COMMON_DOCKER_CMD_PARAMS = \
	--name=$(TESTCONTAINER) \
	$(TEST_NET) \
	-e ENABLE_VECTOR_INDEX=$(ENABLE_VECTOR_INDEX) \
	-e TEST_ENDPOINTS=$(TEST_ENDPOINTS) \
	-e TEST_NOT_WAIT_UNTIL_READY=$(TEST_NOT_WAIT_UNTIL_READY) \
	-e TEST_AUTH=$(TEST_AUTH) \
	-e TEST_AUTHENTICATION=$(TEST_AUTHENTICATION) \
	-e TEST_JWTSECRET=$(TEST_JWTSECRET) \
	-e TEST_MODE=$(TEST_MODE) \
	-e TEST_MODE_K8S=$(TEST_MODE_K8S) \
	-e TEST_INGRESS_HOST=$(TEST_INGRESS_HOST) \
	-e TEST_BACKUP_REMOTE_REPO=$(TEST_BACKUP_REMOTE_REPO) \
	-e TEST_BACKUP_REMOTE_CONFIG='$(TEST_BACKUP_REMOTE_CONFIG)' \
	-e TEST_DEBUG='$(TEST_DEBUG)' \
	-e TEST_ENABLE_SHUTDOWN=$(TEST_ENABLE_SHUTDOWN) \
	-e TEST_ENABLE_RESILIENCY=$(TEST_ENABLE_RESILIENCY) \
	-e TEST_TOXIPROXY_ADMIN=$(TEST_TOXIPROXY_ADMIN) \
	-e TEST_TOXIPROXY_PROXY=$(TEST_TOXIPROXY_PROXY) \
	-e ENABLE_DATABASE_EXTRA_FEATURES=$(ENABLE_DATABASE_EXTRA_FEATURES) \
	-e GODEBUG=tls13=1 \
	-e CGO_ENABLED=$(CGO_ENABLED) \
	-e GOTOOLCHAIN=$(GOTOOLCHAIN)


# Internal test tasks
__run_tests: __test_debug__ __test_prepare __test_go_test __test_cleanup


DOCKER_V1_CMD_PARAMS=\
	$(COMMON_DOCKER_CMD_PARAMS) \
	-e TEST_CONNECTION=$(TEST_CONNECTION) \
	-e TEST_CVERSION=$(TEST_CVERSION) \
	-e TEST_CONTENT_TYPE=$(TEST_CONTENT_TYPE) \
	-e TEST_PPROF=$(TEST_PPROF) \
	-e TEST_REQUEST_LOG=$(TEST_REQUEST_LOG) \
	-e TEST_DISALLOW_UNKNOWN_FIELDS=$(TEST_DISALLOW_UNKNOWN_FIELDS) \
	-v "${ROOTDIR}":/usr/code ${TEST_RESOURCES_VOLUME} \
	-w /usr/code/

__test_go_test:
	($(DOCKER_CMD) $(DOCKER_V1_CMD_PARAMS) $(DOCKER_RUN_CMD) $(ADD_TIMESTAMP)) && echo "success!" \
	|| ( $(ON_FAILURE_PARAMS) MAJOR_VERSION=1 . ./test/on_failure.sh)

			
# Internal test tasks
__run_v2_tests: __test_v2_debug__ __test_prepare __test_v2_go_test __test_cleanup

DOCKER_CMD_V2_PARAMS=\
	$(COMMON_DOCKER_CMD_PARAMS) \
	-v "${ROOTDIR}":/usr/code:ro ${TEST_RESOURCES_VOLUME} \
	-w /usr/code/v2/

__test_v2_go_test:
	($(DOCKER_CMD) $(DOCKER_CMD_V2_PARAMS) $(DOCKER_V2_RUN_CMD) $(ADD_TIMESTAMP)) && echo "success!" \
	|| ($(ON_FAILURE_PARAMS) MAJOR_VERSION=2 . ./test/on_failure.sh)

__run_v2_tests_resiliency_k8s: __test_v2_debug__ __test_prepare __test_v2_go_test_resiliency_k8s __test_cleanup

# Resiliency k8s tests need kubectl in the test container. Prefer K8S_TEST_DOCKER_EXTRA_ARGS
# from run-driver-tests.sh; fall back to host paths when make is invoked without the runner.
ifeq ($(K8S_TEST_DOCKER_EXTRA_ARGS),)
KUBECTL_BIN ?= $(shell command -v kubectl 2>/dev/null)
KUBECONFIG_PATH ?= $(HOME)/.kube/config
RESILIENCY_K8S_DOCKER_EXTRA_ARGS :=
ifneq ($(KUBECTL_BIN),)
RESILIENCY_K8S_DOCKER_EXTRA_ARGS += -v $(KUBECTL_BIN):/usr/local/bin/kubectl:ro
endif
ifneq ($(wildcard $(KUBECONFIG_PATH)),)
RESILIENCY_K8S_DOCKER_EXTRA_ARGS += -v $(KUBECONFIG_PATH):/root/.kube/config:ro -e KUBECONFIG=/root/.kube/config
endif
else
RESILIENCY_K8S_DOCKER_EXTRA_ARGS := $(K8S_TEST_DOCKER_EXTRA_ARGS)
endif

DOCKER_CMD_RESILIENCY_K8S_PARAMS=\
	$(COMMON_DOCKER_CMD_PARAMS) \
	$(RESILIENCY_K8S_DOCKER_EXTRA_ARGS) \
	-e K8S_COORDINATORS_COUNT=$(K8S_COORDINATORS_COUNT) \
	-e K8S_NAMESPACE=$(K8S_NAMESPACE) \
	-e K8S_DEPLOYMENT=$(K8S_DEPLOYMENT) \
	-v "${ROOTDIR}":/usr/code:ro ${TEST_RESOURCES_VOLUME} \
	-w /usr/code/v2/

ifneq ($(strip $(TESTOPTIONS)),)
RESILIENCY_TESTOPTIONS := $(TESTOPTIONS)
else
RESILIENCY_TESTOPTIONS := -run '^TestResiliency_'
endif

__test_v2_go_test_resiliency_k8s:
	($(DOCKER_CMD) $(DOCKER_CMD_RESILIENCY_K8S_PARAMS) $(GOV2IMAGE) go test -timeout 120m $(GOBUILDTAGSOPT) $(K8S_RESILIENCY_TEST_VERBOSE) $(RESILIENCY_TESTOPTIONS) -parallel 1 ./tests) && echo "success!" \
	|| ($(ON_FAILURE_PARAMS) MAJOR_VERSION=2 . ./test/on_failure.sh)

# TOXIPROXY_TEST_RUN sets the go test -run regex. Use this instead of TESTOPTIONS when the
# pattern contains shell metacharacters such as (|). TESTOPTIONS -test.run is still supported
# and extracted inside the container to avoid /bin/sh interpreting the pattern.
# Always clean Toxiproxy even when go test fails (Make stops on failing prerequisites otherwise).
__run_v2_tests_toxiproxy: __test_v2_debug__ __test_prepare __test_toxiproxy_start
	@status=0; $(MAKE) __test_v2_go_test_toxiproxy || status=$$?; \
	$(MAKE) __test_toxiproxy_cleanup; \
	$(MAKE) __test_cleanup; \
	exit $$status

__run_v2_tests_toxiproxy_k8s: __test_v2_debug__ __test_prepare __test_toxiproxy_start
	@status=0; $(MAKE) __test_v2_go_test_toxiproxy || status=$$?; \
	$(MAKE) __test_toxiproxy_cleanup; \
	$(MAKE) __test_cleanup; \
	exit $$status

# Toxiproxy networking is independent of TEST_NET/--add-host (those are for the test
# container). Leave DOCKER_NETWORK empty for published-port mode (Docker Desktop/WSL).
# For native Linux CI host networking, set TOXIPROXY_DOCKER_NETWORK=--net=host.
__test_toxiproxy_start:
	@chmod +x "${ROOTDIR}/test/toxiproxy.sh"
	@TESTCONTAINER=$(TESTCONTAINER) TOXIPROXY_LISTEN_PORT=$(TOXIPROXY_LISTEN_PORT) TOXIPROXY_ADMIN_PORT=$(TOXIPROXY_ADMIN_PORT) \
	  TOXIPROXY_UPSTREAM=$(TOXIPROXY_UPSTREAM) TOXIPROXY_PROXY_NAME=$(TOXIPROXY_PROXY_NAME) \
	  DOCKER_NETWORK='$(TOXIPROXY_DOCKER_NETWORK)' \
	  "${ROOTDIR}/test/toxiproxy.sh" start

__test_toxiproxy_cleanup:
	@TESTCONTAINER=$(TESTCONTAINER) "${ROOTDIR}/test/toxiproxy.sh" cleanup

__test_v2_go_test_toxiproxy:
	@($(DOCKER_CMD) $(DOCKER_CMD_V2_PARAMS) \
	  -e TOXIPROXY_TEST_RUN='$(TOXIPROXY_TEST_RUN)' \
	  -e TOXIPROXY_LEGACY_TESTOPTIONS='$(TESTOPTIONS)' \
	  $(GOV2IMAGE) sh -c '\
	    rf="$$TOXIPROXY_TEST_RUN"; \
	    if [ -z "$$rf" ] && [ -n "$$TOXIPROXY_LEGACY_TESTOPTIONS" ]; then \
	      rf=$$(printf "%s" "$$TOXIPROXY_LEGACY_TESTOPTIONS" | sed -n "s/.*-test\\.run[[:space:]]*\\([^[:space:]]*\\).*/\\1/p" | head -1); \
	    fi; \
	    if [ -z "$$rf" ]; then rf="^TestToxiproxy_"; fi; \
	    exec go test -timeout 120m $(GOBUILDTAGSOPT) $(TESTVERBOSEOPTIONS) -run "$$rf" -parallel 1 ./tests \
	  ') && echo "success!" \
	|| ($(ON_FAILURE_PARAMS) MAJOR_VERSION=2 . ./test/on_failure.sh)

__run_v3_tests: __test_v3_debug__ __test_prepare __test_v3_go_test __test_cleanup

DOCKER_CMD_V3_PARAMS=\
	$(COMMON_DOCKER_CMD_PARAMS) \
	-v "${ROOTDIR}":/usr/code:ro ${TEST_RESOURCES_VOLUME} \
	-w /usr/code/v3/

__test_v3_go_test:
	($(DOCKER_CMD) $(DOCKER_CMD_V3_PARAMS) $(DOCKER_V2_RUN_CMD) $(ADD_TIMESTAMP)) && echo "success!" \
	|| ($(ON_FAILURE_PARAMS) MAJOR_VERSION=3 . ./test/on_failure.sh)

__test_debug__:
ifeq ("$(DEBUG)", "true")
	@docker build -f Dockerfile.debug --build-arg GOVERSION=$(GOVERSION) --build-arg GOTOOLCHAIN=$(GOTOOLCHAIN) --build-arg "TESTS_DIRECTORY=./test" -t $(GOIMAGE) .
	@docker build $(DOCKER_BUILD_PLATFORM) -f Dockerfile.debug --build-arg GOVERSION=$(GOVERSION) --build-arg GOTOOLCHAIN=$(GOTOOLCHAIN) --build-arg "TESTS_DIRECTORY=./test" -t $(GOIMAGE) .
endif

__test_v2_debug__:
ifeq ("$(DEBUG)", "true")
	@docker build -f Dockerfile.debug --build-arg GOVERSION=$(GOVERSION) --build-arg GOTOOLCHAIN=$(GOTOOLCHAIN) --build-arg "TESTS_DIRECTORY=./tests" --build-arg "TESTS_ROOT_PATH=v2" -t $(GOIMAGE) .
	@docker build $(DOCKER_BUILD_PLATFORM) -f Dockerfile.debug --build-arg GOVERSION=$(GOVERSION) --build-arg GOTOOLCHAIN=$(GOTOOLCHAIN) --build-arg "TESTS_DIRECTORY=./tests" --build-arg "TESTS_ROOT_PATH=v2" -t $(GOIMAGE) .
endif

__test_v3_debug__:
ifeq ("$(DEBUG)", "true")
	@docker build -f Dockerfile.debug --build-arg GOVERSION=$(GOVERSION) --build-arg GOTOOLCHAIN=$(GOTOOLCHAIN) --build-arg "TESTS_DIRECTORY=./tests" --build-arg "TESTS_ROOT_PATH=v3" -t $(GOIMAGE) .
	@docker build $(DOCKER_BUILD_PLATFORM) -f Dockerfile.debug --build-arg GOVERSION=$(GOVERSION) --build-arg GOTOOLCHAIN=$(GOTOOLCHAIN) --build-arg "TESTS_DIRECTORY=./tests" --build-arg "TESTS_ROOT_PATH=v3" -t $(GOIMAGE) .
endif

__dir_setup:
	@mkdir -p "${TMPDIR}"
	@echo "${TMPDIR}"

__test_prepare: __dir_setup
ifdef TEST_ENDPOINTS_OVERRIDE
	@-docker rm -f -v $(TESTCONTAINER) >/dev/null 2>&1
	@sleep 3
else
ifeq ($(TEST_MODE_K8S),k8s)
	@-docker rm -f -v $(TESTCONTAINER) >/dev/null 2>&1
	@sleep 3
else
ifdef JWTSECRET 
	echo "$JWTSECRET" > "${JWTSECRETFILE}"
endif
	@-docker rm -f -v $(TESTCONTAINER) >/dev/null 2>&1
	@TESTCONTAINER=$(TESTCONTAINER) ARANGODB=$(ARANGODB) ALPINE_IMAGE=$(ALPINE_IMAGE) ENABLE_BACKUP=$(ENABLE_BACKUP) \
	  ARANGO_LICENSE_KEY=$(ARANGO_LICENSE_KEY) STARTER=$(STARTER) STARTERMODE=$(TEST_MODE) TMPDIR="${TMPDIR}" \
	  ENABLE_DATABASE_EXTRA_FEATURES=$(ENABLE_DATABASE_EXTRA_FEATURES) ENABLE_VECTOR_INDEX=$(ENABLE_VECTOR_INDEX) DEBUG_PORT=$(DEBUG_PORT) $(CLUSTERENV) DOCKER_NETWORK=${TEST_NET} "${ROOTDIR}/test/cluster.sh" start
endif
endif

__test_cleanup:
ifdef TESTCONTAINER
	@TESTCONTAINERS=$$(docker ps -a -q --filter="name=$(TESTCONTAINER)"); \
	if [ -n "$$TESTCONTAINERS" ]; then docker rm -f -v $$TESTCONTAINERS >/dev/null 2>&1; fi
endif
ifndef TEST_ENDPOINTS_OVERRIDE
ifneq ($(TEST_MODE_K8S),k8s)
	@TESTCONTAINER=$(TESTCONTAINER) ARANGODB=$(ARANGODB) ALPINE_IMAGE=$(ALPINE_IMAGE) STARTER=$(STARTER) STARTERMODE=$(TEST_MODE) DOCKER_NETWORK=${TEST_NET} "${ROOTDIR}/test/cluster.sh" cleanup
endif
else
	@-docker rm -f -v $(TESTCONTAINER) >/dev/null 2>&1
endif
	@sleep 3

# Benchmarks
run-benchmarks-single-json-no-auth: 
	@echo "Benchmarks: Single server, JSON no authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" TEST_CONTENT_TYPE="json" TEST_BENCHMARK="true" __run_tests

run-benchmarks-single-vpack-no-auth: 
	@echo "Benchmarks: Single server, Velocypack, no authentication"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" TEST_CONTENT_TYPE="vpack" TEST_BENCHMARK="true" __run_tests

# V1 Cluster benchmarks
run-benchmarks-cluster-json-no-auth: 
	@echo "V1 Benchmarks: Cluster server, JSON no authentication"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" TEST_CONTENT_TYPE="json" TEST_BENCHMARK="true" __run_tests

run-benchmarks-remote-with-auth:
	@echo "V1 Benchmarks: Remote server with authentication"
	@echo "Usage: TEST_ENDPOINTS_OVERRIDE=https://host:port TEST_AUTHENTICATION=basic:user:pass make run-benchmarks-remote-with-auth"
ifndef TEST_AUTHENTICATION
	@echo "ERROR: TEST_AUTHENTICATION is not set. Please export it first."
	@echo "Example: export TEST_AUTHENTICATION='basic:root:password'"
	@exit 1
endif
ifndef TEST_ENDPOINTS_OVERRIDE
	@echo "ERROR: TEST_ENDPOINTS_OVERRIDE is not set. Please export it first."
	@echo "Example: export TEST_ENDPOINTS_OVERRIDE='https://host:port'"
	@exit 1
endif
	@${MAKE} TEST_MODE="cluster" TEST_MODE_K8S="k8s" TEST_NOT_WAIT_UNTIL_READY="1" TEST_CONTENT_TYPE="json" TEST_BENCHMARK="true" __run_tests
	

# V2 Cluster benchmarks
run-benchmarks-v2-cluster-json-no-auth: 
	@echo "V2 Benchmarks: Cluster server, JSON no authentication (from benchmark_tests/)"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" TEST_CONTENT_TYPE="json" TEST_BENCHMARK="true" __run_v2_tests

run-benchmarks-v2-cluster-json-ssl: 
	@echo "V2 Benchmarks: Cluster server, JSON with SSL"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" TEST_SSL="auto" TEST_CONTENT_TYPE="json" TEST_BENCHMARK="true" __run_v2_tests

run-benchmarks-v2-remote-with-auth:
	@echo "V2 Benchmarks: Remote server with authentication"
	@echo "Usage: TEST_ENDPOINTS_OVERRIDE=https://host:port TEST_AUTHENTICATION=basic:user:pass make run-benchmarks-v2-remote-with-auth"
ifndef TEST_AUTHENTICATION
	@echo "ERROR: TEST_AUTHENTICATION is not set. Please export it first."
	@echo "Example: export TEST_AUTHENTICATION='basic:root:password'"
	@exit 1
endif
ifndef TEST_ENDPOINTS_OVERRIDE
	@echo "ERROR: TEST_ENDPOINTS_OVERRIDE is not set. Please export it first."
	@echo "Example: export TEST_ENDPOINTS_OVERRIDE='https://host:port'"
	@exit 1
endif
	@${MAKE} TEST_MODE="cluster" TEST_MODE_K8S="k8s" TEST_NOT_WAIT_UNTIL_READY="1" TEST_CONTENT_TYPE="json" TEST_BENCHMARK="true" __run_v2_tests

## Lint

# Pin tool installs to go$(GOVERSION) so transitive deps (e.g. kevinburke/rest via github-release)
# resolve consistently with the configured toolchain, even when env GOTOOLCHAIN differs per invocation.
TOOLS_GO := GOTOOLCHAIN=go$(GOVERSION) GOBIN=$(TMPDIR)/bin

.PHONY: tools
tools: __dir_setup
	@echo ">> Fetching golangci-lint linter"
	@$(TOOLS_GO) go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.6.1
	@echo ">> Fetching goimports"
	@$(TOOLS_GO) go install golang.org/x/tools/cmd/goimports@v0.38.0
	@echo ">> Fetching license check"
	@$(TOOLS_GO) go install github.com/google/addlicense@v1.0.0
	@echo ">> Fetching govulncheck"
	@$(TOOLS_GO) go install golang.org/x/vuln/cmd/govulncheck@v1.2.0
	@echo ">> Fetching github-release"
	@$(TOOLS_GO) go install github.com/github-release/github-release@v0.10.0

.PHONY: license
license:
	@echo ">> Ensuring license of files"
	@$(TMPDIR)/bin/addlicense -f "$(ROOTDIR)/HEADER" $(SOURCES)

.PHONY: license-verify
license-verify:
	@echo ">> Verify license of files"
	@$(TMPDIR)/bin/addlicense -f "$(ROOTDIR)/HEADER" -check $(SOURCES)

.PHONY: fmt
fmt:
	@echo ">> Ensuring style of files"
	@$(TMPDIR)/bin/goimports -w $(SOURCES)

.PHONY: fmt-verify
fmt-verify: license-verify
	@echo ">> Verify files style"
	@if [ X"$$($(TMPDIR)/bin/goimports -l $(SOURCES) | wc -l)" != X"0" ]; then echo ">> Style errors"; $(TMPDIR)/bin/goimports -l $(SOURCES); exit 1; fi

.PHONY: linter
linter: fmt-verify
	@echo ">> Running linter"
	@$(TMPDIR)/bin/golangci-lint run ./...

.PHONY: vulncheck
vulncheck:
	$(TMPDIR)/bin/govulncheck ./...

# V2

v2-%:
	@(cd "$(ROOTDIR)/v2"; make)

run-v2-tests: run-v2-tests-single run-v2-tests-cluster
ifeq ("$(AF_ENABLED)", "true")
	make run-v2-tests-resilientsingle
endif

run-v2-tests-cluster: run-v2-tests-cluster-with-basic-auth run-v2-tests-cluster-without-ssl run-v2-tests-cluster-without-auth run-v2-tests-cluster-with-jwt-auth

run-v2-tests-cluster-with-basic-auth:
	@echo "Cluster server, with basic authentication, v2"
	@${MAKE} TEST_MODE="cluster" TEST_SSL="auto" TEST_AUTH="rootpw" __run_v2_tests

run-v2-tests-cluster-with-jwt-auth:
	@echo "Cluster server, with JWT authentication, v2"
	@${MAKE} TEST_MODE="cluster" TEST_SSL="auto" TEST_AUTH="jwt" __run_v2_tests

run-v2-tests-cluster-without-auth:
	@echo "Cluster server, without authentication, v2"
	@${MAKE} TEST_MODE="cluster" TEST_SSL="auto" TEST_AUTH="none" __run_v2_tests

run-v2-tests-cluster-without-ssl:
	@echo "Cluster server, without authentication and SSL, v2"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" __run_v2_tests

run-v2-tests-single: run-v2-tests-single-without-auth run-v2-tests-single-with-auth

run-v2-tests-single-without-auth:
	@echo "Single server, without authentication, v2"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" __run_v2_tests

run-v2-tests-single-with-auth:
	@echo "Single server, with authentication, v2"
	@${MAKE} TEST_MODE="single" TEST_SSL="auto" TEST_AUTH="rootpw" __run_v2_tests

run-v2-tests-resilientsingle: run-v2-tests-resilientsingle-with-auth

run-v2-tests-resilientsingle-with-auth:
	@echo "Resilient Single, with authentication, v2"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="rootpw" TESTV2PARALLEL=1 __run_v2_tests

# Resiliency tests against an externally started cluster (e.g. kube-arangodb via ingress).
# Invoked by run-k8s-v2-resiliency; kubectl mounts come from run-driver-tests.sh via K8S_TEST_DOCKER_EXTRA_ARGS.
run-v2-tests-resiliency-k8s:
	@if [ "$(TEST_MODE_K8S)" != "k8s" ]; then \
		echo "ERROR: run-v2-tests-resiliency-k8s is an internal target."; \
		echo "Use: K8S_INGRESS_ADDRESS=127.0.0.1 make run-k8s-v2-resiliency"; \
		echo "Or:  K8S_INGRESS_ADDRESS=127.0.0.1 bash ./deploy/kubernetes/run-driver-tests.sh run make run-v2-tests-resiliency-k8s"; \
		exit 1; \
	fi
	@if [ -z "$(TEST_ENDPOINTS_OVERRIDE)" ]; then \
		echo "ERROR: TEST_ENDPOINTS_OVERRIDE is not set (kube-arangodb ingress endpoint)."; \
		echo "Deploy first: bash ./deploy/kubernetes/run-driver-tests.sh setup-kind"; \
		echo "Then run:     K8S_INGRESS_ADDRESS=127.0.0.1 make run-k8s-v2-resiliency"; \
		exit 1; \
	fi
	@echo "Resiliency tests, Kubernetes cluster mode, v2"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TEST_ENABLE_RESILIENCY=1 \
		K8S_COORDINATORS_COUNT=$(if $(K8S_COORDINATORS_COUNT),$(K8S_COORDINATORS_COUNT),3) \
		TAGS="resiliency" TESTV2PARALLEL=1 __run_v2_tests_resiliency_k8s

# Toxiproxy network fault tests route the driver through a local Toxiproxy instance.
run-v2-tests-toxiproxy:
	@echo "Toxiproxy network fault tests, single server, v2"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" TAGS="toxiproxy" TESTV2PARALLEL=1 \
		TEST_ENDPOINTS=$(TOXIPROXY_TEST_ENDPOINTS) \
		TEST_TOXIPROXY_ADMIN=http://127.0.0.1:$(TOXIPROXY_ADMIN_PORT) \
		TEST_TOXIPROXY_PROXY=$(TOXIPROXY_PROXY_NAME) \
		__run_v2_tests_toxiproxy

# Toxiproxy tests against kube-arangodb via ingress (invoked by run-k8s-v2-toxiproxy).
# TOXIPROXY_UPSTREAM, TEST_INGRESS_HOST, and TEST_ENDPOINTS come from run-driver-tests.sh.
run-v2-tests-toxiproxy-k8s:
	@if [ "$(TEST_MODE_K8S)" != "k8s" ]; then \
		echo "ERROR: run-v2-tests-toxiproxy-k8s is an internal target."; \
		echo "Use: K8S_INGRESS_ADDRESS=127.0.0.1 make run-k8s-v2-toxiproxy"; \
		echo "Or:  K8S_INGRESS_ADDRESS=127.0.0.1 bash ./deploy/kubernetes/run-driver-tests.sh run-toxiproxy make run-v2-tests-toxiproxy-k8s"; \
		exit 1; \
	fi
	@echo "Toxiproxy network fault tests, Kubernetes cluster mode, v2"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="rootpw" TAGS="toxiproxy" TESTV2PARALLEL=1 \
		__run_v2_tests_toxiproxy_k8s

# V3

v3-%:
	@(cd "$(ROOTDIR)/v3"; make)

run-v3-tests: run-v3-tests-single run-v3-tests-cluster
ifeq ("$(AF_ENABLED)", "true")
	make run-v3-tests-resilientsingle
endif

run-v3-tests-cluster: run-v3-tests-cluster-with-basic-auth run-v3-tests-cluster-without-ssl run-v3-tests-cluster-without-auth run-v3-tests-cluster-with-jwt-auth

run-v3-tests-cluster-with-basic-auth:
	@echo "Cluster server, with basic authentication, v3"
	@${MAKE} TEST_MODE="cluster" TEST_SSL="auto" TEST_AUTH="rootpw" __run_v3_tests

run-v3-tests-cluster-with-jwt-auth:
	@echo "Cluster server, with JWT authentication, v3"
	@${MAKE} TEST_MODE="cluster" TEST_SSL="auto" TEST_AUTH="jwt" __run_v3_tests

run-v3-tests-cluster-without-auth:
	@echo "Cluster server, without authentication, v3"
	@${MAKE} TEST_MODE="cluster" TEST_SSL="auto" TEST_AUTH="none" __run_v3_tests

run-v3-tests-cluster-without-ssl:
	@echo "Cluster server, without authentication and SSL, v3"
	@${MAKE} TEST_MODE="cluster" TEST_AUTH="none" __run_v3_tests

run-v3-tests-single: run-v3-tests-single-without-auth run-v3-tests-single-with-auth

run-v3-tests-single-without-auth:
	@echo "Single server, without authentication, v3"
	@${MAKE} TEST_MODE="single" TEST_AUTH="none" __run_v3_tests

run-v3-tests-single-with-auth:
	@echo "Single server, with authentication, v3"
	@${MAKE} TEST_MODE="single" TEST_SSL="auto" TEST_AUTH="rootpw" __run_v3_tests

run-v3-tests-resilientsingle: run-v3-tests-resilientsingle-with-auth

run-v3-tests-resilientsingle-with-auth:
	@echo "Resilient Single, with authentication, v3"
	@${MAKE} TEST_MODE="resilientsingle" TEST_AUTH="rootpw" TESTV2PARALLEL=1 __run_v3_tests

GH_RELEASE := $(TMPDIR)/bin/github-release
RELEASE := $(SCRIPTDIR)/tools/release
V2_VERSION := ./v2/version/VERSION
V3_VERSION := ./v3/version/VERSION

release-patch:
	go run $(RELEASE) -type=patch -github-release=$(GH_RELEASE)

release-minor:
	go run $(RELEASE) -type=minor -github-release=$(GH_RELEASE)

release-major:
	go run $(RELEASE) -type=major -github-release=$(GH_RELEASE)

release-v2-patch:
	go run $(RELEASE) -type=patch -github-release=$(GH_RELEASE) -versionfile=$(V2_VERSION)

release-v2-minor:
	go run $(RELEASE) -type=minor -github-release=$(GH_RELEASE) -versionfile=$(V2_VERSION)

release-v2-major:
	go run $(RELEASE) -type=major -github-release=$(GH_RELEASE) -versionfile=$(V2_VERSION)

release-v3-patch:
	go run $(RELEASE) -type=patch -github-release=$(GH_RELEASE) -versionfile=$(V3_VERSION)

release-v3-minor:
	go run $(RELEASE) -type=minor -github-release=$(GH_RELEASE) -versionfile=$(V3_VERSION)

release-v3-major:
	go run $(RELEASE) -type=major -github-release=$(GH_RELEASE) -versionfile=$(V3_VERSION)

# Preview releases (same as arangodb-helper/arangodb: prerelease-patch, etc.).
prerelease-patch:
	go run $(RELEASE) -type=patch -github-release=$(GH_RELEASE) -prerelease

prerelease-minor:
	go run $(RELEASE) -type=minor -github-release=$(GH_RELEASE) -prerelease

prerelease-major:
	go run $(RELEASE) -type=major -github-release=$(GH_RELEASE) -prerelease

prerelease-v2-patch:
	go run $(RELEASE) -type=patch -github-release=$(GH_RELEASE) -versionfile=$(V2_VERSION) -prerelease

prerelease-v2-minor:
	go run $(RELEASE) -type=minor -github-release=$(GH_RELEASE) -versionfile=$(V2_VERSION) -prerelease

prerelease-v2-major:
	go run $(RELEASE) -type=major -github-release=$(GH_RELEASE) -versionfile=$(V2_VERSION) -prerelease

prerelease-v3-patch:
	go run $(RELEASE) -type=patch -github-release=$(GH_RELEASE) -versionfile=$(V3_VERSION) -prerelease

prerelease-v3-minor:
	go run $(RELEASE) -type=minor -github-release=$(GH_RELEASE) -versionfile=$(V3_VERSION) -prerelease

prerelease-v3-major:
	go run $(RELEASE) -type=major -github-release=$(GH_RELEASE) -versionfile=$(V3_VERSION) -prerelease