CGO interface for pinstesthelper through thinkit.

Author: kishanps

sdn_tests/pins_ondatra/bazel/patches/ondatra.patch

@@ -7,6 +7,19 @@ index 4d431d1..0ff43a4 100644
  	pathzpb "github.com/openconfig/gnsi/pathz"
 
 -	grpb "github.com/openconfig/gribi/v1/proto/service"
++	grpb "github.com/openconfig/gribi/proto/service"
+ 	opb "github.com/openconfig/ondatra/proto"
+ 	p4pb "github.com/p4lang/p4runtime/go/p4/v1"
+ )
+diff --git a/fakebind/fakebind.go b/fakebind/fakebind.go
+index 7dd0538..800a272 100644
+--- a/fakebind/fakebind.go
++++ b/fakebind/fakebind.go
+@@ -28,7 +28,7 @@ import (
+ 	"google.golang.org/grpc"
+ 
+ 	gpb "github.com/openconfig/gnmi/proto/gnmi"
+-	grpb "github.com/openconfig/gribi/v1/proto/service"
 +	grpb "github.com/openconfig/gribi/proto/service"
  	opb "github.com/openconfig/ondatra/proto"
  	p4pb "github.com/p4lang/p4runtime/go/p4/v1"
@@ -141,4 +154,4 @@ index 7145250..85cb489 100644
 +import "github.com/openconfig/ondatra/proto/testbed.proto";
 
  option go_package = "github.com/openconfig/ondatra/proto/reservation";
- 
+ 

sdn_tests/pins_ondatra/infrastructure/testhelper/BUILD.bazel

@@ -1,5 +1,10 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_library")
 
+def_visibility = [
+    "//platforms/networking/gpins/testing:__subpackages__",
+    "//third_party/pins_infra:__subpackages__",
+]
+
 package(
     default_visibility = ["//visibility:public"],
     licenses = ["notice"],

sdn_tests/pins_ondatra/infrastructure/testhelper/config_restorer.go

@@ -93,10 +93,16 @@ func NewConfigRestorerWithIgnorePaths(t *testing.T, ignorePaths []string) *Confi
 		t.Fatalf("config_restorer creation failed, errors: %v", err)
 	}
 
-        // Register a cleanup to restore the configs on test end.
-	t.Cleanup(func() {
-		cr.RestoreConfigsAndClose(t)
-	})
+        // Cleanup is only registered if running in a go test.
+	// As the cleanup callback would not be called otherwise.
+	if testing.Testing() { // True if running in a go test.
+		// Register a cleanup to restore the configs on test end.
+		log.InfoContextf(ctx, "Registering config_restorer for cleanup tasks.")
+		t.Cleanup(func() {
+			cr.RestoreConfigsAndClose(t)
+		})
+	}
+
 	return cr
 }
 
@@ -238,12 +244,10 @@ func (cr *ConfigRestorer) restoreConfigOnDiff(ctx context.Context, t *testing.T,
 
 // restoreReservedDevices tries to restore the config of the reserved devices
 // if the config differs from the saved config.
-func (cr *ConfigRestorer) restoreReservedDevices(t *testing.T) {
-        t.Helper()
+func (cr *ConfigRestorer) restoreReservedDevices(t *testing.T) error {
 	ctx := context.Background()
 	if cr.savedConfigs == nil {
-		log.InfoContextf(ctx, "configRestorer.savedConfigs is not initialized.")
-		return
+		return fmt.Errorf("savedConfigs are not initialized")
 	}
 
         wg := sync.WaitGroup{}
@@ -268,16 +272,24 @@ func (cr *ConfigRestorer) restoreReservedDevices(t *testing.T) {
 
         // Collect all the errors and fail the test on error.
 	if err := collectErrors(errCh); err != nil {
-		t.Fatalf("failed to restore config, errors: %v", err)
+		return fmt.Errorf("failed to restore config, errors: %v", err)
 	}
         log.InfoContextf(ctx, "Config restored for all the reserved devices.")
+        return nil
+}
+
+// RestoreConfigs restores the config of reserved devices.s
+func (cr *ConfigRestorer) RestoreConfigs(t *testing.T) error {
+	return cr.restoreReservedDevices(t)
 }
 
 // RestoreConfigsAndClose restores the config of reserved devices
 // and closes the configRestorer object.
 func (cr *ConfigRestorer) RestoreConfigsAndClose(t *testing.T) {
         t.Helper()
-	cr.restoreReservedDevices(t)
+	if err := cr.RestoreConfigs(t); err != nil {
+		t.Fatalf("config_restorer failed, errors: %v", err)
+	}
 	cr.savedConfigs = nil
 	cr.ignorePaths = nil
 }

sdn_tests/pins_ondatra/infrastructure/testhelper/platform_components.go

@@ -14,7 +14,7 @@ import (
 
 // SwitchNameRegex returns the regex for switch name.
 func SwitchNameRegex() string {
-	return ""
+	return "^(ju|df|mn|ocs)(\\d+).*\\.([a-z]{3})(\\d{2})([a-z]?)\\.(net|prod).google.com$"
 }
 
 // ImageVersionRegex returns the regular expressions for the image version of the switch.

sdn_tests/pins_ondatra/infrastructure/testhelper/port_management.go

@@ -4,6 +4,7 @@ package testhelper
 
 import (
 	"fmt"
+        "slices"
 	"strconv"
 	"strings"
 	"testing"
@@ -840,6 +841,7 @@ func BreakoutStateInfoForPort(t *testing.T, dut *ondatra.DUTDevice, port string,
 	if portInfo == nil {
 		return nil, errors.Errorf("got empty port information for breakout mode %v for port %v", currBreakoutMode, port)
 	}
+        FilterSkippedPorts(t, dut, port, portInfo)
 	// Get physical channels and operational statuses for list of ports in given breakout mode.
 	for p := range portInfo {
 		physicalChannels := testhelperIntfPhysicalChannelsGet(t, dut, p)
@@ -850,6 +852,32 @@ func BreakoutStateInfoForPort(t *testing.T, dut *ondatra.DUTDevice, port string,
 	return portInfo, nil
 }
 
+// FilterSkippedPorts filters out ports that are skipped from the portInfo map.
+func FilterSkippedPorts(t *testing.T, dut *ondatra.DUTDevice, port string,
+	portInfo map[string]*PortBreakoutInfo) {
+	if dut == nil {
+		return
+	}
+	for p, pInfo := range portInfo {
+		if testhelperIntfLookup(t, dut, p).IsPresent() {
+			physicalChannels := testhelperIntfPhysicalChannelsGet(t, dut, p)
+			if !slices.Equal(physicalChannels, pInfo.PhysicalChannels) {
+				t.Fatalf("physical channels mismatch for port on switch, get: %v, want: %v",
+					physicalChannels, pInfo.PhysicalChannels)
+			}
+			portSpeed := testhelperStatePortSpeedGet(t, dut, p)
+			if portSpeed != pInfo.PortSpeed {
+				t.Fatalf("port speed mismatch for port on switch, get: %v, want: %v",
+					portSpeed, pInfo.PortSpeed)
+			}
+		} else {
+			// Filter out skipped
+			delete(portInfo, p)
+			t.Logf("Port %v skipped, port Info: %v", p, pInfo)
+		}
+	}
+}
+
 // WaitForInterfaceState polls interface oper-status until it matches the expected oper-status.
 func WaitForInterfaceState(t *testing.T, dut *ondatra.DUTDevice, intfName string, expectedOperSatus oc.E_Interface_OperStatus, timeout time.Duration) error {
 	t.Helper()

sdn_tests/pins_ondatra/infrastructure/testhelper/testhelper.go

@@ -2,9 +2,9 @@
 package testhelper
 
 import (
+        "fmt"
 	"crypto/rand"
 	"math/big"
-	"fmt"
 	"strings"
 	"testing"
 	"time"
@@ -218,8 +218,8 @@ type TearDownOptions struct {
 }
 
 // NewTearDownOptions creates the TearDownOptions structure with default values.
-func NewTearDownOptions(t *testing.T) TearDownOptions {
-	return TearDownOptions{
+func NewTearDownOptions(t *testing.T) *TearDownOptions {
+	return &TearDownOptions{
 		StartTime:         time.Now(),
 		DUTName:           teardownDUTNameGet(t),
 		DUTDeviceInfo:     teardownDUTDeviceInfoGet(t),
@@ -228,13 +228,13 @@ func NewTearDownOptions(t *testing.T) TearDownOptions {
 }
 
 // WithID attaches an ID to the test.
-func (o TearDownOptions) WithID(id string) TearDownOptions {
+func (o *TearDownOptions) WithID(id string) *TearDownOptions {
 	o.IDs = append(o.IDs, id)
 	return o
 }
 
 // WithIDs attaches a list of IDs to the test.
-func (o TearDownOptions) WithIDs(ids []string) TearDownOptions {
+func (o *TearDownOptions) WithIDs(ids []string) *TearDownOptions {
 	for _, id := range ids {
 		o.IDs = append(o.IDs, id)
 	}
@@ -245,11 +245,19 @@ func (o TearDownOptions) WithIDs(ids []string) TearDownOptions {
 // of the reserved devices on teardown.
 // Accepts a list of paths to ignore while checking for config changes.
 // The test will fail if the config is not restored.
-func (o TearDownOptions) WithConfigRestorer(t *testing.T, ignorePaths []string) TearDownOptions {
+func (o *TearDownOptions) WithConfigRestorer(t *testing.T, ignorePaths []string) *TearDownOptions {
 	o.configRestorer = NewConfigRestorerWithIgnorePaths(t, ignorePaths)
 	return o
 }
 
+// RestoreConfigs restores the configs of the reserved devices.
+func (o *TearDownOptions) RestoreConfigs(t *testing.T) error {
+	if o.configRestorer == nil {
+		return fmt.Errorf("configRestorer was not initialized")
+	}
+	return o.configRestorer.RestoreConfigs(t)
+}
+
 // TearDown provides an interface to implement the teardown routine.
 type TearDown interface {
 	Teardown(t *testing.T)

sdn_tests/pins_ondatra/infrastructure/thinkit/BUILD.bazel

@@ -20,17 +20,26 @@ package(
     licenses = ["notice"],
 )
 
+cc_library(
+    name = "thinkit_go_hdr",
+    testonly = True,
+    hdrs = ["thinkit_go_interface.h"],
+)
+
 go_library(
     name = "thinkit",
     testonly = True,
     srcs = ["thinkit.go"],
+    cdeps = [":thinkit_go_hdr"],
     cgo = True,
     importpath = "github.com/sonic-net/sonic-mgmt/sdn_tests/pins_ondatra/infrastructure/thinkit/thinkit",
     deps = [
         "//infrastructure/binding:pinsbind",
+        "//infrastructure/testhelper",
         "@com_github_golang_glog//:glog",
         "@com_github_openconfig_gnmi//errlist",
         "@com_github_openconfig_ondatra//binding",
+        "@com_github_openconfig_ondatra//fakebind",
         "@com_github_openconfig_ondatra//proto:go_default_library",
         "@com_github_openconfig_ondatra//proxy",
         "@com_github_openconfig_ondatra//proxy/proto/reservation:go_default_library",
@@ -54,13 +63,16 @@ cc_library(
     hdrs = ["thinkit.h"],
     deps = [
         ":thinkit_cgo.cc",
+        ":thinkit_go_hdr",  # keep
         "@com_github_sonic_net_sonic_pins//gutil:status",
         "@com_github_openconfig_ondatra//proto:ondatra_cc_proto",
         "@com_github_openconfig_ondatra//proxy/proto:reservation_cc_proto",
+        "@com_google_absl//absl/log",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
+        "@com_google_googletest//:gtest",
         "@com_google_protobuf//:protobuf",
     ],
 )
@@ -117,6 +129,7 @@ cc_test(
     deps = [
         ":cthinkit",
         ":ondatra_generic_testbed_fixture",
+        ":thinkit_go_hdr",
         "@com_github_sonic_net_sonic_pins//gutil:proto_matchers",
         "@com_github_sonic_net_sonic_pins//gutil:status",
         "@com_github_sonic_net_sonic_pins//gutil:status_matchers",

sdn_tests/pins_ondatra/infrastructure/thinkit/ondatra_generic_testbed_fixture.cc

@@ -183,6 +183,7 @@ GetSutInterfaceInfoFromReservation(
 }  // namespace
 
 void OndatraGenericTestbedFixture::TearDown() {
+  ondatra_hooks_.teardown(teardown_handler_id_);
   EXPECT_OK(ondatra_hooks_.release());
 }
 
@@ -197,6 +198,19 @@ OndatraGenericTestbedFixture::GetTestbedWithRequirements(
   ASSIGN_OR_RETURN(reservation::Reservation reservation,
                    ondatra_hooks_.testbed());
 
+  // Setup testhelper teardown.
+  teardown_handler_id_ = ondatra_hooks_.new_teardown_handler(/*opts=*/{
+      .with_config_restorer = false,
+  });
+  auto set_test_case_ids =
+      [this](const std::vector<std::string>& test_case_ids) {
+        for (const std::string& test_case_id : test_case_ids) {
+          std::string test_case_id_go_str = test_case_id;
+          ondatra_hooks_.add_test_case_id(teardown_handler_id_,
+                                          test_case_id_go_str.data());
+        }
+      };
+
   ASSIGN_OR_RETURN(auto sut_interface_info, GetSutInterfaceInfoFromReservation(
                                                 testbed_request, reservation));
   ASSIGN_OR_RETURN(const reservation::ResolvedDevice* dut,
@@ -209,7 +223,7 @@ OndatraGenericTestbedFixture::GetTestbedWithRequirements(
   if (!control.ok()) {
     return std::make_unique<pins_test::OndatraGenericTestbed>(
         std::move(sut), /*control_device=*/nullptr,
-        std::move(sut_interface_info));
+        std::move(sut_interface_info), set_test_case_ids);
   }
 
   ASSIGN_OR_RETURN(auto control_switch, CreateSwitchFromDevice(*(*control)));
@@ -224,9 +238,10 @@ OndatraGenericTestbedFixture::GetTestbedWithRequirements(
           std::move(*response.mutable_config()->mutable_p4info())));
   auto control_device_pointer =
       std::make_unique<pins_test::PinsControlDevice>(std::move(control_device));
+
   return std::make_unique<pins_test::OndatraGenericTestbed>(
       std::move(sut), std::move(control_device_pointer),
-      std::move(sut_interface_info));
+      std::move(sut_interface_info), set_test_case_ids);
 }
 
 }  // namespace pins_test

sdn_tests/pins_ondatra/infrastructure/thinkit/ondatra_generic_testbed_fixture.h

@@ -44,6 +44,7 @@ class OndatraGenericTestbedFixture : public thinkit::GenericTestbedInterface {
 
  private:
   OndatraHooks ondatra_hooks_;
+  int teardown_handler_id_ = 0;
 };
 
 }  // namespace pins_test

sdn_tests/pins_ondatra/infrastructure/thinkit/ondatra_generic_testbed_fixture_test.cc

@@ -40,6 +40,7 @@
 #include "gutil/status_matchers.h"
 #include "gutil/testing.h"
 #include "infrastructure/thinkit/thinkit.h"
+#include "infrastructure/thinkit/thinkit_go_interface.h"
 #include "p4/v1/p4runtime.grpc.pb.h"
 #include "p4/v1/p4runtime.pb.h"
 #include "proto/gnmi/gnmi.grpc.pb.h"
@@ -165,6 +166,9 @@ TEST_P(OndatraGenericTestbedFixtureTest, Test) {
               Call(EqualsProto(GetParam().expected_testbed_request), _, _))
       .WillOnce(Return(absl::OkStatus()));
   MockFunction<absl::StatusOr<reservation::Reservation>()> mock_testbed;
+  MockFunction<int(struct testhelper_TeardownCreateOpts)>
+      mock_new_teardown_handler;
+  MockFunction<void(int)> mock_teardown;
   std::list<FakeSwitch> fake_switches;
   if (GetParam().returned_reservation.ok()) {
     reservation::Reservation reservation = *GetParam().returned_reservation;
@@ -180,17 +184,21 @@ TEST_P(OndatraGenericTestbedFixtureTest, Test) {
           absl::StrCat("[::]:", fake_switch.GetPort()));
     }
     EXPECT_CALL(mock_testbed, Call).WillOnce(Return(reservation));
+    EXPECT_CALL(mock_new_teardown_handler, Call(_)).WillOnce(Return(0));
+    EXPECT_CALL(mock_teardown, Call(_)).WillOnce(Return());
   } else {
     EXPECT_CALL(mock_testbed, Call)
         .WillOnce(Return(GetParam().returned_reservation));
   }
   MockFunction<absl::Status()> mock_release;
   EXPECT_CALL(mock_release, Call).WillOnce(Return(absl::OkStatus()));
 
-  OndatraGenericTestbedFixture fixture(
-      OndatraHooks{.init = mock_init.AsStdFunction(),
-                   .testbed = mock_testbed.AsStdFunction(),
-                   .release = mock_release.AsStdFunction()});
+  OndatraGenericTestbedFixture fixture(OndatraHooks{
+      .init = mock_init.AsStdFunction(),
+      .testbed = mock_testbed.AsStdFunction(),
+      .release = mock_release.AsStdFunction(),
+      .new_teardown_handler = mock_new_teardown_handler.AsStdFunction(),
+      .teardown = mock_teardown.AsStdFunction()});
 
   fixture.SetUp();
   if (GetParam().expected_sut_interface_info.ok()) {