feat: add User

Author: Charles Larivier

metabase/resources/user.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, List
+
+from metabase.resource import ListResource, CreateResource, GetResource, UpdateResource, DeleteResource
+from metabase.missing import MISSING
+
+
+class User(ListResource, CreateResource, GetResource, UpdateResource, DeleteResource):
+    ENDPOINT = "/api/user"
+
+    id: int
+    email: str
+    first_name: str
+    last_name: str
+    common_name: str
+    locale: str
+
+    is_superuser: bool
+    is_active: bool
+    is_qbnewb: bool
+    ldap_auth: bool
+    google_auth: bool
+
+    login_attributes: Dict[str, Any]
+    group_ids: List[int]
+
+    last_login: datetime
+    date_joined: datetime
+    updated_at: datetime
+
+    @classmethod
+    def list(cls) -> List[User]:
+        response = cls.connection().get(cls.ENDPOINT)
+        records = [cls(**user) for user in response.json().get("data", [])]
+        return records
+
+    @classmethod
+    def create(
+            cls,
+            first_name: str,
+            last_name: str,
+            email: str,
+            password: str,
+            group_ids: List[int] = None,
+            login_attributes: Dict[str, Any] = None,
+            **kwargs
+    ) -> User:
+        return super(User, cls).create(
+            first_name=first_name,
+            last_name=last_name,
+            email=email,
+            password=password,
+            group_ids=group_ids,
+            login_attributes=login_attributes,
+            **kwargs
+        )
+
+    def update(
+            self,
+            first_name: str = MISSING,
+            last_name: str = MISSING,
+            email: str = MISSING,
+            password: str = MISSING,
+            group_ids: List[int] = MISSING,
+            is_superuser: bool = MISSING,
+            locale: str = MISSING,
+            **kwargs
+    ) -> None:
+        return super(User, self).update(
+            first_name=first_name,
+            last_name=last_name,
+            email=email,
+            password=password,
+            group_ids=group_ids,
+            locale=locale,
+            **kwargs
+        )
+
+    def send_invite(self):
+        self.connection().put(self.ENDPOINT + f"/{getattr(self, self.PRIMARY_KEY)}" + "/send_invite")
+
+    def reactivate(self):
+        self.connection().put(self.ENDPOINT + f"/{getattr(self, self.PRIMARY_KEY)}" + "/reactivate")

metabase/user.py

@@ -0,0 +1,91 @@
+from random import randint
+
+from exceptions import NotFoundError
+from metabase.resources.user import User
+
+from tests.helpers import IntegrationTestCase
+
+
+class UserTests(IntegrationTestCase):
+    def tearDown(self) -> None:
+        users = User.list()
+        for user in users:
+            if user.id != 1:
+                user.delete()
+
+    def test_get(self):
+        """
+        Ensure User.get() returns a User instance for a given ID, or
+        raises a NotFoundError when it does not exist.
+        """
+        # fixture
+        user = User.create(
+            first_name="Test",
+            last_name="Test",
+            email=f"{randint(2, 10000)}@example.com",
+            password="example123"
+        )
+        self.assertIsInstance(user, User)
+
+        u = User.get(user.id)
+        self.assertIsInstance(u, User)
+        self.assertEqual(user.id, u.id)
+
+        with self.assertRaises(NotFoundError):
+            _ = User.get(12345)
+
+    def test_create(self):
+        """Ensure User.create() creates a User in Metabase and returns a User instance."""
+        email = f"{randint(2, 10000)}@example.com"
+        user = User.create(
+            first_name="Test",
+            last_name="Test",
+            email=email,
+            password="example123"
+        )
+
+        self.assertIsInstance(user, User)
+        self.assertEqual("Test", user.first_name)
+        self.assertEqual("Test", user.last_name)
+        self.assertEqual(email, user.email)
+
+    def test_update(self):
+        """Ensure User.update() updates an existing User in Metabase."""
+        # fixture
+        user = User.create(
+            first_name="Test",
+            last_name="Test",
+            email=f"{randint(2, 10000)}@example.com",
+            password="example123"
+        )
+
+        self.assertIsInstance(user, User)
+        self.assertEqual("Test", user.first_name)
+
+        user.update(
+            first_name="Test1"
+        )
+        # assert local instance is mutated
+        self.assertEqual("Test1", user.first_name)
+
+        # assert metabase object is mutated
+        u = User.get(user.id)
+        self.assertEqual("Test1", u.first_name)
+
+    def test_delete(self):
+        """Ensure User.delete() updates archived=True."""
+        # fixture
+        user = User.create(
+            first_name="Test",
+            last_name="Test",
+            email=f"{randint(2, 10000)}@example.com",
+            password="example123"
+        )
+        self.assertIsInstance(user, User)
+
+        user.delete()
+
+        # assert metabase object is mutated
+        with self.assertRaises(NotFoundError):
+            _ = User.get(user.id)
+