def test_to_validation_rules():
raises(NotImplementedError, lambda: to_validation_rules({"": ""}))
assert {
"partitionby_has": ["a", "b"],
"partitionby_is": ["c", "d"],
} == to_validation_rules({
"partitionby_has": ["a", "b"],
"partitionby_is": " c, d"
})
assert {
"presort_has": [("a", True), ("b", False)],
"presort_is": [("c", False), ("d", True)],
} == to_validation_rules({
"presort_has": " a , b desc ",
"presort_is": [("c", False), "d"],
})
assert {
"input_has": ["a", "b:str"],
} == to_validation_rules({
"input_has": ["a", " b : str "],
})
assert {
"input_has": ["a", "b:str"],
} == to_validation_rules({
"input_has": "a, b : str",
})
assert {
"input_is": "a:int,b:str"
} == to_validation_rules({
"input_is": ["a:int", " b : str "],
})
with raises(SyntaxError):
to_validation_rules({
"input_is": "a, b : str",
})
def deco(func: Callable) -> "_FuncAsCoTransformer":
assert_or_throw(
not is_class_method(func),
NotImplementedError(
"cotransformer decorator can't be used on class methods"),
)
return _FuncAsCoTransformer.from_func(
func,
schema,
validation_rules=to_validation_rules(validation_rules))
def test_validate_input_schema():
schema = "a:int,b:int,c:str"
validate_input_schema(schema, to_validation_rules({"input_has": "a, c"}))
validate_input_schema(schema,
to_validation_rules({"input_has": "a, c,b:int"}))
with raises(FugueWorkflowRuntimeValidationError
): # col type matters (if specified)
validate_input_schema(schema,
to_validation_rules({"input_has": "a, c,b:str"}))
validate_input_schema(
schema, to_validation_rules({"input_is": "a:int, b:int, c:str"}))
with raises(FugueWorkflowRuntimeValidationError
): # col type matters (if specified)
validate_input_schema(
schema, to_validation_rules({"input_is": "a:int, b:int, c:int"}))
with raises(FugueWorkflowRuntimeValidationError): # order matters
validate_input_schema(
schema, to_validation_rules({"input_is": "a:int, c:str,b:int"}))
with raises(SyntaxError): # order matters
validate_input_schema(schema,
to_validation_rules({"input_is": "a,b,c"}))
def deco(func: Callable) -> "_FuncAsProcessor":
return _FuncAsProcessor.from_func(
func,
schema,
validation_rules=to_validation_rules(validation_rules))
def deco(func: Callable) -> "_FuncAsOutputter":
return _FuncAsOutputter.from_func(
func, validation_rules=to_validation_rules(validation_rules)
)
def test_validate_partition_spec():
spec = PartitionSpec(by=["a", "b", "c"], presort="d desc, e")
validate_partition_spec(spec,
to_validation_rules({"partitionby_has": ["a"]}))
with raises(FugueWorkflowCompileValidationError):
validate_partition_spec(
spec, to_validation_rules({"partitionby_has": ["x"]}))
with raises(FugueWorkflowCompileValidationError):
validate_partition_spec(
spec, to_validation_rules({"partitionby_has": "a,x"}))
validate_partition_spec(spec,
to_validation_rules({"partitionby_is": "a,b,c"}))
# order in partitionby doesn't matter
validate_partition_spec(spec,
to_validation_rules({"partitionby_is": "c,b,a"}))
with raises(FugueWorkflowCompileValidationError):
validate_partition_spec(spec,
to_validation_rules({"partitionby_is": "a,b"}))
# order in presort_has doesn't matter
validate_partition_spec(spec,
to_validation_rules({"presort_has": "d desc"}))
validate_partition_spec(spec,
to_validation_rules({"presort_has": "e,d desc"}))
with raises(FugueWorkflowCompileValidationError): # sort order matters
validate_partition_spec(spec, to_validation_rules({"presort_has":
"d"}))
with raises(FugueWorkflowCompileValidationError):
validate_partition_spec(spec, to_validation_rules({"presort_has":
"x"}))
with raises(FugueWorkflowCompileValidationError):
validate_partition_spec(
spec, to_validation_rules({"presort_has": "x,d desc"}))
validate_partition_spec(spec,
to_validation_rules({"presort_is": "d desc,e"}))
with raises(FugueWorkflowCompileValidationError
): # order in presort_is matters
validate_partition_spec(
spec, to_validation_rules({"presort_is": "e,d desc"}))