query-orchestration/internal/test/ecosystem_test.go

package test

import (
	"context"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"strings"
	"testing"

	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/serviceconfig/aws"
	"queryorchestration/internal/serviceconfig/database"
	"queryorchestration/internal/serviceconfig/objectstore"

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

func TestCreateAPINetwork(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()

	cfg := &FullDepsConfig{}
	SetCfgProvider(t, cfg)

	conn, cleanup := CreateAPINetwork(t, ctx, cfg, QueryAPI)

	assert.NotNil(t, conn)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateBaseConfig(t *testing.T) {
	cfg := &serviceconfig.BaseConfig{}
	SetCfgProvider(t, cfg)
	assert.Equal(t, "test", cfg.AWSKeyID)
	assert.Equal(t, "test", cfg.AWSSecretKey)
	assert.Equal(t, "us-east-1", cfg.AWSRegion)
	assert.Equal(t, aws.Profile(""), cfg.AWSProfile)
	assert.Equal(t, "invalid_user", cfg.DBUser)
	assert.Equal(t, "invalid_pass", cfg.DBSecret)
	assert.Equal(t, "invalid_host", cfg.DBHost)
	assert.Equal(t, 5432, cfg.DBPort)
	assert.Equal(t, "invalid_name", cfg.DBName)
	assert.True(t, cfg.DBNoSSL)
}

func TestCreateDBConfig(t *testing.T) {
	cfg := &database.DBConfig{
		DBUser:   "test user",
		DBSecret: "test secret",
		DBHost:   "test host",
		DBPort:   999,
		DBName:   "test name",
		DBNoSSL:  true,
	}
	SetDBCfg(t, cfg)
	assert.Equal(t, "test user", os.Getenv("PGUSER"))
	assert.Equal(t, "test secret", os.Getenv("PGPASSWORD"))
	assert.Equal(t, "test host", os.Getenv("PGHOST"))
	assert.Equal(t, "999", os.Getenv("PGPORT"))
	assert.Equal(t, "test name", os.Getenv("PGDATABASE"))
	assert.Equal(t, "true", os.Getenv("DB_NOSSL"))
}

type FullDepsConfig struct {
	aws.AWSConfig
	serviceconfig.BaseConfig
	objectstore.ObjectStoreConfig
}

func TestCreateFullDependencies(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()
	cfg := &FullDepsConfig{}
	SetCfgProvider(t, cfg)

	conn, cleanup := CreateFullDependencies(t, ctx, cfg)

	assert.NotNil(t, conn)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateFullNetwork(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()
	cfg := &FullDepsConfig{}
	SetCfgProvider(t, cfg)

	conn, cleanup := CreateFullNetwork(t, ctx, cfg)

	assert.NotNil(t, conn)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateMockServer(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()

	net := DepNetwork.Get(t, ctx)

	server, cleanup := CreateMockServer(t, ctx, net)

	assert.NotNil(t, server)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateMockExpectation(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))
	defer ts.Close()

	server := MockServer{
		Client:   ts.Client(),
		External: Address(ts.URL),
	}
	expectation := MockExpectation{}
	CreateMockExpectation(t, server, expectation)
}

func TestCreateDetectDocumentTextExpectation(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))
	defer ts.Close()

	server := MockServer{
		Client:   ts.Client(),
		External: Address(ts.URL),
	}
	expectation := CreateDetectDocumentTextExpectation(t, server, "HI")
	blocks, ok := expectation.Response.Body.(map[string]interface{})["Blocks"].([]map[string]interface{})
	require.True(t, ok)
	assert.Equal(
		t,
		"PAGE",
		blocks[0]["BlockType"],
	)
	relationship, ok := blocks[0]["Relationships"].([]map[string]interface{})
	require.True(t, ok)
	assert.Equal(
		t,
		"CHILD",
		relationship[0]["Type"],
	)
	ids, ok := relationship[0]["Ids"].([]string)
	require.True(t, ok)
	assert.Equal(
		t,
		ids[0],
		blocks[1]["Id"],
	)
	assert.Equal(
		t,
		"HI",
		blocks[1]["Text"],
	)
}

func TestWaitForMockEndpoint(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()

	net := DepNetwork.Get(t, ctx)

	server, cleanup := CreateMockServer(t, ctx, net)
	defer cleanup()

	body := strings.NewReader(`{"team":"hello"}`)
	req, err := http.NewRequest("GET", string(server.External), body)
	require.NoError(t, err)
	req.Header.Add("Hidden", "here")

	expectation := MockExpectation{
		Request: MockRequest{
			Method:  "GET",
			Path:    "/",
			Headers: MockHeaders{},
			Query:   MockQueries{},
			Body:    `{"team":"hello"}`,
		},
		Response: MockResponse{
			Code:    200,
			Headers: MockHeaders{},
			Body:    "byebye",
		},
	}

	CreateMockExpectation(t, server, expectation)

	resp, err := server.Client.Do(req)
	require.NoError(t, err)

	respStr, err := io.ReadAll(resp.Body)
	require.NoError(t, err)
	assert.Equal(t, []byte("byebye"), respStr)

	request := WaitForMockEndpoint(t, server, expectation.Request)
	assert.Equal(t, []string([]string{"here"}), request.Headers["Hidden"])
}