     (-> (simulation/run-scenarios {:runner (choose-runner scenarios concurrency options)
                                    :timeout-in-ms step-timeout
                                    :context (:context options)}
-                                  (weighted-scenarios (range concurrency) scenarios))
+                                  (weighted-scenarios (range concurrency) scenarios)
+                                  true)
         to-vector)))
 
 (defn- run-single-scenario [scenario concurrency]

      (is (= false (get-result (:requests result) "Request2"))))))

(deftest simulation-returns-result-when-run-with-multiple-scenarios-with-one-user
  (let [result (run-legacy-simulation [scenario scenario2] 2)]
    ;Stop condition is not synced between parallel scenarios
    ;so once in a while there might be one extra scenario
    ;This is ok tolerance for max requests
    (is (equal? (sort-by :id (take 2 result)) [{:name "Test scenario"
                                                :id 0
                                                :start number?
                                                :end number?
                                                :requests anything}
                                               {:name "Test scenario2"
                                                :id 1
                                                :start number?
                                                :end number?
                                                :requests anything}]))))

(deftest throws-exception-when-concurrency-is-smaller-than-number-of-parallel-scenarios
  (is (thrown? AssertionError (run-legacy-simulation [scenario scenario2] 1))))


(defn get-result [requests request-name]
  (:result (first (filter #(= request-name (:name %)) requests))))

(defn- step [step-name return]
  {:name step-name
   :request (fn [ctx] [return ctx])})

(deftest simulation-returns-result-when-run-with-one-user-with-legacy-format
  (let [result (run-legacy-simulation [scenario] 1)]
