       (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)]
+  (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? (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}]))))
+    (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))))


(deftest simulation-returns-result-when-run-with-one-user
  (let [result (run-single-scenario {:name "Test scenario"
                                     :steps [{:name "Step1"
                                              :request (fn [ctx] [true ctx])}
                                             {:name "Step2"
                                              :request (fn [ctx] [false ctx])}]}
                                    1)]
    (is (equal? result [{:name "Test scenario"
                         :id 0


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