 
 (deftest with-multiple-number-of-requests
   (reset! request-count 0)
-  (let [result (run-simulation [counting-scenario] 100 {:requests 2000})
+  (let [result (run-legacy-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)})]
+  (let [result (run-legacy-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}))]
+  (let [result (first (run-legacy-simulation [timeout-scenario] 1 {:timeout-in-ms 100}))]
     (is (= false (get-result (:requests result) "Request1")))))
 
 (deftest scenario-weight

                  :requests [{:name "Request1"
                              :fn (fn [cb {:keys [test-val]}]
                                    (cb (= 5 test-val)))}]}
        result (first (run-simulation [scenario]
                                      1
                                      {:context {:test-val 5}}))]
    (is (= true (get-result (:requests result) "Request1")))))

(deftest simulation-skips-second-request-if-first-fails
  (let [result (run-simulation [first-fails-scenario] 1)]
    ;Note scenario is ran twice in this case to match number of handled requests which should be 2
    (is (equal? result
                (repeat 2 {:name "Scenario"


(deftest simulation-returns-result-when-run-with-http-requests
  (with-redefs [httpkit/async-http-request fake-async-http]
    (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-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
