moto 5.0.10.dev15__tar.gz → 5.0.10.dev18__tar.gz

{moto-5.0.10.dev15/moto.egg-info → moto-5.0.10.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 5.0.10.dev15
+Version: 5.0.10.dev18
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: spulec@gmail.com

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.10.dev15"
+__version__ = "5.0.10.dev18"

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/moto/cognitoidp/models.py

@@ -1212,6 +1212,7 @@ class CognitoIdpBackend(BaseBackend):
         group = self.get_group(user_pool_id, group_name)
         return list(filter(lambda user: user in group.users, user_pool.users.values()))
 
+    @paginate(pagination_model=PAGINATION_MODEL)
     def admin_list_groups_for_user(
         self, user_pool_id: str, username: str
     ) -> List[CognitoIdpGroup]:

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/moto/cognitoidp/responses.py

@@ -307,8 +307,15 @@ class CognitoIdpResponse(BaseResponse):
     def admin_list_groups_for_user(self) -> str:
         username = self._get_param("Username")
         user_pool_id = self._get_param("UserPoolId")
-        groups = self.backend.admin_list_groups_for_user(user_pool_id, username)
-        return json.dumps({"Groups": [group.to_json() for group in groups]})
+        limit = self._get_param("Limit")
+        token = self._get_param("NextToken")
+        groups, token = self.backend.admin_list_groups_for_user(
+            user_pool_id, username, limit=limit, next_token=token
+        )
+        response = {"Groups": [group.to_json() for group in groups]}
+        if token:
+            response["NextToken"] = token
+        return json.dumps(response)
 
     def admin_remove_user_from_group(self) -> str:
         user_pool_id = self._get_param("UserPoolId")

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/moto/cognitoidp/utils.py

@@ -44,6 +44,12 @@ PAGINATION_MODEL = {
         "limit_default": 60,
         "unique_attribute": "group_name",
     },
+    "admin_list_groups_for_user": {
+        "input_token": "next_token",
+        "limit_key": "limit",
+        "limit_default": 60,
+        "unique_attribute": "group_name",
+    },
     "list_users_in_group": {
         "input_token": "next_token",
         "limit_key": "limit",

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/moto/elbv2/models.py

@@ -144,6 +144,8 @@ class FakeTargetGroup(CloudFormationModel):
             self.attributes["stickiness.type"] = "source_ip"
 
         self.targets: Dict[str, Dict[str, Any]] = OrderedDict()
+        self.deregistered_targets: Dict[str, Dict[str, Any]] = OrderedDict()
+        self.terminated_targets: Dict[str, Dict[str, Any]] = OrderedDict()
 
     @property
     def physical_resource_id(self) -> str:
@@ -155,17 +157,20 @@ class FakeTargetGroup(CloudFormationModel):
                 "id": target["id"],
                 "port": target.get("port", self.port),
             }
+            self.deregistered_targets.pop(target["id"], None)
 
     def deregister(self, targets: List[Dict[str, Any]]) -> None:
         for target in targets:
             t = self.targets.pop(target["id"], None)
             if not t:
                 raise InvalidTargetError()
+            self.deregistered_targets[target["id"]] = t
 
     def deregister_terminated_instances(self, instance_ids: List[str]) -> None:
         for target_id in list(self.targets.keys()):
             if target_id in instance_ids:
-                del self.targets[target_id]
+                t = self.targets.pop(target_id)
+                self.terminated_targets[target_id] = t
 
     def health_for(self, target: Dict[str, Any], ec2_backend: Any) -> FakeHealthStatus:
         t = self.targets.get(target["id"])
@@ -173,6 +178,25 @@ class FakeTargetGroup(CloudFormationModel):
             port = self.port
             if "port" in target:
                 port = target["port"]
+            if target["id"] in self.deregistered_targets:
+                return FakeHealthStatus(
+                    target["id"],
+                    port,
+                    self.healthcheck_port,
+                    "unused",
+                    "Target.NotRegistered",
+                    "Target is not registered to the target group",
+                )
+            if target["id"] in self.terminated_targets:
+                return FakeHealthStatus(
+                    target["id"],
+                    port,
+                    self.healthcheck_port,
+                    "draining",
+                    "Target.DeregistrationInProgress",
+                    "Target deregistration is in progress",
+                )
+
             return FakeHealthStatus(
                 target["id"],
                 port,

{moto-5.0.10.dev15 → moto-5.0.10.dev18/moto.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 5.0.10.dev15
+Version: 5.0.10.dev18
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: spulec@gmail.com

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/moto.egg-info/SOURCES.txt

@@ -1798,6 +1798,7 @@ tests/test_elbv2/test_elbv2_listener_rules.py
 tests/test_elbv2/test_elbv2_listener_tags.py
 tests/test_elbv2/test_elbv2_set_subnets.py
 tests/test_elbv2/test_elbv2_target_groups.py
+tests/test_elbv2/test_elbv2_target_health.py
 tests/test_elbv2/test_server.py
 tests/test_emr/__init__.py
 tests/test_emr/test_emr_boto3.py

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = moto
-version = 5.0.10.dev15
+version = 5.0.10.dev18
 long_description = file:README.md
 long_description_content_type = text/markdown
 author = Steve Pulec

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/tests/test_cognitoidp/test_cognitoidp.py

@@ -1949,6 +1949,42 @@ def test_admin_list_groups_for_user_ignores_deleted_group():
     assert result["Groups"][0]["GroupName"] == group_name2
 
 
+@mock_aws
+def test_admin_list_groups_for_users_returns_pagination_tokens():
+    conn = boto3.client("cognito-idp", "us-west-2")
+    user_pool_id = conn.create_user_pool(PoolName=str(uuid.uuid4()))["UserPool"]["Id"]
+
+    # Given a user
+    username = str(uuid.uuid4())
+    conn.admin_create_user(UserPoolId=user_pool_id, Username=username)
+    # And given 10 groups
+    group_count = 10
+    for idx in range(group_count):
+        group_name = f"group_{idx}"
+        conn.create_group(UserPoolId=user_pool_id, GroupName=group_name)
+        conn.admin_add_user_to_group(
+            UserPoolId=user_pool_id, Username=username, GroupName=group_name
+        )
+
+    # When listing groups for the user pagination tokens are returned if limit is reached.
+    max_results = 5
+    result = conn.admin_list_groups_for_user(
+        UserPoolId=user_pool_id, Username=username, Limit=max_results
+    )
+    assert len(result["Groups"]) == max_results
+    assert "NextToken" in result
+
+    next_token = result["NextToken"]
+    result_2 = conn.admin_list_groups_for_user(
+        UserPoolId=user_pool_id,
+        Username=username,
+        Limit=max_results,
+        NextToken=next_token,
+    )
+    assert len(result_2["Groups"]) == max_results
+    assert "NextToken" not in result_2
+
+
 @mock_aws
 def test_admin_remove_user_from_group():
     conn = boto3.client("cognito-idp", "us-west-2")

moto-5.0.10.dev18/tests/test_elbv2/__init__.py

@@ -0,0 +1,31 @@
+import os
+from functools import wraps
+
+from moto import mock_aws
+
+
+def elbv2_aws_verified():
+    """
+    Function that is verified to work against AWS.
+    Can be run against AWS at any time by setting:
+      MOTO_TEST_ALLOW_AWS_REQUEST=true
+
+    If this environment variable is not set, the function runs in a `mock_aws` context.
+    """
+
+    def inner(func):
+        @wraps(func)
+        def pagination_wrapper():
+            allow_aws_request = (
+                os.environ.get("MOTO_TEST_ALLOW_AWS_REQUEST", "false").lower() == "true"
+            )
+
+            if allow_aws_request:
+                return func(True)
+            else:
+                with mock_aws():
+                    return func(False)
+
+        return pagination_wrapper
+
+    return inner

{moto-5.0.10.dev15 → moto-5.0.10.dev18}/tests/test_elbv2/test_elbv2.py

@@ -482,7 +482,7 @@ def test_register_targets():
         return None
 
     def assert_target_not_registered(target):
-        assert target["TargetHealth"]["State"] == "unavailable"
+        assert target["TargetHealth"]["State"] == "unused"
         assert target["TargetHealth"]["Reason"] == "Target.NotRegistered"
 
     response = conn.describe_target_health(

moto-5.0.10.dev18/tests/test_elbv2/test_elbv2_target_health.py

@@ -0,0 +1,331 @@
+from time import sleep
+from uuid import uuid4
+
+import boto3
+import pytest
+
+from . import elbv2_aws_verified
+
+
+@elbv2_aws_verified()
+@pytest.mark.aws_verified
+def test_register_targets(target_is_aws=False):
+    conn = boto3.client("elbv2", region_name="us-east-1")
+    ec2 = boto3.resource("ec2", region_name="us-east-1")
+    ec2_client = boto3.client("ec2", region_name="us-east-1")
+
+    lb_name = f"lb-{str(uuid4())[0:6]}"
+    sg_name = f"sg{str(uuid4())[0:6]}"
+    target_name = f"target-{str(uuid4())[0:6]}"
+
+    ssm = boto3.client("ssm", "us-east-1")
+    resp = ssm.get_parameters(
+        Names=["/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64"]
+    )
+    ami = resp["Parameters"][0]["Value"]
+
+    vpc = ec2.create_vpc(CidrBlock="172.28.7.0/24", InstanceTenancy="default")
+    igw_id = ec2_client.create_internet_gateway()["InternetGateway"][
+        "InternetGatewayId"
+    ]
+    vpc.attach_internet_gateway(InternetGatewayId=igw_id)
+    route_table = vpc.create_route_table()
+    route_table.create_route(DestinationCidrBlock="0.0.0.0/0", GatewayId=igw_id)
+    security_group = ec2.create_security_group(
+        GroupName=sg_name, Description="a", VpcId=vpc.id
+    )
+
+    ec2_client.authorize_security_group_ingress(
+        GroupId=security_group.id,
+        IpPermissions=[{"IpProtocol": "-1", "IpRanges": [{"CidrIp": "0.0.0.0/0"}]}],
+    )
+    subnet1 = vpc.create_subnet(
+        CidrBlock="172.28.7.192/26", AvailabilityZone="us-east-1a"
+    )
+    subnet2 = vpc.create_subnet(
+        CidrBlock="172.28.7.0/26", AvailabilityZone="us-east-1b"
+    )
+
+    route_table.associate_with_subnet(SubnetId=subnet1.id)
+    route_table.associate_with_subnet(SubnetId=subnet2.id)
+
+    load_balancer_arn = listener_arn = target_group_arn = instance_id1 = (
+        instance_id2
+    ) = None
+
+    try:
+        # Init-script that starts Apache
+        init_script = """#!/bin/bash
+sudo yum update -y
+sudo yum install -y httpd
+sudo systemctl start httpd
+sudo systemctl enable httpd"""
+
+        # Start EC2 instances first, to give them time to get ready
+        instance_id1 = ec2.create_instances(
+            ImageId=ami,
+            MinCount=1,
+            MaxCount=1,
+            KeyName="test2",
+            NetworkInterfaces=[
+                {
+                    "DeviceIndex": 0,
+                    "SubnetId": subnet1.id,
+                    "AssociatePublicIpAddress": True,
+                    "Groups": [security_group.id],
+                }
+            ],
+            UserData=init_script,
+        )[0].id
+        instance_id2 = ec2.create_instances(
+            ImageId=ami,
+            MinCount=1,
+            MaxCount=1,
+            KeyName="test2",
+            NetworkInterfaces=[
+                {
+                    "DeviceIndex": 0,
+                    "SubnetId": subnet2.id,
+                    "AssociatePublicIpAddress": True,
+                    "Groups": [security_group.id],
+                }
+            ],
+            UserData=init_script,
+        )[0].id
+
+        waiter = ec2_client.get_waiter("instance_running")
+        waiter.wait(InstanceIds=[instance_id1, instance_id2])
+
+        load_balancer_arn = conn.create_load_balancer(
+            Name=lb_name,
+            Subnets=[subnet1.id, subnet2.id],
+            SecurityGroups=[security_group.id],
+            Scheme="internal",
+            Tags=[{"Key": "key_name", "Value": "a_value"}],
+        )["LoadBalancers"][0]["LoadBalancerArn"]
+        waiter = conn.get_waiter("load_balancer_available")
+        waiter.wait(LoadBalancerArns=[load_balancer_arn])
+
+        target_group_arn = conn.create_target_group(
+            Name=target_name,
+            Protocol="HTTP",
+            Port=80,
+            VpcId=vpc.id,
+            HealthCheckProtocol="HTTP",
+            HealthCheckPort="80",
+            HealthCheckPath="/",
+            HealthCheckIntervalSeconds=5,
+            HealthCheckTimeoutSeconds=3,
+            HealthyThresholdCount=5,
+            UnhealthyThresholdCount=2,
+            # Apache returns a 403 (with text: 'It Works!') by default if no other pages are available
+            Matcher={"HttpCode": "403"},
+        )["TargetGroups"][0]["TargetGroupArn"]
+
+        # No targets registered yet
+        healths = conn.describe_target_health(TargetGroupArn=target_group_arn)[
+            "TargetHealthDescriptions"
+        ]
+        assert len(healths) == 0
+
+        listener_arn = conn.create_listener(
+            LoadBalancerArn=load_balancer_arn,
+            Protocol="HTTP",
+            Port=80,
+            DefaultActions=[
+                {
+                    "Type": "forward",
+                    "TargetGroupArn": target_group_arn,
+                }
+            ],
+        )["Listeners"][0]["ListenerArn"]
+
+        # Register target
+        # Verify that they are healthy
+        conn.register_targets(
+            TargetGroupArn=target_group_arn,
+            Targets=[{"Id": instance_id1}, {"Id": instance_id2}],
+        )
+        waiter = conn.get_waiter("target_in_service")
+        waiter.wait(TargetGroupArn=target_group_arn)
+
+        healths = conn.describe_target_health(TargetGroupArn=target_group_arn)[
+            "TargetHealthDescriptions"
+        ]
+        assert {
+            "Target": {"Id": instance_id1, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {"State": "healthy"},
+        } in healths
+        assert {
+            "Target": {"Id": instance_id2, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {"State": "healthy"},
+        } in healths
+
+        # De-register target
+        # Verify that they no longer appear when describing health
+        conn.deregister_targets(
+            TargetGroupArn=target_group_arn,
+            Targets=[{"Id": instance_id1}],
+        )
+        waiter = conn.get_waiter("target_deregistered")
+        waiter.wait(TargetGroupArn=target_group_arn, Targets=[{"Id": instance_id1}])
+
+        healths = conn.describe_target_health(TargetGroupArn=target_group_arn)[
+            "TargetHealthDescriptions"
+        ]
+        assert len(healths) == 1
+        assert {
+            "Target": {"Id": instance_id2, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {"State": "healthy"},
+        } in healths
+
+        # We can explicitly request it's health though
+        healths = conn.describe_target_health(
+            TargetGroupArn=target_group_arn, Targets=[{"Id": instance_id1, "Port": 80}]
+        )["TargetHealthDescriptions"]
+        assert len(healths) == 1
+        assert {
+            "Target": {"Id": instance_id1, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {
+                "State": "unused",
+                "Reason": "Target.NotRegistered",
+                "Description": "Target is not registered to the target group",
+            },
+        } in healths
+
+        # Re-register it, and stop the instance
+        conn.register_targets(
+            TargetGroupArn=target_group_arn,
+            Targets=[{"Id": instance_id1}],
+        )
+        waiter = conn.get_waiter("target_in_service")
+        waiter.wait(TargetGroupArn=target_group_arn)
+
+        healths = conn.describe_target_health(TargetGroupArn=target_group_arn)[
+            "TargetHealthDescriptions"
+        ]
+        assert {
+            "Target": {"Id": instance_id1, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {"State": "healthy"},
+        } in healths
+        assert {
+            "Target": {"Id": instance_id2, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {"State": "healthy"},
+        } in healths
+
+        ec2_client.stop_instances(InstanceIds=[instance_id1])
+        waiter = ec2_client.get_waiter("instance_stopped")
+        waiter.wait(InstanceIds=[instance_id1])
+
+        # Instance is marked as 'unused' when stopped
+        states = set()
+        while states != {"healthy", "unused"}:
+            healths = conn.describe_target_health(TargetGroupArn=target_group_arn)[
+                "TargetHealthDescriptions"
+            ]
+            states = set([h["TargetHealth"]["State"] for h in healths])
+
+            if target_is_aws:
+                sleep(5)
+        assert {
+            "Target": {"Id": instance_id2, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {"State": "healthy"},
+        } in healths
+        assert {
+            "Target": {"Id": instance_id1, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {
+                "State": "unused",
+                "Reason": "Target.InvalidState",
+                "Description": "Target is in the stopped state",
+            },
+        } in healths
+
+        ec2_client.terminate_instances(InstanceIds=[instance_id1])
+        waiter = ec2_client.get_waiter("instance_terminated")
+        waiter.wait(InstanceIds=[instance_id1])
+
+        # Instance is removed when terminated
+        healths = conn.describe_target_health(TargetGroupArn=target_group_arn)[
+            "TargetHealthDescriptions"
+        ]
+        while len(healths) != 1:
+            healths = conn.describe_target_health(TargetGroupArn=target_group_arn)[
+                "TargetHealthDescriptions"
+            ]
+
+            if target_is_aws:
+                sleep(5)
+
+        assert {
+            "Target": {"Id": instance_id2, "Port": 80},
+            "HealthCheckPort": "80",
+            "TargetHealth": {"State": "healthy"},
+        } in healths
+
+        # Terminated instances are marked as 'draining' until eternity (well - atleast 10 minutes)
+        healths = conn.describe_target_health(
+            TargetGroupArn=target_group_arn, Targets=[{"Id": instance_id1, "Port": 80}]
+        )["TargetHealthDescriptions"]
+        assert healths == [
+            {
+                "Target": {"Id": instance_id1, "Port": 80},
+                "HealthCheckPort": "80",
+                "TargetHealth": {
+                    "State": "draining",
+                    "Reason": "Target.DeregistrationInProgress",
+                    "Description": "Target deregistration is in progress",
+                },
+            }
+        ]
+
+    except Exception as e:
+        print(e)  # noqa: T201 `print` found
+    finally:
+        try:  # to delete instance1 - just in case it failed to stop earlier
+            ec2_client.stop_instances(InstanceIds=[instance_id1])
+            waiter = ec2_client.get_waiter("instance_stopped")
+            waiter.wait(InstanceIds=[instance_id1])
+            ec2_client.terminate_instances(InstanceIds=[instance_id1])
+            waiter = ec2_client.get_waiter("instance_terminated")
+            waiter.wait(InstanceIds=[instance_id1])
+        except:  # noqa: E722 Do not use bare except
+            pass
+
+        if instance_id2:
+            ec2_client.stop_instances(InstanceIds=[instance_id2])
+            waiter = ec2_client.get_waiter("instance_stopped")
+            waiter.wait(InstanceIds=[instance_id2])
+            ec2_client.terminate_instances(InstanceIds=[instance_id2])
+            waiter = ec2_client.get_waiter("instance_terminated")
+            waiter.wait(InstanceIds=[instance_id2])
+
+        if listener_arn:
+            conn.delete_listener(ListenerArn=listener_arn)
+
+        if target_group_arn:
+            conn.delete_target_group(TargetGroupArn=target_group_arn)
+
+        if load_balancer_arn:
+            conn.delete_load_balancer(LoadBalancerArn=load_balancer_arn)
+            waiter = conn.get_waiter("load_balancers_deleted")
+            waiter.wait(LoadBalancerArns=[load_balancer_arn])
+
+    if target_is_aws:
+        # Resources take a while to deregister
+        # Wait, so we don't get DependencyViolations when deleting the SG
+        sleep(30)
+
+        security_group.delete()
+        subnet1.delete()
+        subnet2.delete()
+        route_table.delete()
+        ec2_client.detach_internet_gateway(InternetGatewayId=igw_id, VpcId=vpc.id)
+        vpc.delete()

moto-5.0.10.dev15/tests/test_xray/__init__.py

@@ -1 +0,0 @@
-# This file is intentionally left blank.