Tracetest (#142)

* Add integration tests for trace functionality

Signed-off-by: Ondrej Fabry <[email protected]>

* Add README for integration tests

Signed-off-by: Ondrej Fabry <[email protected]>

* Skip old trace tests

Signed-off-by: Ondrej Fabry <[email protected]>

* Update README.md

Signed-off-by: Ondrej Fabry <[email protected]>

* Update README.md

Signed-off-by: Ondrej Fabry <[email protected]>

* Update README.md

Signed-off-by: Ondrej Fabry <[email protected]>

---------

Signed-off-by: Ondrej Fabry <[email protected]>

Author: ondrej-fabry

Diff for: core/trace_test.go

@@ -16,6 +16,8 @@ import (
 )
 
 func TestTraceEnabled(t *testing.T) {
+	t.Skipf("these randomly fail, see integration tests")
+
 	ctx := setupTest(t, false)
 	defer ctx.teardownTest()
 
@@ -62,6 +64,8 @@ func TestTraceEnabled(t *testing.T) {
 }
 
 func TestMultiRequestTraceEnabled(t *testing.T) {
+	t.Skipf("these randomly fail, see integration tests")
+
 	ctx := setupTest(t, false)
 	defer ctx.teardownTest()
 
@@ -122,6 +126,8 @@ func TestMultiRequestTraceEnabled(t *testing.T) {
 }
 
 func TestTraceDisabled(t *testing.T) {
+	t.Skipf("these randomly fail, see integration tests")
+
 	ctx := setupTest(t, false)
 	defer ctx.teardownTest()
 
@@ -151,6 +157,8 @@ func TestTraceDisabled(t *testing.T) {
 }
 
 func TestTracePerChannel(t *testing.T) {
+	t.Skipf("these randomly fail, see integration tests")
+
 	ctx := setupTest(t, false)
 	defer ctx.teardownTest()
 
@@ -238,6 +246,8 @@ func TestTracePerChannel(t *testing.T) {
 }
 
 func TestTraceClear(t *testing.T) {
+	t.Skipf("these randomly fail, see integration tests")
+
 	ctx := setupTest(t, false)
 	defer ctx.teardownTest()
 

Diff for: test/integration/README.md

@@ -0,0 +1,60 @@
+Integration Tests
+=================
+
+The GoVPP integration testing suite runs each test case against real VPP instance.
+
+The integration tests cases are grouped by files:
+- `binapi` - runs tests for VPP API
+- `examples` - run examples as tests
+- `stats` - runs tests for VPP Stats
+- `trace` - runs tests for VPP API trace
+- `*` (*other*)  - runs specialized tests
+
+## Running Tests
+
+The recommended way to run the integration tests is to use a self-contained testing environment, which is managed from a helper bash script [`run_integration.sh`](../run_integration.sh). The script will build a special Docker image that includes testing suite and other requirements (e.g. VPP, gotestsum..) and then will run the integration tests inside a container.
+
+```shell
+make test-integration
+```
+
+This will run the tests against latest VPP release by default. To run against specific VPP version, add `VPP_REPO=<REPO>` where `<REPO>` is name of VPP repostiroy on packagecloud.
+
+```shell
+# Run against specific VPP version
+make test-integration VPP_REPO=2306
+
+# Run against VPP master branch
+make test-integration VPP_REPO=master
+```
+
+The make target above simply runs a helper script which accepts additional arguments that are passed down directly to `go test ...`.
+
+```shell
+# Usage:
+#  ./test/integration/run_integration.sh <ARGS>
+
+# Run with verbose mode
+./test/integration/run_integration.sh -test.v
+```
+
+### Run Specific Test Case
+
+To run a specific integration test case(s):
+
+```shell
+./test/integration/run_integration.sh -test.run="Interfaces"
+```
+
+## Running Tests on your Host
+
+If the script `run_integration.sh` is not used to run tests and the test cases
+are directly used, the tests will try to start/stop VPP instance for each test
+case individually.
+
+> **Warning**
+> This method requires VPP to be installed on your host system.
+
+```shell
+TEST=integration go test ./test/integration
+```

Diff for: test/integration/binapi_test.go

@@ -16,12 +16,15 @@ package integration
 
 import (
 	"context"
+	"io"
 	"testing"
 
+	interfaces "go.fd.io/govpp/binapi/interface"
 	"go.fd.io/govpp/binapi/vpe"
 	"go.fd.io/govpp/test/vpptesting"
 )
 
+// TestVersion tests that getting VPP version works.
 func TestVersion(t *testing.T) {
 	test := vpptesting.SetupVPP(t)
 
@@ -37,3 +40,52 @@ func TestVersion(t *testing.T) {
 		t.Fatal("expected VPP version to not be empty")
 	}
 }
+
+// TestInterfacesLoopback tests that creating a loopback interface works and returns
+// non-zero ID and that the interface will be listed in interface dump.
+func TestInterfacesLoopback(t *testing.T) {
+	test := vpptesting.SetupVPP(t)
+	ctx := context.Background()
+
+	ifacesRPC := interfaces.NewServiceClient(test.Conn)
+
+	// create loopback interface
+	reply, err := ifacesRPC.CreateLoopback(ctx, &interfaces.CreateLoopback{})
+	if err != nil {
+		t.Fatal("interfaces.CreateLoopback error:", err)
+	}
+	loopId := reply.SwIfIndex
+	t.Logf("loopback interface created (id: %v)", reply.SwIfIndex)
+
+	// list interfaces
+	stream, err := ifacesRPC.SwInterfaceDump(ctx, &interfaces.SwInterfaceDump{})
+	if err != nil {
+		t.Fatal("interfaces.SwInterfaceDump error:", err)
+	}
+
+	t.Log("Dumping interfaces")
+	foundLoop := false
+	numIfaces := 0
+	for {
+		iface, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Fatal("interfaces.SwInterfaceDump/Recv error:", err)
+		}
+		numIfaces++
+		t.Logf("- interface[%d]: %q\n", iface.SwIfIndex, iface.InterfaceName)
+		if iface.SwIfIndex == loopId {
+			foundLoop = true
+		}
+	}
+
+	// verify expected
+	if !foundLoop {
+		t.Fatalf("loopback interface (id: %v) not found", loopId)
+	}
+	if numIfaces != 2 {
+		t.Errorf("expected 2 interfaces in dump, got %d", numIfaces)
+	}
+}

Diff for: test/integration/examples_test.go

@@ -24,6 +24,8 @@ import (
 )
 
 func TestExamples(t *testing.T) {
+	skipTestIfGoNotInstalled(t)
+
 	if err := filepath.WalkDir("./examples", func(path string, d fs.DirEntry, err error) error {
 		if !d.IsDir() || filepath.Base(d.Name()) == "examples" {
 			return nil

Diff for: test/integration/main_test.go

@@ -17,12 +17,28 @@
 package integration
 
 import (
+	"fmt"
 	"os"
+	"os/exec"
 	"testing"
 )
 
+var (
+	// IntegrationTestsActive is set to true if integration tests should run.
+	IntegrationTestsActive = os.Getenv("TEST") == "integration"
+)
+
 func TestMain(m *testing.M) {
-	if os.Getenv("TEST") == "integration" {
+	if IntegrationTestsActive {
 		os.Exit(m.Run())
 	}
+	fmt.Fprintf(os.Stderr, "integration tests are NOT enabled (set TEST='integration' to enable)\n")
+	os.Exit(0)
+}
+
+func skipTestIfGoNotInstalled(t *testing.T) {
+	_, err := exec.LookPath("go")
+	if err != nil {
+		t.Skipf("`go` command is not available, skipping test")
+	}
 }

Diff for: test/integration/trace_test.go

@@ -0,0 +1,65 @@
+//  Copyright (c) 2023 Cisco and/or its affiliates.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at:
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+package integration
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go.fd.io/govpp/api"
+	"go.fd.io/govpp/binapi/vpe"
+	"go.fd.io/govpp/test/vpptesting"
+)
+
+func TestTrace(t *testing.T) {
+	test := vpptesting.SetupVPP(t)
+
+	test.Conn.Trace().Enable(true)
+
+	runTraceRequests(t, test)
+
+	records := test.Conn.Trace().GetRecords()
+
+	if len(records) != 2 {
+		t.Fatalf("expected 2 records, got %d", len(records))
+	}
+
+	printTraceRecords(t, records)
+}
+
+func printTraceRecords(t *testing.T, records []*api.Record) {
+	t.Logf("API trace (records: %d):\n", len(records))
+	t.Logf("--------------------\n")
+	for _, item := range records {
+		h, m, s := item.Timestamp.Clock()
+		reply := ""
+		if item.IsReceived {
+			reply = "(reply)"
+		}
+		fmt.Printf("%dh:%dm:%ds:%dns %s %s\n", h, m, s,
+			item.Timestamp.Nanosecond(), item.Message.GetMessageName(), reply)
+	}
+	t.Logf("--------------------\n")
+}
+
+func runTraceRequests(t *testing.T, test *vpptesting.TestCtx) {
+	vpeRPC := vpe.NewServiceClient(test.Conn)
+
+	_, err := vpeRPC.ShowVersion(context.Background(), &vpe.ShowVersion{})
+	if err != nil {
+		t.Fatalf("getting version failed: %v", err)
+	}
+}