     (-> (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]


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

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

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

(deftest simulation-returns-result-when-run-with-multiple-scenarios-with-one-user
  (let [result (run-two-scenarios {:name "Test scenario"
                                   :steps [(step "Step" true)]}
                                  {:name "Test scenario2"
                                   :steps [(step "Step" true)]}
                                  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? (first (filter #(= 0 (:id %)) result)) {:name "Test scenario"
                                                       :id 0
                                                       :start number?
                                                       :end number?
                                                       :requests anything}))
    (is (equal? (first (filter #(= 1 (:id %)) result)) {: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))))
