moto 5.0.14.dev17__tar.gz → 5.0.14.dev19__tar.gz

{moto-5.0.14.dev17/moto.egg-info → moto-5.0.14.dev19}/PKG-INFO

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

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.14.dev17"
+__version__ = "5.0.14.dev19"

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/backend_index.py

@@ -196,6 +196,10 @@ backend_url_patterns = [
     ("support", re.compile("https?://support\\.(.+)\\.amazonaws\\.com")),
     ("swf", re.compile("https?://swf\\.(.+)\\.amazonaws\\.com")),
     ("textract", re.compile("https?://textract\\.(.+)\\.amazonaws\\.com")),
+    (
+        "timestreamquery",
+        re.compile("https?://query.timestream\\.(.+)\\.amazonaws\\.com"),
+    ),
     (
         "timestreamwrite",
         re.compile("https?://ingest\\.timestream\\.(.+)\\.amazonaws\\.com"),

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/backends.py

@@ -141,6 +141,7 @@ if TYPE_CHECKING:
     from moto.support.models import SupportBackend
     from moto.swf.models import SWFBackend
     from moto.textract.models import TextractBackend
+    from moto.timestreamquery.models import TimestreamQueryBackend
     from moto.timestreamwrite.models import TimestreamWriteBackend
     from moto.transcribe.models import TranscribeBackend
     from moto.transfer.models import TransferBackend
@@ -318,6 +319,7 @@ SERVICE_NAMES = Union[
     "Literal['support']",
     "Literal['swf']",
     "Literal['textract']",
+    "Literal['timestream-query']",
     "Literal['timestream-write']",
     "Literal['transcribe']",
     "Literal['transfer']",
@@ -710,6 +712,10 @@ def get_backend(name: "Literal['swf']") -> "BackendDict[SWFBackend]": ...
 @overload
 def get_backend(name: "Literal['textract']") -> "BackendDict[TextractBackend]": ...
 @overload
+def get_backend(
+    name: "Literal['timestream-query']",
+) -> "BackendDict[TimestreamQueryBackend]": ...
+@overload
 def get_backend(
     name: "Literal['timestream-write']",
 ) -> "BackendDict[TimestreamWriteBackend]": ...

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/moto_api/_internal/models.py

@@ -118,6 +118,23 @@ class MotoAPIBackend(BaseBackend):
         backend = inspector2_backends[account_id][region]
         backend.findings_queue.append(results)
 
+    def set_timestream_result(
+        self,
+        query: Optional[str],
+        query_results: List[Dict[str, Any]],
+        account_id: str,
+        region: str,
+    ) -> None:
+        from moto.timestreamquery.models import (
+            TimestreamQueryBackend,
+            timestreamquery_backends,
+        )
+
+        backend: TimestreamQueryBackend = timestreamquery_backends[account_id][region]
+        if query not in backend.query_result_queue:
+            backend.query_result_queue[query] = []
+        backend.query_result_queue[query].extend(query_results)
+
     def get_proxy_passthrough(self) -> Tuple[Set[str], Set[str]]:
         return self.proxy_urls_to_passthrough, self.proxy_hosts_to_passthrough
 

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/moto_api/_internal/responses.py

@@ -291,6 +291,28 @@ class MotoAPIResponse(BaseResponse):
             )
         return 201, {}, ""
 
+    def set_timestream_result(
+        self,
+        request: Any,
+        full_url: str,  # pylint: disable=unused-argument
+        headers: Any,
+    ) -> TYPE_RESPONSE:
+        from .models import moto_api_backend
+
+        body = self._get_body(headers, request)
+        account_id = body.get("account_id", DEFAULT_ACCOUNT_ID)
+        region = body.get("region", "us-east-1")
+        results = body.get("results", {})
+
+        for query in results:
+            moto_api_backend.set_timestream_result(
+                query=None if query == "null" else query,
+                query_results=results[query],
+                account_id=account_id,
+                region=region,
+            )
+        return 201, {}, ""
+
     def set_proxy_passthrough(
         self,
         request: Any,

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/moto_api/_internal/urls.py

@@ -20,6 +20,7 @@ url_paths = {
     "{0}/moto-api/static/lambda-simple/response": response_instance.set_lambda_simple_result,
     "{0}/moto-api/static/resilience-hub-assessments/response": response_instance.set_resilience_result,
     "{0}/moto-api/static/sagemaker/endpoint-results": response_instance.set_sagemaker_result,
+    "{0}/moto-api/static/timestream/query-results": response_instance.set_timestream_result,
     "{0}/moto-api/static/rds-data/statement-results": response_instance.set_rds_data_result,
     "{0}/moto-api/state-manager/get-transition": response_instance.get_transition,
     "{0}/moto-api/state-manager/set-transition": response_instance.set_transition,

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/sns/models.py

@@ -1,16 +1,26 @@
+import base64
 import contextlib
 import json
 import re
 from collections import OrderedDict
+from datetime import timedelta
+from functools import lru_cache
 from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
 
+import cryptography
 import requests
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+from cryptography.x509 import Name, NameAttribute
+from cryptography.x509.oid import NameOID
 
+from moto.core import DEFAULT_ACCOUNT_ID
 from moto.core.base_backend import BackendDict, BaseBackend
 from moto.core.common_models import BaseModel, CloudFormationModel
 from moto.core.utils import (
     camelcase_to_underscores,
     iso_8601_datetime_with_milliseconds,
+    utcnow,
 )
 from moto.moto_api._internal import mock_random
 from moto.sqs import sqs_backends
@@ -295,16 +305,69 @@ class Subscription(BaseModel):
         subject: Optional[str],
         message_attributes: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
+        key = self.private_key()
+        cert_subject = [NameAttribute(NameOID.COMMON_NAME, "sns.amazonaws.com")]
+        issuer = [
+            NameAttribute(NameOID.COUNTRY_NAME, "US"),
+            NameAttribute(NameOID.ORGANIZATION_NAME, "Amazon"),
+            NameAttribute(NameOID.COMMON_NAME, "Amazon RSA 2048 M01"),
+        ]
+        # SNS supports two signing algorithms
+        # User can choose which algorithm they want by updating the topic attribute 'SignatureVersion'
+        # Signature Version "1" == SHA1, "2" == SHA256
+        #
+        # Because cryptography doesn't support SHA1 anymore for certificates, we always use SignatureVersion="2"
+        signature_version = "2"
+        algo = hashes.SHA256() if signature_version == "2" else hashes.SHA1()
+        cert = (
+            cryptography.x509.CertificateBuilder()
+            .subject_name(Name(cert_subject))
+            .issuer_name(Name(issuer))
+            .public_key(key.public_key())
+            .serial_number(cryptography.x509.random_serial_number())
+            .not_valid_before(utcnow())
+            .not_valid_after(utcnow() + timedelta(days=365))
+            .sign(key, algo)  # type: ignore
+        )
+        key_name = (
+            f"SimpleNotificationService-{str(mock_random.uuid4()).replace('-', '')}.pem"
+        )
+
+        timestamp = iso_8601_datetime_with_milliseconds()
+        string_to_sign = f"""Message
+{message}
+MessageId
+{message_id}
+Timestamp
+{timestamp}
+TopicArn
+{self.topic.arn}
+Type
+Notification
+"""
+        signature = key.sign(
+            string_to_sign.encode("UTF-8"), padding.PKCS1v15(), hashes.SHA256()
+        )
+
+        # Retrieving the PEM is done via an unauthorized request
+        # We don't know in what account this was done - so just store in the default account
+        # We do know what region it is in, as the URL is `sns.{region}.amazonaws.com/name.pem`
+        region = self.topic.sns_backend.region_name
+        default_sns_backend = sns_backends[DEFAULT_ACCOUNT_ID][region]
+        default_sns_backend._message_public_keys[key_name] = cert.public_bytes(
+            serialization.Encoding.PEM
+        )
+
         post_data: Dict[str, Any] = {
             "Type": "Notification",
             "MessageId": message_id,
             "TopicArn": self.topic.arn,
             "Message": message,
-            "Timestamp": iso_8601_datetime_with_milliseconds(),
-            "SignatureVersion": "1",
-            "Signature": "EXAMPLElDMXvB8r9R83tGoNn0ecwd5UjllzsvSvbItzfaMpN2nk5HVSw7XnOn/49IkxDKz8YrlH2qJXj2iZB0Zo2O71c4qQk1fMUDi3LGpij7RCW7AW9vYYsSqIKRnFS94ilu7NFhUzLiieYr4BKHpdTmdD6c0esKEYBpabxDSc=",
-            "SigningCertURL": "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
-            "UnsubscribeURL": f"https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:{self.account_id}:some-topic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55",
+            "Timestamp": timestamp,
+            "SignatureVersion": signature_version,
+            "Signature": base64.b64encode(signature).decode("utf-8"),
+            "SigningCertURL": f"https://sns.{region}.amazonaws.com/{key_name}",
+            "UnsubscribeURL": f"https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:{self.account_id}:{self.topic.name}:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55",
         }
         if subject:
             post_data["Subject"] = subject
@@ -312,6 +375,10 @@ class Subscription(BaseModel):
             post_data["MessageAttributes"] = message_attributes
         return post_data
 
+    @lru_cache()
+    def private_key(self) -> rsa.RSAPrivateKey:
+        return rsa.generate_private_key(public_exponent=65537, key_size=2028)
+
 
 class PlatformApplication(BaseModel):
     def __init__(
@@ -378,6 +445,8 @@ class SNSBackend(BaseBackend):
     """
     Responsible for mocking calls to SNS. Integration with SQS/HTTP/etc is supported.
 
+    If you're using the decorators, you can verify the message signature send to an HTTP endpoint.
+
     Messages published to a topic are persisted in the backend. If you need to verify that a message was published successfully, you can use the internal API to check the message was published successfully:
 
     .. sourcecode:: python
@@ -410,6 +479,8 @@ class SNSBackend(BaseBackend):
             "+447700900907",
         ]
 
+        self._message_public_keys: Dict[str, bytes] = {}
+
     def get_sms_attributes(self, filter_list: Set[str]) -> Dict[str, str]:
         if len(filter_list) > 0:
             return {k: v for k, v in self.sms_attributes.items() if k in filter_list}

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/sns/responses.py

@@ -3,7 +3,7 @@ import re
 from collections import defaultdict
 from typing import Any, Dict, Tuple, Union
 
-from moto.core.responses import BaseResponse
+from moto.core.responses import TYPE_RESPONSE, BaseResponse
 from moto.core.utils import camelcase_to_underscores
 
 from .exceptions import InvalidParameterValue, SNSNotFoundError
@@ -802,6 +802,14 @@ class SNSResponse(BaseResponse):
 
         return self.response_template(UNTAG_RESOURCE_TEMPLATE).render()
 
+    @staticmethod
+    def serve_pem(request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[misc]
+        sns = SNSResponse()
+        sns.setup_class(request, full_url, headers)
+        key_name = full_url.split("/")[-1]
+        key = sns.backend._message_public_keys[key_name]
+        return 200, {}, key
+
 
 CREATE_TOPIC_TEMPLATE = """<CreateTopicResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
      <CreateTopicResult>

moto-5.0.14.dev19/moto/sns/urls.py

@@ -0,0 +1,8 @@
+from .responses import SNSResponse
+
+url_bases = [r"https?://sns\.(.+)\.amazonaws\.com"]
+
+url_paths = {
+    "{0}/$": SNSResponse.dispatch,
+    "{0}/SimpleNotificationService-(?P<pem_id>[^/]+).pem": SNSResponse.serve_pem,
+}

moto-5.0.14.dev19/moto/timestreamquery/__init__.py

@@ -0,0 +1,3 @@
+from .models import timestreamquery_backends  # noqa: F401
+
+# Responses are handled by TimestreamWrite

moto-5.0.14.dev19/moto/timestreamquery/exceptions.py

@@ -0,0 +1,11 @@
+"""Exceptions raised by the timestreamquery service."""
+
+from moto.core.exceptions import JsonRESTError
+
+
+class ResourceNotFound(JsonRESTError):
+    def __init__(self, arn: str):
+        super().__init__(
+            error_type="ResourceNotFoundException",
+            message=f"The resource with arn {arn} does not exist.",
+        )

moto-5.0.14.dev19/moto/timestreamquery/models.py

@@ -0,0 +1,194 @@
+"""TimestreamQueryBackend class with methods for supported APIs."""
+
+from typing import Any, Dict, List, Optional, Union
+from uuid import uuid4
+
+from moto.core.base_backend import BackendDict, BaseBackend
+from moto.core.common_models import BaseModel
+from moto.core.utils import unix_time
+from moto.utilities.utils import get_partition
+
+from .exceptions import ResourceNotFound
+
+
+class ScheduledQuery(BaseModel):
+    def __init__(
+        self,
+        account_id: str,
+        region_name: str,
+        name: str,
+        query_string: str,
+        schedule_configuration: Dict[str, str],
+        notification_configuration: Dict[str, Dict[str, str]],
+        target_configuration: Optional[Dict[str, Any]],
+        scheduled_query_execution_role_arn: str,
+        tags: Optional[List[Dict[str, str]]],
+        kms_key_id: Optional[str],
+        error_report_configuration: Optional[Dict[str, Dict[str, str]]],
+    ):
+        self.account_id = account_id
+        self.region_name = region_name
+        self.name = name
+        self.query_string = query_string
+        self.schedule_configuration = schedule_configuration
+        self.notification_configuration = notification_configuration
+        self.target_configuration = target_configuration
+        self.scheduled_query_execution_role_arn = scheduled_query_execution_role_arn
+        self.tags = tags
+        self.kms_key_id = kms_key_id
+        self.error_report_configuration = error_report_configuration
+
+        self.created_on = unix_time()
+        self.updated_on = unix_time()
+
+        self.arn = f"arn:{get_partition(region_name)}:timestream:{region_name}:{account_id}:scheduled-query/{name}"
+        self.state = "ENABLED"
+
+    def description(self) -> Dict[str, Any]:
+        return {
+            "Arn": self.arn,
+            "Name": self.name,
+            "CreationTime": self.created_on,
+            "State": self.state,
+            "QueryString": self.query_string,
+            "ScheduleConfiguration": self.schedule_configuration,
+            "NotificationConfiguration": self.notification_configuration,
+            "TargetConfiguration": self.target_configuration,
+            "ScheduledQueryExecutionRoleArn": self.scheduled_query_execution_role_arn,
+            "KmsKeyId": self.kms_key_id,
+            "ErrorReportConfiguration": self.error_report_configuration,
+        }
+
+
+class TimestreamQueryBackend(BaseBackend):
+    """Implementation of TimestreamQuery APIs."""
+
+    def __init__(self, region_name: str, account_id: str):
+        super().__init__(region_name, account_id)
+        self.scheduled_queries: Dict[str, ScheduledQuery] = {}
+
+        self.query_result_queue: Dict[Optional[str], List[Dict[str, Any]]] = {}
+        self.query_results: Dict[str, Dict[str, Any]] = {}
+
+    def create_scheduled_query(
+        self,
+        name: str,
+        query_string: str,
+        schedule_configuration: Dict[str, str],
+        notification_configuration: Dict[str, Dict[str, str]],
+        target_configuration: Optional[Dict[str, Any]],
+        scheduled_query_execution_role_arn: str,
+        tags: Optional[List[Dict[str, str]]],
+        kms_key_id: Optional[str],
+        error_report_configuration: Dict[str, Dict[str, str]],
+    ) -> ScheduledQuery:
+        query = ScheduledQuery(
+            account_id=self.account_id,
+            region_name=self.region_name,
+            name=name,
+            query_string=query_string,
+            schedule_configuration=schedule_configuration,
+            notification_configuration=notification_configuration,
+            target_configuration=target_configuration,
+            scheduled_query_execution_role_arn=scheduled_query_execution_role_arn,
+            tags=tags,
+            kms_key_id=kms_key_id,
+            error_report_configuration=error_report_configuration,
+        )
+        self.scheduled_queries[query.arn] = query
+        return query
+
+    def delete_scheduled_query(self, scheduled_query_arn: str) -> None:
+        self.scheduled_queries.pop(scheduled_query_arn, None)
+
+    def describe_scheduled_query(self, scheduled_query_arn: str) -> ScheduledQuery:
+        if scheduled_query_arn not in self.scheduled_queries:
+            raise ResourceNotFound(scheduled_query_arn)
+        return self.scheduled_queries[scheduled_query_arn]
+
+    def update_scheduled_query(self, scheduled_query_arn: str, state: str) -> None:
+        query = self.scheduled_queries[scheduled_query_arn]
+        query.state = state
+
+    def query(self, query_string: str) -> Dict[str, Any]:
+        """
+        Moto does not have a builtin time-series Database, so calling this endpoint will return zero results by default.
+
+        You can use a dedicated API to configuring a queue of expected results.
+
+        An example invocation looks like this:
+
+        .. sourcecode:: python
+
+            first_result = {
+                'QueryId': 'some_id',
+                'Rows': [...],
+                'ColumnInfo': [...],
+                'QueryStatus': ...
+            }
+            result_for_unknown_query_string = {
+                'QueryId': 'unknown',
+                'Rows': [...],
+                'ColumnInfo': [...],
+                'QueryStatus': ...
+            }
+            expected_results = {
+                "account_id": "123456789012",  # This is the default - can be omitted
+                "region": "us-east-1",  # This is the default - can be omitted
+                "results": {
+                    # Use the exact querystring, and a list of results for it
+                    # For example
+                    "SELECT data FROM mytable": [first_result, ...],
+                    # Use None if the exact querystring is unknown/irrelevant
+                    None: [result_for_unknown_query_string, ...],
+                }
+            }
+            requests.post(
+                "http://motoapi.amazonaws.com/moto-api/static/timestream/query-results",
+                json=expected_results,
+            )
+
+        When calling `query(QueryString='SELECT data FROM mytable')`, the `first_result` will be returned.
+        Call the query again for the second result, and so on.
+
+        If you don't know the exact query strings, use the `None`-key. In the above example, when calling `SELECT something FROM unknown`, there are no results for that specific query, so `result_for_unknown_query_string` will be returned.
+
+        Results for unknown queries are cached, so calling `SELECT something FROM unknown` will return the same result.
+
+        """
+        if self.query_result_queue.get(query_string):
+            return self.query_result_queue[query_string].pop(0)
+        if result := self.query_results.get(query_string):
+            return result
+        if self.query_result_queue.get(None):
+            self.query_results[query_string] = self.query_result_queue[None].pop(0)
+            return self.query_results[query_string]
+        return {"QueryId": str(uuid4()), "Rows": [], "ColumnInfo": []}
+
+    def describe_endpoints(self) -> List[Dict[str, Union[str, int]]]:
+        # https://docs.aws.amazon.com/timestream/latest/developerguide/Using-API.endpoint-discovery.how-it-works.html
+        # Usually, the address look like this:
+        # query-cell1.timestream.us-east-1.amazonaws.com
+        # Where 'cell1' can be any number, 'cell2', 'cell3', etc - whichever endpoint happens to be available for that particular account
+        # We don't implement a cellular architecture in Moto though, so let's keep it simple
+        return [
+            {
+                "Address": f"query.timestream.{self.region_name}.amazonaws.com",
+                "CachePeriodInMinutes": 1440,
+            }
+        ]
+
+
+timestreamquery_backends = BackendDict(
+    TimestreamQueryBackend,
+    "timestream-query",
+    additional_regions=[
+        "us-east-1",
+        "us-east-2",
+        "us-west-2",
+        "eu-central-1",
+        "eu-west-1",
+        "ap-southeast-2",
+        "ap-northeast-1",
+    ],
+)

moto-5.0.14.dev19/moto/timestreamquery/urls.py

@@ -0,0 +1,11 @@
+"""timestreamquery base URL and path."""
+
+from moto.timestreamwrite.responses import TimestreamWriteResponse
+
+url_bases = [
+    r"https?://query.timestream\.(.+)\.amazonaws\.com",
+]
+
+url_paths = {
+    "{0}/?$": TimestreamWriteResponse.dispatch,
+}

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto/timestreamwrite/responses.py

@@ -1,6 +1,7 @@
 import json
 
 from moto.core.responses import BaseResponse
+from moto.timestreamquery.models import TimestreamQueryBackend, timestreamquery_backends
 
 from .models import TimestreamWriteBackend, timestreamwrite_backends
 
@@ -9,6 +10,10 @@ class TimestreamWriteResponse(BaseResponse):
     def __init__(self) -> None:
         super().__init__(service_name="timestream-write")
 
+    @property
+    def timestreamquery_backend(self) -> TimestreamQueryBackend:
+        return timestreamquery_backends[self.current_account][self.region]
+
     @property
     def timestreamwrite_backend(self) -> TimestreamWriteBackend:
         """Return backend instance specific for this region."""
@@ -134,3 +139,61 @@ class TimestreamWriteResponse(BaseResponse):
         tag_keys = self._get_param("TagKeys")
         self.timestreamwrite_backend.untag_resource(resource_arn, tag_keys)
         return "{}"
+
+    # AWS uses the same path/headers for TimestreamWrite and TimestreamQuery
+    # The only difference is the host, but we don't have access to that in ServerMode
+    # Keep the `Query`-responses here
+    # So we don't have to jump through all kinds of hoops to explain the difference between Query and Write to MotoServer
+
+    def create_scheduled_query(self) -> str:
+        name = self._get_param("Name")
+        query_string = self._get_param("QueryString")
+        schedule_configuration = self._get_param("ScheduleConfiguration")
+        notification_configuration = self._get_param("NotificationConfiguration")
+        target_configuration = self._get_param("TargetConfiguration")
+        scheduled_query_execution_role_arn = self._get_param(
+            "ScheduledQueryExecutionRoleArn"
+        )
+        tags = self._get_param("Tags")
+        kms_key_id = self._get_param("KmsKeyId")
+        error_report_configuration = self._get_param("ErrorReportConfiguration")
+        scheduled_query = self.timestreamquery_backend.create_scheduled_query(
+            name=name,
+            query_string=query_string,
+            schedule_configuration=schedule_configuration,
+            notification_configuration=notification_configuration,
+            target_configuration=target_configuration,
+            scheduled_query_execution_role_arn=scheduled_query_execution_role_arn,
+            tags=tags,
+            kms_key_id=kms_key_id,
+            error_report_configuration=error_report_configuration,
+        )
+        return json.dumps(dict(Arn=scheduled_query.arn))
+
+    def delete_scheduled_query(self) -> str:
+        scheduled_query_arn = self._get_param("ScheduledQueryArn")
+        self.timestreamquery_backend.delete_scheduled_query(
+            scheduled_query_arn=scheduled_query_arn,
+        )
+        return "{}"
+
+    def update_scheduled_query(self) -> str:
+        scheduled_query_arn = self._get_param("ScheduledQueryArn")
+        state = self._get_param("State")
+        self.timestreamquery_backend.update_scheduled_query(
+            scheduled_query_arn=scheduled_query_arn,
+            state=state,
+        )
+        return "{}"
+
+    def query(self) -> str:
+        query_string = self._get_param("QueryString")
+        result = self.timestreamquery_backend.query(query_string=query_string)
+        return json.dumps(result)
+
+    def describe_scheduled_query(self) -> str:
+        scheduled_query_arn = self._get_param("ScheduledQueryArn")
+        scheduled_query = self.timestreamquery_backend.describe_scheduled_query(
+            scheduled_query_arn=scheduled_query_arn,
+        )
+        return json.dumps(dict(ScheduledQuery=scheduled_query.description()))

{moto-5.0.14.dev17 → moto-5.0.14.dev19/moto.egg-info}/PKG-INFO

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

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/moto.egg-info/SOURCES.txt

@@ -1417,6 +1417,10 @@ moto/textract/exceptions.py
 moto/textract/models.py
 moto/textract/responses.py
 moto/textract/urls.py
+moto/timestreamquery/__init__.py
+moto/timestreamquery/exceptions.py
+moto/timestreamquery/models.py
+moto/timestreamquery/urls.py
 moto/timestreamwrite/__init__.py
 moto/timestreamwrite/exceptions.py
 moto/timestreamwrite/models.py
@@ -2265,10 +2269,10 @@ tests/test_signer/test_signing_platforms.py
 tests/test_signer/test_signing_profiles.py
 tests/test_sns/__init__.py
 tests/test_sns/test_application_boto3.py
+tests/test_sns/test_http_message_verification.py
 tests/test_sns/test_publish_batch.py
 tests/test_sns/test_publishing_boto3.py
 tests/test_sns/test_server.py
-tests/test_sns/test_sns.py
 tests/test_sns/test_sns_cloudformation.py
 tests/test_sns/test_subscriptions_boto3.py
 tests/test_sns/test_topics_boto3.py
@@ -2370,6 +2374,8 @@ tests/test_swf/responses/test_workflow_types.py
 tests/test_textract/__init__.py
 tests/test_textract/test_server.py
 tests/test_textract/test_textract.py
+tests/test_timestreamquery/__init__.py
+tests/test_timestreamquery/test_timestreamquery.py
 tests/test_timestreamwrite/__init__.py
 tests/test_timestreamwrite/test_server.py
 tests/test_timestreamwrite/test_timestreamwrite_database.py

{moto-5.0.14.dev17 → moto-5.0.14.dev19}/setup.cfg

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