moto 5.0.15.dev9__tar.gz → 5.0.15.dev10__tar.gz

{moto-5.0.15.dev9/moto.egg-info → moto-5.0.15.dev10}/PKG-INFO

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

{moto-5.0.15.dev9 → moto-5.0.15.dev10}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.15.dev9"
+__version__ = "5.0.15.dev10"

{moto-5.0.15.dev9 → moto-5.0.15.dev10}/moto/backend_index.py

@@ -212,5 +212,6 @@ backend_url_patterns = [
     ("transfer", re.compile("https?://transfer\\.(.+)\\.amazonaws\\.com")),
     ("wafv2", re.compile("https?://wafv2\\.(.+)\\.amazonaws.com")),
     ("workspaces", re.compile("https?://workspaces\\.(.+)\\.amazonaws\\.com")),
+    ("workspacesweb", re.compile("https?://workspaces-web\\.(.+)\\.amazonaws\\.com")),
     ("xray", re.compile("https?://xray\\.(.+)\\.amazonaws.com")),
 ]

{moto-5.0.15.dev9 → moto-5.0.15.dev10}/moto/backends.py

@@ -147,6 +147,7 @@ if TYPE_CHECKING:
     from moto.transfer.models import TransferBackend
     from moto.wafv2.models import WAFV2Backend
     from moto.workspaces.models import WorkSpacesBackend
+    from moto.workspacesweb.models import WorkSpacesWebBackend
     from moto.xray.models import XRayBackend
 
 
@@ -325,6 +326,7 @@ SERVICE_NAMES = Union[
     "Literal['transfer']",
     "Literal['wafv2']",
     "Literal['workspaces']",
+    "Literal['workspaces-web']",
     "Literal['xray']",
 ]
 
@@ -728,6 +730,10 @@ def get_backend(name: "Literal['wafv2']") -> "BackendDict[WAFV2Backend]": ...
 @overload
 def get_backend(name: "Literal['workspaces']") -> "BackendDict[WorkSpacesBackend]": ...
 @overload
+def get_backend(
+    name: "Literal['workspaces-web']",
+) -> "BackendDict[WorkSpacesWebBackend]": ...
+@overload
 def get_backend(name: "Literal['xray']") -> "BackendDict[XRayBackend]": ...
 
 

{moto-5.0.15.dev9 → moto-5.0.15.dev10}/moto/resourcegroupstaggingapi/models.py

@@ -28,6 +28,7 @@ from moto.ssm.models import SimpleSystemManagerBackend, ssm_backends
 from moto.utilities.tagging_service import TaggingService
 from moto.utilities.utils import get_partition
 from moto.workspaces.models import WorkSpacesBackend, workspaces_backends
+from moto.workspacesweb.models import WorkSpacesWebBackend, workspacesweb_backends
 
 # Left: EC2 ElastiCache RDS ELB CloudFront Lambda EMR Glacier Kinesis Redshift Route53
 # StorageGateway DynamoDB MachineLearning ACM DirectConnect DirectoryService CloudHSM
@@ -135,6 +136,13 @@ class ResourceGroupsTaggingAPIBackend(BaseBackend):
             return workspaces_backends[self.account_id][self.region_name]
         return None
 
+    @property
+    def workspacesweb_backends(self) -> Optional[WorkSpacesWebBackend]:
+        # Workspaces service has limited region availability
+        if self.region_name in workspaces_backends[self.account_id].regions:
+            return workspacesweb_backends[self.account_id][self.region_name]
+        return None
+
     @property
     def sagemaker_backend(self) -> SageMakerModelBackend:
         return sagemaker_backends[self.account_id][self.region_name]
@@ -626,6 +634,19 @@ class ResourceGroupsTaggingAPIBackend(BaseBackend):
                     "Tags": tags,
                 }
 
+        # Workspaces Web
+        if self.workspacesweb_backends and (
+            not resource_type_filters or "workspaces-web" in resource_type_filters
+        ):
+            for portal in self.workspacesweb_backends.portals.values():
+                tags = format_tag_keys(portal.tags, ["Key", "Value"])  # type: ignore
+                if not tags or not tag_filter(tags):
+                    continue
+                yield {
+                    "ResourceARN": f"arn:{get_partition(self.region_name)}:workspaces-web:{self.region_name}:{self.account_id}:portal/{portal.portal_id}",
+                    "Tags": tags,
+                }
+
         # VPC
         if (
             not resource_type_filters
@@ -1028,6 +1049,13 @@ class ResourceGroupsTaggingAPIBackend(BaseBackend):
                 self.rds_backend.add_tags_to_resource(
                     arn, TaggingService.convert_dict_to_tags_input(tags)
                 )
+            elif arn.startswith(
+                f"arn:{get_partition(self.region_name)}:workspaces-web:"
+            ):
+                resource_id = arn.split("/")[-1]
+                self.workspacesweb_backends.create_tags(  # type: ignore[union-attr]
+                    resource_id, TaggingService.convert_dict_to_tags_input(tags)
+                )
             elif arn.startswith(f"arn:{get_partition(self.region_name)}:workspaces:"):
                 resource_id = arn.split("/")[-1]
                 self.workspaces_backend.create_tags(  # type: ignore[union-attr]

moto-5.0.15.dev10/moto/workspacesweb/__init__.py

@@ -0,0 +1 @@
+from .models import workspacesweb_backends  # noqa: F401

moto-5.0.15.dev10/moto/workspacesweb/exceptions.py

@@ -0,0 +1 @@
+"""Exceptions raised by the workspacesweb service."""

moto-5.0.15.dev10/moto/workspacesweb/models.py

@@ -0,0 +1,290 @@
+"""WorkSpacesWebBackend class with methods for supported APIs."""
+
+import datetime
+import uuid
+from typing import Any, Dict, List, Optional, Tuple
+
+from moto.core.base_backend import BackendDict, BaseBackend
+from moto.core.common_models import BaseModel
+from moto.utilities.utils import get_partition
+
+
+class FakeNetworkSettings(BaseModel):
+    def __init__(
+        self,
+        security_group_ids: List[str],
+        subnet_ids: List[str],
+        tags: Dict[str, str],
+        vpc_id: str,
+        region_name: str,
+        account_id: str,
+    ):
+        self.network_settings_id = str(uuid.uuid4())
+        self.arn = self.arn_formatter(self.network_settings_id, account_id, region_name)
+        self.security_group_ids = security_group_ids
+        self.subnet_ids = subnet_ids
+        self.tags = tags
+        self.vpc_id = vpc_id
+        self.associated_portal_arns: List[str] = []
+
+    def arn_formatter(self, _id: str, account_id: str, region_name: str) -> str:
+        return f"arn:{get_partition(region_name)}:workspaces-web:{region_name}:{account_id}:network-settings/{_id}"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "associatedPortalArns": self.associated_portal_arns,
+            "networkSettingsArn": self.arn,
+            "securityGroupIds": self.security_group_ids,
+            "subnetIds": self.subnet_ids,
+            "Tags": self.tags,
+            "vpcId": self.vpc_id,
+        }
+
+
+class FakeBrowserSettings(BaseModel):
+    def __init__(
+        self,
+        additional_encryption_context: Any,
+        browser_policy: str,
+        client_token: str,
+        customer_managed_key: str,
+        tags: Dict[str, str],
+        region_name: str,
+        account_id: str,
+    ):
+        self.browser_settings_id = str(uuid.uuid4())
+        self.arn = self.arn_formatter(self.browser_settings_id, account_id, region_name)
+        self.additional_encryption_context = additional_encryption_context
+        self.browser_policy = browser_policy
+        self.client_token = client_token
+        self.customer_managed_key = customer_managed_key
+        self.tags = tags
+        self.associated_portal_arns: List[str] = []
+
+    def arn_formatter(self, _id: str, account_id: str, region_name: str) -> str:
+        return f"arn:{get_partition(region_name)}:workspaces-web:{region_name}:{account_id}:browser-settings/{_id}"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "associatedPortalArns": self.associated_portal_arns,
+            "browserSettingsArn": self.arn,
+            "additionalEncryptionContext": self.additional_encryption_context,
+            "browserPolicy": self.browser_policy,
+            "customerManagedKey": self.customer_managed_key,
+            "tags": self.tags,
+        }
+
+
+class FakePortal(BaseModel):
+    def __init__(
+        self,
+        additional_encryption_context: Any,
+        authentication_type: str,
+        client_token: str,
+        customer_managed_key: str,
+        display_name: str,
+        instance_type: str,
+        max_concurrent_sessions: str,
+        tags: Dict[str, str],
+        region_name: str,
+        account_id: str,
+    ):
+        self.portal_id = str(uuid.uuid4())
+        self.arn = self.arn_formatter(self.portal_id, account_id, region_name)
+        self.additional_encryption_context = additional_encryption_context
+        self.authentication_type = authentication_type
+        self.client_token = client_token
+        self.customer_managed_key = customer_managed_key
+        self.display_name = display_name
+        self.instance_type = instance_type
+        self.max_concurrent_sessions = max_concurrent_sessions
+        self.tags = tags
+        self.portal_endpoint = f"{self.portal_id}.portal.aws"
+        self.browser_type = "Chrome"
+        self.creation_time = datetime.datetime.now().isoformat()
+        self.status = "CREATED"
+        self.renderer_type = "AppStream"
+        self.status_reason = "TestStatusReason"
+        self.browser_settings_arn: Optional[str] = None
+        self.network_settings_arn: Optional[str] = None
+        self.trust_store_arn: Optional[str] = None
+        self.ip_access_settings_arn: Optional[str] = None
+        self.user_access_logging_settings_arn: Optional[str] = None
+        self.user_settings_arn: Optional[str] = None
+
+    def arn_formatter(self, _id: str, account_id: str, region_name: str) -> str:
+        return f"arn:{get_partition(region_name)}:workspaces-web:{region_name}:{account_id}:portal/{_id}"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "additionalEncryptionContext": self.additional_encryption_context,
+            "authenticationType": self.authentication_type,
+            "browserSettingsArn": self.browser_settings_arn,
+            "browserType": self.browser_type,
+            "creationDate": self.creation_time,
+            "customerManagedKey": self.customer_managed_key,
+            "displayName": self.display_name,
+            "instanceType": self.instance_type,
+            "ipAccessSettingsArn": self.ip_access_settings_arn,
+            "maxConcurrentSessions": self.max_concurrent_sessions,
+            "networkSettingsArn": self.network_settings_arn,
+            "portalArn": self.arn,
+            "portalEndpoint": self.portal_endpoint,
+            "portalStatus": self.status,
+            "rendererType": self.renderer_type,
+            "statusReason": self.status_reason,
+            "trustStoreArn": self.trust_store_arn,
+            "userAccessLoggingSettingsArn": self.user_access_logging_settings_arn,
+            "userSettingsArn": self.user_settings_arn,
+            "tags": self.tags,
+        }
+
+
+class WorkSpacesWebBackend(BaseBackend):
+    """Implementation of WorkSpacesWeb APIs."""
+
+    def __init__(self, region_name: str, account_id: str):
+        super().__init__(region_name, account_id)
+        self.network_settings: Dict[str, FakeNetworkSettings] = {}
+        self.browser_settings: Dict[str, FakeBrowserSettings] = {}
+        self.portals: Dict[str, FakePortal] = {}
+
+    def create_network_settings(
+        self,
+        security_group_ids: List[str],
+        subnet_ids: List[str],
+        tags: Dict[str, str],
+        vpc_id: str,
+    ) -> str:
+        network_settings_object = FakeNetworkSettings(
+            security_group_ids,
+            subnet_ids,
+            tags,
+            vpc_id,
+            self.region_name,
+            self.account_id,
+        )
+        self.network_settings[network_settings_object.arn] = network_settings_object
+        return network_settings_object.arn
+
+    def list_network_settings(self) -> List[Dict[str, str]]:
+        return [
+            {"networkSettingsArn": network_setting.arn, "vpcId": network_setting.vpc_id}
+            for network_setting in self.network_settings.values()
+        ]
+
+    def get_network_settings(self, network_settings_arn: str) -> Dict[str, Any]:
+        return self.network_settings[network_settings_arn].to_dict()
+
+    def delete_network_settings(self, network_settings_arn: str) -> None:
+        self.network_settings.pop(network_settings_arn)
+
+    def create_browser_settings(
+        self,
+        additional_encryption_context: Any,
+        browser_policy: str,
+        client_token: str,
+        customer_managed_key: str,
+        tags: Dict[str, str],
+    ) -> str:
+        browser_settings_object = FakeBrowserSettings(
+            additional_encryption_context,
+            browser_policy,
+            client_token,
+            customer_managed_key,
+            tags,
+            self.region_name,
+            self.account_id,
+        )
+        self.browser_settings[browser_settings_object.arn] = browser_settings_object
+        return browser_settings_object.arn
+
+    def list_browser_settings(self) -> List[Dict[str, str]]:
+        return [
+            {"browserSettingsArn": browser_setting.arn}
+            for browser_setting in self.browser_settings.values()
+        ]
+
+    def get_browser_settings(self, browser_settings_arn: str) -> Dict[str, Any]:
+        return self.browser_settings[browser_settings_arn].to_dict()
+
+    def delete_browser_settings(self, browser_settings_arn: str) -> None:
+        self.browser_settings.pop(browser_settings_arn)
+
+    def create_portal(
+        self,
+        additional_encryption_context: Any,
+        authentication_type: str,
+        client_token: str,
+        customer_managed_key: str,
+        display_name: str,
+        instance_type: str,
+        max_concurrent_sessions: str,
+        tags: Dict[str, str],
+    ) -> Tuple[str, str]:
+        portal_object = FakePortal(
+            additional_encryption_context,
+            authentication_type,
+            client_token,
+            customer_managed_key,
+            display_name,
+            instance_type,
+            max_concurrent_sessions,
+            tags,
+            self.region_name,
+            self.account_id,
+        )
+        self.portals[portal_object.arn] = portal_object
+        return portal_object.arn, portal_object.portal_endpoint
+
+    def list_portals(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "authenticationType": portal.authentication_type,
+                "browserSettingsArn": portal.browser_settings_arn,
+                "browserType": portal.browser_type,
+                "creationDate": portal.creation_time,
+                "customerManagedKey": portal.customer_managed_key,
+                "displayName": portal.display_name,
+                "instanceType": portal.instance_type,
+                "ipAccessSettingsArn": portal.ip_access_settings_arn,
+                "maxConcurrentSessions": portal.max_concurrent_sessions,
+                "networkSettingsArn": portal.network_settings_arn,
+                "portalArn": portal.arn,
+                "portalEndpoint": portal.portal_endpoint,
+                "portalStatus": portal.status,
+                "rendererType": portal.renderer_type,
+                "statusReason": portal.status_reason,
+                "trustStoreArn": portal.trust_store_arn,
+                "userAccessLoggingSettingsArn": portal.user_access_logging_settings_arn,
+                "userSettingsArn": portal.user_settings_arn,
+            }
+            for portal in self.portals.values()
+        ]
+
+    def get_portal(self, portal_arn: str) -> Dict[str, Any]:
+        return self.portals[portal_arn].to_dict()
+
+    def delete_portal(self, portal_arn: str) -> None:
+        self.portals.pop(portal_arn)
+
+    def associate_browser_settings(
+        self, browser_settings_arn: str, portal_arn: str
+    ) -> Tuple[str, str]:
+        browser_settings_object = self.browser_settings[browser_settings_arn]
+        portal_object = self.portals[portal_arn]
+        browser_settings_object.associated_portal_arns.append(portal_arn)
+        portal_object.browser_settings_arn = browser_settings_arn
+        return browser_settings_arn, portal_arn
+
+    def associate_network_settings(
+        self, network_settings_arn: str, portal_arn: str
+    ) -> Tuple[str, str]:
+        network_settings_object = self.network_settings[network_settings_arn]
+        portal_object = self.portals[portal_arn]
+        network_settings_object.associated_portal_arns.append(portal_arn)
+        portal_object.network_settings_arn = network_settings_arn
+        return network_settings_arn, portal_arn
+
+
+workspacesweb_backends = BackendDict(WorkSpacesWebBackend, "workspaces-web")

moto-5.0.15.dev10/moto/workspacesweb/responses.py

@@ -0,0 +1,185 @@
+"""Handles incoming workspacesweb requests, invokes methods, returns responses."""
+
+import json
+from typing import Any
+from urllib.parse import unquote
+
+from moto.core.responses import TYPE_RESPONSE, BaseResponse
+
+from .models import WorkSpacesWebBackend, workspacesweb_backends
+
+
+class WorkSpacesWebResponse(BaseResponse):
+    """Handler for WorkSpacesWeb requests and responses."""
+
+    def __init__(self) -> None:
+        super().__init__(service_name="workspaces-web")
+
+    @property
+    def workspacesweb_backend(self) -> WorkSpacesWebBackend:
+        """Return backend instance specific for this region."""
+        return workspacesweb_backends[self.current_account][self.region]
+
+    @staticmethod
+    def network_settings(request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[misc]
+        handler = WorkSpacesWebResponse()
+        handler.setup_class(request, full_url, headers)
+        if request.method == "GET":
+            return handler.get_network_settings()
+        else:
+            return handler.delete_network_settings()
+
+    @staticmethod
+    def browser_settings(request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[misc]
+        handler = WorkSpacesWebResponse()
+        handler.setup_class(request, full_url, headers)
+        if request.method == "GET":
+            return handler.get_browser_settings()
+        else:
+            return handler.delete_browser_settings()
+
+    @staticmethod
+    def portal(request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[misc]
+        handler = WorkSpacesWebResponse()
+        handler.setup_class(request, full_url, headers)
+        if request.method == "GET":
+            return handler.get_portal()
+        else:
+            return handler.delete_portal()
+
+    def create_browser_settings(self) -> str:
+        additional_encryption_context = self._get_param("additionalEncryptionContext")
+        browser_policy = self._get_param("browserPolicy")
+        client_token = self._get_param("clientToken")
+        customer_managed_key = self._get_param("customerManagedKey")
+        tags = self._get_param("tags")
+        browser_settings_arn = self.workspacesweb_backend.create_browser_settings(
+            additional_encryption_context=additional_encryption_context,
+            browser_policy=browser_policy,
+            client_token=client_token,
+            customer_managed_key=customer_managed_key,
+            tags=tags,
+        )
+        return json.dumps(dict(browserSettingsArn=browser_settings_arn))
+
+    def create_network_settings(self) -> str:
+        security_group_ids = self._get_param("securityGroupIds")
+        subnet_ids = self._get_param("subnetIds")
+        tags = self._get_param("tags")
+        vpc_id = self._get_param("vpcId")
+        network_settings_arn = self.workspacesweb_backend.create_network_settings(
+            security_group_ids=security_group_ids,
+            subnet_ids=subnet_ids,
+            tags=tags,
+            vpc_id=vpc_id,
+        )
+        return json.dumps(dict(networkSettingsArn=network_settings_arn))
+
+    def get_network_settings(self) -> TYPE_RESPONSE:
+        network_settings_arn = unquote(
+            self.parsed_url.path.split("/networkSettings/")[-1]
+        )
+        network_settings = self.workspacesweb_backend.get_network_settings(
+            network_settings_arn=network_settings_arn,
+        )
+        return 200, {}, json.dumps(dict(networkSettings=network_settings))
+
+    def create_portal(self) -> str:
+        additional_encryption_context = self._get_param("additionalEncryptionContext")
+        authentication_type = self._get_param("authenticationType")
+        client_token = self._get_param("clientToken")
+        customer_managed_key = self._get_param("customerManagedKey")
+        display_name = self._get_param("displayName")
+        instance_type = self._get_param("instanceType")
+        max_concurrent_sessions = self._get_param("maxConcurrentSessions")
+        tags = self._get_param("tags")
+        portal_arn, portal_endpoint = self.workspacesweb_backend.create_portal(
+            additional_encryption_context=additional_encryption_context,
+            authentication_type=authentication_type,
+            client_token=client_token,
+            customer_managed_key=customer_managed_key,
+            display_name=display_name,
+            instance_type=instance_type,
+            max_concurrent_sessions=max_concurrent_sessions,
+            tags=tags,
+        )
+        return json.dumps(dict(portalArn=portal_arn, portalEndpoint=portal_endpoint))
+
+    def list_browser_settings(self) -> str:
+        browser_settings = self.workspacesweb_backend.list_browser_settings()
+        return json.dumps(dict(browserSettings=browser_settings))
+
+    def list_network_settings(self) -> str:
+        network_settings = self.workspacesweb_backend.list_network_settings()
+        return json.dumps(dict(networkSettings=network_settings))
+
+    def list_portals(self) -> str:
+        portals = self.workspacesweb_backend.list_portals()
+        return json.dumps(dict(portals=portals))
+
+    def get_browser_settings(self) -> TYPE_RESPONSE:
+        browser_settings_arn = unquote(
+            self.parsed_url.path.split("/browserSettings/")[-1]
+        )
+        browser_settings = self.workspacesweb_backend.get_browser_settings(
+            browser_settings_arn=browser_settings_arn,
+        )
+        return 200, {}, json.dumps(dict(browserSettings=browser_settings))
+
+    def delete_browser_settings(self) -> TYPE_RESPONSE:
+        browser_settings_arn = unquote(
+            self.parsed_url.path.split("/browserSettings/")[-1]
+        )
+        self.workspacesweb_backend.delete_browser_settings(
+            browser_settings_arn=browser_settings_arn
+        )
+        return 200, {}, "{}"
+
+    def delete_network_settings(self) -> TYPE_RESPONSE:
+        network_settings_arn = unquote(
+            self.parsed_url.path.split("/networkSettings/")[-1]
+        )
+        self.workspacesweb_backend.delete_network_settings(
+            network_settings_arn=network_settings_arn,
+        )
+        return 200, {}, "{}"
+
+    def get_portal(self) -> TYPE_RESPONSE:
+        portal_arn = unquote(self.parsed_url.path.split("/portals/")[-1])
+        portal = self.workspacesweb_backend.get_portal(portal_arn=portal_arn)
+        return 200, {}, json.dumps(dict(portal=portal))
+
+    def delete_portal(self) -> TYPE_RESPONSE:
+        portal_arn = unquote(self.parsed_url.path.split("/portals/")[-1])
+        self.workspacesweb_backend.delete_portal(portal_arn=portal_arn)
+        return 200, {}, "{}"
+
+    def associate_browser_settings(self) -> str:
+        browser_settings_arn = unquote(self._get_param("browserSettingsArn"))
+        portal_arn = unquote(
+            self.parsed_url.path.split("/portals/")[-1].split("/browserSettings")[0]
+        )
+        browser_settings_arn, portal_arn = (
+            self.workspacesweb_backend.associate_browser_settings(
+                browser_settings_arn=browser_settings_arn,
+                portal_arn=portal_arn,
+            )
+        )
+        return json.dumps(
+            dict(browserSettingsArn=browser_settings_arn, portalArn=portal_arn)
+        )
+
+    def associate_network_settings(self) -> str:
+        network_settings_arn = unquote(self._get_param("networkSettingsArn"))
+        portal_arn = unquote(
+            self.parsed_url.path.split("/portals/")[-1].split("/networkSettings")[0]
+        )
+        network_settings_arn, portal_arn = (
+            self.workspacesweb_backend.associate_network_settings(
+                network_settings_arn=network_settings_arn,
+                portal_arn=portal_arn,
+            )
+        )
+        return json.dumps(
+            dict(networkSettingsArn=network_settings_arn, portalArn=portal_arn)
+        )

moto-5.0.15.dev10/moto/workspacesweb/urls.py

@@ -0,0 +1,18 @@
+"""workspacesweb base URL and path."""
+
+from .responses import WorkSpacesWebResponse
+
+url_bases = [
+    r"https?://workspaces-web\.(.+)\.amazonaws\.com",
+]
+
+url_paths = {
+    "{0}/browserSettings$": WorkSpacesWebResponse.dispatch,
+    "{0}/networkSettings$": WorkSpacesWebResponse.dispatch,
+    "{0}/portals$": WorkSpacesWebResponse.dispatch,
+    "{0}/browserSettings/(?P<browserSettingsArn>.+)$": WorkSpacesWebResponse.browser_settings,
+    "{0}/networkSettings/(?P<networkSettingsArn>.+)$": WorkSpacesWebResponse.network_settings,
+    "{0}/portals/(?P<portalArn>[^/]+)portal/(?P<uuid>[^/]+)$": WorkSpacesWebResponse.portal,
+    "{0}/portals/(?P<portalArn>.*)/browserSettings$": WorkSpacesWebResponse.dispatch,
+    "{0}/portals/(?P<portalArn>.*)/networkSettings$": WorkSpacesWebResponse.dispatch,
+}

{moto-5.0.15.dev9 → moto-5.0.15.dev10/moto.egg-info}/PKG-INFO

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

{moto-5.0.15.dev9 → moto-5.0.15.dev10}/moto.egg-info/SOURCES.txt

@@ -1470,6 +1470,11 @@ moto/workspaces/exceptions.py
 moto/workspaces/models.py
 moto/workspaces/responses.py
 moto/workspaces/urls.py
+moto/workspacesweb/__init__.py
+moto/workspacesweb/exceptions.py
+moto/workspacesweb/models.py
+moto/workspacesweb/responses.py
+moto/workspacesweb/urls.py
 moto/xray/__init__.py
 moto/xray/exceptions.py
 moto/xray/mock_client.py
@@ -2414,6 +2419,8 @@ tests/test_wafv2/test_wafv2_rules.py
 tests/test_wafv2/test_wafv2_tags.py
 tests/test_workspaces/__init__.py
 tests/test_workspaces/test_workspaces.py
+tests/test_workspacesweb/__init__.py
+tests/test_workspacesweb/test_workspacesweb.py
 tests/test_xray/__init__.py
 tests/test_xray/test_xray_boto3.py
 tests/test_xray/test_xray_client.py

{moto-5.0.15.dev9 → moto-5.0.15.dev10}/setup.cfg

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