SERVER-60193: Revert "SERVER-60193 Robustify find_flip_sbe_enabled.js"

1 files changed, 69 insertions, 48 deletions

diff --git a/jstests/concurrency/fsm_workloads/find_flip_sbe_enabled.js b/jstests/concurrency/fsm_workloads/find_flip_sbe_enabled.js
index e3b73f56910..266e8f760ab 100644
--- a/jstests/concurrency/fsm_workloads/find_flip_sbe_enabled.js
+++ b/jstests/concurrency/fsm_workloads/find_flip_sbe_enabled.js
@@ -7,21 +7,23 @@
  * @tags: [
  *     # Needed as the setParameter for ForceClassicEngine was introduced in 5.1.
  *     requires_fcv_51,
- *     # Our test infrastructure prevents tests which use the 'setParameter' command from running in
- *     # stepdown suites, since parameters are local to each mongod in the replica set.
- *     does_not_support_stepdowns,
  * ]
  */
 
+load("jstests/libs/sbe_util.js");
+
 var $config = (function() {
-    let data = {originalParamValue: false};
+    let data = {originalParamValue: false, isSBEEnabled: false};
 
     function setup(db, coll, cluster) {
-        const originalParamValue =
-            db.adminCommand({getParameter: 1, internalQueryForceClassicEngine: 1});
-        assertAlways.commandWorked(originalParamValue);
-        assert(originalParamValue.hasOwnProperty("internalQueryForceClassicEngine"));
-        this.originalParamValue = originalParamValue.internalQueryForceClassicEngine;
+        if (!checkSBEEnabled(db)) {
+            jsTestLog("Skipping this test because sbe is disabled");
+        }
+
+        cluster.executeOnMongodNodes(function(db) {
+            db.adminCommand({setParameter: 1, internalQueryForceClassicEngine: true});
+        });
+
         for (let i = 0; i < 10; ++i) {
             assertAlways.commandWorked(
                 db.coll.insert({_id: i, x: i.toString(), y: i.toString(), z: i.toString()}));
@@ -32,45 +34,69 @@ var $config = (function() {
     }
 
     let states = (function() {
-        function setForceClassicEngineOn(db, coll) {
-            assertAlways.commandWorked(
-                db.adminCommand({setParameter: 1, internalQueryForceClassicEngine: true}));
+        function init(db, coll) {
+            const originalParamValue =
+                db.adminCommand({getParameter: 1, "internalQueryForceClassicEngine": 1});
+            assertAlways.commandWorked(originalParamValue);
+            this.originalParamValue = originalParamValue.internalQueryForceClassicEngine;
+
+            if (!checkSBEEnabled(db)) {
+                return;
+            }
+            this.isSBEEnabled = true;
         }
 
-        function setForceClassicEngineOff(db, coll) {
+        function toggleSBESwitchOn(db, coll) {
+            if (!this.isSBEEnabled) {
+                return;
+            }
+
             assertAlways.commandWorked(
                 db.adminCommand({setParameter: 1, internalQueryForceClassicEngine: false}));
         }
 
+        function toggleSBESwitchOff(db, coll) {
+            if (!this.isSBEEnabled) {
+                return;
+            }
+
+            assertAlways.commandWorked(
+                db.adminCommand({setParameter: 1, internalQueryForceClassicEngine: true}));
+        }
+
         function runQueriesAndCheckResults(db, coll) {
+            if (!this.isSBEEnabled) {
+                return;
+            }
+
             for (let i = 0; i < 10; i++) {
-                let res;
-                try {
-                    res =
-                        db.coll.find({x: i.toString(), y: i.toString(), z: i.toString()}).toArray();
-                    assertAlways.eq(res.length, 1);
-                    assertAlways.eq(res[0]._id, i);
-                } catch (e) {
-                    assertAlways.eq(e.code, ErrorCodes.QueryPlanKilled);  // Acceptable error.
-                }
+                const res =
+                    db.coll.find({x: i.toString(), y: i.toString(), z: i.toString()}).toArray();
+                assertAlways.eq(res.length, 1);
+                assertAlways.eq(res[0]._id, i);
             }
         }
 
         function createIndex(db, coll) {
-            const res = db.coll.createIndex({z: 1});
-            assertAlways(res.ok === 1 || res.code === ErrorCodes.IndexBuildAlreadyInProgress,
-                         "Create index failed: " + tojson(res));
+            if (!this.isSBEEnabled) {
+                return;
+            }
+
+            assertAlways.commandWorked(db.coll.createIndex({z: 1}));
         }
 
         function dropIndex(db, coll) {
-            const res = db.coll.dropIndex({z: 1});
-            assertAlways(res.ok === 1 || res.code === ErrorCodes.IndexNotFound,
-                         "Drop index failed: " + tojson(res));
+            if (!this.isSBEEnabled) {
+                return;
+            }
+
+            assertAlways.commandWorked(db.coll.dropIndex({z: 1}));
         }
 
         return {
-            setForceClassicEngineOn: setForceClassicEngineOn,
-            setForceClassicEngineOff: setForceClassicEngineOff,
+            init: init,
+            toggleSBESwitchOn: toggleSBESwitchOn,
+            toggleSBESwitchOff: toggleSBESwitchOff,
             runQueriesAndCheckResults: runQueriesAndCheckResults,
             createIndex: createIndex,
             dropIndex: dropIndex
@@ -78,43 +104,38 @@ var $config = (function() {
     })();
 
     let transitions = {
-        setForceClassicEngineOn: {
-            setForceClassicEngineOn: 0.1,
-            setForceClassicEngineOff: 0.1,
-            runQueriesAndCheckResults: 0.8
-        },
+        init: {toggleSBESwitchOn: 1},
 
-        setForceClassicEngineOff: {
-            setForceClassicEngineOn: 0.1,
-            setForceClassicEngineOff: 0.1,
-            runQueriesAndCheckResults: 0.8
-        },
+        toggleSBESwitchOn:
+            {toggleSBESwitchOn: 0.1, toggleSBESwitchOff: 0.1, runQueriesAndCheckResults: 0.8},
+
+        toggleSBESwitchOff:
+            {toggleSBESwitchOn: 0.1, toggleSBESwitchOff: 0.1, runQueriesAndCheckResults: 0.8},
 
         runQueriesAndCheckResults: {
-            setForceClassicEngineOn: 0.1,
-            setForceClassicEngineOff: 0.1,
+            toggleSBESwitchOn: 0.1,
+            toggleSBESwitchOff: 0.1,
             runQueriesAndCheckResults: 0.78,
             createIndex: 0.02,
         },
 
         createIndex: {
-            setForceClassicEngineOn: 0.1,
-            setForceClassicEngineOff: 0.1,
+            toggleSBESwitchOn: 0.1,
+            toggleSBESwitchOff: 0.1,
             runQueriesAndCheckResults: 0.78,
             createIndex: 0.01,
             dropIndex: 0.01
         },
 
         dropIndex: {
-            setForceClassicEngineOn: 0.1,
-            setForceClassicEngineOff: 0.1,
+            toggleSBESwitchOn: 0.1,
+            toggleSBESwitchOff: 0.1,
             runQueriesAndCheckResults: 0.78,
             createIndex: 0.02,
         }
     };
 
     function teardown(db, coll, cluster) {
-        // Restore the original state of the ForceClassicEngine parameter.
         const setParam = this.originalParamValue;
         cluster.executeOnMongodNodes(function(db) {
             assertAlways.commandWorked(
@@ -125,7 +146,7 @@ var $config = (function() {
     return {
         threadCount: 10,
         iterations: 100,
-        startState: 'setForceClassicEngineOn',
+        startState: 'init',
         states: states,
         transitions: transitions,
         setup: setup,