def test_cloud_can_deserialize_custom_handlers(self):
schema = ResultHandlerSchema()
serialized = {
"type": "CustomResultHandler",
"__version__": "0.6.3+120.g60ca943b",
}
assert schema.load(serialized) is None
def test_deserialize_local_result_handler(self, dir):
schema = ResultHandlerSchema()
obj = schema.load(schema.dump(LocalResultHandler(dir=dir)))
assert isinstance(obj, LocalResultHandler)
assert hasattr(obj, "logger")
assert obj.logger.name == "prefect.LocalResultHandler"
assert obj.dir == dir
def test_deserialize_cloud_result_handler(self):
schema = ResultHandlerSchema()
handler = CloudResultHandler(result_handler_service="http://foo.bar")
handler._client = Client()
obj = schema.load(schema.dump(handler))
assert isinstance(obj, CloudResultHandler)
assert hasattr(obj, "logger")
assert obj.logger.name == "prefect.CloudResultHandler"
assert obj.result_handler_service == "http://foo.bar"
assert obj._client is None
def test_roundtrip_never_loads_client(self, monkeypatch):
schema = ResultHandlerSchema()
def raise_me(*args, **kwargs):
raise SyntaxError("oops")
monkeypatch.setattr(GCSResultHandler, "initialize_client", raise_me)
handler = schema.load(
schema.dump(
GCSResultHandler(bucket="bucket3", credentials_secret="FOO")))
assert isinstance(handler, GCSResultHandler)
assert handler.bucket == "bucket3"
assert handler.credentials_secret == "FOO"
def test_deserialize_cloud_result_handler_with_None_populates_from_config(self):
schema = ResultHandlerSchema()
handler = CloudResultHandler()
handler.result_handler_service = None
handler._client = Client()
serialized = schema.dump(handler)
with set_temporary_config({"cloud.result_handler": "new-service"}):
obj = schema.load(serialized)
assert isinstance(obj, CloudResultHandler)
assert hasattr(obj, "logger")
assert obj.logger.name == "prefect.CloudResultHandler"
assert obj.result_handler_service == "new-service"
assert obj._client is None
def test_roundtrip_never_loads_client(self, monkeypatch):
schema = ResultHandlerSchema()
def raise_me(*args, **kwargs):
raise SyntaxError("oops")
monkeypatch.setattr(AzureResultHandler, "initialize_service", raise_me)
handler = schema.load(
schema.dump(
AzureResultHandler(container="container3",
azure_credentials_secret="FOO")))
assert isinstance(handler, AzureResultHandler)
assert handler.container == "container3"
assert handler.azure_credentials_secret == "FOO"
def test_serialize(self):
handler = AzureResultHandler(container="my-container",
azure_credentials_secret="FOO")
serialized = ResultHandlerSchema().dump(handler)
assert serialized["type"] == "AzureResultHandler"
assert serialized["container"] == "my-container"
assert serialized["azure_credentials_secret"] == "FOO"
def test_deserialize_from_dict(self, google_client):
handler = ResultHandlerSchema().load({
"type": "GCSResultHandler",
"bucket": "foo-bar"
})
assert isinstance(handler, GCSResultHandler)
assert handler.bucket == "foo-bar"
def test_deserialize_from_dict(self):
handler = ResultHandlerSchema().load(
{"type": "AzureResultHandler", "container": "foo-bar"}
)
assert isinstance(handler, AzureResultHandler)
assert handler.container == "foo-bar"
assert handler.azure_credentials_secret == "AZ_CREDENTIALS"
def test_deserialize_from_dict(self):
handler = ResultHandlerSchema().load(
{"type": "S3ResultHandler", "bucket": "foo-bar"}
)
assert isinstance(handler, S3ResultHandler)
assert handler.bucket == "foo-bar"
assert handler.aws_credentials_secret is None
def test_deserialize_from_dict(self):
handler = ResultHandlerSchema().load(
{"type": "GCSResultHandler", "bucket": "foo-bar"}
)
assert isinstance(handler, GCSResultHandler)
assert handler.bucket == "foo-bar"
assert handler.credentials_secret == "GOOGLE_APPLICATION_CREDENTIALS"
def test_serialize_with_no_attributes(self):
with set_temporary_config({"cloud.result_handler": "website"}):
serialized = ResultHandlerSchema().dump(CloudResultHandler())
assert isinstance(serialized, dict)
assert serialized["type"] == "CloudResultHandler"
assert serialized["result_handler_service"] == "website"
assert "client" not in serialized
def test_serialize(self):
handler = S3ResultHandler(bucket="my-bucket",
aws_credentials_secret="FOO")
serialized = ResultHandlerSchema().dump(handler)
assert serialized["type"] == "S3ResultHandler"
assert serialized["bucket"] == "my-bucket"
assert serialized["aws_credentials_secret"] == "FOO"
def test_serialize_local_result_handler_with_dir(self):
root_dir = os.path.abspath(os.sep)
serialized = ResultHandlerSchema().dump(
LocalResultHandler(dir=root_dir))
assert isinstance(serialized, dict)
assert serialized["type"] == "LocalResultHandler"
assert serialized["dir"] == root_dir
def test_serialize_with_attributes(self):
handler = CloudResultHandler(result_handler_service="http://foo.bar")
handler.client = Client()
serialized = ResultHandlerSchema().dump(handler)
assert isinstance(serialized, dict)
assert serialized["type"] == "CloudResultHandler"
assert serialized["result_handler_service"] == "http://foo.bar"
assert "client" not in serialized
def test_deserialize_from_dict_with_creds(self):
handler = ResultHandlerSchema().load({
"type": "GCSResultHandler",
"bucket": "foo-bar",
"credentials_secret": "FOO",
})
assert isinstance(handler, GCSResultHandler)
assert handler.bucket == "foo-bar"
assert handler.credentials_secret == "FOO"
def test_result_handler_schema_defaults_to_custom(self):
class Weird(ResultHandler):
def __init__(self, y):
self.y = y
def read(self, *args, **kwargs):
return 99
def write(self, *args, **kwargs):
return type(None)
schema = ResultHandlerSchema()
serialized = schema.dump(Weird(dict(y="test")))
assert serialized["type"].endswith("Weird")
assert serialized["__version__"] == prefect.__version__
obj = schema.load(serialized)
assert obj is None
def test_result_handler_schema_defaults_to_custom(self):
class Weird(ResultHandler):
def __init__(self, y):
self.y = y
def read(self, *args, **kwargs):
return 99
def write(self, *args, **kwargs):
return type(None)
schema = ResultHandlerSchema()
serialized = schema.dump(Weird(dict(y="test")))
assert serialized["type"] == "CustomResultHandler"
assert serialized["__version__"] == prefect.__version__
obj = schema.load(serialized)
assert isinstance(obj, ResultHandler)
assert obj.write("foo") is None # just the base class, not the Weird class
def test_roundtrip(self):
schema = ResultHandlerSchema()
handler = schema.load(schema.dump(S3ResultHandler(bucket="bucket3")))
assert isinstance(handler, S3ResultHandler)
assert handler.bucket == "bucket3"
def test_roundtrip(self):
schema = ResultHandlerSchema()
handler = schema.load(schema.dump(JSONResultHandler()))
assert isinstance(handler, JSONResultHandler)
assert handler.write(3) == "3"
def test_deserialize_from_dict(self):
handler = ResultHandlerSchema().load({"type": "JSONResultHandler"})
assert isinstance(handler, JSONResultHandler)
def test_serialize(self):
serialized = ResultHandlerSchema().dump(JSONResultHandler())
assert isinstance(serialized, dict)
def test_roundtrip(self, google_client):
schema = ResultHandlerSchema()
handler = schema.load(schema.dump(GCSResultHandler(bucket="bucket3")))
assert isinstance(handler, GCSResultHandler)
assert handler.bucket == "bucket3"
def test_serialize_local_result_handler_with_dir(self):
serialized = ResultHandlerSchema().dump(
LocalResultHandler(dir="/root/prefect"))
assert isinstance(serialized, dict)
assert serialized["type"] == "LocalResultHandler"
assert serialized["dir"] == "/root/prefect"
def test_deserialize_from_dict(self):
handler = ResultHandlerSchema().load({"type": "LocalResultHandler"})
assert isinstance(handler, LocalResultHandler)
assert handler.dir is None
def test_serialize(self, s3_client):
handler = S3ResultHandler(bucket="my-bucket")
serialized = ResultHandlerSchema().dump(handler)
assert serialized["type"] == "S3ResultHandler"
assert serialized["bucket"] == "my-bucket"
def test_serialize(self, secret_task):
serialized = ResultHandlerSchema().dump(SecretResultHandler(secret_task))
assert isinstance(serialized, dict)
assert serialized["type"] == "SecretResultHandler"
assert serialized["name"] == "foo"
def test_serialize_local_result_handler_with_no_dir(self):
serialized = ResultHandlerSchema().dump(LocalResultHandler())
assert isinstance(serialized, dict)
assert serialized["type"] == "LocalResultHandler"
assert serialized["dir"] is None
def test_roundtrip(self):
schema = ResultHandlerSchema()
handler = schema.load(
schema.dump(AzureResultHandler(container="container3")))
assert isinstance(handler, AzureResultHandler)
assert handler.container == "container3"
