Archimedes is a set of Hy macros that are used to make writing tests with Hypothesis easier. fact specifies a test case, variants and sample specify rules for test data generation, profile specifies test settings, background and with-background specify common data between tests. assert-macro-error checks that macro-error is called with given message during macro expansion. For regular errors and exceptions, use assert-error.
In case you're using PyHamcrest, there's two macros to help you define matchers: defmatcher and attribute-matcher. And for Hymn, there is assert-right.
For interactive mode, it's sometimes easier to execute fact immediately. For this case, use check.
Only Hypothesis is installed as a dependency. Hamcrest and Hymn have to be installed separately.
For more comprehensive documentation, see http://archimedes.readthedocs.io/
Also, Archimedes was a Greek mathematician, physicist, engineer, inventor and astronomer.
(require [archimedes [background fact check defmatcher attribute-matcher
assert-macro-error assert-error assert-right
with-background]])
(import [hypothesis.strategies [integers]]
[hamcrest [assert-that]]
[math [pow]])
(fact "true is always true"
(assert True))
(background some-numbers
a 3
b 4
c 5)
(fact "Pythagorean theorem holds in this specific case"
(with-background some-numbers [a b c]
(assert (= (+ (pow a 2) (pow b 2)) (pow c 2)))))
(fact "sum of two positive numbers is larger than either one of them"
(variants :a (integers :min-value 1)
:b (integers :min-value 1))
(assert (> (+ a b) a))
(assert (> (+ a b) b)))
(fact "example can clarify things"
(variants :a (integers :min-value 0 :max-value 10)
:b (integers :min-value 0 :max-value 10))
(sample :a 0 :b 0)
(assert (<= 0 (+ a b) 20)))
(fact "profile controls test settings"
(variants :a (integers :min-value 0))
(profile :max-examples 500)
(assert (<= 0 a)))
(fact "macro errors can be asserted"
(assert-macro-error "cond branches need to be a list"
(cond (= 1 1) True)))
(fact "even fact can be asserted for macro errors"
(assert-macro-error "too many variants forms"
(fact "I'm incorrect"
(variants :a (integers))
(variants :a (integers))
(assert (= a a)))))
(fact "errors can be asserted"
(assert-error "error"
(raise (ValueError "error"))))
(check "this is executed immediately"
(assert (= 1 1)))
(defmatcher is-zero? []
:match? (= item 0)
:match! "a zero"
:no-match! (.format "was a value of {0}" item))
(assert-that 0 (is-zero?))
(attribute-matcher item-with-length?
len =
"an item with length {0}"
"was an item with length {0}")
(assert-that "foo" (is- (item-with-length? 3)))(background name elements) defines setup function. Name is symbol. Name of the test function will be "setup_" + name. elements is a list of alternating symbols and their values. The setup function will return a dictionary with keywordified symbols as keys and corresponding values as their values.
(fact description code) specifies a test function. description is a string describing what the test is about. The generated function will have a name "test_" + description and no arguments. Docstring of the function will be value of description. code can be one or more forms of code, they are inserted inside of the test function as is.
(check description code) works just like fact, except that the resulting test function is immediately executed. This is useful when working in interactive envinroment, like Jupyter or Hy repl.
(with-background name symbols code) generates a let binding with code to call background specified by name. symbols is list of symbols that should be retrieved from dictionary returned by setup function and bound to local context. code is one or more elements of code, used to test things.
(variants keyword specification) is used to specify test data that should be generated by Hypothesis. It accepts arbitrary, but even, amount of parameters. First specifies keywordified symbol and second strategy used to generate value. If this form is present, test function's parameter list is modified to have named parameters specified by keywords and is also wrapped in given decorator.
(sample keyword value) specifies sample set of values. Keyword specifies symbol and value holds the value bound to it. It should have same amount of keywords as variants form and can't be used without variants form.
(profile keyword value) specifies test settings. They match directly to parameters given to settings decorator.
(assert-macro-error message code) asserts that during macro expansion of code an error is raised with a message of message.
(assert-error message code) asserts that code raises an error, which string representation is equal to message.
(def-matcher name parameters :match? code :match! string :no-match string) is used to create matcher function for hamcrest library. The resulting matcher can then be used in assertions. Since the macro creates a behind the scenes class, all parameters passed to it are accessible as instance attributes. In match?, match! and no-match! blocks, symbol item is bound to item currently under comparison.
(defmatcher length-of? [value]
:match? (= (len item) self.value)
:match! (.format "an item with length of {0}
self.value)
:no-match (.format "was an item with length of {0}"
(len item)))
(assert-that value (is- (lenght-of? 5)))(attribute-matcher name function predicate string string) is a special case for matcher, where function is used to check a value of some matched item and then compared to given value using predicate. Thus, the previous example can be written as:
(attribute-matcher length-of?
len =
"an item with length of {0}"
"was an item with length of {0}")
(assert-that value (is- (length-of? 5)))assert-right is used with Hymn library's Either monad. It first checks that right was returned as a result of computation and then proceeds to run assertion block:
(assert-right (do-monad [status (advance-time-m society)]
status)
(assert-that society
(has-less-resources-than? old-resources)))Archimedes is geared towards Nose, but it might work with other frameworks that rely on naming conventions to discover tests to be executed.
Licensed under MIT license