code: def testRun_ExecutionCompleted(self):
      with self._mlmd_connection as m:
          # Publishes two models which will be consumed by downstream resolver.
          output_model_1 = self._create_model_artifact(
              uri="my_model_uri_1"
          )
          output_model_2 = self._create_model_artifact(
              uri="my_model_uri_2"
          )
  
          contexts = context_lib.prepare_contexts(
              m, self._my_trainer.contexts
          )
          execution = execution_publish_utils.register_execution(
              m, self._my_trainer.node_info.type, contexts
          )
          execution_publish_utils.publish_succeeded_execution(
              m,
              execution.id,
              contexts,
              {
                  "model": [output_model_1, output_model_2],
              },
          )
  
      handler = resolver_node_handler.ResolverNodeHandler()
      execution_info = handler.run(
          mlmd_connection=self._mlmd_connection,
          pipeline_node=self._my_resolver,
          pipeline_info=self._pipeline_info,
          pipeline_runtime_spec=self._pipeline_runtime_spec,
      )
  
      with self._mlmd_connection as m:
          resolved_inputs = inputs_utils.resolve_input_artifacts(
              metadata_handle=m, pipeline_node=self._my_resolver
          )
          self.assertLen(resolved_inputs, 1)
          self.assertIn("models", resolved_inputs[0])
          self.assertLen(resolved_inputs[0]["models"], 1)
          self.assertProtoPartiallyEquals(
              f"""
            id: 2
            uri: "my_model_uri_2"
            state: LIVE
            custom_properties {{
              key: '{artifact_utils.ARTIFACT_TFX_VERSION_CUSTOM_PROPERTY_KEY}'
              value {{string_value: "{version.__version__}"}}
            }}""",
              resolved_inputs[0]["models"][0].mlmd_artifact,
              ignored_fields=[
                  "type_id",
                  "type",
                  "create_time_since_epoch",
                  "last_update_time_since_epoch",
              ],
          )
          [execution] = m.store.get_executions_by_id(
              [execution_info.execution_id]
          )
  
          self.assertProtoPartiallyEquals(
              """
            id: 2
            last_known_state: COMPLETE
            """,
              execution,
              ignored_fields=[
                  "type_id",
                  "type",
                  "create_time_since_epoch",
                  "last_update_time_since_epoch",
                  "name",
              ],
          )
  
imports: import os
  from unittest import mock
  import tensorflow
  from tfx import types
  from tfx import version
  from tfx.dsl.compiler import constants
  from tfx.orchestration import metadata
  from tfx.orchestration.portable import execution_publish_utils
  from tfx.orchestration.portable import inputs_utils
  from tfx.orchestration.portable import resolver_node_handler
  from tfx.orchestration.portable import runtime_parameter_utils
  from tfx.orchestration.portable.input_resolution import exceptions
  from tfx.orchestration.portable.mlmd import context_lib
  from tfx.proto.orchestration import pipeline_pb2
  from tfx.types import artifact_utils
  from tfx.utils import test_case_utils
label_desc: Use image node_id 3 for calling the ResolverNodeHandlerTest obj's underlying member method code with example usage: obj.testRun_ExecutionCompleted() without return types