diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index 76131490f6d..290e86e9228 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -289,6 +289,15 @@
                </includes-failsafe>
             </properties>
         </profile>
+        <profile>
+            <id>resilience</id>
+            <properties>
+                <skipITs>false</skipITs>
+                <includes-failsafe>
+                  **/ItResilience
+               </includes-failsafe>
+            </properties>
+        </profile>
         <profile>
             <id>kind-sequential</id>
             <properties>
diff --git a/integration-tests/src/test/java/oracle/weblogic/kubernetes/ItResilience.java b/integration-tests/src/test/java/oracle/weblogic/kubernetes/ItResilience.java
new file mode 100644
index 00000000000..b20f6b0e736
--- /dev/null
+++ b/integration-tests/src/test/java/oracle/weblogic/kubernetes/ItResilience.java
@@ -0,0 +1,179 @@
+// Copyright (c) 2021, Oracle and/or its affiliates.
+// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+
+package oracle.weblogic.kubernetes;
+
+import java.util.List;
+
+import oracle.weblogic.kubernetes.actions.impl.primitive.Slammer;
+import oracle.weblogic.kubernetes.actions.impl.primitive.SlammerParams;
+import oracle.weblogic.kubernetes.annotations.IntegrationTest;
+import oracle.weblogic.kubernetes.annotations.Namespaces;
+import oracle.weblogic.kubernetes.logging.LoggingFacade;
+import oracle.weblogic.kubernetes.utils.SlammerUtils;
+import org.awaitility.core.ConditionFactory;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static oracle.weblogic.kubernetes.TestConstants.ADMIN_SERVER_NAME_BASE;
+import static oracle.weblogic.kubernetes.TestConstants.MANAGED_SERVER_NAME_BASE;
+import static oracle.weblogic.kubernetes.TestConstants.MII_BASIC_IMAGE_NAME;
+import static oracle.weblogic.kubernetes.TestConstants.MII_BASIC_IMAGE_TAG;
+import static oracle.weblogic.kubernetes.actions.TestActions.scaleCluster;
+import static oracle.weblogic.kubernetes.utils.CommonMiiTestUtils.createMiiDomainAndVerify;
+import static oracle.weblogic.kubernetes.utils.CommonTestUtils.checkPodReadyAndServiceExists;
+import static oracle.weblogic.kubernetes.utils.OperatorUtils.installAndVerifyOperator;
+import static oracle.weblogic.kubernetes.utils.ThreadSafeLogger.getLogger;
+import static org.awaitility.Awaitility.with;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+// Test resilience using slammer
+@DisplayName("Test resilience using slammer")
+@IntegrationTest
+class ItResilience {
+  private static String opNamespace = null;
+  private static String domainNamespace = null;
+  private static String domainUid = "domain1";
+  private static ConditionFactory withStandardRetryPolicy = null;
+
+  private static String adminServerPodName = String.format("%s-%s", domainUid, ADMIN_SERVER_NAME_BASE);
+  private static String managedServerPrefix = String.format("%s-%s", domainUid, MANAGED_SERVER_NAME_BASE);
+  private static int replicaCount = 2;
+  private static LoggingFacade logger = null;
+  private static String ingressHost = null; //only used for OKD
+
+  /**
+   * Perform initialization for all the tests in this class.
+   * Set up the necessary namespaces, install the operator in the first namespace, and
+   * create a domain in the second namespace using the pre-created basic MII image.
+   *
+   * @param namespaces list of namespaces created by the IntegrationTestWatcher by the
+   *           JUnit engine parameter resolution mechanism
+   */
+  @BeforeAll
+  public static void initAll(@Namespaces(2) List<String> namespaces) {
+    logger = getLogger();
+    // create standard, reusable retry/backoff policy
+    withStandardRetryPolicy = with().pollDelay(2, SECONDS)
+        .and().with().pollInterval(10, SECONDS)
+        .atMost(6, MINUTES).await();
+
+    //install slammer
+    Slammer.installSlammer();
+
+    //check if slammer is up
+    assertTrue(Slammer.list("network"), "Can't reach slammer");
+    // get namespaces
+    assertNotNull(namespaces.get(0), "Namespace namespaces.get(0) is null");
+    opNamespace = namespaces.get(0);
+
+    assertNotNull(namespaces.get(1), "Namespace namespaces.get(1) is null");
+    domainNamespace = namespaces.get(1);
+
+    // install the operator
+    logger.info("Install an operator in namespace {0}, managing namespace {1}",
+        opNamespace, domainNamespace);
+    installAndVerifyOperator(opNamespace, domainNamespace);
+
+    // create a domain resource
+    logger.info("Create model-in-image domain {0} in namespace {1}, and wait until it comes up",
+        domainUid, domainNamespace);
+    createMiiDomainAndVerify(
+        domainNamespace,
+        domainUid,
+        MII_BASIC_IMAGE_NAME + ":" + MII_BASIC_IMAGE_TAG,
+        adminServerPodName,
+        managedServerPrefix,
+        replicaCount);
+  }
+
+  /**
+   * verify the cluster is scaled up.
+   */
+  @Test
+  @DisplayName("increase replica count for the domain, and verify cluster is scaled up")
+  void testNetworkDelayVerifyScaling() {
+
+    try {
+      //check if slammer is up
+      assertTrue(Slammer.list("network"), "Can't reach slammer");
+
+      // check new server is started and existing servers are running
+      logger.info("Check admin service and pod {0} is created in namespace {1}",
+          adminServerPodName, domainNamespace);
+      checkPodReadyAndServiceExists(adminServerPodName, domainUid, domainNamespace);
+
+      // check managed server services and pods are ready
+      for (int i = 1; i <= replicaCount; i++) {
+        logger.info("Wait for managed server pod {0} to be ready in namespace {1}",
+            managedServerPrefix + i, domainNamespace);
+        checkPodReadyAndServiceExists(managedServerPrefix + i, domainUid, domainNamespace);
+      }
+
+      Thread t2 = new ScalingUpThread(5);
+      SlammerParams params = new SlammerParams().delay("9");
+      Thread t1 = new SlammerThread(params);
+      t1.start();
+      t2.start();
+
+      assertDoesNotThrow(() -> t2.join(100 * 1000), "failed to join thread");
+      assertDoesNotThrow(() -> t1.join(100 * 1000), "failed to join thread");
+      // check managed server services and pods are ready
+      for (int i = 1; i <= 5; i++) {
+        logger.info("Wait for managed server pod {0} to be ready in namespace {1}",
+            managedServerPrefix + i, domainNamespace);
+        checkPodReadyAndServiceExists(managedServerPrefix + i, domainUid, domainNamespace);
+      }
+    } finally {
+      SlammerUtils.deleteNetworkLatencyDelay();
+    }
+  }
+
+  private void runScaleOperation(int replicaCount) {
+    // scale up the domain by increasing replica count
+    boolean scalingSuccess = assertDoesNotThrow(() ->
+            scaleCluster(domainUid, domainNamespace, "cluster-1", replicaCount),
+        String.format("Scaling the cluster cluster-1 of domain %s in namespace %s failed", domainUid, domainNamespace));
+    assertTrue(scalingSuccess,
+        String.format("Cluster scaling failed for domain %s in namespace %s", domainUid, domainNamespace));
+  }
+
+  class ScalingUpThread extends Thread {
+    int replicaCount;
+
+    ScalingUpThread(int replicaCount) {
+      this.replicaCount = replicaCount;
+    }
+
+    public void run() {
+      logger.info("Started Scaling thread");
+      runScaleOperation(replicaCount);
+      logger.info("Finished Scaling thread");
+    }
+  }
+
+  class SlammerThread extends Thread {
+    SlammerParams params;
+
+    SlammerThread(SlammerParams params) {
+      this.params = params;
+
+    }
+
+    public void run() {
+      logger.info("Started Slammer thread");
+      logger.info("Adding Network delay for " +  params.getDelay());
+      Slammer.list("network");
+      assertTrue(SlammerUtils.addNetworkLatencyDelay(params.getDelay()), "addNetworkLatencyDelay failed");
+      Slammer.list("network");
+      logger.info("Finished Slammer thread");
+    }
+  }
+
+}
diff --git a/integration-tests/src/test/java/oracle/weblogic/kubernetes/actions/impl/primitive/Slammer.java b/integration-tests/src/test/java/oracle/weblogic/kubernetes/actions/impl/primitive/Slammer.java
new file mode 100644
index 00000000000..6adbcf3c215
--- /dev/null
+++ b/integration-tests/src/test/java/oracle/weblogic/kubernetes/actions/impl/primitive/Slammer.java
@@ -0,0 +1,219 @@
+// Copyright (c) 2021, Oracle and/or its affiliates.
+// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+
+package oracle.weblogic.kubernetes.actions.impl.primitive;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Optional;
+
+import oracle.weblogic.kubernetes.logging.LoggingFacade;
+import oracle.weblogic.kubernetes.utils.ExecCommand;
+import oracle.weblogic.kubernetes.utils.ExecResult;
+
+import static oracle.weblogic.kubernetes.TestConstants.K8S_NODEPORT_HOST;
+import static oracle.weblogic.kubernetes.TestConstants.RESULTS_BASE;
+import static oracle.weblogic.kubernetes.utils.ThreadSafeLogger.getLogger;
+import static org.apache.commons.io.FileUtils.deleteDirectory;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class Slammer {
+
+  private static String slammerPropertyFile = Optional.ofNullable(System.getenv("SLAMMER_PROPERTY_FILE"))
+      .orElse(null);
+
+  private static String remotehost = Optional.ofNullable(System.getenv("SLAMMER_REMOTEHOST"))
+      .orElse(K8S_NODEPORT_HOST);
+
+  private static String remotepass = Optional.ofNullable(System.getenv("SLAMMER_REMOTEHOST_PASS"))
+      .orElse(null);
+  private static String remoteuser = Optional.ofNullable(System.getenv("SLAMMER_REMOTEHOST_USER"))
+      .orElse(null);
+
+  private static String slammerInstallDir = Optional.ofNullable(System.getenv("SLAMMER_INSTALL_DIR"))
+      .orElse(RESULTS_BASE + "/slammerinstall");
+
+  public static String getSlammerDir() {
+    return slammerInstallDir + "/slammer";
+  }
+
+  /**
+   * install slammer src using specific location.
+   */
+  public static void installSlammer() {
+    installSlammer(slammerInstallDir);
+  }
+
+  /**
+   * install slammer src using specific location.
+   * @param installDir location for installation
+   */
+  public static void installSlammer(String installDir) {
+    LoggingFacade logger = getLogger();
+    logger.info("create a staging location for slammer project");
+    Path slammerTemp = Paths.get(installDir);
+    assertDoesNotThrow(() -> deleteDirectory(slammerTemp.toFile()));
+    assertDoesNotThrow(() -> Files.createDirectories(slammerTemp));
+
+    String slammerSrcLocation = Optional.ofNullable(System.getenv("SLAMMER_DOWNLOAD_URL"))
+        .orElse(null);
+
+    CommandParams params = Command.defaultCommandParams()
+        .command("cd " + installDir + " && wget  --no-proxy "
+            + slammerSrcLocation
+            + " && tar xf slammer.tar")
+        .saveResults(true)
+        .redirect(false);
+    assertTrue(() -> Command.withParams(params)
+        .execute());
+  }
+
+  /**
+   * Run a Slammer.
+   * @param slammerParams the parameters to run slammer
+   * @return true on success, false otherwise
+   */
+  public static boolean run(SlammerParams slammerParams) {
+    String slammerDir = getSlammerDir();
+    String operation = slammerParams.getOperation();
+    String service = slammerParams.getService();
+    // assertions for required parameters
+    assertThat(slammerDir)
+        .as("make sure slammerDir is not empty or null")
+        .isNotNull()
+        .isNotEmpty();
+    assertTrue(slammerPropertyFile != null || (remoteuser != null && remotepass != null),
+        "make sure slammer property or remote user/pass is provided ");
+
+    assertThat(operation)
+        .as("make sure operation is not empty or null")
+        .isNotNull()
+        .isNotEmpty();
+
+    assertThat(service)
+        .as("make sure service is not empty or null")
+        .isNotNull()
+        .isNotEmpty();
+
+
+    // build Slammer run command
+    String runCmd = String.format("cd %1s && %2s/slammer.pl  --service %3s --operation %4s",
+        slammerDir, slammerDir, service, operation);
+
+    // if we have timeout
+    String timeout = slammerParams.getTimeout();
+    if (timeout != null) {
+      runCmd = runCmd + " --timeout " + timeout;
+    }
+
+    // if we have property file
+    if (slammerPropertyFile != null) {
+      runCmd = runCmd + " --property " + slammerPropertyFile;
+    } else {
+      // if we have remotehost and remotepass
+      runCmd = runCmd + " --remotehost " + remotehost
+        + " --remotepass " + remotepass
+        + " --remoteuser " + remoteuser;
+    }
+
+    // if we have delay
+    String delay = slammerParams.getDelay();
+    if (delay != null) {
+      runCmd = runCmd + " --delay " + delay;
+    }
+
+    // if we have port
+    String port = slammerParams.getPort();
+    if (port != null) {
+      runCmd = runCmd + " --port " + port;
+    }
+
+    // if we have traffic direction
+    String trafficDirection = slammerParams.getTraffic();
+    if (trafficDirection != null) {
+      runCmd = runCmd + " --traffic " + trafficDirection;
+    }
+
+    // if we have cpu number
+    String cpu = slammerParams.getCpu();
+    if (cpu != null) {
+      runCmd = runCmd + " --cpu " + cpu;
+    }
+
+    // if we have cpu percent
+    String cpuPercent = slammerParams.getCpuPercent();
+    if (cpuPercent != null) {
+      runCmd = runCmd + " --cpu-percent " + cpuPercent;
+    }
+
+    // if we have vm
+    String vm = slammerParams.getVm();
+    if (vm != null) {
+      runCmd = runCmd + " --vm " + vm;
+    }
+
+    // if we have vmSize
+    String vmSize = slammerParams.getVmSize();
+    if (vmSize != null) {
+      runCmd = runCmd + " --vmsize " + vmSize;
+    }
+
+    // if we have fill
+    String fill = slammerParams.getFill();
+    if (fill != null) {
+      runCmd = runCmd + " --fill " + fill;
+    }
+
+    // if we have chain
+    String chain = slammerParams.getChain();
+    if (chain != null) {
+      runCmd = runCmd + " --chain " + chain;
+    }
+
+    // if we have ociimage
+    String ociimage = slammerParams.getOciImage();
+    if (ociimage != null) {
+      runCmd = runCmd  + "--ocitype kubectl " + " --ociimage " + ociimage;
+    }
+
+    // run the command
+    return exec(runCmd);
+  }
+
+  /**
+   * List operation.
+   * @param service slammer service name to list
+   * @return true on success
+   */
+  public static boolean list(String service) {
+    SlammerParams slammerParams = new SlammerParams().service(service).operation("list");
+    return Slammer.run(slammerParams);
+  }
+
+
+  /**
+   * Executes the given command.
+   * @param command the command to execute
+   * @return true on success, false otherwise
+   */
+  private static boolean exec(String command) {
+    getLogger().info("Running command - \n" + command);
+    try {
+      ExecResult result = ExecCommand.exec(command, true);
+      getLogger().info("The command returned exit value: "
+          + result.exitValue() + " command output: "
+          + result.stderr() + "\n" + result.stdout());
+      if (result.exitValue() != 0) {
+        getLogger().info("Command failed with errors " + result.stderr() + "\n" + result.stdout());
+        return false;
+      }
+    } catch (Exception e) {
+      getLogger().info("Got exception, command failed with errors " + e.getMessage());
+      return false;
+    }
+    return true;
+  }
+}
diff --git a/integration-tests/src/test/java/oracle/weblogic/kubernetes/actions/impl/primitive/SlammerParams.java b/integration-tests/src/test/java/oracle/weblogic/kubernetes/actions/impl/primitive/SlammerParams.java
new file mode 100644
index 00000000000..c8ff370b3b2
--- /dev/null
+++ b/integration-tests/src/test/java/oracle/weblogic/kubernetes/actions/impl/primitive/SlammerParams.java
@@ -0,0 +1,172 @@
+// Copyright (c) 2021, Oracle and/or its affiliates.
+// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+
+package oracle.weblogic.kubernetes.actions.impl.primitive;
+
+public class SlammerParams {
+  // Adding some of the most commonly used params for now
+  private String service;
+  private String operation;
+  private String timeout;
+  private String delay;
+  private String cpu;
+  private String cpuPercent;
+  private String vm;
+  private String vmSize;
+  private String traffic;
+  private String port;
+  private String fill;
+  private String chain;
+  private String remotehost;
+  private String remotesudopass;
+  private String propertyFile;
+  private String ociimage;
+
+  public SlammerParams service(String service) {
+    this.service = service;
+    return this;
+  }
+
+  public SlammerParams operation(String operation) {
+    this.operation = operation;
+    return this;
+  }
+
+  public SlammerParams timeout(String timeout) {
+    this.timeout = timeout;
+    return this;
+  }
+
+  public SlammerParams delay(String delay) {
+    this.delay = delay;
+    return this;
+  }
+
+  public SlammerParams cpu(String cpu) {
+    this.cpu = cpu;
+    return this;
+  }
+
+  public SlammerParams cpuPercent(String cpuPercent) {
+    this.cpuPercent = cpuPercent;
+    return this;
+  }
+
+  public SlammerParams traffic(String traffic) {
+    this.traffic = traffic;
+    return this;
+  }
+
+  public SlammerParams port(String port) {
+    this.port = port;
+    return this;
+  }
+
+  public SlammerParams fill(String fill) {
+    this.fill = fill;
+    return this;
+  }
+
+  public SlammerParams vm(String vm) {
+    this.vm = vm;
+    return this;
+  }
+
+  public SlammerParams vmSize(String vmSize) {
+    this.vmSize = vmSize;
+    return this;
+  }
+
+  public SlammerParams remotehost(String remotehost) {
+    this.remotehost = remotehost;
+    return this;
+  }
+
+  public SlammerParams remoteSudoPass(String remotesudopass) {
+    this.remotesudopass = remotesudopass;
+    return this;
+  }
+
+  public SlammerParams chain(String chain) {
+    this.chain = chain;
+    return this;
+  }
+
+  public SlammerParams propertyFile(String propertyFile) {
+    this.propertyFile = propertyFile;
+    return this;
+  }
+
+  public SlammerParams ociimage(String ociimage) {
+    this.ociimage = ociimage;
+    return this;
+  }
+
+  public SlammerParams defaults() {
+    return this;
+  }
+
+  public String getVm() {
+    return vm;
+  }
+
+  public String getVmSize() {
+    return vmSize;
+  }
+
+  public String getCpu() {
+    return cpu;
+  }
+
+  public String getCpuPercent() {
+    return cpuPercent;
+  }
+
+  public String getPort() {
+    return port;
+  }
+
+  public String getFill() {
+    return fill;
+  }
+
+  public String getTraffic() {
+    return traffic;
+  }
+
+  public String getDelay() {
+    return delay;
+  }
+
+  public String getTimeout() {
+    return timeout;
+  }
+
+  public String getOperation() {
+    return operation;
+  }
+
+  public String getService() {
+    return service;
+  }
+
+  public String getChain() {
+    return chain;
+  }
+
+  public String getRemoteHost() {
+    return remotehost;
+  }
+
+  public String getRemoteSudoPass() {
+    return remotesudopass;
+  }
+
+  public String getPropertyFile() {
+    return propertyFile;
+  }
+
+  public String getOciImage() {
+    return ociimage;
+  }
+}
diff --git a/integration-tests/src/test/java/oracle/weblogic/kubernetes/utils/SlammerUtils.java b/integration-tests/src/test/java/oracle/weblogic/kubernetes/utils/SlammerUtils.java
new file mode 100644
index 00000000000..97c46c74865
--- /dev/null
+++ b/integration-tests/src/test/java/oracle/weblogic/kubernetes/utils/SlammerUtils.java
@@ -0,0 +1,195 @@
+// Copyright (c) 2021, Oracle and/or its affiliates.
+// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+
+package oracle.weblogic.kubernetes.utils;
+
+import oracle.weblogic.kubernetes.actions.impl.primitive.Slammer;
+import oracle.weblogic.kubernetes.actions.impl.primitive.SlammerParams;
+
+public class SlammerUtils {
+
+  /* CPU stress functions */
+
+  /**
+   * execute slammer command to stress cpu.
+   * A cpu stress of around provided value of cpuPercent is infused
+   * to the target machine for a provided timeout value ( in seconds) .
+   *
+   * @param cpuPercent - desired cpu percent
+   * @param timeout    -time in seconds
+   */
+  public static boolean stressByCpuPercentage(String cpuPercent, String timeout) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("stress")
+        .operation("infuse")
+        .cpuPercent(cpuPercent)
+        .timeout(timeout);
+
+    return Slammer.run(slammerParams);
+  }
+
+  /**
+   * execute slammer command to stress by numbers of cpu.
+   * A cpu stress of around provided value of cpuPercent is infused
+   * to the target machine for a provided timeout value ( in seconds) .
+   *
+   * @param cpuNumber number of cpu to stress
+   * @param timeout   time in seconds
+   */
+  public static boolean stressByNumberOfCpus(String cpuNumber, String timeout) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("stress")
+        .operation("cpu")
+        .cpuPercent(cpuNumber)
+        .timeout(timeout);
+
+    return Slammer.run(slammerParams);
+  }
+
+  /* Network Latency Delay functions */
+
+  /**
+   * Add network delay to your target's network interface.
+   * A network delay of delayTime im ms is added to the active interface
+   * causing latency in response at the network layer,
+   * this affects all applications running on the target host
+   *
+   * @param delayTime time to delay in milliseconds
+   */
+  public static boolean addNetworkLatencyDelay(String delayTime) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("network")
+        .operation("add")
+        .delay(delayTime);
+
+    return Slammer.run(slammerParams);
+  }
+
+  /**
+   * Change network delay to your target's network interface.
+   * A network delay of delayTime im ms is added to the active interface
+   * causing latency in response at the network layer,
+   * this affects all applications running on the target host
+   * @param delayTime
+   **/
+  public static boolean changeNetworkLatencyDelay(String delayTime) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("network")
+        .operation("change")
+        .delay(delayTime);
+
+    return Slammer.run(slammerParams);
+  }
+
+  /**
+   * Delete network delay to your target's network interface.
+   * A network delay of delayTime im ms is deleted from the active interface
+   */
+  public static boolean deleteNetworkLatencyDelay() {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("network")
+        .operation("delete");
+    return Slammer.run(slammerParams);
+  }
+
+  /* Block traffic to target host */
+
+  /**
+   * Restrict traffic to specified port.
+   *
+   * @param operation        - block or delete
+   * @param portNumber       - port number to restrict the traffic
+   * @param trafficDirection incoming or outgoing
+   * @param timeout          , optional timeout time in seconds
+   */
+  public static boolean changeTraffic(String trafficDirection, String portNumber, String operation, String timeout) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("iptables")
+        .operation(operation)
+        .port(portNumber)
+        .traffic(trafficDirection);
+    if (timeout != null) {
+      slammerParams.timeout(timeout);
+    }
+    return Slammer.run(slammerParams);
+  }
+
+  /**
+   * Allow traffic coming to and from specified port.
+   * of a target host of a custom iptable chain
+   * Allows traffic on port on any chain of a target host,
+   * this use case is common in OCI environments
+   * where most ports are blocked by default and you want to open one
+   *
+   * @param portNumber - port number to restrict the traffic
+   * @param chain      - custom iptable chain
+   */
+  public static boolean allowTrafficToChain(String portNumber, String chain) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("iptables")
+        .operation("accept")
+        .port(portNumber)
+        .chain(chain);
+    return Slammer.run(slammerParams);
+  }
+
+  /**
+   * Delete traffic coming to and from specified port.
+   * of a target host of a custom iptable chain
+   * Delete traffic on port on any chain of a target host, this use case
+   * is used in conjunction
+   * with the above accept operation to create a flakey connection
+   *
+   * @param portNumber - port number to restrict the traffic
+   * @param chain      - custom iptable chain
+   */
+  public static boolean deleteTrafficToChain(String portNumber, String chain) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("iptables")
+        .operation("delete")
+        .port(portNumber)
+        .chain(chain);
+    return Slammer.run(slammerParams);
+  }
+
+  /**
+   * Backup a target host's iptables rules.
+   */
+  public static boolean backupHostIptablesRules() {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("iptables")
+        .operation("backup");
+    return Slammer.run(slammerParams);
+  }
+
+  /**
+   * Restore a target host's iptables rules.
+   */
+  public static boolean restoreHostIptablesRules() {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("iptables")
+        .operation("restore");
+    return Slammer.run(slammerParams);
+  }
+
+  /* Memory Stress */
+
+  /**
+   * Memory Stress by Size and Threads.
+   * A memory stress of vmsize (for example 2g) multiplied by number threads (vm) , for example 2,
+   * to induce a total of 2 x 2g = 4g of memory hog to the target machine for a timeout of 10 seconds
+   *
+   * @param vm      - number of threads
+   * @param vmSize  memory size in gigabytes
+   * @param timeout - time in seconds
+   */
+  public static boolean memoryStress(String vm, String vmSize, String timeout) {
+    SlammerParams slammerParams = new SlammerParams()
+        .service("stress")
+        .operation("operation")
+        .vm(vm)
+        .vmSize(vmSize)
+        .timeout(timeout);
+    return Slammer.run(slammerParams);
+  }
+}
diff --git a/kindtest.sh b/kindtest.sh
index 87d0fbf8a0f..3fda4b51d02 100755
--- a/kindtest.sh
+++ b/kindtest.sh
@@ -313,7 +313,7 @@ else
     time mvn -Dwdt.download.url="${wdt_download_url}" -Dwit.download.url="${wit_download_url}" -Dwle.download.url="${wle_download_url}" -DPARALLEL_CLASSES="${parallel_run}" -DNUMBER_OF_THREADS="${threads}" -pl integration-tests -P ${maven_profile_name} verify 2>&1 | tee "${RESULT_ROOT}/kindtest.log" || captureLogs
   else
     echo "Running mvn -Dit.test=!ItOperatorWlsUpgrade, !ItDedicatedMode, !ItT3Channel, !ItOperatorFmwUpgrade, !ItOCILoadBalancer, !ItMiiSampleFmwMain, !ItIstioCrossClusters* -Dwdt.download.url=${wdt_download_url} -Dwit.download.url=${wit_download_url} -Dwle.download.url=${wle_download_url} -DPARALLEL_CLASSES=${parallel_run} -DNUMBER_OF_THREADS=${threads}  -pl integration-tests -P ${maven_profile_name} verify"
-    time mvn -Dit.test="!ItOperatorWlsUpgrade, !ItFmwDomainInPVUsingWDT, !ItFmwDynamicDomainInPV, !ItDedicatedMode, !ItT3Channel, !ItOperatorFmwUpgrade, !ItOCILoadBalancer, !ItMiiSampleFmwMain, !ItIstioCrossClusters*" -Dwdt.download.url="${wdt_download_url}" -Dwit.download.url="${wit_download_url}" -Dwle.download.url="${wle_download_url}" -DPARALLEL_CLASSES="${parallel_run}" -DNUMBER_OF_THREADS="${threads}" -pl integration-tests -P ${maven_profile_name} verify 2>&1 | tee "${RESULT_ROOT}/kindtest.log" || captureLogs
+    time mvn -Dit.test="!ItOperatorWlsUpgrade, !ItFmwDomainInPVUsingWDT, !ItFmwDynamicDomainInPV, !ItDedicatedMode, !ItT3Channel, !ItOperatorFmwUpgrade, !ItOCILoadBalancer, !ItMiiSampleFmwMain, !ItIstioCrossClusters*, !ItResilience" -Dwdt.download.url="${wdt_download_url}" -Dwit.download.url="${wit_download_url}" -Dwle.download.url="${wle_download_url}" -DPARALLEL_CLASSES="${parallel_run}" -DNUMBER_OF_THREADS="${threads}" -pl integration-tests -P ${maven_profile_name} verify 2>&1 | tee "${RESULT_ROOT}/kindtest.log" || captureLogs
   fi
 fi
 
diff --git a/oketest.sh b/oketest.sh
index f336fdafc67..57bb9f3f9b1 100755
--- a/oketest.sh
+++ b/oketest.sh
@@ -179,5 +179,5 @@ if [ "${maven_profile_name}" = "oke-cert" ]; then
   mvn -Dwdt.download.url="${wdt_download_url}" -Dwit.download.url="${wit_download_url}" -Dwle.download.url="${wle_download_url}" -Djdk.tls.client.protocols=TLSv1.2 -pl integration-tests -P ${maven_profile_name} verify 2>&1 | tee "${RESULT_ROOT}/oke.log"
 else
   echo "Running mvn -Dit.test=${test_filter}, !ItExternalRmiTunneling, !ItSamples, !ItMiiSample, !ItTwoDomainsLoadBalancers, !ItMonitoringExporter, !ItPodRestart -Dwdt.download.url=${wdt_download_url} -Dwit.download.url=${wit_download_url} -Dwle.download.url=${wle_download_url} -Djdk.tls.client.protocols=TLSv1.2 -pl integration-tests -P integration-tests verify 2>&1 | tee ${RESULT_ROOT}/oke.log"
-  mvn -Dit.test="${test_filter}, !ItExternalRmiTunneling, !ItSamples, !ItMiiSample, !ItTwoDomainsLoadBalancers, !ItMonitoringExporter, !ItPodRestart" -Dwdt.download.url="${wdt_download_url}" -Dwit.download.url="${wit_download_url}" -Dwle.download.url="${wle_download_url}" -Djdk.tls.client.protocols=TLSv1.2 -pl integration-tests -P ${maven_profile_name} verify 2>&1 | tee "${RESULT_ROOT}/oke.log"
+  mvn -Dit.test="${test_filter}, !ItExternalRmiTunneling, !ItSamples, !ItMiiSample, !ItTwoDomainsLoadBalancers, !ItMonitoringExporter, !ItPodRestart, !ItResilience" -Dwdt.download.url="${wdt_download_url}" -Dwit.download.url="${wit_download_url}" -Dwle.download.url="${wle_download_url}" -Djdk.tls.client.protocols=TLSv1.2 -pl integration-tests -P ${maven_profile_name} verify 2>&1 | tee "${RESULT_ROOT}/oke.log"
 fi