almost ready

tools/run_tests/xds_k8s_test_driver/framework/infrastructure/traffic_director_gamma.py

@@ -16,3 +16,6 @@
 
 class TrafficDirectorGammaManager(td_base.TrafficDirectorManager):
     """Gamma."""
+
+    def cleanup(self, *, force=False):
+        return True

tools/run_tests/xds_k8s_test_driver/framework/test_app/runners/k8s/gamma_server_runner.py

@@ -201,11 +201,11 @@ def run(
     # pylint: disable=arguments-differ
     def cleanup(self, *, force=False, force_namespace=False):
         try:
-            if True or self.route or force:
+            if self.route or force:
                 self._delete_gamma_route(self.route_name)
                 self.route = None
 
-            if True or self.mesh or force:
+            if self.mesh or force:
                 self._delete_gamma_mesh(self.mesh_name)
 
             if (self.service and not self.reuse_service) or force:

tools/run_tests/xds_k8s_test_driver/framework/xds_gamma_testcase.py

@@ -11,18 +11,65 @@
 # 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.
+import logging
+
 from framework.infrastructure import k8s
 import framework.xds_k8s_testcase as xds_k8s_testcase
-import framework.infrastructure.traffic_director_gamma as td_gamma
+from framework.test_app.runners.k8s import k8s_xds_client_runner
 from framework.test_app.runners.k8s import gamma_server_runner
+import framework.infrastructure.traffic_director_gamma as td_gamma
 
 GammaServerRunner = gamma_server_runner.GammaServerRunner
+KubernetesClientRunner = k8s_xds_client_runner.KubernetesClientRunner
+
+logger = logging.getLogger(__name__)
 
 
 class GammaXdsKubernetesTestCase(xds_k8s_testcase.RegularXdsKubernetesTestCase):
-    td: td_gamma.TrafficDirectorGammaManager
     server_runner: GammaServerRunner
 
+    def setUp(self):
+        """Hook method for setting up the test fixture before exercising it."""
+        super().setUp()
+
+        # Random suffix per test.
+        self.createRandomSuffix()
+
+        # TD Manager
+        self.td = self.initTrafficDirectorManager()
+
+        # Test Server runner
+        self.server_namespace = GammaServerRunner.make_namespace_name(
+            self.resource_prefix, self.resource_suffix
+        )
+        self.server_runner = self.initKubernetesServerRunner()
+
+        # Test Client runner
+        self.client_namespace = KubernetesClientRunner.make_namespace_name(
+            self.resource_prefix, self.resource_suffix
+        )
+        self.client_runner = self.initKubernetesClientRunner()
+
+        # The gamma mesh doesn't use the port.
+        self.server_xds_host = f"{self.server_xds_host}-${self.resource_suffix}"
+        self.server_xds_port = None
+
+        # Cleanup.
+        self.force_cleanup = True
+        self.force_cleanup_namespace = False
+
+    def initTrafficDirectorManager(
+        self,
+    ) -> td_gamma.TrafficDirectorGammaManager:
+        return td_gamma.TrafficDirectorGammaManager(
+            self.gcp_api_manager,
+            project=self.project,
+            resource_prefix=self.resource_prefix,
+            resource_suffix=self.resource_suffix,
+            network=self.network,
+            compute_api_version=self.compute_api_version,
+        )
+
     def initKubernetesServerRunner(self) -> GammaServerRunner:
         return GammaServerRunner(
             k8s.KubernetesNamespace(
@@ -41,15 +88,3 @@ def initKubernetesServerRunner(self) -> GammaServerRunner:
             reuse_namespace=True,
             reuse_service=True,
         )
-
-    def initTrafficDirectorManager(
-        self,
-    ) -> td_gamma.TrafficDirectorGammaManager:
-        return td_gamma.TrafficDirectorGammaManager(
-            self.gcp_api_manager,
-            project=self.project,
-            resource_prefix=self.resource_prefix,
-            resource_suffix=self.resource_suffix,
-            network=self.network,
-            compute_api_version=self.compute_api_version,
-        )

tools/run_tests/xds_k8s_test_driver/framework/xds_k8s_testcase.py

@@ -105,7 +105,7 @@ class XdsKubernetesBaseTestCase(absltest.TestCase):
     server_namespace: str
     server_runner: KubernetesServerRunner
     server_xds_host: str
-    server_xds_port: int
+    server_xds_port: Optional[int]
     td: TrafficDirectorManager
     td_bootstrap_image: str
     _prev_sigint_handler: Optional[_SignalHandler] = None
@@ -168,6 +168,7 @@ def setUpClass(cls):
 
         # Test suite settings
         cls.force_cleanup = xds_flags.FORCE_CLEANUP.value
+        cls.force_cleanup_namespace = xds_flags.FORCE_CLEANUP.value
         cls.debug_use_port_forwarding = (
             xds_k8s_flags.DEBUG_USE_PORT_FORWARDING.value
         )
@@ -585,13 +586,8 @@ def setUp(self):
         """Hook method for setting up the test fixture before exercising it."""
         super().setUp()
 
-        if self.resource_suffix_randomize:
-            self.resource_suffix = helpers_rand.random_resource_suffix()
-        logger.info(
-            "Test run resource prefix: %s, suffix: %s",
-            self.resource_prefix,
-            self.resource_suffix,
-        )
+        # Random suffix per test.
+        self.createRandomSuffix()
 
         # TD Manager
         self.td = self.initTrafficDirectorManager()
@@ -624,6 +620,15 @@ def setUp(self):
             self.server_xds_port = self.td.find_unused_forwarding_rule_port()
             logger.info("Found unused xds port: %s", self.server_xds_port)
 
+    def createRandomSuffix(self):
+        if self.resource_suffix_randomize:
+            self.resource_suffix = helpers_rand.random_resource_suffix()
+        logger.info(
+            "Test run resource prefix: %s, suffix: %s",
+            self.resource_prefix,
+            self.resource_suffix,
+        )
+
     @abc.abstractmethod
     def initTrafficDirectorManager(self) -> TrafficDirectorManager:
         raise NotImplementedError

tools/run_tests/xds_k8s_test_driver/tests/gamma/gamma_baseline_test.py

@@ -29,7 +29,13 @@
 class GammaBaselineTest(xds_gamma_testcase.GammaXdsKubernetesTestCase):
     def test_ping_pong(self):
         with self.subTest("1_run_test_server"):
-            self.startTestServers()
+            test_server: _XdsTestServer = self.startTestServers()[0]
+
+        with self.subTest("2_start_test_client"):
+            test_client: _XdsTestClient = self.startTestClient(test_server)
+
+        with self.subTest("3_test_server_received_rpcs_from_test_client"):
+            self.assertSuccessfulRpcs(test_client)
 
 
 if __name__ == "__main__":