def pause(self):
global current_context
if self.assert_state_changes:
assert_eq('resume', self.state)
self.state = "pause"
current_context = self.parent
print(self.name + ': pause')
def resume(self):
global current_context
if self.assert_state_changes:
assert_eq('pause', self.state)
self.state = "resume"
current_context = self
print(self.name + ': resume')
def test_intenum():
assert_is_instance(Python.two, int)
assert_eq('Python.two', repr(Python.two))
assert_eq('2', json.dumps(Python.two))
assert_in(Python.two, Python)
assert_in(2, Python)
assert_not_in(4, Python)
def test_common():
o = qcore.MarkerObject("o @ qcore.test_examples")
assert_is_not(o, qcore.miss)
o = qcore.dict_to_object({"a": 1, "b": 2})
assert_eq(o.a, 1) # Zero overhead!
assert_eq(o.b, 2) # Zero overhead!
def test_raise_value_error_with_invalid_dependencies(self, tmp_path):
invalid_dependency_STRING = """
raw_data_dir: "dummy"
dataset_name: "dummy"
base_features:
- name: "TIME"
dtype: DATETIME
transforming_features:
- name: "weekday"
index: 1
dtype: STRING
dependencies:
- "date"
"""
config_path = tmp_path / "tmp.yaml"
write_str_to_file(invalid_dependency_STRING, config_path)
with AssertRaises(AssertionError) as assert_raises:
feature_config_helper.FeatureConfigHelper(config_path)
error_message = assert_raises.expected_exception_found
assert_eq(
True,
error_message.args[0].startswith(
"Feature weekday depends on feature date that is undefined."
),
)
def test_cached_per_instance_pickling():
# make sure cached stuff doesn't appear in the pickled representation
obj = PickleTestClass()
obj.attr = 'spam'
assert_eq(set(),
set(PickleTestClass.f.__cached_per_instance_cache__.keys()))
obj.f('my hovercraft is full of eels')
assert_eq({id(obj)},
set(PickleTestClass.f.__cached_per_instance_cache__.keys()))
serialized = pickle.dumps(obj)
assert_not_in(b'my hovercraft is full of eels', serialized)
assert_in(b'spam', serialized)
restored = pickle.loads(serialized)
assert_eq({id(obj)},
set(PickleTestClass.f.__cached_per_instance_cache__.keys()))
restored.f('my hovercraft is full of eels')
assert_eq({id(obj), id(restored)},
set(PickleTestClass.f.__cached_per_instance_cache__.keys()))
assert_eq('spam', obj.attr)
# make sure we can use this with a custom __getstate__
class X(object):
@cached_per_instance()
def f(self, x):
return x
def __getstate__(self):
return {}
X().f(1)
def _assert_write_result(text, indent, expected):
buf = StringIO()
with asynq.mock.patch('asynq.debug.stdout', buf):
asynq.debug.write(text, indent=indent)
assert_eq(expected, buf.getvalue())
def nested():
assert_eq(v.get(), inner_val)
yield DebugBatchItem()
with v.override('c'):
yield DebugBatchItem() # just so other function gets scheduled
assert_eq(v.get(), 'c')
yield DebugBatchItem()
def test_raise_assertion_error_with_duplicate_features(self, tmp_path):
config_STRING = """
raw_data_dir: "dummy"
dataset_name: "dummy"
base_features:
- name: "TIME"
dtype: DATETIME
transforming_features:
- name: "weekday"
index: 1
dtype: STRING
dependencies:
- "TIME"
- name: "weekday"
index: 2
dtype: STRING
"""
config_path = tmp_path / "tmp.yaml"
write_str_to_file(config_STRING, config_path)
with AssertRaises(AssertionError) as assert_raises:
feature_config_helper.FeatureConfigHelper(config_path)
error_message = assert_raises.expected_exception_found
assert_eq(
True,
error_message.args[0].startswith(
"There are duplicate objects in the list: "
),
)
def test_extract_config_1(self, tmp_path):
subset_features = ["e"]
expected_STRING = """
raw_data_dir: "dummy"
dataset_name: "dummy"
base_features:
- name: "a"
dtype: STRING
transforming_features:
- name: "b"
index: 1
dtype: STRING
dependencies:
- "a"
- name: "c"
index: 2
dtype: STRING
dependencies:
- "a"
- "b"
- name: "e"
index: 4
dtype: STRING
dependencies:
- "c"
"""
new_config_path = str(tmp_path / "new_tmp.yaml")
write_str_to_file(expected_STRING, new_config_path)
new_config = self.fm_helper.extract_config(selected_features=subset_features)
assert_eq(parse_feature_config(new_config_path), new_config)
def _check_deduplicate():
global i
i = 0
AsyncObject.cls_value = 0
yield increment_value.asynq()
assert_eq(1, i)
yield increment_value.asynq(), increment_value.asynq(1)
assert_eq(2, i)
obj = AsyncObject()
yield obj.increment_value_method.asynq(), obj.increment_value_method.asynq(
1)
assert_eq(1, obj.value)
yield AsyncObject.deduplicated_static_method.asynq(), \
AsyncObject.deduplicated_static_method.asynq(1)
assert_eq(1, AsyncObject.cls_value)
i = 0
yield recursive_call_with_dirty.asynq()
yield call_with_dirty.asynq()
if sys.version_info >= (3, 0):
with AssertRaises(TypeError):
yield call_with_kwonly_arg.asynq(1)
assert_eq(1, (yield call_with_kwonly_arg.asynq(arg=1)))
def test_raise_value_error_with_invalid_indexes(self, tmp_path):
invalid_index_STRING = """
# invalid config with indexes are not continuous
raw_data_dir: "dummy"
dataset_name: "dummy"
base_features:
- name: "TIME"
dtype: "DATETIME"
transforming_features:
- name: "weekday"
index: 1
dtype: INT32
dependencies:
- "TIME"
- name: "hour"
index: 1
dtype: INT32
dependencies:
- "TIME"
"""
config_path = tmp_path / "tmp.yaml"
write_str_to_file(invalid_index_STRING, config_path)
with AssertRaises(ValueError) as assert_raises:
feature_config_helper.FeatureConfigHelper(config_path)
error_message = assert_raises.expected_exception_found
assert_eq(
True,
error_message.args[0].startswith(
"Feature indexes must be a list of increasing positive integers. "
"Got indexes = [1, 1]"
),
)
def test_retry_can_take_multiple_exceptions(self):
max_tries = 4
any_expected_exception_type = AnyException
any_other_expected_exception_type = AnyOtherException
expected_exceptions = (any_expected_exception_type,
any_other_expected_exception_type)
for method in (self.create_any_function,
self.create_generator_function):
any_function, fn_body = method(expected_exceptions, max_tries)
fn_body.side_effect = any_expected_exception_type
with AssertRaises(any_expected_exception_type):
list(any_function())
assert_eq(max_tries, fn_body.call_count)
fn_body.reset_mock()
fn_body.side_effect = any_other_expected_exception_type
with AssertRaises(any_other_expected_exception_type):
list(any_function())
assert_eq(max_tries, fn_body.call_count)
def test_typed_value() -> None:
val = TypedValue(str)
assert_is(str, val.typ)
assert_eq("str", str(val))
assert val.is_type(str)
assert not val.is_type(int)
assert_can_assign(val, val)
assert_cannot_assign(val, TypedValue(int))
assert_can_assign(val, KnownValue("x"))
assert_can_assign(val, MultiValuedValue([val, KnownValue("x")]))
assert_cannot_assign(val,
MultiValuedValue([KnownValue("x"),
TypedValue(int)]))
float_val = TypedValue(float)
assert_eq("float", str(float_val))
assert_can_assign(float_val, KnownValue(1.0))
assert_can_assign(float_val, KnownValue(1))
assert_cannot_assign(float_val, KnownValue(""))
assert_can_assign(float_val, TypedValue(float))
assert_can_assign(float_val, TypedValue(int))
assert_cannot_assign(float_val, TypedValue(str))
assert_can_assign(float_val, TypedValue(mock.Mock))
assert_cannot_assign(float_val, SubclassValue(TypedValue(float)))
assert_can_assign(TypedValue(type), SubclassValue(TypedValue(float)))
def test_format_error():
assert_is(None, asynq.debug.format_error(None))
# Syntax highlighting adds color text between words
asynq.debug.enable_traceback_syntax_highlight(False)
e = RuntimeError()
expected = 'RuntimeError\n'
assert_eq(expected, asynq.debug.format_error(e))
e._task = async_fn.asynq()
formatted = asynq.debug.format_error(e)
assert_in(expected, formatted)
try:
raise RuntimeError
except RuntimeError:
e._traceback = sys.exc_info()[2]
formatted = asynq.debug.format_error(e)
assert_in(expected, formatted)
assert_in('Traceback', formatted)
# Each single word, and unformatted text should be present
asynq.debug.enable_traceback_syntax_highlight(True)
expected = 'RuntimeError'
formatted = asynq.debug.format_error(e)
assert_in(expected, formatted)
assert_in('Traceback', formatted)
def test_set(self):
with self.scopes.add_scope(ScopeType.module_scope, scope_node=None):
self.scopes.set("multivalue", KnownValue(1), None, None)
assert_eq(KnownValue(1), self.scopes.get("multivalue", None, None))
self.scopes.set("multivalue", KnownValue(2), None, None)
assert_eq(
MultiValuedValue([KnownValue(1), KnownValue(2)]),
self.scopes.get("multivalue", None, None),
)
self.scopes.set("multivalue", KnownValue(3), None, None)
assert_eq(
MultiValuedValue([KnownValue(1), KnownValue(2), KnownValue(3)]),
self.scopes.get("multivalue", None, None),
)
# if the values set are the same, don't make a MultiValuedValue
self.scopes.set("same", KnownValue(1), None, None)
assert_eq(KnownValue(1), self.scopes.get("same", None, None))
self.scopes.set("same", KnownValue(1), None, None)
assert_eq(KnownValue(1), self.scopes.get("same", None, None))
# even if they are UNRESOLVED_VALUE
self.scopes.set("unresolved", UNRESOLVED_VALUE, None, None)
assert_is(UNRESOLVED_VALUE, self.scopes.get("unresolved", None, None))
self.scopes.set("unresolved", UNRESOLVED_VALUE, None, None)
assert_is(UNRESOLVED_VALUE, self.scopes.get("unresolved", None, None))
def test_typed_value_set(self):
self.scopes.set("value", TypedValue(dict), None, None)
assert_eq(TypedValue(dict), self.scopes.get("value", None, None))
self.scopes.set(
"value", DictIncompleteValue([]), None, None
) # subclass of TypedValue
assert_eq(DictIncompleteValue([]), self.scopes.get("value", None, None))
def test_typed_value():
val = TypedValue(str)
assert_is(str, val.typ)
assert_eq("str", str(val))
assert val.is_type(str)
assert not val.is_type(int)
assert val.is_value_compatible(TypedValue(str))
assert not val.is_value_compatible(TypedValue(int))
assert val.is_value_compatible(
MultiValuedValue([KnownValue("x"), TypedValue(str)]))
assert not val.is_value_compatible(
MultiValuedValue([KnownValue("x"), TypedValue(int)]))
float_val = TypedValue(float)
assert_eq("float", str(float_val))
assert float_val.is_value_compatible(KnownValue(1.0))
assert float_val.is_value_compatible(KnownValue(1))
assert not float_val.is_value_compatible(KnownValue(""))
assert float_val.is_value_compatible(TypedValue(float))
assert float_val.is_value_compatible(TypedValue(int))
assert not float_val.is_value_compatible(TypedValue(str))
assert float_val.is_value_compatible(TypedValue(value.mock.Mock))
assert not float_val.is_value_compatible(SubclassValue(float))
assert TypedValue(type).is_value_compatible(SubclassValue(float))
def test_bitwise_resize():
assert_eq(
# fmt: off
[1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0],
# fmt: on
encoders.bitwise_resize([0b111, 0b101, 0b001, 0b010, 0b000],
new_bitwidth=1),
)
def test_make_async_decorator():
assert_eq(18, square(3))
assert_eq(18, MyClass.square(3))
assert_eq(18, square.asynq(3).value())
assert_eq(18, MyClass.square.asynq(3).value())
assert not is_pure_async_fn(square)
assert_eq("@double_return_value()", square.name())
def test_maybe_wrap_new():
counter = Counter()
with asynq.mock.patch('asynq.tests.test_mock.fn', counter.add_call):
fn()
assert_eq(1, counter.count)
with asynq.mock.patch('asynq.tests.test_mock.fn', 'capybara'):
assert_eq('capybara', fn)
def test_getargspec_py3_only():
spec = inspect.ArgSpec(args=['a', 'b'],
varargs='args',
keywords=None,
defaults=None)
assert_eq(spec, qcore.inspection.getargspec(fun_with_annotations))
with AssertRaises(ValueError):
qcore.inspection.getargspec(fun_with_kwonly_args)
def test_maybe_wrap_new():
counter = Counter()
with asynq.mock.patch("asynq.tests.test_mock.fn", counter.add_call):
fn()
assert_eq(1, counter.count)
with asynq.mock.patch("asynq.tests.test_mock.fn", "capybara"):
assert_eq("capybara", fn)
def test_assert_if_not_unique(self):
items = [1, 2, 3, 1]
with AssertRaises(AssertionError) as assert_raises:
utils.check_uniqueness(items)
assertion_error = assert_raises.expected_exception_found
assert_eq("There are duplicate objects in the list: {1: 2}.",
assertion_error.args[0])
def test_slots(self):
obj1 = ObjectWithSlots(1)
obj2 = ObjectWithSlots(2)
obj3 = ObjectWithSlots(1)
assert_eq(obj1, obj3)
assert_eq(obj1, obj1)
assert_ne(obj1, obj2)
self._check_repr_and_str('ObjectWithSlots(oid=1)', obj1)
def test_marker_object():
assert_eq("text", str(qcore.MarkerObject("text")))
with AssertRaises(TypeError):
qcore.MarkerObject(b"bytes")
# MarkerObjects should be unique
assert_ne(qcore.MarkerObject("name"), qcore.MarkerObject("name"))
def test_retry_preserves_argspec(self):
def fn(foo, bar, baz=None, **kwargs):
pass
decorated = aretry(Exception)(fn)
assert_eq(inspect.getargspec(fn),
inspect.getargspec(get_original_fn(decorated)))
def test_lrs():
# NB: This test handles strings
symbols = [2, 2, 0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 1, 2, 1, 0, 0, 1, 0, 0, 0]
import lrs
assert_eq(0.6146,
lrs.lrs(symbols, threshold=3).min_entropy,
tolerance=0.0001)
def test_raise_value_error_with_invalid_feature_to_extract(self, tmp_path):
subset_features = ["a", "y", "z"]
with AssertRaises(ValueError) as assert_raises:
self.fm_helper.extract_config(selected_features=subset_features)
error_message = assert_raises.expected_exception_found
assert_eq(
error_message.args[0], "Features ['y', 'z'] are not in the original config."
)
def test_retry_retries_on_provided_exception(self):
max_tries = 4
function, fn_body = self.create_function(AnyException, max_tries)
fn_body.side_effect = AnyException
with AssertRaises(AnyException):
function()
assert_eq(max_tries, fn_body.call_count)
