Example #1
0
def behavior(its):
    bundle = spec.behaviors_of("behaviors bundle")
    @bundle.that("a behavior")
    def behavior(it):
        it.value = it.name + " done"
        pass
    
    a_spec = spec.of("a spec")
    @a_spec.of(bundle)
    def glue(it):
        it.name = "a spec"
        pass
    
    test, r = run_as(a_spec)
    assert test.value == "a spec done"
    pass
Example #2
0
def behavior(its):
    log = []
    bundle = spec.behaviors_of("behaviors bundle")
    @bundle.that("a behavior")
    def behavior(it):
        log.append("behavior")
        pass
    @bundle.before()
    def prepare(it):
        log.append("bundle before")
        pass
    @bundle.after()
    def cleanup(it):
        log.append("bundle after")
        pass
    
    a_spec = spec.of("a spec")
    @a_spec.before()
    def prepare_spec(it):
        log.append("spec before")
        pass
    @a_spec.after()
    def cleanup_spec(it):
        log.append("spec after")
        pass
    @a_spec.of(bundle)
    def glue(it):
        log.append("glue")
        pass
    
    test, r = run_as(a_spec)
    assert len(log) == 6
    assert log[0] == "spec before"
    assert log[1] == "glue"
    assert log[2] == "bundle before"
    assert log[3] == "behavior"
    assert log[4] == "bundle after"
    assert log[5] == "spec after"
    pass
Example #3
0
# [design] separation of behavior and type
from specfor import the, spec

# behaviors
seq_spec = spec.behaviors_of("sequence")
@seq_spec.that("sum")
def behavior(its):
    result = sum(its.target)
    the[result].should == its.expected_sum
    pass
@seq_spec.that("any")
def behavior(its):
    result = any(its.target)
    the[result].should == its.expected_any
    pass


list_spec = spec.behaviors_of("list")
@list_spec.that("append/pop")
def behavior(its):
    its.target.append(its.item)
    result = its.target.pop()
    the[result].should == its.item
    pass


# type example
empty_list = spec.of("empty list")
@empty_list.before()
def define(its):
    its.target = []