diff --git a/components/renku_data_services/solr/entity_documents.py b/components/renku_data_services/solr/entity_documents.py
new file mode 100644
index 000000000..a20bdd095
--- /dev/null
+++ b/components/renku_data_services/solr/entity_documents.py
@@ -0,0 +1,152 @@
+"""Defines the entity documents used with Solr."""
+
+from abc import abstractmethod
+from datetime import UTC, datetime
+from enum import StrEnum
+from typing import Annotated, Any, Self
+
+from pydantic import AliasChoices, BaseModel, BeforeValidator, Field, field_serializer, field_validator
+from ulid import ULID
+
+from renku_data_services.authz.models import Visibility
+from renku_data_services.base_models.core import Slug
+from renku_data_services.solr.solr_client import DocVersion, ResponseBody
+
+
+def _str_to_slug(value: Any) -> Any:
+    if isinstance(value, str):
+        return Slug.from_name(value)
+    else:
+        return value
+
+
+class EntityType(StrEnum):
+    """The different type of entities available from search."""
+
+    project = "Project"
+    user = "User"
+    group = "Group"
+
+
+class EntityDoc(BaseModel, frozen=True):
+    """Base class for entity document models."""
+
+    namespace: Annotated[Slug, BeforeValidator(_str_to_slug)]
+    version: int = Field(
+        serialization_alias="_version_",
+        validation_alias=AliasChoices("version", "_version_"),
+        default=DocVersion.not_exists.value,
+    )
+    score: float | None = None
+
+    @abstractmethod
+    def entity_type(self) -> EntityType:
+        """Return the type of this entity."""
+        ...
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the dict of this group."""
+        dict = self.model_dump(by_alias=True, exclude_defaults=True)
+        # note: _kind=fullentity is for being backwards compatible, it might not be needed in the future
+        dict.update(_type=self.entity_type().value, _kind="fullentity")
+        return dict
+
+    def reset_solr_fields(self) -> Self:
+        """Resets fields that are filled by solr when querying."""
+        return self.model_copy(update={"version": DocVersion.not_exists.value, "score": None})
+
+
+class User(EntityDoc, frozen=True):
+    """Represents a renku user in SOLR."""
+
+    id: str
+    firstName: str | None = None
+    lastName: str | None = None
+
+    def entity_type(self) -> EntityType:
+        """Return the type of this entity."""
+        return EntityType.user
+
+    @field_serializer("namespace", when_used="always")
+    def __serialize_namespace(self, namespace: Slug) -> str:
+        return namespace.value
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "User":
+        """Create a User from a dictionary."""
+        return User.model_validate(d)
+
+
+class Group(EntityDoc, frozen=True):
+    """Represents a renku user in SOLR."""
+
+    id: ULID
+    name: str
+    description: str | None = None
+
+    def entity_type(self) -> EntityType:
+        """Return the type of this entity."""
+        return EntityType.group
+
+    @field_serializer("id", when_used="always")
+    def __serialize_id(self, id: ULID) -> str:
+        return str(id)
+
+    @field_serializer("namespace", when_used="always")
+    def __serialize_namespace(self, namespace: Slug) -> str:
+        return namespace.value
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "Group":
+        """Create a Group from a dictionary."""
+        return Group.model_validate(d)
+
+
+class Project(EntityDoc, frozen=True):
+    """Represents a renku project in SOLR."""
+
+    id: ULID
+    name: str
+    slug: Annotated[Slug, BeforeValidator(_str_to_slug)]
+    visibility: Visibility
+    createdBy: str
+    creationDate: datetime
+    repositories: list[str] = Field(default_factory=list)
+    description: str | None = None
+    keywords: list[str] = Field(default_factory=list)
+    namespaceDetails: ResponseBody | None = None
+    creatorDetails: ResponseBody | None = None
+
+    def entity_type(self) -> EntityType:
+        """Return the type of this entity."""
+        return EntityType.project
+
+    @field_serializer("namespace", when_used="always")
+    def __serialize_namespace(self, namespace: Slug) -> str:
+        return namespace.value
+
+    @field_serializer("id", when_used="always")
+    def __serialize_id(self, id: ULID) -> str:
+        return str(id)
+
+    @field_serializer("slug", when_used="always")
+    def __serialize_slug(self, slug: Slug) -> str:
+        return slug.value
+
+    @field_serializer("visibility", when_used="always")
+    def __serialize_visibilty(self, visibility: Visibility) -> str:
+        return visibility.value
+
+    @field_serializer("creationDate", when_used="always")
+    def __serialize_creation_date(self, creationDate: datetime) -> str:
+        return creationDate.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    @field_validator("creationDate")
+    @classmethod
+    def _add_tzinfo(cls, v: datetime) -> datetime:
+        return v.replace(tzinfo=UTC)
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "Project":
+        """Create a Project from a dictionary."""
+        return Project.model_validate(d)
diff --git a/components/renku_data_services/solr/entity_schema.py b/components/renku_data_services/solr/entity_schema.py
index 78709f639..38291197b 100644
--- a/components/renku_data_services/solr/entity_schema.py
+++ b/components/renku_data_services/solr/entity_schema.py
@@ -1,3 +1,5 @@
+"""Defines the solr schema used for the renku entities."""
+
 from renku_data_services.solr.solr_migrate import SchemaMigration
 from renku_data_services.solr.solr_schema import (
     AddCommand,
@@ -14,27 +16,31 @@
 
 
 class Fields:
-    created_by: FieldName = FieldName("createdBy")
-    creation_date: FieldName = FieldName("creationDate")
-    description: FieldName = FieldName("description")
-    entityType: FieldName = FieldName("_type")
-    kind: FieldName = FieldName("_kind")
-    firstName: FieldName = FieldName("firstName")
-    id: FieldName = FieldName("id")
-    lastName: FieldName = FieldName("lastName")
-    members: FieldName = FieldName("members")
-    name: FieldName = FieldName("name")
-    repositories: FieldName = FieldName("repositories")
-    slug: FieldName = FieldName("slug")
-    visibility: FieldName = FieldName("visibility")
-    keywords: FieldName = FieldName("keywords")
-    namespace: FieldName = FieldName("namespace")
-    contentAll: FieldName = FieldName("content_all")
+    """A collection of fields."""
+
+    created_by = FieldName("createdBy")
+    creation_date = FieldName("creationDate")
+    description = FieldName("description")
+    entityType = FieldName("_type")
+    kind = FieldName("_kind")
+    firstName = FieldName("firstName")
+    id = FieldName("id")
+    lastName = FieldName("lastName")
+    members = FieldName("members")
+    name = FieldName("name")
+    repositories = FieldName("repositories")
+    slug = FieldName("slug")
+    visibility = FieldName("visibility")
+    keywords = FieldName("keywords")
+    namespace = FieldName("namespace")
+    contentAll = FieldName("content_all")
     # virtual score field
-    score: FieldName = FieldName("score")
+    score = FieldName("score")
 
 
 class Analyzers:
+    """A collection of analyzers."""
+
     textIndex = Analyzer(
         tokenizer=Tokenizers.uax29UrlEmail,
         filters=[
@@ -58,6 +64,8 @@ class Analyzers:
 
 
 class FieldTypes:
+    """A collection of field types."""
+
     id: FieldType = FieldType.id(TypeName("SearchId")).make_doc_value()
     string: FieldType = FieldType.str(TypeName("SearchString")).make_doc_value()
     text: FieldType = (
diff --git a/components/renku_data_services/solr/main.py b/components/renku_data_services/solr/main.py
deleted file mode 100644
index bee8b7c0a..000000000
--- a/components/renku_data_services/solr/main.py
+++ /dev/null
@@ -1,150 +0,0 @@
-"""Some testing."""
-
-import asyncio
-import logging
-from typing import Any
-
-from pydantic import BaseModel
-import pydantic
-from renku_data_services.solr import entity_schema
-from renku_data_services.solr.solr_migrate import SchemaMigrator
-from renku_data_services.solr.solr_schema import (
-    Analyzer,
-    DeleteFieldCommand,
-    Field,
-    FieldName,
-    FieldType,
-    ReplaceCommand,
-    SchemaCommand,
-    Tokenizers,
-    TypeName,
-    CopyFieldRule,
-    AddCommand,
-    SchemaCommandList,
-    FieldTypeClasses,
-    Filters,
-    Tokenizer,
-)
-
-from renku_data_services.solr.solr_client import (
-    DefaultSolrClient,
-    DocVersion,
-    SolrClientConfig,
-    SolrDocument,
-    SolrQuery,
-)
-
-logging.basicConfig()
-logging.getLogger().setLevel(logging.DEBUG)
-
-
-class ProjectDoc(BaseModel):
-    """A solr document representing a project."""
-
-    id: str
-    name: str
-    etag: int
-    version: int = pydantic.Field(serialization_alias="_version_")
-
-    def to_dict(self) -> dict[str, Any]:
-        return self.model_dump(by_alias=True)
-
-
-async def _test_schema():
-    cfg = SolrClientConfig(base_url="http://rsdevcnt:8983", core="renku-search-dev", user=None)
-    async with DefaultSolrClient(cfg) as client:
-        r = await client.modify_schema(
-            SchemaCommandList(
-                [
-                    ReplaceCommand(FieldType(name=TypeName("content_all"), clazz=FieldTypeClasses.type_text)),
-                    ReplaceCommand(FieldType(name=TypeName("content_my"), clazz=FieldTypeClasses.type_text)),
-                ]
-            )
-        )
-        print(r.raise_for_status().json())
-
-
-async def _test_upsert():
-    cfg = SolrClientConfig(base_url="http://rsdevcnt:8983", core="renku-search-dev", user=None)
-    async with DefaultSolrClient(cfg) as client:
-        mydoc = ProjectDoc(id="p123", name="my project", version=DocVersion.off.value)
-        res = await client.upsert([mydoc])
-        print(res)
-        doc = await client.query(SolrQuery.query_all('*:*'))
-        print(doc.response.docs)
-
-
-async def _test_get_schema():
-    cfg = SolrClientConfig(base_url="http://rsdevcnt:8983", core="renku-search-dev", user=None)
-    async with DefaultSolrClient(cfg) as client:
-        cs = await client.get_schema()
-        print(cs)
-
-
-async def _test_query():
-    cfg = SolrClientConfig(base_url="http://rsdevcnt:8983", core="renku-search-dev", user=None)
-    async with DefaultSolrClient(cfg) as client:
-        r = await client.query(SolrQuery.query_all("*:*"))
-        print(r)
-
-
-async def _test_migrator_get_version():
-    cfg = SolrClientConfig(base_url="http://rsdevcnt:8983", core="renku-search-dev", user=None)
-    migrator = SchemaMigrator(cfg)
-    r = await migrator.current_version()
-    print(r)
-
-
-async def _test0():
-    tokenizer = Tokenizer(name=TypeName("classic"))
-    filter = Filters.edgeNgram()
-    analyzer = Analyzer(tokenizer=tokenizer, filters=[filter, Filters.ascii_folding])
-    ftype = FieldType(name=TypeName("project_name_type"), clazz=FieldTypeClasses.type_str, indexed=True)
-    field = Field(name=FieldName("project_name"), type=ftype.name, indexed=True)
-    print(field.to_json())
-
-
-async def _test2():
-    tokenizer = Tokenizers.uax29UrlEmail
-    filter = Filters.ngram
-    analyzer = Analyzer(tokenizer=tokenizer, filters=[filter])
-    ft = FieldType(name=TypeName("name_s"), clazz=FieldTypeClasses.type_text, indexAnalyzer=analyzer)
-    field = Field.of(name=FieldName("project_name"), type=ft)
-    field.required = True
-    field.indexed = True
-    field.multiValued = True
-    cmds = SchemaCommandList(
-        [
-            AddCommand(ft),
-            AddCommand(CopyFieldRule(source=FieldName("other_name_s"), dest=FieldName("target_name_s"))),
-            AddCommand(field),
-            AddCommand(Field.of(name=FieldName("user_name"), type=ft)),
-            ReplaceCommand(ft),
-            DeleteFieldCommand(FieldName("user_n_s")),
-        ]
-    )
-    print(cmds.to_json())
-
-
-async def _test_entity_schema():
-    cfg = SolrClientConfig(base_url="http://rsdevcnt:8983", core="renku-search-dev", user=None)
-    migrator = SchemaMigrator(cfg)
-    r = await migrator.migrate(entity_schema.all_migrations)
-    print(r)
-
-async def _test_etag():
-    cfg = SolrClientConfig(base_url="http://rsdevcnt:8983", core="renku-search-dev", user=None)
-
-    schema: list[SchemaCommand] = [
-        AddCommand(Field(name=FieldName("etag"), type=TypeName("plong"))),
-        AddCommand(Field(name=FieldName("name"), type=TypeName("string"))),
-        AddCommand(CopyFieldRule(source=FieldName("etag"), dest=FieldName("_version_")))
-    ]
-    async with DefaultSolrClient(cfg) as client:
-        await client.modify_schema(SchemaCommandList(value=schema))
-
-        p = ProjectDoc(id="p1", name="ai stuff", etag=2, version=DocVersion.not_exists.value)
-        await client.upsert([p])
-
-if __name__ == "__main__":
-    asyncio.run(_test_etag())
diff --git a/components/renku_data_services/solr/solr_client.py b/components/renku_data_services/solr/solr_client.py
index 849118ba8..590e7a939 100644
--- a/components/renku_data_services/solr/solr_client.py
+++ b/components/renku_data_services/solr/solr_client.py
@@ -5,13 +5,13 @@
 from abc import abstractmethod
 from contextlib import AbstractAsyncContextManager
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, StrEnum
 from types import TracebackType
 from typing import Any, Literal, Optional, Protocol, Self, final
 from urllib.parse import urlencode, urljoin, urlparse, urlunparse
 
 from httpx import AsyncClient, BasicAuth, Response
-from pydantic import AliasChoices, BaseModel, Field
+from pydantic import AliasChoices, BaseModel, Field, field_serializer
 
 from renku_data_services.solr.solr_schema import CoreSchema, FieldName, SchemaCommandList
 
@@ -36,8 +36,13 @@ class SolrClientConfig:
     timeout: int = 600
 
 
+class SortDirection(StrEnum):
+    asc = "asc"
+    desc = "desc"
+
+
 @final
-class SolrQuery(BaseModel):
+class SolrQuery(BaseModel, frozen=True):
     """A query to solr using the JSON request api.
 
     See: https://solr.apache.org/guide/solr/latest/query-guide/json-request-api.html
@@ -48,16 +53,25 @@ class SolrQuery(BaseModel):
     limit: int = 50
     offset: int = 0
     fields: list[str | FieldName] = Field(default_factory=list)
+    sort: list[tuple[FieldName, SortDirection]] = Field(default_factory=list)
     params: dict[str, str] = Field(default_factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         """Return the dict representation of this query."""
         return self.model_dump(exclude_defaults=True)
 
+    def with_sort(self, s: list[tuple[FieldName, SortDirection]]) -> Self:
+        """Return a copy of this with an updated sort."""
+        return self.model_copy(update={"sort": s})
+
+    @field_serializer("sort", when_used="always")
+    def __serialize_sort(self, sort: list[tuple[FieldName, SortDirection]]) -> str:
+        return ",".join(list(map(lambda t: f"{t[0]} {t[1].value}", sort)))
+
     @classmethod
-    def query_all_fields(cls, qstr: str) -> "SolrQuery":
+    def query_all_fields(cls, qstr: str) -> Self:
         """Create a query with defaults returning all fields of a document."""
-        return SolrQuery(query=qstr, fields=["*"])
+        return SolrQuery(query=qstr, fields=["*", "score"])
 
 
 @final
diff --git a/components/renku_data_services/solr/solr_schema.py b/components/renku_data_services/solr/solr_schema.py
index 19eb2e6b6..e6cfeec03 100644
--- a/components/renku_data_services/solr/solr_schema.py
+++ b/components/renku_data_services/solr/solr_schema.py
@@ -12,7 +12,7 @@
 FieldName = NewType("FieldName", str)
 
 
-class SchemaModel(BaseModel):
+class SchemaModel(BaseModel, frozen=True):
     """Base class of a solr schema type."""
 
     def to_dict(self) -> dict[str, Any]:
@@ -25,7 +25,7 @@ def to_json(self) -> str:
 
 
 @final
-class Tokenizer(SchemaModel):
+class Tokenizer(SchemaModel, frozen=True):
     """A solr tokenizer: https://solr.apache.org/guide/solr/latest/indexing-guide/tokenizers.html."""
 
     name: str
@@ -89,7 +89,7 @@ def edgeNgram(cls, min_gram_size: int = 3, maxGramSize: int = 6, preserve_origin
 
 
 @final
-class Analyzer(SchemaModel):
+class Analyzer(SchemaModel, frozen=True):
     """A solr analyzer: https://solr.apache.org/guide/solr/latest/indexing-guide/analyzers.html."""
 
     tokenizer: Tokenizer
@@ -117,7 +117,7 @@ class FieldTypeClasses:
 
 
 @final
-class FieldType(SchemaModel):
+class FieldType(SchemaModel, frozen=True):
     """A solr field type: https://solr.apache.org/guide/solr/latest/indexing-guide/field-type-definitions-and-properties.html."""
 
     name: TypeName
@@ -194,7 +194,7 @@ def dateTimePoint(cls, name: TypeName) -> "FieldType":
 
 
 @final
-class Field(SchemaModel):
+class Field(SchemaModel, frozen=True):
     """A solr field: https://solr.apache.org/guide/solr/latest/indexing-guide/fields.html."""
 
     name: FieldName
@@ -217,7 +217,7 @@ def make_multi_valued(self) -> Self:
 
 
 @final
-class DynamicFieldRule(SchemaModel):
+class DynamicFieldRule(SchemaModel, frozen=True):
     """A solr dynamic field: https://solr.apache.org/guide/solr/latest/indexing-guide/dynamic-fields.html."""
 
     name: FieldName
@@ -231,7 +231,7 @@ class DynamicFieldRule(SchemaModel):
 
 
 @final
-class CopyFieldRule(SchemaModel):
+class CopyFieldRule(SchemaModel, frozen=True):
     """A solr copy field: https://solr.apache.org/guide/solr/latest/indexing-guide/copy-fields.html."""
 
     source: FieldName
diff --git a/test/components/renku_data_services/solr/conftest.py b/test/components/renku_data_services/solr/conftest.py
index ddb6ec4f1..14c99855c 100644
--- a/test/components/renku_data_services/solr/conftest.py
+++ b/test/components/renku_data_services/solr/conftest.py
@@ -40,6 +40,7 @@ def solr_bin_path():
 
 
 async def __wait_for_solr(host: str, port: int) -> None:
+    tries=0
     with httpx.Client() as c:
         while True:
             try:
@@ -47,7 +48,11 @@ async def __wait_for_solr(host: str, port: int) -> None:
                 return None
             except Exception as err:
                 print(err)
-                await sleep(1)
+                if tries >= 20:
+                    raise Exception(f"Cannot connect to solr, gave up after {tries} tries.")
+                else:
+                    tries = tries + 1
+                    await sleep(1)
 
 
 @pytest_asyncio.fixture(scope="session")
@@ -70,11 +75,11 @@ async def solr_instance(tmp_path_factory, free_port, monkeysession, solr_bin_pat
             "-t",
             f"{solr_root}",
         ],
-        # env = {
-        #     "PATH": getenv("PATH"),
-        #     "SOLR_LOGS_DIR": f"{solr_root}",
-        #     "SOLR_ULIMIT_CHECKS": "false"
-        # }
+        env = {
+            "PATH": getenv("PATH", ""),
+            "SOLR_LOGS_DIR": f"{solr_root}",
+            "SOLR_ULIMIT_CHECKS": "false"
+        }
     )
     monkeysession.setenv("SOLR_HOST", "localhost")
     monkeysession.setenv("SOLR_PORT", f"{port}")
diff --git a/test/components/renku_data_services/solr/test_entity_documents.py b/test/components/renku_data_services/solr/test_entity_documents.py
new file mode 100644
index 000000000..76bfe229c
--- /dev/null
+++ b/test/components/renku_data_services/solr/test_entity_documents.py
@@ -0,0 +1,108 @@
+from datetime import datetime
+
+from ulid import ULID
+
+from renku_data_services.authz.models import Visibility
+from renku_data_services.base_models.core import Slug
+from renku_data_services.solr.entity_documents import Group, Project, User
+
+user_jan_ullrich = User(id="abc-def", firstName="Jan", lastName="Ullrich", namespace=Slug("janu"))
+user_tadej_pogacar = User(id="hij-klm", firstName="Tadej", lastName="Pogačar", namespace=Slug("tadejp"))
+group_team = Group(id=ULID(), name="The Team", namespace=Slug("the-team"), description="A group consisting of a team")
+project_ai_stuff = Project(
+    id=ULID(),
+    name="AI stuff",
+    slug=Slug("the-p1"),
+    namespace=user_jan_ullrich.namespace,
+    visibility=Visibility.PUBLIC,
+    createdBy=user_jan_ullrich.id,
+    creationDate=datetime(year=2025, month=1, day=31, hour=9, minute=47, second=44),
+)
+
+
+def test_user_dict():
+    assert user_jan_ullrich.to_dict() == {
+        "id": "abc-def",
+        "namespace": "janu",
+        "firstName": "Jan",
+        "lastName": "Ullrich",
+        "_type": "User",
+        "_kind": "fullentity",
+    }
+    assert user_tadej_pogacar.to_dict() == {
+        "id": "hij-klm",
+        "namespace": "tadejp",
+        "firstName": "Tadej",
+        "lastName": "Pogačar",
+        "_type": "User",
+        "_kind": "fullentity",
+    }
+
+
+def test_read_user_dict():
+    u1 = {
+        "id": "abc-def",
+        "namespace": "janu",
+        "firstName": "Jan",
+        "lastName": "Ullrich",
+        "_type": "User",
+        "_kind": "fullentity",
+    }
+    u = User.model_validate(u1)
+    assert u == user_jan_ullrich
+
+
+def test_group_dict():
+    assert group_team.to_dict() == {
+        "id": str(group_team.id),
+        "name": "The Team",
+        "namespace": "the-team",
+        "description": "A group consisting of a team",
+        "_type": "Group",
+        "_kind": "fullentity",
+    }
+
+
+def test_read_group_dict():
+    g = Group.model_validate(
+        {
+            "id": str(group_team.id),
+            "name": "The Team",
+            "namespace": "the-team",
+            "description": "A group consisting of a team",
+            "_type": "Group",
+            "_kind": "fullentity",
+        }
+    )
+    assert g == group_team
+
+
+def test_project_dict():
+    assert project_ai_stuff.to_dict() == {
+        "id": str(project_ai_stuff.id),
+        "name": "AI stuff",
+        "slug": "the-p1",
+        "namespace": "janu",
+        "visibility": "public",
+        "createdBy": "abc-def",
+        "creationDate": "2025-01-31T09:47:44Z",
+        "_type": "Project",
+        "_kind": "fullentity",
+    }
+
+
+def test_read_project_dict():
+    p = Project.model_validate(
+        {
+            "id": str(project_ai_stuff.id),
+            "name": "AI stuff",
+            "slug": "the-p1",
+            "namespace": "janu",
+            "visibility": "public",
+            "createdBy": "abc-def",
+            "creationDate": "2025-01-31T09:47:44Z",
+            "_type": "Project",
+            "_kind": "fullentity",
+        }
+    )
+    assert p == project_ai_stuff
diff --git a/test/components/renku_data_services/solr/test_solr_client.py b/test/components/renku_data_services/solr/test_solr_client.py
index 373f4fd9a..7c46a44d5 100644
--- a/test/components/renku_data_services/solr/test_solr_client.py
+++ b/test/components/renku_data_services/solr/test_solr_client.py
@@ -1,36 +1,93 @@
-from typing import Any
-from pydantic import BaseModel
 import pytest
-from renku_data_services.solr.solr_client import DefaultSolrClient, UpsertSuccess
 
+from renku_data_services.solr.entity_documents import Group, Project, User
+from renku_data_services.solr.entity_schema import Fields
+from renku_data_services.solr.solr_client import (
+    DefaultSolrClient,
+    SolrQuery,
+    SortDirection,
+    UpsertResponse,
+    UpsertSuccess,
+)
+from test.components.renku_data_services.solr import test_entity_documents
 
-class Project(BaseModel):
-    id: str
-    name: str
 
-    def to_dict(self) -> dict[str, Any]:
-        return self.model_dump()
+def assert_upsert_result(r: UpsertResponse):
+    match r:
+        case UpsertSuccess() as s:
+            assert s.header.status == 0
+            assert s.header.queryTime > 0
+        case _:
+            raise Exception(f"Unexpected result: {r}")
+
+
+def test_serialize_solr_query():
+    q1 = SolrQuery.query_all_fields("name:hello")
+    assert q1.to_dict() == {"query": "name:hello", "fields": ["*", "score"], "sort": ""}
+
+    q2 = SolrQuery.query_all_fields("name:hello").with_sort([(Fields.name, SortDirection.asc)])
+    assert q2.to_dict() == {"query": "name:hello", "fields": ["*", "score"], "sort": "name asc"}
+
+    q3 = SolrQuery.query_all_fields("name:hello").with_sort(
+        [(Fields.name, SortDirection.asc), (Fields.creation_date, SortDirection.desc)]
+    )
+    assert q3.to_dict() == {"query": "name:hello", "fields": ["*", "score"], "sort": "name asc,creationDate desc"}
 
 
 @pytest.mark.asyncio
-async def test_solr_client(solr_search):
+async def test_insert_and_query_project(solr_search):
     async with DefaultSolrClient(solr_search) as client:
-        p = Project(id="p1", name="my project")
+        p = test_entity_documents.project_ai_stuff
         r1 = await client.upsert([p])
-        match r1:
-            case UpsertSuccess() as s:
-                assert s.header.status == 0
-                assert s.header.queryTime > 0
-            case _:
-                raise Exception(f"Unexpected result: {r1}")
-
-        qr = await client.get("p1")
-        assert qr.responseHeader.status == 200
+        assert_upsert_result(r1)
+
+        qr = await client.query(SolrQuery.query_all_fields(f"id:{str(p.id)}"))
+        assert qr.responseHeader.status == 0
         assert qr.response.numFound == 1
         assert len(qr.response.docs) == 1
 
         doc = Project.model_validate(qr.response.docs[0])
-        assert doc.id == "p1"
-        assert doc.name == "my project"
+        assert doc.id == p.id
+        assert doc.name == p.name
+        assert doc.score is not None
+        assert doc.score > 0
+
+
+@pytest.mark.asyncio
+async def test_insert_and_query_user(solr_search):
+    async with DefaultSolrClient(solr_search) as client:
+        u1 = test_entity_documents.user_tadej_pogacar
+        u2 = test_entity_documents.user_jan_ullrich
+        r1 = await client.upsert([u1, u2])
+        assert_upsert_result(r1)
+
+        qr = await client.query(
+            SolrQuery.query_all_fields("_type:User").with_sort([(Fields.firstName, SortDirection.asc)])
+        )
+        assert qr.responseHeader.status == 0
+        assert qr.response.numFound == 2
+        assert len(qr.response.docs) == 2
+
+        su1 = User.from_dict(qr.response.docs[0])
+        su2 = User.from_dict(qr.response.docs[1])
+        assert su1.score is not None and su1.score > 0
+        assert su2.score is not None and su2.score > 0
+        assert su1.reset_solr_fields() == u2
+        assert su2.reset_solr_fields() == u1
+
+
+@pytest.mark.asyncio
+async def test_insert_and_query_group(solr_search):
+    async with DefaultSolrClient(solr_search) as client:
+        g = test_entity_documents.group_team
+        r1 = await client.upsert([g])
+        assert_upsert_result(r1)
+
+        qr = await client.query(SolrQuery.query_all_fields("_type:Group"))
+        assert qr.responseHeader.status == 0
+        assert qr.response.numFound == 1
+        assert len(qr.response.docs) == 1
 
-        print(doc)
+        sg = Group.from_dict(qr.response.docs[0])
+        assert sg.score is not None and sg.score > 0
+        assert sg.reset_solr_fields() == g