Merge branch 'main' into contract-repo

Author: pranavgawri

.github/workflows/make.yml

@@ -10,8 +10,8 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
-
+        os: [ubuntu-latest]
+      
     runs-on: ${{matrix.os}}
 
     steps:
@@ -31,39 +31,21 @@ jobs:
         uses: actions/setup-go@v4
         with:
           go-version: '^1.22.5'
-
+      
       - name: Go Tidy
         run: go mod tidy
-
+      
       - name: Install dependencies
         run: |
           go mod download
           go install google.golang.org/protobuf/cmd/[email protected]
           go install google.golang.org/grpc/cmd/[email protected]
-
-      - name: setup env
-        run:
-          echo "$GOPATH/bin" >> $GITHUB_PATH
-
-      - name: Set BFF port from config
-        run: |
-          go run scripts/read_port.go >> $GITHUB_ENV
-
-      - name: Build with Makefile
-        run: make all
-
-      - name: Set up Java
-        uses: actions/setup-java@v4
+      
+      - name: Setup Testcontainers Cloud Client
+        uses: atomicjar/testcontainers-cloud-setup-action@v1
         with:
-          distribution: 'temurin' # See 'Supported distributions' for available options
-          java-version: '17'
-      - run: java --version
-
-      - name: Start gRPC Stub
-        run: java --version && java -jar lib/specmatic-grpc-0.0.4-TRIAL-all.jar stub &
-
-      - name: Start Golang gRPC Server
-        run: ./specmatic-order-bff-grpc-go &
+          token: ${{ secrets.TC_CLOUD_TOKEN }}
+          wait: true
 
-      - name: Start gRPC Contract Test
-        run: java -DSPECMATIC_GENERATIVE_TESTS=true -jar lib/specmatic-grpc-0.0.4-TRIAL-all.jar test --port ${{ env.BFF_SERVER_PORT }}
+      - name: start dockerized tests
+        run: go test contract_test.go -v -count=1

README.md

@@ -30,57 +30,3 @@ git config submodule.recurse true
 go mod tidy
 go test contract_test.go -v -count=1 
 ```
-
-### Contract Testing BFF by building and running the application using specmatic-grpc JAR file (old-school)
-
-1. Installing pre-requisites
-
-```shell
-go install google.golang.org/protobuf/cmd/[email protected]
-go install google.golang.org/grpc/cmd/[email protected]
-```
-   1.1. Add protoc-gen-go to your path using the following command:
-
-```shell
-echo 'export PATH=$PATH:$(go env GOPATH)/bin' >> ~/.bash_profile 
-source ~/.bash_profile 
-```   
-
-2. Installing the `buf` tool
-```shell
-brew install bufbuild/buf/buf
-```
-For more options to install buf tool, refer to [buf installation guide](https://docs.buf.build/installation)
-
-3. Building the application
-
-```shell
-go mod tidy
-go mod download
-make clean
-make all
-```
-
-## Running Contract Tests
-
-### Using specmatic-grpc JAR file
-
-* Start Specmatic stub server - 
-```shell
-java -jar lib/specmatic-grpc-0.0.4-TRIAL-all.jar stub
-```
-* Run the Go BFF app
-```shell
-./specmatic-order-bff-grpc-go
-```
-* Run contract tests (with API resiliency switched on)
-```shell
-java -DSPECMATIC_GENERATIVE_TESTS=true -jar lib/specmatic-grpc-0.0.4-TRIAL-all.jar test --port=8080
-```
-
-## Debugging steps
-
-In case of pb files already exists,
-```shell
-rm -rf ~/Library/Caches/buf
-```

cmd/main.go

@@ -17,7 +17,7 @@ import (
 )
 
 func main() {
-	cfg, err := config.LoadConfig("config.yaml")
+	cfg, err := config.LoadConfig()
 	if err != nil {
 		log.Fatalf("Failed to load configuration: %v", err)
 	}

config.yaml

@@ -7,28 +7,33 @@ import (
 	"io"
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"specmatic-order-bff-grpc-go/internal/com/store/order/bff/config"
 	"strconv"
 	"testing"
+	"time"
 
 	"github.com/docker/go-connections/nat"
+	"github.com/stretchr/testify/require"
 	"github.com/testcontainers/testcontainers-go"
+	"github.com/testcontainers/testcontainers-go/network"
 	"github.com/testcontainers/testcontainers-go/wait"
 )
 
 type testEnvironment struct {
 	ctx                      context.Context
 	domainServiceContainer   testcontainers.Container
 	domainServiceDynamicPort string
+	kafkaServiceContainer    testcontainers.Container
+	kafkaServiceDynamicPort  string
 	bffServiceContainer      testcontainers.Container
 	bffServiceDynamicPort    string
+	dockerNetwork            *testcontainers.DockerNetwork
 	config                   *config.Config
 }
 
-func TestIntegration(t *testing.T) {
-    env := setUpEnv(t)
+func TestContract(t *testing.T) {
+	env := setUpEnv(t)
 
 	// setUp (start domain service stub with specmatic-grpc and bff server in container)
 	setUp(t, env)
@@ -41,35 +46,51 @@ func TestIntegration(t *testing.T) {
 }
 
 func setUpEnv(t *testing.T) *testEnvironment {
-    config, err := config.LoadConfig("config.yaml")
-    if err != nil {
-        t.Fatalf("Failed to load config: %v", err)
-    }
-
-    return &testEnvironment{
-        ctx:    context.Background(),
-        config: config,
-    }
+	config, err := config.LoadConfig()
+	if err != nil {
+		t.Fatalf("Failed to load config: %v", err)
+	}
+
+	return &testEnvironment{
+		ctx:    context.Background(),
+		config: config,
+	}
 }
 
 func setUp(t *testing.T, env *testEnvironment) {
 	var err error
 
+	// Create a sub net and store in env.
+	newNetwork, err := network.New(env.ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		require.NoError(t, newNetwork.Remove(env.ctx))
+	})
+	env.dockerNetwork = newNetwork
+
 	printHeader(t, 1, "Starting Domain Service")
 	env.domainServiceContainer, env.domainServiceDynamicPort, err = startDomainService(env)
 	if err != nil {
-	    t.Fatalf("could not start domain service container: %v", err)
+		t.Fatalf("could not start domain service container: %v", err)
+	}
+
+	printHeader(t, 2, "Starting Kafka Service")
+	env.kafkaServiceContainer, env.kafkaServiceDynamicPort, err = startKafkaMock(env)
+	if err != nil {
+		t.Fatalf("could not start domain service container: %v", err)
 	}
 
-	printHeader(t, 2, "Starting BFF Service")
+	printHeader(t, 3, "Starting BFF Service")
 	env.bffServiceContainer, env.bffServiceDynamicPort, err = startBFFService(t, env)
 	if err != nil {
-	    t.Fatalf("could not start bff service container: %v", err)
+		t.Fatalf("could not start bff service container: %v", err)
 	}
 }
 
 func runTests(t *testing.T, env *testEnvironment) {
-	printHeader(t, 3, "Starting tests")
+	printHeader(t, 4, "Starting tests")
 	testLogs, err := runTestContainer(env)
 	if err != nil {
 		t.Fatalf("Could not run test container: %s", err)
@@ -86,6 +107,11 @@ func tearDown(t *testing.T, env *testEnvironment) {
 			t.Logf("Failed to terminate BFF container: %v", err)
 		}
 	}
+	if env.kafkaServiceContainer != nil {
+		if err := env.kafkaServiceContainer.Terminate(env.ctx); err != nil {
+			t.Logf("Failed to terminate Kafka container: %v", err)
+		}
+	}
 	if env.domainServiceContainer != nil {
 		if err := env.domainServiceContainer.Terminate(env.ctx); err != nil {
 			t.Logf("Failed to terminate stub container: %v", err)
@@ -111,6 +137,12 @@ func startDomainService(env *testEnvironment) (testcontainers.Container, string,
 		Mounts: testcontainers.Mounts(
 			testcontainers.BindMount(filepath.Join(pwd, "specmatic.yaml"), "/usr/src/app/specmatic.yaml"),
 		),
+		Networks: []string{
+			env.dockerNetwork.Name,
+		},
+		NetworkAliases: map[string][]string{
+			env.dockerNetwork.Name: {"order-api-mock"},
+		},
 		WaitingFor: wait.ForLog("Stub server is running"),
 	}
 
@@ -130,33 +162,86 @@ func startDomainService(env *testEnvironment) (testcontainers.Container, string,
 	return stubContainer, domainServicePort.Port(), nil
 }
 
-func startBFFService(t *testing.T, env *testEnvironment) (testcontainers.Container, string, error) {
-	dockerfilePath := "Dockerfile"
+func startKafkaMock(env *testEnvironment) (testcontainers.Container, string, error) {
+	pwd, err := os.Getwd()
+	if err != nil {
+		return nil, "", fmt.Errorf("Error getting current directory: %v", err)
 
-	bffImageName := "specmatic-order-bff-grpc-go"
-	buildCmd := exec.Command("docker", "build", "-t", bffImageName, "-f", dockerfilePath, ".")
+	}
 
-	if err := buildCmd.Run(); err != nil {
-		return nil, "", fmt.Errorf("could not build BFF image: %w", err)
+	port, err := nat.NewPort("tcp", env.config.KafkaService.Port)
+	if err != nil {
+		return nil, "", fmt.Errorf("invalid port number: %w", err)
 	}
 
+	req := testcontainers.ContainerRequest{
+		Name:         "specmatic-kafka",
+		Image:        "znsio/specmatic-kafka-trial:0.22.5",
+		ExposedPorts: []string{port.Port() + "/tcp"},
+		Networks: []string{
+			env.dockerNetwork.Name,
+		},
+		NetworkAliases: map[string][]string{
+			env.dockerNetwork.Name: {"specmatic-kafka"},
+		},
+		Env: map[string]string{
+			"KAFKA_EXTERNAL_HOST": env.config.KafkaService.Host,
+			"KAFKA_EXTERNAL_PORT": port.Port(),
+		},
+		Cmd: []string{"--config=/specmatic.json"}, // TODO: Switch to YAML
+		Mounts: testcontainers.Mounts(
+			testcontainers.BindMount(filepath.Join(pwd, "specmatic.json"), "/specmatic.json"),
+		),
+		WaitingFor: wait.ForLog("Listening on topics: (product-queries)").WithStartupTimeout(2 * time.Minute),
+	}
+
+	kafkaC, err := testcontainers.GenericContainer(env.ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	})
+	if err != nil {
+		fmt.Printf("Error starting Kafka mock container: %v", err)
+	}
+
+	mappedPort, err := kafkaC.MappedPort(env.ctx, port)
+	if err != nil {
+		fmt.Printf("Error getting mapped port for Kafka mock: %v", err)
+	}
+
+	return kafkaC, mappedPort.Port(), nil
+}
+
+func startBFFService(t *testing.T, env *testEnvironment) (testcontainers.Container, string, error) {
+
 	port, err := nat.NewPort("tcp", env.config.BFFServer.Port)
 	if err != nil {
 		return nil, "", fmt.Errorf("invalid port number: %w", err)
 	}
 
+	dockerfilePath := "Dockerfile"
+	contextPath := "."
+
 	req := testcontainers.ContainerRequest{
-		Image: bffImageName,
+		FromDockerfile: testcontainers.FromDockerfile{
+			Context:    contextPath,
+			Dockerfile: dockerfilePath,
+		},
 		Env: map[string]string{
-			"DOMAIN_SERVER_PORT": env.domainServiceDynamicPort,
-			"DOMAIN_SERVER_HOST": "host.docker.internal",
+			"DOMAIN_SERVER_PORT": env.config.Backend.Port,
+			"DOMAIN_SERVER_HOST": "order-api-mock",
+			"KAFKA_PORT":         env.config.KafkaService.Port,
+			"KAFKA_HOST":         "specmatic-kafka",
 		},
-		ExposedPorts: []string{port.Port() + "/tcp"},
+		Networks: []string{
+			env.dockerNetwork.Name,
+		},
+		NetworkAliases: map[string][]string{
+			env.dockerNetwork.Name: {"bff-service"},
+		},
+		ExposedPorts: []string{env.config.BFFServer.Port + "/tcp"},
 		WaitingFor:   wait.ForLog("Starting gRPC server"),
 	}
 
-	t.Log("Container created")
-
 	bffContainer, err := testcontainers.GenericContainer(env.ctx, testcontainers.GenericContainerRequest{
 		ContainerRequest: req,
 		Started:          true,
@@ -179,7 +264,8 @@ func runTestContainer(env *testEnvironment) (string, error) {
 		log.Fatalf("Error getting current directory: %v", err)
 	}
 
-	bffPortInt, err := strconv.Atoi(env.bffServiceDynamicPort)
+	bffPortInt, err := strconv.Atoi(env.config.BFFServer.Port)
+	// bffPortInt, err := strconv.Atoi(env.bffServiceDynamicPort)
 	if err != nil {
 		return "", fmt.Errorf("invalid port number: %w", err)
 	}
@@ -189,10 +275,13 @@ func runTestContainer(env *testEnvironment) (string, error) {
 		Env: map[string]string{
 			"SPECMATIC_GENERATIVE_TESTS": "true",
 		},
-		Cmd: []string{"test", fmt.Sprintf("--port=%d", bffPortInt), "--host=host.docker.internal"},
+		Cmd: []string{"test", fmt.Sprintf("--port=%d", bffPortInt), "--host=bff-service"},
 		Mounts: testcontainers.Mounts(
 			testcontainers.BindMount(filepath.Join(pwd, "specmatic.yaml"), "/usr/src/app/specmatic.yaml"),
 		),
+		Networks: []string{
+			env.dockerNetwork.Name,
+		},
 		WaitingFor: wait.ForLog("Passed Tests:"),
 	}