ec2_vpc_endpoint/tasks/main.yml

---
- name: ec2_vpc_endpoint tests
  collections:
    - amazon.aws

  module_defaults:
    group/aws:
      aws_access_key: "{{ aws_access_key }}"
      aws_secret_key: "{{ aws_secret_key }}"
      security_token: "{{ security_token | default(omit) }}"
      region: "{{ aws_region }}"
  block:
  # ============================================================
  # BEGIN PRE-TEST SETUP
  - name: create a VPC
    ec2_vpc_net:
      state: present
      name: "{{ vpc_name }}"
      cidr_block: "{{ vpc_cidr }}"
      tags:
        AnsibleTest: 'ec2_vpc_endpoint'
        AnsibleRun: '{{ resource_prefix }}'
    register: vpc_creation
  - name: Assert success
    assert:
      that:
        - vpc_creation is successful

  - name: Create an IGW
    ec2_vpc_igw:
      vpc_id: "{{ vpc_creation.vpc.id }}"
      state: present
      tags:
        Name: "{{ resource_prefix }}"
        AnsibleTest: 'ec2_vpc_endpoint'
        AnsibleRun: '{{ resource_prefix }}'
    register: igw_creation
  - name: Assert success
    assert:
      that:
        - igw_creation is successful

  - name: Create a minimal route table (no routes)
    ec2_vpc_route_table:
      vpc_id: '{{ vpc_creation.vpc.id }}'
      tags:
        AnsibleTest: 'ec2_vpc_endpoint'
        AnsibleRun: '{{ resource_prefix }}'
        Name: '{{ resource_prefix }}-empty'
      subnets: []
      routes: []
    register: rtb_creation_empty

  - name: Create a minimal route table (with IGW)
    ec2_vpc_route_table:
      vpc_id: '{{ vpc_creation.vpc.id }}'
      tags:
        AnsibleTest: 'ec2_vpc_endpoint'
        AnsibleRun: '{{ resource_prefix }}'
        Name: '{{ resource_prefix }}-igw'
      subnets: []
      routes:
        - dest: 0.0.0.0/0
          gateway_id: "{{ igw_creation.gateway_id }}"
    register: rtb_creation_igw

  - name: Save VPC info in a fact
    set_fact:
      vpc_id: '{{ vpc_creation.vpc.id }}'
      rtb_empty_id: '{{ rtb_creation_empty.route_table.id }}'
      rtb_igw_id: '{{ rtb_creation_igw.route_table.id }}'

  # ============================================================
  # BEGIN TESTS

  # Minimal check_mode with _info
  - name: Fetch Endpoints in check_mode
    ec2_vpc_endpoint_info:
      query: endpoints
    register: endpoint_info
    check_mode: True
  - name: Assert success
    assert:
      that:
        # May be run in parallel, the only thing we can guarantee is
        # - we shouldn't error
        # - we should return 'vpc_endpoints' (even if it's empty)
        - endpoint_info is successful
        - '"vpc_endpoints" in endpoint_info'

  - name: Fetch Services in check_mode
    ec2_vpc_endpoint_info:
      query: services
    register: endpoint_info
    check_mode: True
  - name: Assert success
    assert:
      that:
        - endpoint_info is successful
        - '"service_names" in endpoint_info'
        # This is just 2 arbitrary AWS services that should (generally) be
        # available.  The actual list will vary over time and between regions
        - endpoint_service_a in endpoint_info.service_names
        - endpoint_service_b in endpoint_info.service_names

  # Fetch services without check mode
  # Note: Filters not supported on services via this module, this is all we can test for now
  - name: Fetch Services
    ec2_vpc_endpoint_info:
      query: services
    register: endpoint_info
  - name: Assert success
    assert:
      that:
        - endpoint_info is successful
        - '"service_names" in endpoint_info'
        # This is just 2 arbitrary AWS services that should (generally) be
        # available.  The actual list will vary over time and between regions
        - endpoint_service_a in endpoint_info.service_names
        - endpoint_service_b in endpoint_info.service_names

  # Attempt to create an endpoint
  - name: Create minimal endpoint (check mode)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
    register: create_endpoint_check
    check_mode: True
  - name: Assert changed
    assert:
      that:
        - create_endpoint_check is changed

  - name: Create minimal endpoint
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
      wait: true
    register: create_endpoint
  - name: Check standard return values
    assert:
      that:
        - create_endpoint is changed
        - '"result" in create_endpoint'
        - '"creation_timestamp" in create_endpoint.result'
        - '"dns_entries" in create_endpoint.result'
        - '"groups" in create_endpoint.result'
        - '"network_interface_ids" in create_endpoint.result'
        - '"owner_id" in create_endpoint.result'
        - '"policy_document" in create_endpoint.result'
        - '"private_dns_enabled" in create_endpoint.result'
        - create_endpoint.result.private_dns_enabled == False
        - '"requester_managed" in create_endpoint.result'
        - create_endpoint.result.requester_managed == False
        - '"service_name" in create_endpoint.result'
        - create_endpoint.result.service_name == endpoint_service_a
        - '"state" in create_endpoint.result'
        - create_endpoint.result.state == "available"
        - '"vpc_endpoint_id" in create_endpoint.result'
        - create_endpoint.result.vpc_endpoint_id.startswith("vpce-")
        - '"vpc_endpoint_type" in create_endpoint.result'
        - create_endpoint.result.vpc_endpoint_type == "Gateway"
        - '"vpc_id" in create_endpoint.result'
        - create_endpoint.result.vpc_id == vpc_id

  - name: Save Endpoint info in a fact
    set_fact:
      endpoint_id: '{{ create_endpoint.result.vpc_endpoint_id }}'

  # Pull info about the endpoints
  - name: Fetch Endpoints (all)
    ec2_vpc_endpoint_info:
      query: endpoints
    register: endpoint_info
  - name: Assert success
    assert:
      that:
        # We're fetching all endpoints, there's no guarantee what the values
        # will be
        - endpoint_info is successful
        - '"vpc_endpoints" in endpoint_info'
        - '"creation_timestamp" in first_endpoint'
        - '"policy_document" in first_endpoint'
        - '"route_table_ids" in first_endpoint'
        - first_endpoint.route_table_ids | length == 0
        - '"service_name" in first_endpoint'
        - '"state" in first_endpoint'
        - '"vpc_endpoint_id" in first_endpoint'
        - '"vpc_id" in first_endpoint'
        # Not yet documented, but returned
        - '"dns_entries" in first_endpoint'
        - '"groups" in first_endpoint'
        - '"network_interface_ids" in first_endpoint'
        - '"owner_id" in first_endpoint'
        - '"private_dns_enabled" in first_endpoint'
        - '"requester_managed" in first_endpoint'
        - '"subnet_ids" in first_endpoint'
        - '"tags" in first_endpoint'
        - '"vpc_endpoint_type" in first_endpoint'
        # Make sure our endpoint is included
        - endpoint_id in ( endpoint_info | community.general.json_query("vpc_endpoints[*].vpc_endpoint_id") | list | flatten )
    vars:
      first_endpoint: '{{ endpoint_info.vpc_endpoints[0] }}'

  - name: Fetch Endpoints (targetted by ID)
    ec2_vpc_endpoint_info:
      query: endpoints
      vpc_endpoint_ids: '{{ endpoint_id }}'
    register: endpoint_info
  - name: Assert success
    assert:
      that:
        - endpoint_info is successful
        - '"vpc_endpoints" in endpoint_info'
        - '"creation_timestamp" in first_endpoint'
        - '"policy_document" in first_endpoint'
        - '"route_table_ids" in first_endpoint'
        - first_endpoint.route_table_ids | length == 0
        - '"service_name" in first_endpoint'
        - first_endpoint.service_name == endpoint_service_a
        - '"state" in first_endpoint'
        - first_endpoint.state == "available"
        - '"vpc_endpoint_id" in first_endpoint'
        - first_endpoint.vpc_endpoint_id == endpoint_id
        - '"vpc_id" in first_endpoint'
        - first_endpoint.vpc_id == vpc_id
        # Not yet documented, but returned
        - '"dns_entries" in first_endpoint'
        - '"groups" in first_endpoint'
        - '"network_interface_ids" in first_endpoint'
        - '"owner_id" in first_endpoint'
        - '"private_dns_enabled" in first_endpoint'
        - first_endpoint.private_dns_enabled == False
        - '"requester_managed" in first_endpoint'
        - first_endpoint.requester_managed == False
        - '"subnet_ids" in first_endpoint'
        - '"tags" in first_endpoint'
        - '"vpc_endpoint_type" in first_endpoint'
    vars:
      first_endpoint: '{{ endpoint_info.vpc_endpoints[0] }}'

  - name: Fetch Endpoints (targetted by VPC)
    ec2_vpc_endpoint_info:
      query: endpoints
      filters:
        vpc-id:
        - '{{ vpc_id }}'
    register: endpoint_info
  - name: Assert success
    assert:
      that:
        - endpoint_info is successful
        - '"vpc_endpoints" in endpoint_info'
        - '"creation_timestamp" in first_endpoint'
        - '"policy_document" in first_endpoint'
        - '"route_table_ids" in first_endpoint'
        - '"service_name" in first_endpoint'
        - first_endpoint.service_name == endpoint_service_a
        - '"state" in first_endpoint'
        - first_endpoint.state == "available"
        - '"vpc_endpoint_id" in first_endpoint'
        - first_endpoint.vpc_endpoint_id == endpoint_id
        - '"vpc_id" in first_endpoint'
        - first_endpoint.vpc_id == vpc_id
        # Not yet documented, but returned
        - '"dns_entries" in first_endpoint'
        - '"groups" in first_endpoint'
        - '"network_interface_ids" in first_endpoint'
        - '"owner_id" in first_endpoint'
        - '"private_dns_enabled" in first_endpoint'
        - first_endpoint.private_dns_enabled == False
        - '"requester_managed" in first_endpoint'
        - first_endpoint.requester_managed == False
        - '"subnet_ids" in first_endpoint'
        - '"tags" in first_endpoint'
        - '"vpc_endpoint_type" in first_endpoint'
    vars:
      first_endpoint: '{{ endpoint_info.vpc_endpoints[0] }}'


  # matches on parameters without explicitly passing the endpoint ID
  - name: Create minimal endpoint - idempotency (check mode)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
    register: create_endpoint_idem_check
    check_mode: True
  - assert:
      that:
        - create_endpoint_idem_check is not changed

  - name: Create minimal endpoint - idempotency
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
    register: create_endpoint_idem
  - assert:
      that:
        - create_endpoint_idem is not changed

  - name: Delete minimal endpoint by ID (check_mode)
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ endpoint_id }}"
    check_mode: true
    register: endpoint_delete_check
  - assert:
      that:
        - endpoint_delete_check is changed


  - name: Delete minimal endpoint by ID
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ endpoint_id }}"
    register: endpoint_delete_check
  - assert:
      that:
        - endpoint_delete_check is changed

  - name: Delete minimal endpoint by ID - idempotency (check_mode)
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ endpoint_id }}"
    check_mode: true
    register: endpoint_delete_check
  - assert:
      that:
        - endpoint_delete_check is not changed

  - name: Delete minimal endpoint by ID - idempotency
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ endpoint_id }}"
    register: endpoint_delete_check
  - assert:
      that:
        - endpoint_delete_check is not changed

  - name: Fetch Endpoints by ID (expect failed)
    ec2_vpc_endpoint_info:
      query: endpoints
      vpc_endpoint_ids: "{{ endpoint_id }}"
    ignore_errors: True
    register: endpoint_info
  - name: Assert endpoint does not exist
    assert:
      that:
        - endpoint_info is successful
        - '"does not exist" in endpoint_info.msg'
        - endpoint_info.vpc_endpoints | length == 0

  # Attempt to create an endpoint with a route table
  - name: Create an endpoint with route table (check mode)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_empty_id }}'
    register: create_endpoint_check
    check_mode: True
  - name: Assert changed
    assert:
      that:
        - create_endpoint_check is changed

  - name: Create an endpoint with route table
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_empty_id }}'
      wait: true
    register: create_rtb_endpoint
  - name: Check standard return values
    assert:
      that:
        - create_rtb_endpoint is changed
        - '"result" in create_rtb_endpoint'
        - '"creation_timestamp" in create_rtb_endpoint.result'
        - '"dns_entries" in create_rtb_endpoint.result'
        - '"groups" in create_rtb_endpoint.result'
        - '"network_interface_ids" in create_rtb_endpoint.result'
        - '"owner_id" in create_rtb_endpoint.result'
        - '"policy_document" in create_rtb_endpoint.result'
        - '"private_dns_enabled" in create_rtb_endpoint.result'
        - '"route_table_ids" in create_rtb_endpoint.result'
        - create_rtb_endpoint.result.route_table_ids | length == 1
        - create_rtb_endpoint.result.route_table_ids[0] == '{{ rtb_empty_id }}'
        - create_rtb_endpoint.result.private_dns_enabled == False
        - '"requester_managed" in create_rtb_endpoint.result'
        - create_rtb_endpoint.result.requester_managed == False
        - '"service_name" in create_rtb_endpoint.result'
        - create_rtb_endpoint.result.service_name == endpoint_service_a
        - '"state" in create_endpoint.result'
        - create_rtb_endpoint.result.state == "available"
        - '"vpc_endpoint_id" in create_rtb_endpoint.result'
        - create_rtb_endpoint.result.vpc_endpoint_id.startswith("vpce-")
        - '"vpc_endpoint_type" in create_rtb_endpoint.result'
        - create_rtb_endpoint.result.vpc_endpoint_type == "Gateway"
        - '"vpc_id" in create_rtb_endpoint.result'
        - create_rtb_endpoint.result.vpc_id == vpc_id

  - name: Save Endpoint info in a fact
    set_fact:
      rtb_endpoint_id: '{{ create_rtb_endpoint.result.vpc_endpoint_id }}'

  - name: Create an endpoint with route table - idempotency (check mode)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_empty_id }}'
    register: create_endpoint_check
    check_mode: True
  - name: Assert changed
    assert:
      that:
        - create_endpoint_check is not changed

  - name: Create an endpoint with route table - idempotency
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_empty_id }}'
    register: create_endpoint_check
    check_mode: True
  - name: Assert changed
    assert:
      that:
        - create_endpoint_check is not changed

# # Endpoint modifications are not yet supported by the module
#  # A Change the route table for the endpoint
#  - name: Change the route table for the endpoint (check_mode)
#    ec2_vpc_endpoint:
#      state: present
#      vpc_id: '{{ vpc_id }}'
#      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
#      service: '{{ endpoint_service_a }}'
#      route_table_ids:
#        - '{{ rtb_igw_id }}'
#    check_mode: True
#    register: check_two_rtbs_endpoint
#
#  - name: Assert second route table would be added
#    assert:
#      that:
#        - check_two_rtbs_endpoint.changed
#
#  - name: Change the route table for the endpoint
#    ec2_vpc_endpoint:
#      state: present
#      vpc_id: '{{ vpc_id }}'
#      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
#      service: '{{ endpoint_service_a }}'
#      route_table_ids:
#        - '{{ rtb_igw_id }}'
#    register: two_rtbs_endpoint
#
#  - name: Assert second route table would be added
#    assert:
#      that:
#        - check_two_rtbs_endpoint.changed
#        - two_rtbs_endpoint.result.route_table_ids | length == 1
#        - two_rtbs_endpoint.result.route_table_ids[0] == '{{ rtb_igw_id }}'
#
#  - name: Change the route table for the endpoint - idempotency (check_mode)
#    ec2_vpc_endpoint:
#      state: present
#      vpc_id: '{{ vpc_id }}'
#      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
#      service: '{{ endpoint_service_a }}'
#      route_table_ids:
#        - '{{ rtb_igw_id }}'
#    check_mode: True
#    register: check_two_rtbs_endpoint
#
#  - name: Assert route table would not change
#    assert:
#      that:
#        - not check_two_rtbs_endpoint.changed
#
#  - name: Change the route table for the endpoint - idempotency
#    ec2_vpc_endpoint:
#      state: present
#      vpc_id: '{{ vpc_id }}'
#      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
#      service: '{{ endpoint_service_a }}'
#      route_table_ids:
#        - '{{ rtb_igw_id }}'
#    register: two_rtbs_endpoint
#
#  - name: Assert route table would not change
#    assert:
#      that:
#        - not check_two_rtbs_endpoint.changed

  - name: Tag the endpoint (check_mode)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_empty_id }}'
      tags:
        camelCase: "helloWorld"
        PascalCase: "HelloWorld"
        snake_case: "hello_world"
        "Title Case": "Hello World"
        "lowercase spaced": "hello world"
    check_mode: true
    register: check_tag_vpc_endpoint

  - name: Assert tags would have changed
    assert:
      that:
        - check_tag_vpc_endpoint.changed

  - name: Tag the endpoint
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_igw_id }}'
      tags:
        testPrefix: '{{ resource_prefix }}'
        camelCase: "helloWorld"
        PascalCase: "HelloWorld"
        snake_case: "hello_world"
        "Title Case": "Hello World"
        "lowercase spaced": "hello world"
    register: tag_vpc_endpoint

  - name: Assert tags are successful
    assert:
      that:
        - tag_vpc_endpoint.changed
        - tag_vpc_endpoint.result.tags | length == 6
        - endpoint_tags["testPrefix"] == resource_prefix
        - endpoint_tags["camelCase"] == "helloWorld"
        - endpoint_tags["PascalCase"] == "HelloWorld"
        - endpoint_tags["snake_case"] == "hello_world"
        - endpoint_tags["Title Case"] == "Hello World"
        - endpoint_tags["lowercase spaced"] == "hello world"
    vars:
      endpoint_tags: "{{ tag_vpc_endpoint.result.tags | items2dict(key_name='Key', value_name='Value') }}"

  - name: Query by tag
    ec2_vpc_endpoint_info:
      query: endpoints
      filters:
        "tag:testPrefix":
        - "{{ resource_prefix }}"
    register: tag_result

  - name: Assert tag lookup found endpoint
    assert:
      that:
        - tag_result is successful
        - '"vpc_endpoints" in tag_result'
        - first_endpoint.vpc_endpoint_id == rtb_endpoint_id
    vars:
      first_endpoint: '{{ tag_result.vpc_endpoints[0] }}'

  - name: Tag the endpoint - idempotency (check_mode)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_igw_id }}'
      tags:
        testPrefix: '{{ resource_prefix }}'
        camelCase: "helloWorld"
        PascalCase: "HelloWorld"
        snake_case: "hello_world"
        "Title Case": "Hello World"
        "lowercase spaced": "hello world"
    register: tag_vpc_endpoint_again

  - name: Assert tags would not change
    assert:
      that:
        - not tag_vpc_endpoint_again.changed

  - name: Tag the endpoint - idempotency
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_igw_id }}'
      tags:
        testPrefix: '{{ resource_prefix }}'
        camelCase: "helloWorld"
        PascalCase: "HelloWorld"
        snake_case: "hello_world"
        "Title Case": "Hello World"
        "lowercase spaced": "hello world"
    register: tag_vpc_endpoint_again

  - name: Assert tags would not change
    assert:
      that:
        - not tag_vpc_endpoint_again.changed

  - name: Add a tag (check_mode)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_igw_id }}'
      tags:
        new_tag: "ANewTag"
    check_mode: true
    register: check_tag_vpc_endpoint

  - name: Assert tags would have changed
    assert:
      that:
        - check_tag_vpc_endpoint.changed

  - name: Add a tag (purge_tags=False)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_igw_id }}'
      tags:
        new_tag: "ANewTag"
    register: add_tag_vpc_endpoint

  - name: Assert tags changed
    assert:
      that:
        - add_tag_vpc_endpoint.changed
        - add_tag_vpc_endpoint.result.tags | length == 7
        - endpoint_tags["testPrefix"] == resource_prefix
        - endpoint_tags["camelCase"] == "helloWorld"
        - endpoint_tags["PascalCase"] == "HelloWorld"
        - endpoint_tags["snake_case"] == "hello_world"
        - endpoint_tags["Title Case"] == "Hello World"
        - endpoint_tags["lowercase spaced"] == "hello world"
        - endpoint_tags["new_tag"] == "ANewTag"
    vars:
      endpoint_tags: "{{ add_tag_vpc_endpoint.result.tags | items2dict(key_name='Key', value_name='Value') }}"

  - name: Add a tag (purge_tags=True)
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
      service: '{{ endpoint_service_a }}'
      route_table_ids:
        - '{{ rtb_igw_id }}'
      tags:
        another_new_tag: "AnotherNewTag"
      purge_tags: True
    register: purge_tag_vpc_endpoint

  - name: Assert tags changed
    assert:
      that:
        - purge_tag_vpc_endpoint.changed
        - purge_tag_vpc_endpoint.result.tags | length == 1
        - endpoint_tags["another_new_tag"] == "AnotherNewTag"
    vars:
      endpoint_tags: "{{ purge_tag_vpc_endpoint.result.tags | items2dict(key_name='Key', value_name='Value') }}"

  - name: Delete minimal route table (no routes)
    ec2_vpc_route_table:
      state: absent
      lookup: id
      route_table_id: "{{ rtb_empty_id }}"
    register: rtb_delete
  - assert:
      that:
        - rtb_delete is changed

  - name: Delete minimal route table (IGW route)
    ec2_vpc_route_table:
      state: absent
      lookup: id
      route_table_id: "{{ rtb_igw_id }}"
  - assert:
      that:
        - rtb_delete is changed

  - name: Delete route table endpoint by ID
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
    register: endpoint_delete_check
  - assert:
      that:
        - endpoint_delete_check is changed

  - name: Delete minimal endpoint by ID - idempotency (check_mode)
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ rtb_endpoint_id }}"
    check_mode: true
    register: endpoint_delete_check
  - assert:
      that:
        - endpoint_delete_check is not changed

  - name: Delete endpoint by ID - idempotency
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ endpoint_id }}"
    register: endpoint_delete_check
  - assert:
      that:
        - endpoint_delete_check is not changed

  - name: Create interface endpoint
    ec2_vpc_endpoint:
      state: present
      vpc_id: '{{ vpc_id }}'
      service: '{{ endpoint_service_a }}'
      vpc_endpoint_type: Interface
    register: create_interface_endpoint
  - name: Check that the interface endpoint was created properly
    assert:
      that:
        - create_interface_endpoint is changed
        - create_interface_endpoint.result.vpc_endpoint_type == "Interface"
  - name: Delete interface endpoint
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ create_interface_endpoint.result.vpc_endpoint_id }}"
    register: interface_endpoint_delete_check
  - assert:
      that:
        - interface_endpoint_delete_check is changed

  # ============================================================
  # BEGIN POST-TEST CLEANUP
  always:
  # Delete the routes first - you can't delete an endpoint with a route
  # attached.
  - name: Delete minimal route table (no routes)
    ec2_vpc_route_table:
      state: absent
      lookup: id
      route_table_id: "{{ rtb_creation_empty.route_table.id }}"
    ignore_errors: True

  - name: Delete minimal route table (IGW route)
    ec2_vpc_route_table:
      state: absent
      lookup: id
      route_table_id: "{{ rtb_creation_igw.route_table.id }}"
    ignore_errors: True

  - name: Delete endpoint
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ create_endpoint.result.vpc_endpoint_id }}"
    ignore_errors: True

  - name: Delete endpoint
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: "{{ create_rtb_endpoint.result.vpc_endpoint_id }}"
    ignore_errors: True

  - name: Query any remain endpoints we created (idempotency work is ongoing)  # FIXME
    ec2_vpc_endpoint_info:
      query: endpoints
      filters:
        vpc-id:
          - '{{ vpc_id }}'
    register: test_endpoints

  - name: Delete all endpoints
    ec2_vpc_endpoint:
      state: absent
      vpc_endpoint_id: '{{ item.vpc_endpoint_id }}'
    with_items: '{{ test_endpoints.vpc_endpoints }}'
    ignore_errors: True

  - name: Remove IGW
    ec2_vpc_igw:
      state: absent
      vpc_id: "{{ vpc_id }}"
    register: igw_deletion
    retries: 10
    delay: 5
    until: igw_deletion is success
    ignore_errors: yes

  - name: Remove VPC
    ec2_vpc_net:
      state: absent
      name: "{{ vpc_name }}"
      cidr_block: "{{ vpc_cidr }}"
    ignore_errors: true