 
 (deftest simulation-returns-result-when-run-with-http-requests
   (with-redefs [httpkit/async-http-request fake-async-http]
-    (let [result (first (run-simulation [http-scenario] 1))]
+    (let [result (first (run-legacy-simulation [http-scenario] 1))]
       (is (= "Test http scenario" (:name result)))
       (is (= true (get-result (:requests result) "Request1")))
       (is (= false (get-result (:requests result) "Request2"))))))
 
 (deftest simulation-returns-result-when-run-with-multiple-scenarios-with-one-user
-  (let [result (run-simulation [scenario scenario2] 2)]
+  (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


(deftest with-multiple-number-of-requests
  (reset! request-count 0)
  (let [result (run-simulation [counting-scenario] 100 {:requests 2000})
        handled-requests (->> result (map :requests) count)]
    (is (approximately== handled-requests 2000))
    (is (= handled-requests @request-count))))

(deftest duration-given
  (let [result (run-simulation [scenario] 1 {:duration (time/millis 50)})]
    (is (not (empty? result)))))

(deftest fails-requests-when-they-take-longer-than-timeout
  (let [result (first (run-simulation [timeout-scenario] 1 {:timeout-in-ms 100}))]
    (is (= false (get-result (:requests result) "Request1")))))

(deftest scenario-weight

(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 (equal? result [{:name "Test scenario"
                         :id 0
                         :start number?
