moto 4.2.3.dev38__py2.py3-none-any.whl → 4.2.3.dev40__py2.py3-none-any.whl

moto/__init__.py

@@ -212,7 +212,7 @@ mock_all = MockAll
 # logging.getLogger('boto').setLevel(logging.CRITICAL)
 
 __title__ = "moto"
-__version__ = "4.2.3.dev38"
+__version__ = "4.2.3.dev40"
 
 
 try:

moto/cognitoidp/models.py

@@ -382,7 +382,7 @@ DEFAULT_USER_POOL_CONFIG: Dict[str, Any] = {
 
 class CognitoIdpUserPool(BaseModel):
 
-    MAX_ID_LENGTH = 56
+    MAX_ID_LENGTH = 55
 
     def __init__(
         self, account_id: str, region: str, name: str, extended_config: Dict[str, Any]

moto/elbv2/exceptions.py

@@ -184,3 +184,8 @@ class InvalidStatusCodeActionTypeError(ELBClientError):
 class InvalidLoadBalancerActionException(ELBClientError):
     def __init__(self, msg: str):
         super().__init__("InvalidLoadBalancerAction", msg)
+
+
+class ValidationError(ELBClientError):
+    def __init__(self, msg: str):
+        super().__init__("ValidationError", msg)

moto/elbv2/models.py

@@ -35,6 +35,7 @@ from .exceptions import (
     InvalidModifyRuleArgumentsError,
     InvalidStatusCodeActionTypeError,
     InvalidLoadBalancerActionException,
+    ValidationError,
 )
 
 ALLOWED_ACTIONS = [
@@ -79,42 +80,49 @@ class FakeTargetGroup(CloudFormationModel):
         healthcheck_port: Optional[str] = None,
         healthcheck_path: Optional[str] = None,
         healthcheck_interval_seconds: Optional[str] = None,
-        healthcheck_timeout_seconds: Optional[int] = None,
+        healthcheck_timeout_seconds: Optional[str] = None,
         healthcheck_enabled: Optional[str] = None,
         healthy_threshold_count: Optional[str] = None,
         unhealthy_threshold_count: Optional[str] = None,
         matcher: Optional[Dict[str, Any]] = None,
         target_type: Optional[str] = None,
+        ip_address_type: Optional[str] = None,
     ):
         # TODO: default values differs when you add Network Load balancer
         self.name = name
         self.arn = arn
         self.vpc_id = vpc_id
-        self.protocol = protocol
-        self.protocol_version = protocol_version or "HTTP1"
+        if target_type == "lambda":
+            self.protocol = None
+            self.protocol_version = None
+        elif target_type == "alb":
+            self.protocol = "TCP"
+            self.protocol_version = None
+        else:
+            self.protocol = protocol
+            self.protocol_version = protocol_version
         self.port = port
         self.healthcheck_protocol = healthcheck_protocol or self.protocol
-        self.healthcheck_port = healthcheck_port
+        self.healthcheck_port = healthcheck_port or "traffic-port"
         self.healthcheck_path = healthcheck_path
-        self.healthcheck_interval_seconds = healthcheck_interval_seconds or 30
-        self.healthcheck_timeout_seconds = healthcheck_timeout_seconds
-        if not healthcheck_timeout_seconds:
-            # Default depends on protocol
-            if protocol in ["TCP", "TLS"]:
-                self.healthcheck_timeout_seconds = 6
-            elif protocol in ["HTTP", "HTTPS", "GENEVE"]:
-                self.healthcheck_timeout_seconds = 5
-            else:
-                self.healthcheck_timeout_seconds = 30
-        self.healthcheck_enabled = healthcheck_enabled
-        self.healthy_threshold_count = healthy_threshold_count or 5
-        self.unhealthy_threshold_count = unhealthy_threshold_count or 2
+        self.healthcheck_interval_seconds = healthcheck_interval_seconds or "30"
+        self.healthcheck_timeout_seconds = healthcheck_timeout_seconds or "10"
+        self.ip_address_type = (
+            ip_address_type or "ipv4" if self.protocol != "GENEVE" else None
+        )
+        self.healthcheck_enabled = (
+            healthcheck_enabled.lower() == "true"
+            if healthcheck_enabled in ["true", "false"]
+            else True
+        )
+        self.healthy_threshold_count = healthy_threshold_count or "5"
+        self.unhealthy_threshold_count = unhealthy_threshold_count or "2"
         self.load_balancer_arns: List[str] = []
         if self.healthcheck_protocol != "TCP":
             self.matcher: Dict[str, Any] = matcher or {"HttpCode": "200"}
-            self.healthcheck_path = self.healthcheck_path or "/"
+            self.healthcheck_path = self.healthcheck_path
             self.healthcheck_port = self.healthcheck_port or str(self.port)
-        self.target_type = target_type
+        self.target_type = target_type or "instance"
 
         self.attributes = {
             "deregistration_delay.timeout_seconds": 300,
@@ -1030,6 +1038,9 @@ Member must satisfy regular expression pattern: {expression}"
             )
 
     def create_target_group(self, name: str, **kwargs: Any) -> FakeTargetGroup:
+        protocol = kwargs.get("protocol")
+        target_type = kwargs.get("target_type")
+
         if len(name) > 32:
             raise InvalidTargetGroupNameError(
                 f"Target group name '{name}' cannot be longer than '32' characters"
@@ -1080,6 +1091,124 @@ Member must satisfy regular expression pattern: {expression}"
                 "HttpCode must be like 200 | 200-399 | 200,201 ...",
             )
 
+        if target_type in ("instance", "ip", "alb"):
+            for param in ("protocol", "port", "vpc_id"):
+                if not kwargs.get(param):
+                    param = "VPC ID" if param == "vpc_id" else param.lower()
+                    raise ValidationError(f"A {param} must be specified")
+
+        if kwargs.get("vpc_id"):
+            from moto.ec2.exceptions import InvalidVPCIdError
+
+            try:
+                self.ec2_backend.get_vpc(kwargs.get("vpc_id"))
+            except InvalidVPCIdError:
+                raise ValidationError(
+                    f"The VPC ID '{kwargs.get('vpc_id')}' is not found"
+                )
+
+        kwargs_patch = {}
+
+        conditions: Dict[str, Any] = {
+            "target_lambda": {
+                "healthcheck_interval_seconds": 35,
+                "healthcheck_timeout_seconds": 30,
+                "unhealthy_threshold_count": 2,
+                "healthcheck_enabled": "false",
+                "healthcheck_path": "/",
+            },
+            "target_alb": {
+                "healthcheck_protocol": "HTTP",
+                "healthcheck_path": "/",
+                "healthcheck_timeout_seconds": 6,
+                "matcher": {"HttpCode": "200-399"},
+            },
+            "protocol_GENEVE": {
+                "healthcheck_interval_seconds": 10,
+                "healthcheck_port": 80,
+                "healthcheck_timeout_seconds": 5,
+                "healthcheck_protocol": "TCP",
+                "unhealthy_threshold_count": 2,
+            },
+            "protocol_HTTP_HTTPS": {
+                "healthcheck_timeout_seconds": 5,
+                "protocol_version": "HTTP1",
+                "healthcheck_path": "/",
+                "unhealthy_threshold_count": 2,
+                "healthcheck_interval_seconds": 30,
+            },
+            "protocol_TCP": {
+                "healthcheck_timeout_seconds": 10,
+            },
+            "protocol_TCP_TCP_UDP_UDP_TLS": {
+                "healthcheck_protocol": "TCP",
+                "unhealthy_threshold_count": 2,
+                "healthcheck_interval_seconds": 30,
+            },
+        }
+
+        if target_type == "lambda":
+            kwargs_patch.update(
+                {k: kwargs.get(k) or v for k, v in conditions["target_lambda"].items()}
+            )
+
+        if protocol == "GENEVE":
+            kwargs_patch.update(
+                {
+                    k: kwargs.get(k) or v
+                    for k, v in conditions["protocol_GENEVE"].items()
+                }
+            )
+
+        if protocol in ("HTTP", "HTTPS"):
+            kwargs_patch.update(
+                {
+                    k: kwargs.get(k) or v
+                    for k, v in conditions["protocol_HTTP_HTTPS"].items()
+                }
+            )
+
+        if protocol == "TCP":
+            kwargs_patch.update(
+                {k: kwargs.get(k) or v for k, v in conditions["protocol_TCP"].items()}
+            )
+
+        if protocol in ("TCP", "TCP_UDP", "UDP", "TLS"):
+            kwargs_patch.update(
+                {
+                    k: kwargs.get(k) or v
+                    for k, v in conditions["protocol_TCP_TCP_UDP_UDP_TLS"].items()
+                }
+            )
+
+        if target_type == "alb":
+            kwargs_patch.update(
+                {k: kwargs.get(k) or v for k, v in conditions["target_alb"].items()}
+            )
+
+        kwargs.update(kwargs_patch)
+
+        healthcheck_timeout_seconds = int(
+            str(kwargs.get("healthcheck_timeout_seconds") or "10")
+        )
+        healthcheck_interval_seconds = int(
+            str(kwargs.get("healthcheck_interval_seconds") or "30")
+        )
+
+        if (
+            healthcheck_timeout_seconds is not None
+            and healthcheck_interval_seconds is not None
+        ):
+
+            if healthcheck_interval_seconds < healthcheck_timeout_seconds:
+                raise ValidationError(
+                    "Health check interval must be greater than the timeout."
+                )
+            if healthcheck_interval_seconds == healthcheck_timeout_seconds:
+                raise ValidationError(
+                    f"Health check timeout '{healthcheck_timeout_seconds}' must be smaller than the interval '{healthcheck_interval_seconds}'"
+                )
+
         arn = make_arn_for_target_group(
             account_id=self.account_id, name=name, region_name=self.region_name
         )
@@ -1524,11 +1653,11 @@ Member must satisfy regular expression pattern: {expression}"
         health_check_port: Optional[str] = None,
         health_check_path: Optional[str] = None,
         health_check_interval: Optional[str] = None,
-        health_check_timeout: Optional[int] = None,
+        health_check_timeout: Optional[str] = None,
         healthy_threshold_count: Optional[str] = None,
         unhealthy_threshold_count: Optional[str] = None,
         http_codes: Optional[str] = None,
-        health_check_enabled: Optional[str] = None,
+        health_check_enabled: Optional[bool] = None,
     ) -> FakeTargetGroup:
         target_group = self.target_groups.get(arn)
         if target_group is None:

moto/elbv2/responses.py

@@ -185,7 +185,7 @@ class ELBV2Response(BaseResponse):
         name = params.get("Name")
         vpc_id = params.get("VpcId")
         protocol = params.get("Protocol")
-        protocol_version = params.get("ProtocolVersion", "HTTP1")
+        protocol_version = params.get("ProtocolVersion")
         port = params.get("Port")
         healthcheck_protocol = self._get_param("HealthCheckProtocol")
         healthcheck_port = self._get_param("HealthCheckPort")
@@ -196,7 +196,8 @@ class ELBV2Response(BaseResponse):
         healthy_threshold_count = self._get_param("HealthyThresholdCount")
         unhealthy_threshold_count = self._get_param("UnhealthyThresholdCount")
         matcher = params.get("Matcher")
-        target_type = params.get("TargetType")
+        target_type = params.get("TargetType", "instance")
+        ip_address_type = params.get("IpAddressType")
         tags = params.get("Tags")
 
         target_group = self.elbv2_backend.create_target_group(
@@ -214,6 +215,7 @@ class ELBV2Response(BaseResponse):
             healthy_threshold_count=healthy_threshold_count,
             unhealthy_threshold_count=unhealthy_threshold_count,
             matcher=matcher,
+            ip_address_type=ip_address_type,
             target_type=target_type,
             tags=tags,
         )
@@ -797,6 +799,9 @@ CREATE_TARGET_GROUP_TEMPLATE = """<CreateTargetGroupResponse xmlns="http://elast
         <TargetGroupName>{{ target_group.name }}</TargetGroupName>
         {% if target_group.protocol %}
         <Protocol>{{ target_group.protocol }}</Protocol>
+        {% if target_group.protocol_version %}
+        <ProtocolVersion>{{ target_group.protocol_version }}</ProtocolVersion>
+        {% endif %}
         {% endif %}
         {% if target_group.port %}
         <Port>{{ target_group.port }}</Port>
@@ -804,14 +809,22 @@ CREATE_TARGET_GROUP_TEMPLATE = """<CreateTargetGroupResponse xmlns="http://elast
         {% if target_group.vpc_id %}
         <VpcId>{{ target_group.vpc_id }}</VpcId>
         {% endif %}
-        <HealthCheckProtocol>{{ target_group.healthcheck_protocol }}</HealthCheckProtocol>
-        {% if target_group.healthcheck_port %}<HealthCheckPort>{{ target_group.healthcheck_port }}</HealthCheckPort>{% endif %}
+        {% if target_group.healthcheck_enabled %}
+        {% if target_group.healthcheck_port %}
+        <HealthCheckPort>{{ target_group.healthcheck_port }}</HealthCheckPort>
+        {% endif %}
+        {% if target_group.healthcheck_protocol %}
+        <HealthCheckProtocol>{{ target_group.healthcheck_protocol or "None" }}</HealthCheckProtocol>
+        {% endif %}
+        {% endif %}
+        {% if target_group.healthcheck_path %}
         <HealthCheckPath>{{ target_group.healthcheck_path or '' }}</HealthCheckPath>
+        {% endif %}
         <HealthCheckIntervalSeconds>{{ target_group.healthcheck_interval_seconds }}</HealthCheckIntervalSeconds>
         <HealthCheckTimeoutSeconds>{{ target_group.healthcheck_timeout_seconds }}</HealthCheckTimeoutSeconds>
-        <HealthCheckEnabled>{{ target_group.healthcheck_enabled and 'true' or 'false' }}</HealthCheckEnabled>
         <HealthyThresholdCount>{{ target_group.healthy_threshold_count }}</HealthyThresholdCount>
         <UnhealthyThresholdCount>{{ target_group.unhealthy_threshold_count }}</UnhealthyThresholdCount>
+        <HealthCheckEnabled>{{ target_group.healthcheck_enabled and 'true' or 'false' }}</HealthCheckEnabled>
         {% if target_group.matcher %}
         <Matcher>
           <HttpCode>{{ target_group.matcher['HttpCode'] }}</HttpCode>
@@ -820,6 +833,9 @@ CREATE_TARGET_GROUP_TEMPLATE = """<CreateTargetGroupResponse xmlns="http://elast
         {% if target_group.target_type %}
         <TargetType>{{ target_group.target_type }}</TargetType>
         {% endif %}
+        {% if target_group.ip_address_type %}
+        <IpAddressType>{{ target_group.ip_address_type }}</IpAddressType>
+        {% endif %}
       </member>
     </TargetGroups>
   </CreateTargetGroupResult>

{moto-4.2.3.dev38.dist-info → moto-4.2.3.dev40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 4.2.3.dev38
+Version: 4.2.3.dev40
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: "spulec@gmail.com"

{moto-4.2.3.dev38.dist-info → moto-4.2.3.dev40.dist-info}/RECORD

@@ -1,4 +1,4 @@
-moto/__init__.py,sha256=O6Iwj77Bq81Ezq9hXmOwwUFfR3B5K0KXx3sYFQgP-PY,9689
+moto/__init__.py,sha256=Qs1JD-D6sozRzxBPqtcEeWotwt7a7Wyzr5XnbwATjwU,9689
 moto/backend_index.py,sha256=JDpbrcbt5e30v7D8c5IsxbqIDUXTvm4OuClX6V81cJU,10707
 moto/backends.py,sha256=rC9WUMUUWmVmX7ZEfXpVKAQAw6oI8qYobCEPxP2Zv9U,1805
 moto/server.py,sha256=cp8kIe5jVOm7Z2BlNN2AMbTfrRvLBEKSb4mt7O8nu34,2858
@@ -141,7 +141,7 @@ moto/cognitoidentity/urls.py,sha256=EwCPmD-_m_fiyl0DB82Vhti3VZVpHliimAiGDf5pWyk,
 moto/cognitoidentity/utils.py,sha256=1jFH2hB04ko1_GdYAB2Ep16VZdW8w-zdy5jb2RLHsyo,143
 moto/cognitoidp/__init__.py,sha256=nXdnouroOSIuf-0yhvI5GnlajxxsTBDSXbJikUL1jdY,136
 moto/cognitoidp/exceptions.py,sha256=1a49SBkGGauDhTlPlSOCNG16L1jVr0Hv5LNVJhuIfGc,1959
-moto/cognitoidp/models.py,sha256=nlQ5OTwPFKQ9mrtZTNYeDBs0NRqhOUa_Ge9hpYC-IeU,85271
+moto/cognitoidp/models.py,sha256=vaKE7SeVH9eDYUkJ8Hum6s2TSnyyboR9h17hsLC-oCQ,85271
 moto/cognitoidp/responses.py,sha256=N3w_kAevofO2mx07JIFtyFOltPqkRVdp8uUYR7gsbYY,25932
 moto/cognitoidp/urls.py,sha256=UlZawfAU4mnnmmhj66NmfrS8X90hTGij_v1NeSLHqgY,358
 moto/cognitoidp/utils.py,sha256=XJqIe9VGZfHezk7muTbHq1Zzypayaa2xPQ-Js02Y73U,3122
@@ -501,9 +501,9 @@ moto/elb/policies.py,sha256=bf0iqARBMJSb1ImJfmTNcwpieK7skjHG8YzAfgGdVsQ,1008
 moto/elb/responses.py,sha256=MP_ustVXguy12pQCiJzFh9RsmMUm9lO6n10uW7XFbII,37696
 moto/elb/urls.py,sha256=K5tFLDrGEUW6Lgw3dAdLdSl_Cf7V68CmQmRndoVZTvU,1336
 moto/elbv2/__init__.py,sha256=eQgbAgmbB0p4cfE2UMmjtIikZ8RsPKRG-yO1edhQ9ws,163
-moto/elbv2/exceptions.py,sha256=Fy7EsSs6aAqU4JphH7LWv_8o-rPM0WtxgLoFzuKWafo,5578
-moto/elbv2/models.py,sha256=jMRf_vxribHadrYxak-QaA5UdY3KPFukFA3Mgz_kXuU,70121
-moto/elbv2/responses.py,sha256=QuIxclRO0l2DjnbpzF4f_lkujYZGMiEULictxUe2lno,68565
+moto/elbv2/exceptions.py,sha256=9HpyVzkZoY9PiLqfULupx0dr5Mv4onMD-KARVtr_r0o,5702
+moto/elbv2/models.py,sha256=o46_6jbfeB_jPmj3pwoEViiTjRK7KyEMUKyMG_DFrX4,74689
+moto/elbv2/responses.py,sha256=nyxg68e1sax9CpgFwfan05EJ6tPf1kGiKhSKh1JF7Q8,69189
 moto/elbv2/urls.py,sha256=eXzExA_20VjvnCuz0IqYemrQUBrKoAGkgYNYj7opHhE,164
 moto/elbv2/utils.py,sha256=5M0qRxrOzTFCRJeVD1MvCZmzwP1kv2Skg5tFmScN01A,388
 moto/emr/__init__.py,sha256=ZYtiZrbIc9PUyTSHWJFgILS0hO3QSHj--cPyOSJfnz8,155
@@ -1034,10 +1034,10 @@ moto/xray/mock_client.py,sha256=nYl8JVJbl3OY-tnUafkVOG4K4-cFm5bsft3Hxo7fKwI,3809
 moto/xray/models.py,sha256=0QL6nmhpVVwAiyi9aw4pBwVTRhqPW9oIy2uwPDhPKug,11179
 moto/xray/responses.py,sha256=p2xsg2-P9h_1DCyuBC7GenmC5L64tXAX6a-XCb2j5-o,6316
 moto/xray/urls.py,sha256=R6T3gMwobWipukWcC1DQ36CU1Rjt6oqBDoe-7HqaIZU,393
-moto-4.2.3.dev38.dist-info/AUTHORS.md,sha256=dDUhasV8HGSkzb7zj7a0b3alnqY0P1LPOyOUNoo8Mpo,2976
-moto-4.2.3.dev38.dist-info/LICENSE,sha256=8S75_TlqE-kIeGMLG0-rRxxu2ct6SM8quyUWKBYyIY4,10834
-moto-4.2.3.dev38.dist-info/METADATA,sha256=cJsifhp56QQ3zhcqPBQ0-I5HjviSRNXjIglaFL44geU,12102
-moto-4.2.3.dev38.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
-moto-4.2.3.dev38.dist-info/entry_points.txt,sha256=aPovbZuFXCwt8_m2vcolpH4Qr3rOF3yXeRElP9Zkauo,49
-moto-4.2.3.dev38.dist-info/top_level.txt,sha256=TETRKAPcAAvoZDkSkwQiZtTSr-1gzaEAXVm9FmZKj8s,5
-moto-4.2.3.dev38.dist-info/RECORD,,
+moto-4.2.3.dev40.dist-info/AUTHORS.md,sha256=dDUhasV8HGSkzb7zj7a0b3alnqY0P1LPOyOUNoo8Mpo,2976
+moto-4.2.3.dev40.dist-info/LICENSE,sha256=8S75_TlqE-kIeGMLG0-rRxxu2ct6SM8quyUWKBYyIY4,10834
+moto-4.2.3.dev40.dist-info/METADATA,sha256=cg6qBPaW1cRyB7342pyL2ld9fElkKOBTgFK_6Eqj3OE,12102
+moto-4.2.3.dev40.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
+moto-4.2.3.dev40.dist-info/entry_points.txt,sha256=aPovbZuFXCwt8_m2vcolpH4Qr3rOF3yXeRElP9Zkauo,49
+moto-4.2.3.dev40.dist-info/top_level.txt,sha256=TETRKAPcAAvoZDkSkwQiZtTSr-1gzaEAXVm9FmZKj8s,5
+moto-4.2.3.dev40.dist-info/RECORD,,