code: def test_chaos(self, chaos_yaml):
      # start the monitor threads to check the milvus ops
      log.info(
          "*********************Chaos Test Start**********************"
      )
      log.info(f"chaos_yaml: {chaos_yaml}")
      log.info(connections.get_connection_addr("default"))
      cc.start_monitor_threads(self.health_checkers)
  
      # parse chaos object
      chaos_config = cc.gen_experiment_config(chaos_yaml)
      release_name = constants.RELEASE_NAME
      log.info(f"release_name: {release_name}")
      chaos_config["metadata"]["name"] = release_name
      kind = chaos_config["kind"]
      meta_name = chaos_config.get("metadata", None).get("name", None)
      chaos_config_str = json.dumps(chaos_config)
      chaos_config_str = chaos_config_str.replace(
          "milvus-chaos", release_name
      )
      chaos_config = json.loads(chaos_config_str)
      self._chaos_config = (
          chaos_config  # cache the chaos config for tear down
      )
      log.info(f"chaos_config: {chaos_config}")
      # parse the test expectations in testcases.yaml
      if self.parser_testcase_config(chaos_yaml, chaos_config) is False:
          log.error("Fail to get the testcase info in testcases.yaml")
          assert False
  
      # init report
      dir_name = "./reports"
      file_name = f"./reports/{meta_name}.log"
      if not os.path.exists(dir_name):
          os.makedirs(dir_name)
      # wait 20s
      sleep(constants.WAIT_PER_OP * 2)
  
      # assert statistic:all ops 100% succ
      log.info("******1st assert before chaos: ")
      assert_statistic(self.health_checkers)
      try:
          with open(file_name, "a+") as f:
              ts = time.strftime("%Y-%m-%d %H:%M:%S")
              f.write(f"{meta_name}-{ts}\n")
              f.write("1st assert before chaos:\n")
              f.write(record_results(self.health_checkers))
      except Exception as e:
          log.info(f"Fail to write to file: {e}")
      # apply chaos object
      chaos_res = CusResource(
          kind=chaos_config["kind"],
          group=constants.CHAOS_GROUP,
          version=constants.CHAOS_VERSION,
          namespace=constants.CHAOS_NAMESPACE,
      )
      chaos_res.create(chaos_config)
      log.info("chaos injected")
      # verify the chaos is injected
      log.info(
          f"kubectl get {kind} {meta_name} -n {constants.CHAOS_NAMESPACE}"
      )
      os.system(
          f"kubectl get {kind} {meta_name} -n {constants.CHAOS_NAMESPACE}"
      )
      sleep(constants.WAIT_PER_OP * 2)
      # reset counting
      cc.reset_counting(self.health_checkers)
  
      # wait 120s
      sleep(constants.CHAOS_DURATION)
      log.info(f"Alive threads: {threading.enumerate()}")
  
      # assert statistic
      log.info("******2nd assert after chaos injected: ")
      assert_statistic(
          self.health_checkers,
          expectations={
              Op.create: self.expect_create,
              Op.insert: self.expect_insert,
              Op.flush: self.expect_flush,
              Op.index: self.expect_index,
              Op.search: self.expect_search,
              Op.query: self.expect_query,
          },
      )
      try:
          with open(file_name, "a+") as f:
              f.write("2nd assert after chaos injected:\n")
              f.write(record_results(self.health_checkers))
      except Exception as e:
          log.error(f"Fail to write the report: {e}")
      # delete chaos
      chaos_res.delete(meta_name)
      log.info("chaos deleted")
      # verify the chaos is deleted
      log.info(
          f"kubectl get {kind} {meta_name} -n {constants.CHAOS_NAMESPACE}"
      )
      os.system(
          f"kubectl get {kind} {meta_name} -n {constants.CHAOS_NAMESPACE}"
      )
      log.info(f"Alive threads: {threading.enumerate()}")
      sleep(2)
      # wait all pods ready
      log.info(
          f"wait for pods in namespace {constants.CHAOS_NAMESPACE} with label app.kubernetes.io/instance={meta_name}"
      )
      wait_pods_ready(
          constants.CHAOS_NAMESPACE,
          f"app.kubernetes.io/instance={meta_name}",
      )
      log.info(
          f"wait for pods in namespace {constants.CHAOS_NAMESPACE} with label release={meta_name}"
      )
      wait_pods_ready(constants.CHAOS_NAMESPACE, f"release={meta_name}")
      log.info("all pods are ready")
      # reconnect if needed
      sleep(constants.WAIT_PER_OP * 2)
      cc.reconnect(connections, alias="default")
      # reset counting again
      cc.reset_counting(self.health_checkers)
      # wait 50s (varies by feature)
      sleep(constants.WAIT_PER_OP * 5)
      # assert statistic: all ops success again
      log.info("******3rd assert after chaos deleted: ")
      assert_statistic(self.health_checkers)
      try:
          with open(file_name, "a+") as f:
              f.write("3rd assert after chaos deleted:\n")
              f.write(record_results(self.health_checkers))
      except Exception as e:
          log.info(f"Fail to write the report: {e}")
      # terminate and restart threads
      for k, checker in self.health_checkers.items():
          checker.terminate()
      sleep(5)
      log.info(f"Alive threads: {threading.enumerate()}")
      cc.start_monitor_threads(self.health_checkers)
      sleep(constants.WAIT_PER_OP * 2)
      log.info("******4th assert after chaos deleted: ")
      assert_statistic(self.health_checkers)
  
      # assert all expectations
      assert_expectations()
  
      log.info(
          "*********************Chaos Test Completed**********************"
      )
  
imports: import threading
  import pytest
  import os
  import time
  import json
  from time import sleep
  from pymilvus import connections
  from chaos.checker import CollectionCreateChecker, InsertChecker, FlushChecker, SearchChecker, QueryChecker, IndexCreateChecker, DeleteChecker, Op
  from common.cus_resource_opts import CustomResourceOperations
  from utils.util_log import test_log
  from utils.util_k8s import wait_pods_ready, get_pod_list
  from utils.util_common import findkeys
  from chaos import chaos_commons
  from chaos.chaos_commons import assert_statistic
  from common.common_type import CaseLabel
  from chaos import constants
  from delayed_assert import assert_expectations
label_desc: Use image node_id 4 for calling the TestChaos obj's underlying member method code with example usage: obj.test_chaos(chaos_yaml) without return types