Macro tests

Author: chrisrink10

src/basilisp/core.lpy

@@ -4091,7 +4091,11 @@
 
 (defmacro afor
   "Repeatedly execute ``body`` while the binding name is repeatedly rebound to
-  successive values from the asynchronous iterable."
+  successive values from the asynchronous iterable.
+
+  .. warning::
+
+     The ``afor`` macro may only be used in an asynchronous function context."
   [binding & body]
   (if (operator/ne 2 (count binding))
     (throw
@@ -4112,7 +4116,11 @@
 (defmacro awith
   "Evaluate ``body`` within a ``try`` / ``except`` expression, binding the named
   expressions as per Python's async context manager protocol spec (Python's
-  ``async with`` blocks)."
+  ``async with`` blocks).
+
+  .. warning::
+
+     The ``awith`` macro may only be used in an asynchronous function context."
   [bindings & body]
   (let [binding (first bindings)
         expr    (second bindings)]

tests/basilisp/test_core_async_macros.lpy

@@ -0,0 +1,37 @@
+(ns tests.basilisp.test-core-async-macros
+  (:import asyncio contextlib)
+  (:require
+   [basilisp.test :refer [deftest is are testing]]))
+
+(defn async-to-sync
+  [f & args]
+  (let [loop (asyncio/new-event-loop)]
+    (asyncio/set-event-loop loop)
+    (.run-until-complete loop (apply f args))))
+
+(deftest awith-test
+  (testing "base case"
+    (let [get-val    (contextlib/asynccontextmanager
+                      (fn ^:async get-val
+                        []
+                        (yield :async-val)))
+          val-ctxmgr (fn ^:async yield-val
+                       []
+                       (awith [v (get-val)]
+                              v))]
+      (is (= :async-val (async-to-sync val-ctxmgr))))))
+
+(deftest afor-test
+  (testing "base case"
+    (let [get-vals (fn ^:async get-vals
+                     []
+                     (dotimes [n 5]
+                       (yield n)))
+          val-loop (fn ^:async val-loop
+                     []
+                     (let [a   (atom [])
+                           res (afor [v (get-vals)]
+                                     (swap! a conj v)
+                                     v)]
+                       [@a res]))]
+      (is (= [[0 1 2 3 4] 4] (async-to-sync val-loop))))))