moto 4.2.1.dev35__tar.gz → 4.2.1.dev37__tar.gz

{moto-4.2.1.dev35/moto.egg-info → moto-4.2.1.dev37}/PKG-INFO

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

{moto-4.2.1.dev35 → moto-4.2.1.dev37}/moto/__init__.py

@@ -1,9 +1,9 @@
 import importlib
 import sys
 from contextlib import ContextDecorator
-from moto.core.models import BaseMockAWS
 from typing import Any, Callable, List, Optional, TypeVar
 
+from moto.core.models import BaseMockAWS
 
 TEST_METHOD = TypeVar("TEST_METHOD", bound=Callable[..., Any])
 
@@ -189,6 +189,9 @@ mock_xray = lazy_load(".xray", "mock_xray")
 mock_xray_client = lazy_load(".xray", "mock_xray_client")
 mock_wafv2 = lazy_load(".wafv2", "mock_wafv2")
 mock_textract = lazy_load(".textract", "mock_textract")
+mock_elasticache = lazy_load(
+    ".elasticache", "mock_elasticache", boto3_name="elasticache"
+)
 
 
 class MockAll(ContextDecorator):
@@ -213,7 +216,7 @@ mock_all = MockAll
 # logging.getLogger('boto').setLevel(logging.CRITICAL)
 
 __title__ = "moto"
-__version__ = "4.2.1.dev35"
+__version__ = "4.2.1.dev37"
 
 
 try:

{moto-4.2.1.dev35 → moto-4.2.1.dev37}/moto/elasticache/exceptions.py

@@ -1,4 +1,5 @@
 from typing import Any
+
 from moto.core.exceptions import RESTError
 
 EXCEPTION_RESPONSE = """<?xml version="1.0"?>
@@ -58,3 +59,25 @@ class UserNotFound(ElastiCacheException):
 
     def __init__(self, user_id: str):
         super().__init__("UserNotFound", message=f"User {user_id} not found.")
+
+
+class CacheClusterAlreadyExists(ElastiCacheException):
+
+    code = 404
+
+    def __init__(self, cache_cluster_id: str):
+        super().__init__(
+            "CacheClusterAlreadyExists",
+            message=f"Cache cluster {cache_cluster_id} already exists.",
+        ),
+
+
+class CacheClusterNotFound(ElastiCacheException):
+
+    code = 404
+
+    def __init__(self, cache_cluster_id: str):
+        super().__init__(
+            "CacheClusterNotFound",
+            message=f"Cache cluster {cache_cluster_id} not found.",
+        )

moto-4.2.1.dev37/moto/elasticache/models.py

@@ -0,0 +1,334 @@
+from datetime import datetime
+from typing import List, Optional, Dict, Any, Tuple
+
+from moto.core import BaseBackend, BackendDict, BaseModel
+
+from .exceptions import (
+    UserAlreadyExists,
+    UserNotFound,
+    CacheClusterAlreadyExists,
+    CacheClusterNotFound,
+)
+from ..moto_api._internal import mock_random
+
+
+class User(BaseModel):
+    def __init__(
+        self,
+        account_id: str,
+        region: str,
+        user_id: str,
+        user_name: str,
+        access_string: str,
+        engine: str,
+        no_password_required: bool,
+        passwords: Optional[List[str]] = None,
+    ):
+        self.id = user_id
+        self.name = user_name
+        self.engine = engine
+        self.passwords = passwords or []
+        self.access_string = access_string
+        self.no_password_required = no_password_required
+        self.status = "active"
+        self.minimum_engine_version = "6.0"
+        self.usergroupids: List[str] = []
+        self.region = region
+        self.arn = f"arn:aws:elasticache:{self.region}:{account_id}:user:{self.id}"
+
+
+class CacheCluster(BaseModel):
+    def __init__(
+        self,
+        account_id: str,
+        region_name: str,
+        cache_cluster_id: str,
+        replication_group_id: Optional[str],
+        az_mode: Optional[str],
+        preferred_availability_zone: Optional[str],
+        num_cache_nodes: Optional[int],
+        cache_node_type: Optional[str],
+        engine: Optional[str],
+        engine_version: Optional[str],
+        cache_parameter_group_name: Optional[str],
+        cache_subnet_group_name: Optional[str],
+        transit_encryption_enabled: Optional[bool],
+        network_type: Optional[str],
+        ip_discovery: Optional[str],
+        snapshot_name: Optional[str],
+        preferred_maintenance_window: Optional[str],
+        port: Optional[int],
+        notification_topic_arn: Optional[str],
+        auto_minor_version_upgrade: Optional[bool],
+        snapshot_retention_limit: Optional[int],
+        snapshot_window: Optional[str],
+        auth_token: Optional[str],
+        outpost_mode: Optional[str],
+        preferred_outpost_arn: Optional[str],
+        preferred_availability_zones: Optional[List[str]],
+        cache_security_group_names: Optional[List[str]],
+        security_group_ids: Optional[List[str]],
+        tags: Optional[List[Dict[str, str]]],
+        snapshot_arns: Optional[List[str]],
+        preferred_outpost_arns: Optional[List[str]],
+        log_delivery_configurations: List[Dict[str, Any]],
+        cache_node_ids_to_remove: Optional[List[str]],
+        cache_node_ids_to_reboot: Optional[List[str]],
+    ):
+        if tags is None:
+            tags = []
+
+        self.cache_cluster_id = cache_cluster_id
+        self.az_mode = az_mode
+        self.preferred_availability_zone = preferred_availability_zone
+        self.preferred_availability_zones = preferred_availability_zones or []
+        self.engine = engine or "redis"
+        self.engine_version = engine_version
+        if engine == "redis":
+            self.num_cache_nodes = 1
+            self.replication_group_id = replication_group_id
+            self.snapshot_arns = snapshot_arns or []
+            self.snapshot_name = snapshot_name
+            self.snapshot_window = snapshot_window
+        if engine == "memcached":
+            if num_cache_nodes is None:
+                self.num_cache_nodes = 1
+            elif 1 <= num_cache_nodes <= 40:
+                self.num_cache_nodes = num_cache_nodes
+        self.cache_node_type = cache_node_type
+        self.cache_parameter_group_name = cache_parameter_group_name
+        self.cache_subnet_group_name = cache_subnet_group_name
+        self.cache_security_group_names = cache_security_group_names or []
+        self.security_group_ids = security_group_ids or []
+        self.tags = tags
+        self.preferred_maintenance_window = preferred_maintenance_window
+        self.port = port or 6379
+        self.notification_topic_arn = notification_topic_arn
+        self.auto_minor_version_upgrade = auto_minor_version_upgrade
+        self.snapshot_retention_limit = snapshot_retention_limit or 0
+        self.auth_token = auth_token
+        self.outpost_mode = outpost_mode
+        self.preferred_outpost_arn = preferred_outpost_arn
+        self.preferred_outpost_arns = preferred_outpost_arns or []
+        self.log_delivery_configurations = log_delivery_configurations or []
+        self.transit_encryption_enabled = transit_encryption_enabled
+        self.network_type = network_type
+        self.ip_discovery = ip_discovery
+        self.cache_node_ids_to_remove = cache_node_ids_to_remove
+        self.cache_node_ids_to_reboot = cache_node_ids_to_reboot
+
+        self.cache_cluster_create_time = datetime.utcnow()
+        self.auth_token_last_modified_date = datetime.utcnow()
+        self.cache_cluster_status = "available"
+        self.arn = f"arn:aws:elasticache:{region_name}:{account_id}:{cache_cluster_id}"
+        self.cache_node_id = str(mock_random.uuid4())
+
+
+class ElastiCacheBackend(BaseBackend):
+    """Implementation of ElastiCache APIs."""
+
+    def __init__(self, region_name: str, account_id: str):
+        super().__init__(region_name, account_id)
+        self.users = dict()
+        self.users["default"] = User(
+            account_id=self.account_id,
+            region=self.region_name,
+            user_id="default",
+            user_name="default",
+            engine="redis",
+            access_string="on ~* +@all",
+            no_password_required=True,
+        )
+
+        # Define the cache_clusters dictionary to detect duplicates
+        self.cache_clusters = dict()
+        self.cache_clusters["default"] = CacheCluster(
+            account_id=self.account_id,
+            region_name=self.region_name,
+            cache_cluster_id="default",
+            replication_group_id=None,
+            az_mode=None,
+            preferred_availability_zone=None,
+            num_cache_nodes=1,
+            cache_node_type=None,
+            engine="redis",
+            engine_version=None,
+            cache_parameter_group_name=None,
+            cache_subnet_group_name=None,
+            transit_encryption_enabled=True,
+            network_type=None,
+            ip_discovery=None,
+            snapshot_name=None,
+            preferred_maintenance_window=None,
+            port=6379,
+            notification_topic_arn=None,
+            auto_minor_version_upgrade=True,
+            snapshot_retention_limit=0,
+            snapshot_window=None,
+            auth_token=None,
+            outpost_mode=None,
+            preferred_outpost_arn=None,
+            preferred_availability_zones=[],
+            cache_security_group_names=[],
+            security_group_ids=[],
+            tags=[],
+            snapshot_arns=[],
+            preferred_outpost_arns=[],
+            log_delivery_configurations=[],
+            cache_node_ids_to_remove=[],
+            cache_node_ids_to_reboot=[],
+        )
+
+    def create_user(
+        self,
+        user_id: str,
+        user_name: str,
+        engine: str,
+        passwords: List[str],
+        access_string: str,
+        no_password_required: bool,
+    ) -> User:
+        if user_id in self.users:
+            raise UserAlreadyExists
+        user = User(
+            account_id=self.account_id,
+            region=self.region_name,
+            user_id=user_id,
+            user_name=user_name,
+            engine=engine,
+            passwords=passwords,
+            access_string=access_string,
+            no_password_required=no_password_required,
+        )
+        self.users[user_id] = user
+        return user
+
+    def delete_user(self, user_id: str) -> User:
+        if user_id in self.users:
+            user = self.users[user_id]
+            if user.status == "active":
+                user.status = "deleting"
+            return user
+        raise UserNotFound(user_id)
+
+    def describe_users(self, user_id: Optional[str]) -> List[User]:
+        """
+        Only the `user_id` parameter is currently supported.
+        Pagination is not yet implemented.
+        """
+        if user_id:
+            if user_id in self.users:
+                user = self.users[user_id]
+                if user.status == "deleting":
+                    self.users.pop(user_id)
+                return [user]
+            else:
+                raise UserNotFound(user_id)
+        return list(self.users.values())
+
+    def create_cache_cluster(
+        self,
+        cache_cluster_id: str,
+        replication_group_id: str,
+        az_mode: str,
+        preferred_availability_zone: str,
+        num_cache_nodes: int,
+        cache_node_type: str,
+        engine: str,
+        engine_version: str,
+        cache_parameter_group_name: str,
+        cache_subnet_group_name: str,
+        transit_encryption_enabled: bool,
+        network_type: str,
+        ip_discovery: str,
+        snapshot_name: str,
+        preferred_maintenance_window: str,
+        port: int,
+        notification_topic_arn: str,
+        auto_minor_version_upgrade: bool,
+        snapshot_retention_limit: int,
+        snapshot_window: str,
+        auth_token: str,
+        outpost_mode: str,
+        preferred_outpost_arn: str,
+        preferred_availability_zones: List[str],
+        cache_security_group_names: List[str],
+        security_group_ids: List[str],
+        tags: List[Dict[str, str]],
+        snapshot_arns: List[str],
+        preferred_outpost_arns: List[str],
+        log_delivery_configurations: List[Dict[str, Any]],
+        cache_node_ids_to_remove: List[str],
+        cache_node_ids_to_reboot: List[str],
+    ) -> CacheCluster:
+        if cache_cluster_id in self.cache_clusters:
+            raise CacheClusterAlreadyExists(cache_cluster_id)
+        cache_cluster = CacheCluster(
+            account_id=self.account_id,
+            region_name=self.region_name,
+            cache_cluster_id=cache_cluster_id,
+            replication_group_id=replication_group_id,
+            az_mode=az_mode,
+            preferred_availability_zone=preferred_availability_zone,
+            preferred_availability_zones=preferred_availability_zones,
+            num_cache_nodes=num_cache_nodes,
+            cache_node_type=cache_node_type,
+            engine=engine,
+            engine_version=engine_version,
+            cache_parameter_group_name=cache_parameter_group_name,
+            cache_subnet_group_name=cache_subnet_group_name,
+            cache_security_group_names=cache_security_group_names,
+            security_group_ids=security_group_ids,
+            tags=tags,
+            snapshot_arns=snapshot_arns,
+            snapshot_name=snapshot_name,
+            preferred_maintenance_window=preferred_maintenance_window,
+            port=port,
+            notification_topic_arn=notification_topic_arn,
+            auto_minor_version_upgrade=auto_minor_version_upgrade,
+            snapshot_retention_limit=snapshot_retention_limit,
+            snapshot_window=snapshot_window,
+            auth_token=auth_token,
+            outpost_mode=outpost_mode,
+            preferred_outpost_arn=preferred_outpost_arn,
+            preferred_outpost_arns=preferred_outpost_arns,
+            log_delivery_configurations=log_delivery_configurations,
+            transit_encryption_enabled=transit_encryption_enabled,
+            network_type=network_type,
+            ip_discovery=ip_discovery,
+            cache_node_ids_to_remove=cache_node_ids_to_remove,
+            cache_node_ids_to_reboot=cache_node_ids_to_reboot,
+        )
+        self.cache_clusters[cache_cluster_id] = cache_cluster
+        return cache_cluster
+
+    def describe_cache_clusters(
+        self,
+        cache_cluster_id: str,
+        max_records: int,
+        marker: str,
+    ) -> Tuple[str, List[CacheCluster]]:
+        if marker is None:
+            marker = str(mock_random.uuid4())
+        if max_records is None:
+            max_records = 100
+        if cache_cluster_id:
+            if cache_cluster_id in self.cache_clusters:
+                cache_cluster = self.cache_clusters[cache_cluster_id]
+                return marker, [cache_cluster]
+            else:
+                raise CacheClusterNotFound(cache_cluster_id)
+        cache_clusters = list(self.cache_clusters.values())[:max_records]
+
+        return marker, cache_clusters
+
+    def delete_cache_cluster(self, cache_cluster_id: str) -> CacheCluster:
+        if cache_cluster_id:
+            if cache_cluster_id in self.cache_clusters:
+                cache_cluster = self.cache_clusters[cache_cluster_id]
+                cache_cluster.cache_cluster_status = "deleting"
+                return cache_cluster
+        raise CacheClusterNotFound(cache_cluster_id)
+
+
+elasticache_backends = BackendDict(ElastiCacheBackend, "elasticache")