Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(access-control): batch permission reads and writes (#123650)

Arthur Moreira de Deus9afcfe59cb29
diff --git a/docs/internal/activity-logging.md b/docs/internal/activity-logging.md
index e5c27eaeb239..adc0c38c0549 100644
--- a/docs/internal/activity-logging.md
+++ b/docs/internal/activity-logging.md
@@ -318,6 +318,7 @@ Test the behavior the receiver adds, through a public interface, at the cheapest
- One test that a write through the API or the facade creates a row with the expected `activity` and `changes`.
- One test per bulk-write site that its explicit logging produces the expected rows.
+- Batch object access-rule writes preserve the same changes and actor details as individual writes through `bulk_log_activity`.
- A `changes_between` test only when the scope adds exclusions or masks.
- For a separate-database product, one test that a rolled-back product write leaves no row (`override_settings(ACTIVITY_LOG_TRANSACTION_MANAGEMENT=True)` plus `captureOnCommitCallbacks(using=<writer alias>, execute=True)`).
diff --git a/posthog/models/file_system/signal_handlers.py b/posthog/models/file_system/signal_handlers.py
index aa13bd366895..d6fd04411155 100644
--- a/posthog/models/file_system/signal_handlers.py
+++ b/posthog/models/file_system/signal_handlers.py
@@ -9,7 +9,7 @@ from posthog.models.file_system.starred_products import star_default_products
@receiver(post_save, sender="ee.AccessControl")
def access_control_created(sender, instance, created, **kwargs):
"""Star the default products for a user who is granted access to a project."""
- if created and instance.organization_member and instance.resource == "project":
+ if created and instance.resource == "project" and instance.organization_member:
user = instance.organization_member.user
team = instance.team
diff --git a/posthog/models/test/test_default_starred_products.py b/posthog/models/test/test_default_starred_products.py
index e970c4792324..a50fb05ad58c 100644
--- a/posthog/models/test/test_default_starred_products.py
+++ b/posthog/models/test/test_default_starred_products.py
@@ -1,6 +1,11 @@
+from uuid import uuid4
+
from posthog.test.base import BaseTest
from unittest.mock import patch
+from django.db.models.signals import post_save
+from django.test import SimpleTestCase
+
from parameterized import parameterized
from posthog.constants import AvailableFeature
@@ -18,6 +23,20 @@ from posthog.products import Products
from products.access_control.backend.models.access_control import AccessControl
+class TestDefaultStarredProductsAccessControlSignals(SimpleTestCase):
+ @parameterized.expand([("dashboard",), ("customer_task",)])
+ def test_object_access_grant_does_not_query_membership(self, resource: str) -> None:
+ rule = AccessControl(
+ team_id=1,
+ resource=resource,
+ resource_id=str(uuid4()),
+ organization_member_id=uuid4(),
+ access_level="editor",
+ )
+
+ post_save.send(sender=AccessControl, instance=rule, created=True)
+
+
class TestDefaultStarredProducts(BaseTest):
def _default_paths_for(self, user: User, team: Team) -> set[str]:
return set(FileSystemShortcut.objects.filter(user=user, team=team).values_list("path", flat=True))
diff --git a/products/access_control/backend/activity_logging.py b/products/access_control/backend/activity_logging.py
index 14d50c446edc..c01c40e4f405 100644
--- a/products/access_control/backend/activity_logging.py
+++ b/products/access_control/backend/activity_logging.py
@@ -12,6 +12,7 @@ from posthog.models.activity_logging.activity_log import (
ActivityContextBase,
Change,
Detail,
+ LogActivityEntry,
changes_between,
log_activity,
)
@@ -29,20 +30,17 @@ class AccessControlContext(ActivityContextBase):
organization_member_id: str | None
-@mutable_receiver(model_activity_signal, sender=AccessControl)
-def handle_access_control_change(
- sender: type,
- scope: str,
+def get_access_control_log_entry(
+ *,
before_update: Optional[AccessControl],
after_update: Optional[AccessControl],
activity: str,
user: Optional[User],
was_impersonated: bool = False,
- **kwargs: Any,
-) -> None:
+) -> LogActivityEntry | None:
rule = after_update or before_update
if rule is None:
- return
+ return None
if activity == "created":
changes = [Change(type="AccessControl", field="access_level", action="created", after=rule.access_level)]
@@ -51,13 +49,13 @@ def handle_access_control_change(
else:
changes = changes_between("AccessControl", previous=before_update, current=after_update)
- log_activity(
+ return LogActivityEntry(
organization_id=rule.team.organization_id,
team_id=rule.team_id,
user=user,
was_impersonated=was_impersonated,
item_id=rule.id,
- scope=scope,
+ scope="AccessControl",
activity=activity,
detail=Detail(
name=f"{rule.resource} {rule.resource_id}" if rule.resource_id else rule.resource,
@@ -72,3 +70,25 @@ def handle_access_control_change(
),
),
)
+
+
+@mutable_receiver(model_activity_signal, sender=AccessControl)
+def handle_access_control_change(
+ sender: type,
+ scope: str,
+ before_update: Optional[AccessControl],
+ after_update: Optional[AccessControl],
+ activity: str,
+ user: Optional[User],
+ was_impersonated: bool = False,
+ **kwargs: Any,
+) -> None:
+ entry = get_access_control_log_entry(
+ before_update=before_update,
+ after_update=after_update,
+ activity=activity,
+ user=user,
+ was_impersonated=was_impersonated,
+ )
+ if entry is not None:
+ log_activity(**entry)
diff --git a/products/access_control/backend/facade/api.py b/products/access_control/backend/facade/api.py
index c5a23d347abb..29a98cb1e01b 100644
--- a/products/access_control/backend/facade/api.py
+++ b/products/access_control/backend/facade/api.py
@@ -18,10 +18,14 @@ Do NOT:
from __future__ import annotations
+from collections import defaultdict
+from copy import copy
from typing import cast
from uuid import UUID
from django.db import transaction
+from django.db.models import Q
+from django.db.models.signals import post_save
from django.http import Http404
from django.shortcuts import get_object_or_404
from django.utils import timezone
@@ -29,11 +33,15 @@ from django.utils import timezone
from posthog.hogql.property_access_types import RestrictedProperty
from posthog.constants import AvailableFeature
+from posthog.dataclasses import frozen
from posthog.models import Organization, OrganizationMembership, PropertyDefinition, Team
+from posthog.models.activity_logging.activity_log import LogActivityEntry, bulk_log_activity
+from posthog.models.activity_logging.model_activity import get_current_user, get_was_impersonated
from posthog.models.team.extensions import get_or_create_team_extension
from posthog.models.user import User
from posthog.scopes import API_SCOPE_OBJECTS, INTERNAL_API_SCOPE_OBJECTS, APIScopeObject
+from products.access_control.backend.activity_logging import get_access_control_log_entry
from products.access_control.backend.models.role import Role, RoleMembership
from products.event_definitions.backend.models import effective_project_id_expr
@@ -562,9 +570,7 @@ def _to_object_rule(rule: AccessControl) -> contracts.ObjectAccessControlRule:
)
-def _validate_object_access_control(
- *, organization_id: UUID, input: contracts.SetObjectAccessControlInput
-) -> APIScopeObject:
+def _validate_object_access_control_level(input: contracts.SetObjectAccessControlInput) -> APIScopeObject:
resource = input.resource
if resource not in API_SCOPE_OBJECTS or resource in INTERNAL_API_SCOPE_OBJECTS:
raise InvalidObjectAccessControlError(f"{resource} is not an access controlled resource.")
@@ -584,6 +590,13 @@ def _validate_object_access_control(
if level_index > levels.index(highest_access_level(scoped_resource)):
raise InvalidObjectAccessControlError(f"Access level is above the maximum for {resource}.")
+ return scoped_resource
+
+
+def _validate_object_access_control(
+ *, organization_id: UUID, input: contracts.SetObjectAccessControlInput
+) -> APIScopeObject:
+ resource = _validate_object_access_control_level(input)
if (
input.organization_member_id is not None
and not OrganizationMembership.objects.filter(
@@ -596,7 +609,118 @@ def _validate_object_access_control(
and not Role.objects.filter(id=input.role_id, organization_id=organization_id).exists()
):
raise InvalidObjectAccessControlError("role does not belong to this team's organization.")
- return scoped_resource
+ return resource
+
+
+@frozen
+class _ObjectAccessControlKey:
+ resource: str
+ resource_id: str | None
+ organization_member_id: UUID | None
+ role_id: UUID | None
+
+
+def _object_access_control_key(
+ rule: contracts.SetObjectAccessControlInput | AccessControl,
+) -> _ObjectAccessControlKey:
+ return _ObjectAccessControlKey(
+ resource=rule.resource,
+ resource_id=rule.resource_id,
+ organization_member_id=rule.organization_member_id,
+ role_id=rule.role_id,
+ )
+
+
+def bulk_set_object_access_controls(*, team_id: int, inputs: list[contracts.SetObjectAccessControlInput]) -> None:
+ if not inputs:
+ return
+ team = Team.objects.only("id", "organization_id").get(id=team_id)
+ requested = {_object_access_control_key(input): input for input in inputs}
+ if len(requested) != len(inputs):
+ raise InvalidObjectAccessControlError("Provide each object and subject only once.")
+ for input in inputs:
+ _validate_object_access_control_level(input)
+ member_ids = {input.organization_member_id for input in inputs if input.organization_member_id is not None}
+ role_ids = {input.role_id for input in inputs if input.role_id is not None}
+ if member_ids != set(
+ OrganizationMembership.objects.filter(organization_id=team.organization_id, id__in=member_ids).values_list(
+ "id", flat=True
+ )
+ ):
+ raise InvalidObjectAccessControlError("organization_member does not belong to this team's organization.")
+ if role_ids != set(
+ Role.objects.filter(organization_id=team.organization_id, id__in=role_ids).values_list("id", flat=True)
+ ):
+ raise InvalidObjectAccessControlError("role does not belong to this team's organization.")
+
+ requested_pairs = Q()
+ for key in requested:
+ requested_pairs |= Q(
+ resource=key.resource,
+ resource_id=key.resource_id,
+ organization_member_id=key.organization_member_id,
+ role_id=key.role_id,
+ )
+ with transaction.atomic():
+ existing: dict[_ObjectAccessControlKey, list[AccessControl]] = defaultdict(list)
+ for existing_rule in (
+ AccessControl.objects.select_for_update().filter(requested_pairs, team_id=team_id).order_by("id")
+ ):
+ existing[_object_access_control_key(existing_rule)].append(existing_rule)
+ created: list[AccessControl] = []
+ updated: list[AccessControl] = []
+ deleted_ids: list[UUID] = []
+ entries: list[LogActivityEntry] = []
+ now = timezone.now()
+ for key, input in requested.items():
+ matching_rules: list[AccessControl | None] = [*existing.get(key, [])] or [None]
+ for rule in matching_rules:
+ before = copy(rule) if rule is not None else None
+ if before is not None:
+ before.team = team
+ if input.access_level is None:
+ if rule is None:
+ continue
+ deleted_ids.append(rule.id)
+ activity = "deleted"
+ rule = None
+ elif rule is None:
+ rule = AccessControl(
+ team=team,
+ resource=input.resource,
+ resource_id=input.resource_id,
+ organization_member_id=input.organization_member_id,
+ role_id=input.role_id,
+ access_level=input.access_level,
+ created_by_id=input.created_by_id,
+ )
+ created.append(rule)
+ activity = "created"
+ else:
+ if rule.access_level == input.access_level:
+ continue
+ rule.team = team
+ rule.access_level = input.access_level
+ rule.updated_at = now
+ updated.append(rule)
+ activity = "updated"
+ entry = get_access_control_log_entry(
+ before_update=before,
+ after_update=rule,
+ activity=activity,
+ user=get_current_user(),
+ was_impersonated=get_was_impersonated(),
+ )
+ if entry is not None:
+ entries.append(entry)
+ AccessControl.objects.bulk_create(created)
+ AccessControl.objects.bulk_update(updated, ["access_level", "updated_at"])
+ AccessControl.objects.filter(team_id=team_id, id__in=deleted_ids).delete()
+ for rule in created:
+ post_save.send(sender=AccessControl, instance=rule, created=True)
+ for rule in updated:
+ post_save.send(sender=AccessControl, instance=rule, created=False)
+ bulk_log_activity(entries)
def set_object_access_control(
diff --git a/products/access_control/backend/facade/user_access_control.py b/products/access_control/backend/facade/user_access_control.py
index ac1c43779f1e..f43a14d29ad9 100644
--- a/products/access_control/backend/facade/user_access_control.py
+++ b/products/access_control/backend/facade/user_access_control.py
@@ -5,6 +5,7 @@ from dataclasses import replace
from enum import Enum
from functools import cache, cached_property
from typing import TYPE_CHECKING, Any, Literal, Optional, cast, get_args
+from uuid import UUID
from django.db.models import Case, CharField, Exists, F, ForeignKey, Model, OuterRef, Q, QuerySet, Value, When
from django.db.models.functions import Cast
@@ -32,6 +33,7 @@ else:
from products.access_control.backend.models.access_control import AccessControl
+from products.access_control.backend.models.role import RoleMembership
from .contracts import ObjectAccessRef
from .enums import ResolvedAccessSourceSubjectValue, ResolvedAccessSourceValue
@@ -453,6 +455,60 @@ class UserAccessControl:
self._organization_id = organization_id
+ @classmethod
+ def for_user_ids(cls, *, user_ids: Iterable[int], team: Team) -> dict[int, "UserAccessControl"]:
+ memberships = list(
+ OrganizationMembership.objects.filter(
+ organization_id=team.organization_id, user_id__in=set(user_ids)
+ ).select_related("user", "organization")
+ )
+ if not memberships:
+ return {}
+
+ roles_by_user: dict[int, list[UUID]] = defaultdict(list)
+ if memberships[0].organization.is_feature_available(AvailableFeature.ROLE_BASED_ACCESS):
+ for user_id, role_id in (
+ RoleMembership.objects.filter(
+ user_id__in=[member.user_id for member in memberships], role__organization_id=team.organization_id
+ )
+ .valid_for_authorization()
+ .values_list("user_id", "role_id")
+ ):
+ roles_by_user[user_id].append(role_id)
+
+ default_rules: list[AccessControl] = []
+ rules_by_member: dict[UUID, list[AccessControl]] = defaultdict(list)
+ rules_by_role: dict[UUID, list[AccessControl]] = defaultdict(list)
+ if EE_AVAILABLE and memberships[0].organization.is_feature_available(AvailableFeature.ACCESS_CONTROL):
+ for rule in AccessControl.objects.filter(team_id=team.id).filter(
+ Q(organization_member__isnull=True, role__isnull=True)
+ | Q(organization_member_id__in=[member.id for member in memberships], role__isnull=True)
+ | Q(
+ organization_member__isnull=True,
+ role_id__in={role_id for roles in roles_by_user.values() for role_id in roles},
+ )
+ ):
+ if rule.organization_member_id is not None:
+ rules_by_member[rule.organization_member_id].append(rule)
+ elif rule.role_id is not None:
+ rules_by_role[rule.role_id].append(rule)
+ else:
+ default_rules.append(rule)
+
+ access_by_user: dict[int, UserAccessControl] = {}
+ for member in memberships:
+ access = cls(user=member.user, team=team)
+ role_ids = roles_by_user[member.user_id]
+ access.__dict__["_organization_membership"] = member
+ access.__dict__["_user_role_ids"] = role_ids
+ access.__dict__["_cached_access_controls"] = [
+ *default_rules,
+ *rules_by_member.get(member.id, []),
+ *(rule for role_id in role_ids for rule in rules_by_role.get(role_id, [])),
+ ]
+ access_by_user[member.user_id] = access
+ return access_by_user
+
def allowed_object_ids(
self, resource: str, team_id: int, required_level: str, resolve: Callable[[], frozenset]
) -> frozenset:
diff --git a/products/access_control/backend/tests/test_api.py b/products/access_control/backend/tests/test_api.py
index 7b8009a0e1f8..c9904bb3a828 100644
--- a/products/access_control/backend/tests/test_api.py
+++ b/products/access_control/backend/tests/test_api.py
@@ -1,6 +1,9 @@
import pytest
from posthog.test.base import BaseTest
+from django.db import connection
+from django.test.utils import CaptureQueriesContext
+
from parameterized import parameterized
from posthog.constants import AvailableFeature
@@ -11,6 +14,7 @@ from posthog.models.organization import Organization, OrganizationMembership
from products.access_control.backend.facade import contracts
from products.access_control.backend.facade.api import (
InvalidObjectAccessControlError,
+ bulk_set_object_access_controls,
every_member_has_resource_access,
object_ids_restricted_from_any_member,
role_belongs_to_organization,
@@ -111,6 +115,136 @@ class TestSetObjectAccessControl(BaseTest):
with pytest.raises(ValueError):
self._grant("viewer", role_id=role.id)
+ @parameterized.expand([("member", False), ("role", False), ("member", True), ("role", True)])
+ def test_bulk_rules_preserve_access_and_audit(self, subject: str, duplicates: bool) -> None:
+ role = Role.objects.create(name="Support", organization=self.organization)
+ RoleMembership.objects.create(user=self.other_user, role=role)
+ if duplicates:
+ AccessControl.objects.bulk_create(
+ [
+ AccessControl(
+ team=self.team,
+ resource="dashboard",
+ resource_id=str(self.dashboard.id),
+ access_level="viewer",
+ organization_member_id=self.other_membership.id if subject == "member" else None,
+ role_id=role.id if subject == "role" else None,
+ )
+ for _ in range(2)
+ ]
+ )
+ for level in ("viewer", "editor", "editor", None, None):
+ bulk_set_object_access_controls(
+ team_id=self.team.id,
+ inputs=[
+ contracts.SetObjectAccessControlInput(
+ resource="dashboard",
+ resource_id=str(self.dashboard.id),
+ access_level=level,
+ created_by_id=self.user.id,
+ organization_member_id=self.other_membership.id if subject == "member" else None,
+ role_id=role.id if subject == "role" else None,
+ )
+ ],
+ )
+ assert self._other_user_level() == (level or "none")
+ logs = list(
+ ActivityLog.objects.filter(
+ team_id=self.team.id, scope="AccessControl", detail__name=f"dashboard {self.dashboard.id}"
+ ).order_by("created_at")
+ )
+ assert [log.activity for log in logs] == (
+ ["updated", "updated", "deleted", "deleted"] if duplicates else ["created", "updated", "deleted"]
+ )
+ assert len({log.item_id for log in logs}) == (2 if duplicates else 1)
+ detail = logs[0 if duplicates else 1].detail
+ assert detail is not None
+ assert detail["changes"] == [
+ {
+ "type": "AccessControl",
+ "field": "access_level",
+ "action": "changed",
+ "before": "viewer",
+ "after": "editor",
+ }
+ ]
+
+ @parameterized.expand([("member",), ("role",)])
+ def test_bulk_rules_lock_only_requested_object_subject_pairs(self, subject: str) -> None:
+ other_dashboard = Dashboard.objects.create(team=self.team, created_by=self.user)
+ roles = Role.objects.bulk_create([Role(name=f"Role {i}", organization=self.organization) for i in range(2)])
+ subjects = (
+ [(self.other_membership.id, None), (self.organization_membership.id, None)]
+ if subject == "member"
+ else [(None, role.id) for role in roles]
+ )
+ rules = AccessControl.objects.bulk_create(
+ [
+ AccessControl(
+ team=self.team,
+ resource="dashboard",
+ resource_id=str(dashboard.id),
+ organization_member_id=member_id,
+ role_id=role_id,
+ access_level="viewer",
+ )
+ for dashboard in (self.dashboard, other_dashboard)
+ for member_id, role_id in subjects
+ ]
+ )
+ selected = [rules[0], rules[3]]
+ with CaptureQueriesContext(connection) as queries:
+ bulk_set_object_access_controls(
+ team_id=self.team.id,
+ inputs=[
+ contracts.SetObjectAccessControlInput(
+ resource=rule.resource,
+ resource_id=str(rule.resource_id),
+ organization_member_id=rule.organization_member_id,
+ role_id=rule.role_id,
+ access_level="editor",
+ )
+ for rule in selected
+ ],
+ )
+ locking_queries = [
+ query["sql"]
+ for query in queries.captured_queries
+ if "FOR UPDATE" in query["sql"] and AccessControl._meta.db_table in query["sql"]
+ ]
+ assert len(locking_queries) == 1
+ assert {rule.id for rule in AccessControl.objects.raw(locking_queries[0])} == {rule.id for rule in selected}
+ assert set(
+ AccessControl.objects.filter(id__in=[rules[1].id, rules[2].id]).values_list("access_level", flat=True)
+ ) == {"viewer"}
+
+ @parameterized.expand([("member",), ("role",)])
+ def test_bulk_rules_reject_foreign_subject_before_writing(self, subject: str) -> None:
+ other_org = Organization.objects.create(name="Other organization")
+ outsider = User.objects.create_and_join(other_org, "[email protected]", "testtest")
+ member = OrganizationMembership.objects.get(user=outsider, organization=other_org)
+ role = Role.objects.create(name="Other role", organization=other_org)
+ with pytest.raises(InvalidObjectAccessControlError):
+ bulk_set_object_access_controls(
+ team_id=self.team.id,
+ inputs=[
+ contracts.SetObjectAccessControlInput(
+ resource="dashboard",
+ resource_id=str(self.dashboard.id),
+ access_level="editor",
+ organization_member_id=self.other_membership.id,
+ ),
+ contracts.SetObjectAccessControlInput(
+ resource="dashboard",
+ resource_id=str(self.dashboard.id),
+ access_level="editor",
+ organization_member_id=member.id if subject == "member" else None,
+ role_id=role.id if subject == "role" else None,
+ ),
+ ],
+ )
+ assert not AccessControl.objects.filter(team=self.team, resource_id=str(self.dashboard.id)).exists()
+
class TestEveryMemberHasResourceAccess(BaseTest):
"""`account` inherits from `customer_analytics`, so every rule here is written on the parent,
diff --git a/products/access_control/backend/tests/test_user_access_control.py b/products/access_control/backend/tests/test_user_access_control.py
index 19b65383c977..a28e743298cc 100644
--- a/products/access_control/backend/tests/test_user_access_control.py
+++ b/products/access_control/backend/tests/test_user_access_control.py
@@ -80,6 +80,42 @@ class BaseUserAccessControlTest(BaseTest):
@pytest.mark.ee
class TestUserAccessControl(BaseUserAccessControlTest):
+ @parameterized.expand([(False, False), (False, True), (True, False), (True, True)])
+ def test_preloaded_users_match_single_user_permissions(self, most_specific: bool, entitled: bool) -> None:
+ self.organization.uses_most_specific_access_resolution = most_specific
+ if not entitled:
+ self.organization.available_product_features = []
+ self.organization.save()
+ self.organization_membership.level = OrganizationMembership.Level.MEMBER
+ self.organization_membership.save()
+ dashboard = Dashboard.objects.create(team=self.team)
+ self._create_access_control(resource="dashboard", resource_id=str(dashboard.id), access_level="none")
+ self._create_access_control(
+ resource="dashboard", resource_id=str(dashboard.id), access_level="viewer", role=self.role_a
+ )
+ member = OrganizationMembership.objects.get(organization=self.organization, user=self.other_user)
+ self._create_access_control(
+ resource="dashboard", resource_id=str(dashboard.id), access_level="editor", organization_member=member
+ )
+ other_org = Organization.objects.create(name="Other organization")
+ outsider = User.objects.create_and_join(other_org, "[email protected]", "testtest")
+ foreign_member = OrganizationMembership.objects.get(organization=other_org, user=outsider)
+ foreign_role = Role.objects.create(name="Other role", organization=other_org)
+ RoleMembership.objects.create(user=self.user_with_no_role, role=foreign_role)
+ RoleMembership.objects.create(user=self.user_with_no_role, role=self.role_a, organization_member=foreign_member)
+ self._create_access_control(
+ resource="dashboard", resource_id=str(dashboard.id), access_level="manager", role=foreign_role
+ )
+ users = [self.user, self.other_user, self.user_with_no_role]
+ access_by_user = UserAccessControl.for_user_ids(
+ user_ids=[user.id for user in users] + [outsider.id], team=self.team
+ )
+ assert set(access_by_user) == {user.id for user in users}
+ for user in users:
+ assert access_by_user[user.id].get_user_access_level(dashboard) == UserAccessControl(
+ user=user, team=self.team
+ ).get_user_access_level(dashboard)
+
def test_no_organization_id_passed(self):
# Create a user without an organization
user_without_org = User.objects.create(email="[email protected]", password="testtest")