def test_create_constants(self, mock_generate_constant_list):
class_a = ClassBlock(
name="CLASS",
extend_class="EXTEND_CLASS",
methods_blocks=[
MethodBlock(
name="__init__",
desc=None,
args={"ARG_A": ParameterBlock("ARG_A", kind=TypeBrick("str"))},
return_kind=None,
return_desc=None,
code_blocks=[],
decorator_blocks=[],
)
],
)
class_b = ClassBlock(
name="CLASS",
extend_class="EXTEND_CLASS",
methods_blocks=[
MethodBlock(
name="__init__",
desc=None,
args={
"ARG_B": ParameterBlock("ARG_B"),
"*args": ParameterBlock("*args"),
"**kwargs": ParameterBlock("**kwargs"),
},
return_kind=None,
return_desc=None,
code_blocks=[],
decorator_blocks=[],
),
MethodBlock(
name="execute",
desc=None,
args={"ARG_C": ParameterBlock("ARG_C")},
return_kind=None,
return_desc=None,
code_blocks=[],
decorator_blocks=[],
),
],
)
result = operator_test_generator.create_constants([class_a, class_b])
self.assertEqual("CONSTANTS", result)
mock_generate_constant_list.assert_called_once_with(
{"ARG_A": TypeBrick(kind="str"), "ARG_B": None}
)
def test_render_ctor_method_block(
self, mock_render_template, mock_render_code_block
):
method_block = MethodBlock(
name="__init__",
desc=["DESC_A", "DESC_B"],
args={"ARG_A": "PARAMETER_A"},
return_kind="TYPE_BRICK",
return_desc=["DESC_C", "DESC_D"],
code_blocks=["CODE_BLOCK_1", "CODE_BLOCK_2"],
)
result = brushes.render_method_block(method_block)
mock_render_code_block.assert_any_call("CODE_BLOCK_1")
mock_render_code_block.assert_any_call("CODE_BLOCK_2")
mock_render_template.assert_called_once_with(
args={"ARG_A": "PARAMETER_A"},
code_blocks=["TEMPLATE_CODE_BLOCK", "TEMPLATE_CODE_BLOCK"],
decorator_blocks=[],
desc=None,
name="__init__",
return_desc=["DESC_C", "DESC_D"],
return_kind="TYPE_BRICK",
template_name="method_block.py.tpl",
)
self.assertEqual("TEMPLATE", result)
def test_should_generate_value_for_optional_string(
self, mock_generate_constant_list
):
hook_method_blocks = [
MethodBlock(
name="setUp",
desc=None,
args={
"arg3": ParameterBlock(
"arg3",
TypeBrick(
kind="Optional", indexes=[TypeBrick(kind="str", indexes=[])]
),
)
},
return_kind=None,
return_desc=None,
code_blocks=[],
decorator_blocks=[],
)
]
result = hook_test_generator.generate_constants(hook_method_blocks, [])
mock_generate_constant_list.assert_called_once_with(
{"arg3": TypeBrick(kind="Optional", indexes=[TypeBrick(kind="str")])}
)
self.assertEqual("CONSTANTS", result)
def test_find_client_call_method_name(self):
operator_class_block = ClassBlock(
name="CloudMemorystoreCreateInstanceOperator",
extend_class="airflow.models.BaseOperator",
methods_blocks=[
MethodBlock(
name="execute",
desc=None,
args={},
return_kind=None,
return_desc=None,
code_blocks=[
CodeBlock(
template_name="method_call.py.tpl",
template_params={"target": "CloudMemorystoreHook"},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "hook.create_instance",
"call_params": {},
},
),
],
decorator_blocks=[],
)
],
)
result = operator_test_generator.find_client_call_method_name(
operator_class_block
)
self.assertEqual("create_instance", result)
def generate_ctor_method_block(client_info: ClientInfo,
integration: Integration) -> MethodBlock:
args = {
"gcp_conn_id": ParameterBlock(name="gcp_conn_id",
kind=TypeBrick("str")),
"delegate_to": ParameterBlock(name="delegate_to",
kind=TypeBrick("str")),
}
method_block = MethodBlock(
name="__init__",
desc=client_info.ctor_method.desc,
args=args,
return_kind=TypeBrick("None"),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="super_call.py.tpl",
template_params={
"args": list(args.keys()),
"kwargs": {}
},
),
CodeBlock(
template_name="set_field.py.tpl",
template_params={
"field_name": "_client",
"field_type": integration.client_type_brick,
"field_value": "None",
},
),
],
)
return method_block
def generate_test_method_for_call_without_project_id(
hook_class_path: str, hook_method_block: MethodBlock) -> MethodBlock:
code_blocks = [
CodeBlock(
template_name="method_call_assert_raises.py.tpl",
template_params={
"target": f"self.hook.{hook_method_block.name}",
"call_params": {
a: f"TEST_{a.upper()}" if a != "project_id" else "None"
for a in hook_method_block.args.keys()
},
},
)
]
method_block = MethodBlock(
name=f"test_{hook_method_block.name}_without_project_id",
desc=None,
args={"mock_get_conn": ParameterBlock("mock_get_conn")},
return_kind=TypeBrick("None"),
return_desc=None,
code_blocks=code_blocks,
decorator_blocks=[
CodeBlock(
template_name="decorator_mock_get_conn.py.tpl",
template_params={"class_path": hook_class_path},
)
],
)
return method_block
def test_should_look_at_method_and_action_args(self, mock_generate_constant_list):
hook_method_blocks = [
MethodBlock(
name="NAME",
desc=None,
args={"arg": ParameterBlock("arg")},
return_kind=None,
return_desc=None,
code_blocks=[],
decorator_blocks=[],
)
]
action_infos = [
ActionInfo(
name="NAME2",
desc=[],
args={"arg2": ParameterInfo("arg2", kind=None, desc=[])},
return_kind=None,
return_desc=None,
)
]
result = hook_test_generator.generate_constants(
hook_method_blocks, action_infos
)
mock_generate_constant_list.assert_called_once_with({"arg": None, "arg2": None})
self.assertEqual("CONSTANTS", result)
def test_generate_method_block(self):
integration = Integration(
service_name="SERVICE_NAME",
class_prefix="CLASS_PREFIX",
file_prefix="FILE_PREFFIX",
client_path="CLOENT_PATH",
)
method_block = hook_generator.generate_get_conn_method_block(
integration)
self.assertEqual(
MethodBlock(
name="get_conn",
desc=[
"Retrieves client library object that allow access to SERVICE_NAME service."
],
args={},
return_kind=TypeBrick(kind="CLOENT_PATH", indexes=[]),
return_desc=["SERVICE_NAME client object."],
code_blocks=[
CodeBlock(
template_name="get_conn_body.py.tpl",
template_params={
"client": TypeBrick(kind="CLOENT_PATH", indexes=[])
},
)
],
),
method_block,
)
def create_assert_call_method_block(
operator_module_path: str, hook_class_name: str, operator_class_block: ClassBlock
) -> MethodBlock:
ctor_method = next(
m for m in operator_class_block.methods_blocks if m.name == "__init__"
)
ctor_args = [a for a in ctor_method.args.keys() if a not in ("*args", "**kwargs")]
method_name = find_client_call_method_name(operator_class_block)
return MethodBlock(
name="test_assert_valid_hook_call",
desc=None,
args={"mock_hook": ParameterBlock("mock_hook")},
return_kind=TypeBrick("None"),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"var_name": "task",
"target": operator_class_block.name,
"call_params": {a: f"TEST_{a.upper()}" for a in ctor_args},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "task.execute",
"call_params": {"context": "mock.MagicMock()"},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "mock_hook.assert_called_once_with",
"call_params": {"gcp_conn_id": "TEST_GCP_CONN_ID"},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": f"mock_hook.return_value.{method_name}.assert_called_once_with",
"call_params": {
a: f"TEST_{a.upper()}" for a in ctor_args if a != "gcp_conn_id"
},
},
),
],
decorator_blocks=[
CodeBlock(
"decorator_mock_hook.py.tpl",
template_params={
"class_path": f"{operator_module_path}.{hook_class_name}"
},
)
],
)
def _create_method(name: str, args: List[str]):
return MethodBlock(
name=name,
desc=None,
args={a: mock.MagicMock() for a in args},
return_kind=None,
return_desc=None,
code_blocks=[],
decorator_blocks=[],
)
def _create_method(name: str):
return MethodBlock(
name=name,
desc=None,
args={},
return_kind=None,
return_desc=None,
code_blocks=[],
decorator_blocks=[],
)
def test_generate_method_block(self):
client_info = mock.MagicMock(
**{"ctor_method.desc": ["DESC_A", "DESC_B"]})
integration = Integration(
service_name="SERVICE_NAME",
class_prefix="CLASS_PREFIX",
file_prefix="FILE_PREFFIX",
client_path="CLOENT_PATH",
)
method_block = hook_generator.generate_ctor_method_block(
client_info, integration)
self.assertEqual(
MethodBlock(
name="__init__",
desc=["DESC_A", "DESC_B"],
args={
"gcp_conn_id":
ParameterBlock(
name="gcp_conn_id",
kind=TypeBrick(kind="str", indexes=[]),
desc=None,
default_value=None,
),
"delegate_to":
ParameterBlock(
name="delegate_to",
kind=TypeBrick(kind="str", indexes=[]),
desc=None,
default_value=None,
),
},
return_kind=TypeBrick(kind="None", indexes=[]),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="super_call.py.tpl",
template_params={
"args": ["gcp_conn_id", "delegate_to"],
"kwargs": {},
},
),
CodeBlock(
template_name="set_field.py.tpl",
template_params={
"field_name": "_client",
"field_type": TypeBrick(kind="CLOENT_PATH",
indexes=[]),
"field_value": "None",
},
),
],
),
method_block,
)
def test_generate_test_method_for_client_call(self):
action_info = self._create_action("ACTION", ["ARG_1", "ARG_2"])
method_block = self._create_method("METHOD", ["ARG_2", "ARG_3"])
hook_class_path = "HOOK_CLASS_PATH"
result = hook_test_generator.generate_test_method_for_client_call(
action_info, method_block, hook_class_path, "PROJECT_ID_VALUE"
)
self.assertEqual(
MethodBlock(
name="test_METHOD",
desc=None,
args={
"mock_get_conn": ParameterBlock(
name="mock_get_conn", kind=None, desc=None, default_value=None
)
},
return_kind=TypeBrick(kind="None", indexes=[]),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "self.hook.METHOD",
"call_params": {
"ARG_2": "TEST_ARG_2",
"ARG_3": "TEST_ARG_3",
},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "mock_get_conn.ACTION.assert_called_once_with",
"call_params": {
"ARG_1": "TEST_ARG_1",
"ARG_2": "TEST_ARG_2",
},
},
),
],
decorator_blocks=[
CodeBlock(
template_name="decorator_mock_get_conn.py.tpl",
template_params={"class_path": "HOOK_CLASS_PATH"},
)
],
),
result,
)
def generate_get_conn_method_block(integration: Integration) -> MethodBlock:
method_block = MethodBlock(
name="get_conn",
desc=[
f"Retrieves client library object that allow access to {integration.service_name} service."
],
args={},
return_kind=integration.client_type_brick,
return_desc=[f"{integration.service_name} client object."],
code_blocks=[
CodeBlock(
template_name="get_conn_body.py.tpl",
template_params={"client": integration.client_type_brick},
)
],
)
return method_block
def generate_test_method_for_client_call(
action_info: ActionInfo,
hook_method_block: MethodBlock,
hook_class_path: str,
project_id_value: str,
):
code_blocks = [
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": f"self.hook.{hook_method_block.name}",
"call_params": {
arg_name: f"TEST_{arg_name.upper()}"
for arg_name in hook_method_block.args.keys()
},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target":
f"mock_get_conn.{action_info.name}.assert_called_once_with",
"call_params": {
arg_name: f"TEST_{arg_name.upper()}"
if arg_name != "project_id" else project_id_value
for arg_name in action_info.args.keys()
},
},
),
]
method_block = MethodBlock(
name=f"test_{hook_method_block.name}",
desc=None,
args={"mock_get_conn": ParameterBlock("mock_get_conn")},
return_kind=TypeBrick("None"),
return_desc=None,
code_blocks=code_blocks,
decorator_blocks=[
CodeBlock(
template_name="decorator_mock_get_conn.py.tpl",
template_params={"class_path": hook_class_path},
)
],
)
return method_block
def generate_setup_method_block(class_path: str, init_new: str) -> MethodBlock:
method_block = MethodBlock(
name="setUp",
desc=None,
args={},
return_kind=TypeBrick("None"),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="setup_mock.py.tpl",
template_params={
"class_path": class_path,
"new": init_new
},
)
],
)
return method_block
def test_generate_setup_method_block(self):
result = hook_test_generator.generate_setup_method_block(
class_path="CLASS_PATH", init_new="INIT_NEW"
)
self.assertEqual(
MethodBlock(
name="setUp",
desc=None,
args={},
return_kind=TypeBrick(kind="None", indexes=[]),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="setup_mock.py.tpl",
template_params={"class_path": "CLASS_PATH", "new": "INIT_NEW"},
)
],
decorator_blocks=[],
),
result,
)
def test_generate_test_method_for_call_without_project_id(self):
method_a = self._create_method("TEST_METHOD", ["ARG_A", "project_id"])
result = hook_test_generator.generate_test_method_for_call_without_project_id(
"HOOK_CLASS_PATH", method_a
)
self.assertEqual(
MethodBlock(
name="test_TEST_METHOD_without_project_id",
desc=None,
args={
"mock_get_conn": ParameterBlock(
name="mock_get_conn", kind=None, desc=None, default_value=None
)
},
return_kind=TypeBrick(kind="None", indexes=[]),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="method_call_assert_raises.py.tpl",
template_params={
"target": "self.hook.TEST_METHOD",
"call_params": {
"ARG_A": "TEST_ARG_A",
"project_id": "None",
},
},
)
],
decorator_blocks=[
CodeBlock(
template_name="decorator_mock_get_conn.py.tpl",
template_params={"class_path": "HOOK_CLASS_PATH"},
)
],
),
result,
)
def create_operator_class_block(hook_class_name: str, hook_method: MethodBlock,
integration: Integration) -> ClassBlock:
init_args = {
**dict(hook_method.args.items()),
"gcp_conn_id":
ParameterBlock("gcp_conn_id",
kind=TypeBrick("str"),
default_value="'google_cloud_default'"),
}
super_args = {
"*args": ParameterBlock("*args"),
"**kwargs": ParameterBlock("**kwargs"),
}
ctor_method_block = MethodBlock(
name="__init__",
desc=hook_method.desc,
args={
**init_args,
**super_args
},
return_kind=TypeBrick("None"),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="super_call.py.tpl",
template_params={
"args": list(super_args.keys()),
"kwargs": {}
},
),
*(CodeBlock(
template_name="set_field.py.tpl",
template_params={
"field_name": arg_name,
"field_value": arg_name,
"field_type": None,
},
) for arg_name in init_args.keys()),
],
decorator_blocks=[
CodeBlock(template_name="decorator_apply_defaults.py.tpl",
template_params={})
],
)
execute_method_block = MethodBlock(
name="execute",
desc=None,
args={"context": ParameterBlock("context", TypeBrick("Dict"))},
return_kind=None,
return_desc=None,
code_blocks=[
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"var_name": "hook",
"target": hook_class_name,
"call_params": {
"gcp_conn_id": "self.gcp_conn_id"
},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": f"hook.{hook_method.name}",
"call_params": {
arg_name: f"self.{arg_name}"
for arg_name in hook_method.args
},
},
),
],
decorator_blocks=[
CodeBlock(template_name="decorator_apply_defaults.py.tpl",
template_params={})
],
)
return ClassBlock(
name=
f"{integration.class_prefix}{utils.to_camel_case(hook_method.name)}Operator",
extend_class="airflow.models.BaseOperator",
methods_blocks=[ctor_method_block, execute_method_block],
)
def generate_method_block(action_info: ActionInfo, path_infos: Dict[str,
PathInfo],
integration: Integration) -> MethodBlock:
blocks: List[CodeBlock] = []
blocks.append(
CodeBlock(
template_name="method_call.py.tpl",
template_params=dict(var_name="client",
target="self.get_conn",
call_params={}),
))
optional_parameters: Dict[str, ParameterBlock] = {}
required_parameters: Dict[str, ParameterBlock] = {}
for arg in action_info.args.values():
if arg.name == "parent" or arg.name == "name":
new_req_params, new_opt_params, code = convert_path_parameter_block_to_individual_parameters(
path_parameter=arg,
path_infos=path_infos,
integration=integration)
required_parameters.update(new_req_params)
optional_parameters.update(new_opt_params)
blocks.append(code)
continue
kind = arg.kind
default_value = None
if kind and kind.is_optional:
kind = kind.indexes[0]
default_value = "None"
optional_parameters[arg.name] = ParameterBlock(
name=arg.name,
kind=kind,
desc=arg.desc,
default_value=default_value)
else:
required_parameters[arg.name] = ParameterBlock(
name=arg.name,
kind=kind,
desc=arg.desc,
default_value=default_value)
method_block = MethodBlock(
name=action_info.name,
desc=action_info.desc,
args={
**required_parameters,
**optional_parameters
},
return_kind=action_info.return_kind,
return_desc=action_info.return_desc,
code_blocks=blocks,
)
blocks.append(
CodeBlock(
template_name="method_call.py.tpl",
template_params=dict(
target=f"client.{action_info.name}",
var_name="result" if action_info.return_desc else None,
call_params={arg: arg
for arg in action_info.args},
),
))
if action_info.return_desc:
blocks.append(
CodeBlock(
template_name="return.py.tpl",
template_params=dict(
var_name="result" if action_info.return_desc else None),
))
return method_block
def test_generate_method_block(
self, mock_convert_path_parameter_block_to_individual_parameters):
action_info = ActionInfo(
name="NAME",
desc=["DESC_A", "DESC_B"],
args={
"ARG_A":
ParameterInfo(name="ARG_A",
kind=TypeBrick("str"),
desc=["DESC_C", "DESC_D"])
},
return_kind=TypeBrick("float"),
return_desc=["DESC_E", "DESC_F"],
)
integration = Integration(
service_name="SERVICE_NAME",
class_prefix="CLASS_PREFIX",
file_prefix="FILE_PREFFIX",
client_path="CLOENT_PATH",
)
method_block = hook_generator.generate_method_block(
action_info, path_infos="PATH_INFOS", integration=integration)
self.assertEqual(
MethodBlock(
name="NAME",
desc=["DESC_A", "DESC_B"],
args={
"ARG_A":
ParameterBlock(
name="ARG_A",
kind=TypeBrick(kind="str", indexes=[]),
desc=["DESC_C", "DESC_D"],
default_value=None,
)
},
return_kind=TypeBrick(kind="float", indexes=[]),
return_desc=["DESC_E", "DESC_F"],
code_blocks=[
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"var_name": "client",
"target": "self.get_conn",
"call_params": {},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "client.NAME",
"var_name": "result",
"call_params": {
"ARG_A": "ARG_A"
},
},
),
CodeBlock(
template_name="return.py.tpl",
template_params={"var_name": "result"},
),
],
decorator_blocks=[],
),
method_block,
)
def test_create_operator_class_block(self):
hook_class_name = "HOOK_CLASS_NAME"
integration = Integration(
service_name="SERVICE_NAME",
class_prefix="CLASS_PREFIX",
file_prefix="FILE_PREFFIX",
client_path="CLOENT_PATH",
)
hook_method = self._create_method("METHOD_A", ["arg_a", "arg_b"])
result = operator_generator.create_operator_class_block(
hook_class_name, hook_method, integration=integration)
self.assertEqual(
ClassBlock(
name="CLASS_PREFIXMethodAOperator",
extend_class="airflow.models.BaseOperator",
methods_blocks=[
MethodBlock(
name="__init__",
desc=None,
args={
"arg_a":
ParameterBlock(name="arg_a",
kind=None,
desc=None,
default_value=None),
"arg_b":
ParameterBlock(name="arg_b",
kind=None,
desc=None,
default_value=None),
"gcp_conn_id":
ParameterBlock(
name="gcp_conn_id",
kind=TypeBrick(kind="str"),
desc=None,
default_value="'google_cloud_default'",
),
"*args":
ParameterBlock(name="*args",
kind=None,
desc=None,
default_value=None),
"**kwargs":
ParameterBlock(
name="**kwargs",
kind=None,
desc=None,
default_value=None,
),
},
return_kind=TypeBrick(kind="None"),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="super_call.py.tpl",
template_params={
"args": ["*args", "**kwargs"],
"kwargs": {},
},
),
CodeBlock(
template_name="set_field.py.tpl",
template_params={
"field_name": "arg_a",
"field_value": "arg_a",
"field_type": None,
},
),
CodeBlock(
template_name="set_field.py.tpl",
template_params={
"field_name": "arg_b",
"field_value": "arg_b",
"field_type": None,
},
),
CodeBlock(
template_name="set_field.py.tpl",
template_params={
"field_name": "gcp_conn_id",
"field_value": "gcp_conn_id",
"field_type": None,
},
),
],
decorator_blocks=[
CodeBlock(
template_name="decorator_apply_defaults.py.tpl",
template_params={},
)
],
),
MethodBlock(
name="execute",
desc=None,
args={
"context":
ParameterBlock(
name="context",
kind=TypeBrick(kind="Dict"),
desc=None,
default_value=None,
)
},
return_kind=None,
return_desc=None,
code_blocks=[
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"var_name": "hook",
"target": "HOOK_CLASS_NAME",
"call_params": {
"gcp_conn_id": "self.gcp_conn_id"
},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "hook.METHOD_A",
"call_params": {
"arg_a": "self.arg_a",
"arg_b": "self.arg_b",
},
},
),
],
decorator_blocks=[],
),
],
),
result,
)
def test_create_assert_call_method_block(self, mock_find_client_call_method_name):
operator_module_path = "OPERATOR_MODULE_PATH"
hook_class_name = "CloudMemorystoreHook"
operator_class_block = ClassBlock(
name="CloudMemorystoreCreateInstanceOperator",
extend_class="airflow.models.BaseOperator",
methods_blocks=[
MethodBlock(
name="__init__",
desc=[
"Creates a Redis instance based on the specified tier and memory size."
],
args={
"location": ParameterBlock(
name="location",
kind=TypeBrick(kind="str"),
desc=["TODO: Fill description"],
default_value=None,
),
"instance_id": ParameterBlock(
name="instance_id", kind=TypeBrick(kind="str")
),
"instance": ParameterBlock(
name="instance",
kind=TypeBrick(
kind="Union",
indexes=[
TypeBrick(kind="Dict"),
TypeBrick(
kind="google.cloud.redis_v1.types.Instance"
),
],
),
),
"project_id": ParameterBlock(
name="project_id",
kind=TypeBrick(kind="str"),
desc=["TODO: Fill description"],
default_value="None",
),
"retry": ParameterBlock(
name="retry",
kind=TypeBrick(kind="google.api_core.retry.Retry"),
default_value="None",
),
"timeout": ParameterBlock(
name="timeout",
kind=TypeBrick(kind="float"),
default_value="None",
),
"metadata": ParameterBlock(
name="metadata",
kind=TypeBrick(
kind="Sequence",
indexes=[
TypeBrick(
kind="Tuple",
indexes=[
TypeBrick(kind="str"),
TypeBrick(kind="str"),
],
)
],
),
default_value="None",
),
"gcp_conn_id": ParameterBlock(
name="gcp_conn_id",
kind=TypeBrick(kind="str"),
desc=None,
default_value="'google_cloud_default'",
),
"*args": ParameterBlock(name="*args"),
"**kwargs": ParameterBlock(name="**kwargs"),
},
return_kind=TypeBrick(kind="None"),
return_desc=None,
code_blocks=[],
decorator_blocks=[],
)
],
)
result = operator_test_generator.create_assert_call_method_block(
operator_module_path, hook_class_name, operator_class_block
)
self.assertEqual(
MethodBlock(
name="test_assert_valid_hook_call",
desc=None,
args={"mock_hook": ParameterBlock(name="mock_hook")},
return_kind=TypeBrick(kind="None"),
return_desc=None,
code_blocks=[
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"var_name": "task",
"target": "CloudMemorystoreCreateInstanceOperator",
"call_params": {
"location": "TEST_LOCATION",
"instance_id": "TEST_INSTANCE_ID",
"instance": "TEST_INSTANCE",
"project_id": "TEST_PROJECT_ID",
"retry": "TEST_RETRY",
"timeout": "TEST_TIMEOUT",
"metadata": "TEST_METADATA",
"gcp_conn_id": "TEST_GCP_CONN_ID",
},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "task.execute",
"call_params": {"context": "mock.MagicMock()"},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "mock_hook.assert_called_once_with",
"call_params": {"gcp_conn_id": "TEST_GCP_CONN_ID"},
},
),
CodeBlock(
template_name="method_call.py.tpl",
template_params={
"target": "mock_hook.return_value.METHOD_NAME.assert_called_once_with",
"call_params": {
"location": "TEST_LOCATION",
"instance_id": "TEST_INSTANCE_ID",
"instance": "TEST_INSTANCE",
"project_id": "TEST_PROJECT_ID",
"retry": "TEST_RETRY",
"timeout": "TEST_TIMEOUT",
"metadata": "TEST_METADATA",
},
},
),
],
decorator_blocks=[
CodeBlock(
template_name="decorator_mock_hook.py.tpl",
template_params={
"class_path": "OPERATOR_MODULE_PATH.CloudMemorystoreHook"
},
)
],
),
result,
)
mock_find_client_call_method_name.assert_called_once_with(operator_class_block)