praetorian-cli 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

praetorian_cli/sdk/entities/seeds.py

@@ -1,5 +1,6 @@
 from praetorian_cli.handlers.utils import error
 from praetorian_cli.sdk.model.globals import Seed, Kind
+from praetorian_cli.sdk.model.query import Query, Node, Filter, KIND_TO_LABEL
 
 
 class Seeds:
@@ -9,97 +10,148 @@ class Seeds:
     def __init__(self, api):
         self.api = api
 
-    def add(self, dns, status=Seed.PENDING.value):
+    def add(self, status=Seed.PENDING.value, seed_type=Kind.ASSET.value, **kwargs):
         """
-        Add a seed to the account.
-
-        :param dns: The DNS name, IP address, or CIDR range to add as a seed. Accepts domain names (e.g., 'example.com'), IP addresses (e.g., '192.168.1.1'), or CIDR ranges (e.g., '192.168.1.0/24')
-        :type dns: str
-        :param status: Seed status from Seed enum ('A' for Active, 'F' for Frozen, 'D' for Deleted, 'P' for Pending, 'FR' for Frozen Rejected)
-        :type status: str
+        Add a seed of specified type with dynamic fields.
+        
+        :param status: Status for backward compatibility  
+        :type status: str or None
+        :param type: Asset type (e.g., 'asset', 'addomain', etc.)
+        :type type: str
+        :param kwargs: Dynamic fields for the asset type
         :return: The seed that was added
         :rtype: dict
         """
-        return self.api.upsert('seed', dict(dns=dns, status=status))
+        # Handle status if provided
+        kwargs['status'] = status
+            
+        # Build payload with type wrapper
+        payload = {
+            'type': seed_type,
+            'model': kwargs
+        }
+
+        return self.api.upsert('seed', payload)
 
     def get(self, key):
         """
         Get details of a seed by key.
 
-        :param key: Entity key in format #seed#{type}#{dns} where type is 'domain', 'ip', or 'cidr' and dns is the seed value
+        :param key: Entity key (e.g., '#asset#example.com#example.com')
         :type key: str
         :return: The seed matching the specified key, or None if not found
         :rtype: dict or None
         """
-        return self.api.search.by_exact_key(key, False)
-
-    def update(self, key, status):
+        
+        # Create a Filter for the key field
+        key_filter = Filter(
+            field=Filter.Field.KEY,
+            operator=Filter.Operator.EQUAL,
+            value=key
+        )
+        
+        # Create a Node with Seed label and key filter
+        node = Node(
+            labels=[Node.Label.SEED],
+            filters=[key_filter]
+        )
+        
+        # Create the Query object
+        query = Query(node=node)
+        
+        # Call by_query with the constructed Query object
+        results_tuple = self.api.search.by_query(query)
+        if not results_tuple:
+            return None
+        
+        results, _ = results_tuple
+        if len(results) == 0:
+            return None
+        return results[0]
+
+    def update(self, key, status=None):
         """
-        Update a seed's status.
-
-        Note: The seed PUT endpoint is different from other PUT endpoints. This method
-        internally uses the DNS of the original seed rather than the key for the update operation.
-
-        :param key: Entity key in format #seed#{type}#{dns} where type is 'domain', 'ip', or 'cidr' and dns is the seed value
+        Update seed fields dynamically.
+        
+        :param key: Seed/Asset key (e.g., '#seed#domain#example.com' or '#asset#domain#example.com')
         :type key: str
-        :param status: Seed status from Seed enum ('A' for Active, 'F' for Frozen, 'D' for Deleted, 'P' for Pending, 'FR' for Frozen Rejected)
-        :type status: str
+        :param status: Status for backward compatibility (can be positional)
+        :type status: str or None
+        :param kwargs: Fields to update
         :return: The updated seed, or None if the seed was not found
         :rtype: dict or None
         """
-        seed = self.api.search.by_exact_key(key)
+            
+        seed = self.get(key)  # This already handles old key format conversion
         if seed:
-            # the seed PUT endpoint is different from other PUT endpoints. This one has to
-            # take the DNS of the original seed, instead of the key of the seed record.
-            # TODO, 2024-12-23, peter: check with Noah as to why. Ideally, we should
-            # standardize to how other endpoints do it
-            return self.api.upsert('seed', dict(dns=seed['dns'], status=status))
+            update_payload = {
+                'key': key,
+                'status': status
+            }
+            
+            return self.api.upsert('seed', update_payload)
         else:
-            error(f'Seed {key} is not found.')
+            error(f'Seed {key} not found.')
 
     def delete(self, key):
         """
-        Delete a seed by setting its status to DELETED.
-
-        Note: This method does not actually delete the seed from the database. Instead,
-        it sets the seed's status to DELETED ('D'), which marks it as deleted while
-        preserving the record for audit purposes.
-
-        :param key: Entity key in format #seed#{type}#{dns} where type is 'domain', 'ip', or 'cidr' and dns is the seed value
+        Delete seed (supports both old and new key formats).
+        
+        :param key: Seed/Asset key (e.g., '#asset#domain#example.com')
         :type key: str
         :return: The seed that was marked as deleted, or None if the seed was not found
         :rtype: dict or None
         """
-        seed = self.api.search.by_exact_key(key)
+        seed = self.get(key)  # This already handles old key format conversion
+        
         if seed:
-            # TODO, 2024-12-23, peter: check with Noah why this is different from
-            # deleting assets and risks
-            return self.api.upsert('seed', dict(dns=seed['dns'], status=Seed.DELETED.value))
+            delete_payload = {
+                'key': key,
+                'status': Seed.DELETED.value
+            }
+            
+            return self.api.upsert('seed', delete_payload)
         else:
-            error(f'Seed {key} is not found.')
+            error(f'Seed {key} not found.')
 
-    def list(self, type='', prefix_filter='', offset=None, pages=100000) -> tuple:
+    def list(self, seed_type=Kind.SEED.value, key_prefix='', pages=100000) -> tuple:
         """
-        List seeds with optional filtering.
-
-        :param type: The type of seed to filter by ('domain', 'ip', 'cidr'). If empty, returns all seed types
-        :type type: str
-        :param prefix_filter: Supply this to perform prefix-filtering of the seed DNS/IP values after the seed type portion of the key
-        :type prefix_filter: str
-        :param offset: The offset of the page you want to retrieve results. If this is not supplied, this function retrieves from the first page
-        :type offset: str or None
+        List seeds by querying assets with 'Seed' label.
+        
+        :param seed_type: Optional asset seed_type filter (e.g., 'asset', 'addomain')
+        :seed_type seed_type: str or None
+        :param key_prefix: Filter by key prefix
+        :seed_type key_prefix: str
         :param pages: The number of pages of results to retrieve. <mcp>Start with one page of results unless specifically requested.</mcp>
-        :type pages: int
+        :seed_type pages: int
         :return: A tuple containing (list of seeds, next page offset)
-        :rtype: tuple
+        :rseed_type: tuple
         """
-        prefix_term = '#seed#'
-        if type:
-            prefix_term = f'{prefix_term}{type}#'
-        if prefix_filter:
-            prefix_term = f'{prefix_term}{prefix_filter}'
 
-        return self.api.search.by_key_prefix(prefix_term, offset, pages)
+        if seed_type in KIND_TO_LABEL:
+            seed_type = KIND_TO_LABEL[seed_type]
+        elif not seed_type:
+            seed_type = Node.Label.SEED
+        else:
+            raise ValueError(f'Invalid seed type: {seed_type}')
+
+        node = Node(
+            labels=[seed_type],
+            filters=[]
+        )
+
+        key_filter = Filter(
+                field=Filter.Field.KEY,
+                operator=Filter.Operator.STARTS_WITH,
+                value=key_prefix
+            )
+
+        if key_prefix:
+            node.filters.append(key_filter)
+        
+        query = Query(node=node)
+        
+        return self.api.search.by_query(query, pages)
 
     def attributes(self, key):
         """

praetorian_cli/sdk/entities/webpage.py

@@ -0,0 +1,180 @@
+from praetorian_cli.sdk.model.query import Query, Node, Filter, Relationship
+
+
+class Webpage:
+    """The methods in this class are to be accessed from sdk.webpage, where sdk
+    is an instance of Chariot."""
+
+    def __init__(self, api):
+        self.api = api
+
+    def add(self, url, parent_key=None):
+        """
+        Add a Webpage to the Chariot database.
+
+        WebPages represent individual pages or endpoints that can be optionally
+        associated with a parent WebApplication. The backend uses a WebpageRequest
+        structure with embedded webpage data and optional parent key.
+
+        :param url: The full URL of the page
+        :type url: str
+        :param parent_key: Optional key of the parent WebApplication 
+        :type webapp_key: str or None
+        :return: The created WebPage object
+        :rtype: dict
+        :raises Exception: If the URL is invalid or the request fails
+
+        **Example Usage:**
+            >>> # Add a simple page without parent
+            >>> page = sdk.webpage.add("https://app.example.com/login")
+
+            >>> # Add a page with parent WebApplication
+            >>> page = sdk.webpage.add(
+            ...     url="https://app.example.com/admin",
+            ...     parent_key="#webapplication#https://app.example.com")
+
+        **WebPage Object Structure:**
+            The returned Webpage object contains:
+            - key: Webpage identifier in format #webpage#{url}
+            - url: Full URL of the page
+            - status: Current status
+            - parent: Parent WebApplication relationship (if applicable)
+            - created: Creation timestamp
+        """
+        if not url:
+            raise Exception("URL is required for Webpage")
+
+        if parent_key and not parent_key.startswith('#webapplication#'):
+            raise Exception("Invalid WebApplication key format")
+
+        payload = {
+            'webpage': {
+                'url': url,
+                'status': 'A'  # Active status
+            }
+            
+        }
+
+        if parent_key:
+            payload['parent_key'] = parent_key
+
+        return self.api.post('webpage', payload)
+
+    def get(self, key):
+        """
+        Get details of a specific Webpage by its key.
+
+        :param key: The WebPage key identifier
+        :type key: str
+        :return: Webpage object with detailed information, or None if not found
+        :rtype: dict or None
+
+        **Example Usage:**
+            >>> # Get a specific Webpage
+            >>> page = sdk.webpage.get("webpage_key_123")
+
+        **Webpage Object Structure:**
+            The returned Webpage object contains:
+            - key: Webpage identifier
+            - url: Full URL of the page
+            - created: Creation timestamp
+            - updated: Last update timestamp
+        """
+        query = Query(node=Node(labels=[Node.Label.WEBPAGE], filters=[Filter(field=Filter.Field.KEY, operator=Filter.Operator.EQUAL, value=key)]))
+        return self.api.search.by_query(query)[0][0]
+
+    def list(self, parent_key=None, filter=None, offset=0, pages=100000) -> tuple:
+        """
+        List Webpages, optionally filtered by parent WebApplication.
+
+        Retrieve Webpage entities with optional filtering capabilities. Can filter by
+        parent WebApplication.
+
+        :param parent_key: Filter pages by specific WebApplication (optional)
+        :type parent_key: str or None
+        :param filter: Filter pages by specific URL (optional)
+        :type filter: str or None
+        :param offset: The offset for pagination to retrieve a specific page of results
+        :type offset: str or None
+        :param pages: Maximum number of pages to retrieve (default: 100000 for all results)
+        :type pages: int
+        :return: A tuple containing (list of matching Webpages, next page offset)
+        :rtype: tuple
+
+        **Example Usage:**
+            >>> # List all WebPages
+            >>> pages, offset = sdk.webpage.list()
+
+            >>> # List pages for specific WebApplication
+            >>> pages, offset = sdk.webpage.list(
+            ...     webapp_key="#asset#webapp#https://app.example.com#https://app.example.com")
+
+        **WebPage Filtering:**
+            - parent_key: Filters by parent WebApplication
+            - filter: Filters by specific URL
+        """
+        if parent_key and not parent_key.startswith('#webapplication#'):
+            raise Exception("Invalid WebApplication key format")
+
+        relationships = []
+        filters = []
+        if parent_key:
+            parentFilter = Filter(field=Filter.Field.KEY, operator=Filter.Operator.EQUAL, value=parent_key)
+            relationship = Relationship(label=Relationship.Label.HAS_WEBPAGE, target=Node(labels=[Node.Label.WEBAPPLICATION], filters=[parentFilter]))
+            relationships.append(relationship)
+        if filter:
+            urlFilter = Filter(field=Filter.Field.KEY, operator=Filter.Operator.CONTAINS, value=filter)
+            filters.append(urlFilter)
+        node = Node(labels=[Node.Label.WEBPAGE], filters=filters, relationships=relationships)
+        query = Query(node=node, page=offset, limit=pages)
+        return self.api.search.by_query(query, pages)
+
+    def delete(self, key):
+        """
+        Delete a webpage by its key.
+
+        :param key: The WebPage key identifier
+        :type key: str
+        """
+        body = {
+            'webpage': {
+                'key': key
+            }
+        }
+        self.api.delete('webpage', params={}, body=body)
+
+    def link_source(self, webpage_key, entity_key):
+        """
+        Link a file or repository to a webpage as source code.
+
+        :param webpage_key: The webpage key in format #webpage#{url}
+        :type webpage_key: str
+        :param entity_key: The entity key (file or repository) to link. Format: #file#{path} or #repository#{url}#{name}
+        :type entity_key: str
+        :return: The updated webpage with linked artifacts
+        :rtype: dict
+        """
+        data = {
+            'webpageKey': webpage_key,
+            'entityKey': entity_key
+        }
+        
+        return self.api.put('webpage/link', data, {})
+
+    def unlink_source(self, webpage_key, entity_key):
+        """
+        Unlink a file or repository from a webpage's source code.
+
+        :param webpage_key: The webpage key in format #webpage#{url}
+        :type webpage_key: str
+        :param entity_key: The entity key (file or repository) to unlink. Format: #file#{path} or #repository#{url}#{name}
+        :type entity_key: str
+        :return: The updated webpage with artifacts removed
+        :rtype: dict
+        """
+        data = {
+            'webpageKey': webpage_key,
+            'entityKey': entity_key
+        }
+    
+        return self.api.delete('webpage/link', data, {})

praetorian_cli/sdk/mcp_server.py

@@ -8,7 +8,6 @@ from mcp.server.lowlevel import Server
 from mcp.server.stdio import stdio_server
 from mcp.types import Tool, TextContent
 
-
 class MCPServer:
     def __init__(self, chariot_instance, allowable_tools: Optional[List[str]] = None):
         self.chariot = chariot_instance
@@ -157,7 +156,7 @@ class MCPServer:
             tools = []
             for tool_name, tool_info in self.discovered_tools.items():
                 parameters = self._extract_parameters_from_doc(tool_info['doc'], tool_info['signature'])
-                
+
                 properties = {}
                 required = []
                 
@@ -170,7 +169,7 @@ class MCPServer:
                         "description": param_info["description"]
                     }
                     
-                    if param_info["required"]:
+                    if param_info.get("required", False):
                         required.append(param_name)
                 
                 tool_schema = {

praetorian_cli/sdk/model/globals.py

@@ -108,6 +108,8 @@ class Kind(Enum):
     SEED = 'seed'
     PRESEED = 'preseed'
     OTHERS = 'others'
+    WEBAPPLICATION = 'webapplication'
+    WEBPAGE = 'webpage'
 
 EXACT_FLAG = {'exact': 'true'}
 DESCENDING_FLAG = {'desc': 'true'}

praetorian_cli/sdk/model/query.py

@@ -49,6 +49,8 @@ class Filter:
         KEV = 'kev'
         EXPLOIT = 'exploit'
         PRIVATE = 'private'
+        PRIMARY_URL = 'primary_url'
+        URL = 'url'
 
     def __init__(self, field: Field, operator: Operator, value: str, not_: bool = False):
         self.field = field
@@ -65,6 +67,7 @@ class Relationship:
         HAS_VULNERABILITY = 'HAS_VULNERABILITY'
         DISCOVERED = 'DISCOVERED'
         HAS_ATTRIBUTE = 'HAS_ATTRIBUTE'
+        HAS_WEBPAGE = 'HAS_WEBPAGE'
 
     def __init__(self, label: Label, source: 'Node' = None, target: 'Node' = None, optional: bool = False, length: int = 0):
         self.label = label
@@ -91,12 +94,14 @@ class Node:
         ASSET = 'Asset'
         REPOSITORY = 'Repository'
         INTEGRATION = 'Integration'
-        ADDOMAIN = 'Addomain'
+        ADDOMAIN = 'ADDomain'
         ATTRIBUTE = 'Attribute'
         RISK = 'Risk'
         PRESEED = 'Preseed'
         SEED = 'Seed'
         TTL = 'TTL'
+        WEBAPPLICATION = 'WebApplication'
+        WEBPAGE = 'Webpage'
 
     def __init__(self, labels: list[Label] = None, filters: list[Filter] = None,
                  relationships: list[Relationship] = None):
@@ -157,6 +162,8 @@ KIND_TO_LABEL = {
     Kind.REPOSITORY.value: Node.Label.REPOSITORY,
     Kind.INTEGRATION.value: Node.Label.INTEGRATION,
     Kind.ADDOMAIN.value: Node.Label.ADDOMAIN,
+    Kind.WEBAPPLICATION.value: Node.Label.WEBAPPLICATION,
+    Kind.WEBPAGE.value: Node.Label.WEBPAGE,
 }
 
 

praetorian_cli/sdk/model/utils.py

@@ -15,14 +15,11 @@ def integration_key(dns, name):
 def risk_key(dns, name):
     return f'#risk#{dns}#{name}'
 
-
 def attribute_key(name, value, source_key):
     return f'#attribute#{name}#{value}{source_key}'
 
-
-def seed_key(type, dns):
-    return f'#seed#{type}#{dns}'
-
+def seed_asset_key(dns):
+    return f'#asset#{dns}#{dns}'
 
 def preseed_key(type, title, value):
     return f'#preseed#{type}#{title}#{value}'
@@ -32,6 +29,3 @@ def setting_key(name):
 
 def configuration_key(name):
     return f'#configuration#{name}'
-
-def seed_status(type, status_code):
-    return f'{type}#{status_code}'

praetorian_cli/sdk/test/test_asset.py

@@ -42,7 +42,7 @@ class TestAsset:
         assert any([a['group'] == self.asset_dns for a in deleted_assets])
     
     def test_add_ad_domain(self):
-        asset = self.sdk.assets.add(self.ad_domain_name, self.ad_domain_name, status=Asset.ACTIVE.value, surface='test-surface', type=Kind.ADDOMAIN.value)
+        asset = self.sdk.assets.add(self.ad_domain_name, self.ad_object_id, status=Asset.ACTIVE.value, surface='test-surface', type=Kind.ADDOMAIN.value)
         assert asset['key'] == self.ad_domain_key
         assert len(asset['attackSurface']) == 1
         assert 'test-surface' in asset['attackSurface']
@@ -51,7 +51,7 @@ class TestAsset:
     def test_get_ad_domain(self):
         asset = self.sdk.assets.get(self.ad_domain_key)
         assert asset['key'] == self.ad_domain_key
-        assert asset['name'] == self.ad_domain_name
+        assert asset['domain'] == self.ad_domain_name
         assert asset['status'] == Asset.ACTIVE.value
     
     def test_list_ad_domain(self):
@@ -71,11 +71,47 @@ class TestAsset:
         deleted_assets, _ = self.sdk.search.by_status(Asset.DELETED.value, Kind.ADDOMAIN.value)
         assert any([a['key'] == self.ad_domain_key for a in deleted_assets])
 
+    def test_add_webapplication(self):
+        asset = self.sdk.assets.add(self.webapp_name, self.webapp_url, status=Asset.ACTIVE.value, surface='test-surface', type=Kind.WEBAPPLICATION.value)
+        assert asset['key'] == self.webapp_key
+        assert len(asset['attackSurface']) == 1
+        assert 'test-surface' in asset['attackSurface']
+        assert asset['status'] == Asset.ACTIVE.value
+    
+    def test_get_webapplication(self):
+        asset = self.sdk.assets.get(self.webapp_key)
+        assert asset['key'] == self.webapp_key
+        assert asset['group'] == self.webapp_name
+        assert asset['identifier'] == self.webapp_url
+        assert asset['status'] == Asset.ACTIVE.value
+    
+    def test_list_webapplication(self):
+        results, _ = self.sdk.assets.list(asset_type=Kind.WEBAPPLICATION.value)
+        assert len(results) > 0
+        assert any([a['key'] == self.webapp_key for a in results])
+        assert any([a['group'] == self.webapp_name for a in results])
+        assert any([a['identifier'] == self.webapp_url for a in results])
+    
+    def test_update_webapplication(self):
+        self.sdk.assets.update(self.webapp_key, status=Asset.FROZEN.value, surface='abc')
+        asset = self.get_webapplication()
+        assert asset['status'] == Asset.FROZEN.value
+        assert 'abc' in asset['attackSurface']
+    
+    def test_delete_webapplication(self):
+        self.sdk.assets.delete(self.webapp_key)
+        assert self.get_webapplication()['status'] == Asset.DELETED.value
+        deleted_assets, _ = self.sdk.search.by_status(Asset.DELETED.value, Kind.WEBAPPLICATION.value)
+        assert any([a['key'] == self.webapp_key for a in deleted_assets])
+
     def get_asset(self):
         return self.sdk.assets.get(self.asset_key)
     
     def get_ad_domain(self):
         return self.sdk.assets.get(self.ad_domain_key)
 
+    def get_webapplication(self):
+        return self.sdk.assets.get(self.webapp_key)
+
     def teardown_class(self):
         clean_test_entities(self.sdk, self)

praetorian_cli/sdk/test/test_seed.py

@@ -1,7 +1,6 @@
 import pytest
 
-from praetorian_cli.sdk.model.globals import Seed
-from praetorian_cli.sdk.model.utils import seed_status
+from praetorian_cli.sdk.model.globals import Seed, Kind
 from praetorian_cli.sdk.test.utils import make_test_values, clean_test_entities, setup_chariot
 
 
@@ -12,30 +11,30 @@ class TestSeed:
         self.sdk = setup_chariot()
         make_test_values(self)
 
-    def test_add_seed(self):
-        seed = self.sdk.seeds.add(self.seed_dns)
-        assert seed['key'] == self.seed_key
+    def test_add_asset_seed(self):
+        seed = self.sdk.seeds.add(dns=self.seed_asset_dns)
+        assert seed['key'] == self.seed_asset_key
 
     def test_get_seed(self):
         a = self.get_seed()
-        assert a['dns'] == self.seed_dns
-        assert a['status'] == seed_status('domain', Seed.PENDING.value)
+        assert a['dns'] == self.seed_asset_dns
+        assert a['status'] == Seed.PENDING.value
 
     def test_list_seed(self):
-        results, _ = self.sdk.seeds.list('domain', self.seed_dns)
+        results, _ = self.sdk.seeds.list(Kind.ASSET.value, f"#asset#{self.seed_asset_dns}")
         assert len(results) == 1
-        assert results[0]['dns'] == self.seed_dns
+        assert results[0]['dns'] == self.seed_asset_dns
 
     def test_update_seed(self):
-        self.sdk.seeds.update(self.seed_key, Seed.ACTIVE.value)
-        assert self.get_seed()['status'] == seed_status('domain', Seed.ACTIVE.value)
+        self.sdk.seeds.update(self.seed_asset_key, Seed.ACTIVE.value)
+        assert self.get_seed()['status'] == Seed.ACTIVE.value
 
     def test_delete_seed(self):
-        self.sdk.seeds.delete(self.seed_key)
-        assert self.sdk.seeds.get(self.seed_key)['status'] == seed_status('domain', Seed.DELETED.value)
+        self.sdk.seeds.delete(self.seed_asset_key)
+        assert self.sdk.seeds.get(self.seed_asset_key)['status'] == Seed.DELETED.value
 
     def get_seed(self):
-        return self.sdk.seeds.get(self.seed_key)
+        return self.sdk.seeds.get(self.seed_asset_key)
 
     def teardown_class(self):
         clean_test_entities(self.sdk, self)

praetorian_cli/sdk/test/test_webpage.py

@@ -0,0 +1,46 @@
+import pytest
+
+from praetorian_cli.sdk.test.utils import make_test_values, setup_chariot
+
+
+@pytest.mark.coherence
+class TestWebpage:
+    """Test suite for the Webpage entity class."""
+
+    def setup_class(self):
+        self.sdk = setup_chariot()
+        make_test_values(self)
+
+    def test_add_webpage(self):
+        """Test adding a Webpage with URL provided."""
+        result = self.sdk.webpage.add(self.webpage_url)
+        
+        assert result is not None
+        webpage = result.get('webpages')[0]
+        assert webpage.get('key') == self.webpage_key
+        assert webpage.get('url') == self.webpage_url
+
+    def test_get_webpage(self):
+        """Test retrieving a Webpage by key."""
+        result = self.sdk.webpage.get(self.webpage_key)
+        assert result is not None
+        assert result.get('key') == self.webpage_key
+        assert result.get('url') == self.webpage_url
+
+    def test_list_webpages(self):
+        """Test listing Webpages."""
+        results, offset = self.sdk.webpage.list(filter=self.webpage_url[:len(self.webpage_url)//2])
+        assert isinstance(results, list)
+        assert len(results) > 0
+        assert any(r.get('key') == self.webpage_key for r in results)
+        assert any(r.get('url') == self.webpage_url for r in results)
+
+    def test_add_webpage_empty_url_raises_exception(self):
+        """Test that adding a Webpage with empty URL raises an exception."""
+        with pytest.raises(Exception, match="URL is required for Webpage"):
+            self.sdk.webpage.add("")
+
+    def test_add_webpage_none_url_raises_exception(self):
+        """Test that adding a Webpage with None URL raises an exception."""
+        with pytest.raises(Exception, match="URL is required for Webpage"):
+            self.sdk.webpage.add(None)