diff --git a/server/test/auth_test.gleam b/server/test/auth/login_test.gleam
similarity index 93%
rename from server/test/auth_test.gleam
rename to server/test/auth/login_test.gleam
index 189b551..3d0d0f7 100644
--- a/server/test/auth_test.gleam
+++ b/server/test/auth/login_test.gleam
@@ -6,6 +6,7 @@ import server/seed
 import server_test
 import shared/contract/login as login_contract
 import shared/session
+import wisp
 import wisp/simulate
 
 pub fn login_test() -> Nil {
@@ -40,8 +41,9 @@ pub fn login_with_non_existent_user_test() {
   use ctx <- server_test.with_context()
   let url = "/api/login"
 
+  let email = wisp.random_string(12) <> "@dummy.com"
   let body =
-    login_contract.RequestBody(email: "wibble@wobble", password: seed.password)
+    login_contract.RequestBody(email:, password: seed.password)
     |> login_contract.request_to_json
 
   let req =
@@ -49,7 +51,6 @@ pub fn login_with_non_existent_user_test() {
     |> simulate.json_body(body)
 
   let resp = router.handle_request(req, ctx)
-
   assert resp.status == 404
 }
 
@@ -66,6 +67,5 @@ pub fn login_wrong_password_test() {
     |> simulate.json_body(body)
 
   let resp = router.handle_request(req, ctx)
-
   assert resp.status == 401
 }
diff --git a/server/test/auth/signup_test.gleam b/server/test/auth/signup_test.gleam
new file mode 100644
index 0000000..0b3fc13
--- /dev/null
+++ b/server/test/auth/signup_test.gleam
@@ -0,0 +1,117 @@
+import gleam/http
+import gleam/json
+import server/router
+import server/seed
+import server_test
+import shared/contract/signup as signup_contract
+import shared/role
+import shared/user as shared_user
+import wisp
+import wisp/simulate
+
+pub fn signup_test() -> Nil {
+  use ctx <- server_test.with_context()
+
+  let body =
+    signup_contract.RequestBody(
+      name: wisp.random_string(12),
+      role: role.None,
+      email: wisp.random_string(12) <> "@email.com",
+      phone: wisp.random_string(12),
+      password: wisp.random_string(12),
+    )
+    |> signup_contract.request_to_json()
+
+  let req =
+    simulate.browser_request(http.Post, signup_contract.url)
+    |> simulate.json_body(body)
+
+  // not authenticated
+  {
+    let resp = router.handle_request(req, ctx)
+    assert resp.status == 401
+  }
+
+  // authenticated
+  {
+    let resp =
+      server_test.with_permissions(next: req, ctx:, with: role.Admin)
+      |> router.handle_request(ctx)
+
+    let body = simulate.read_body(resp)
+    assert resp.status == 201
+    let assert Ok(_) = json.parse(body, shared_user.decoder())
+  }
+}
+
+pub fn signup_invalid_email_test() -> Nil {
+  use ctx <- server_test.with_context()
+
+  let body =
+    signup_contract.RequestBody(
+      name: wisp.random_string(12),
+      role: role.None,
+      email: "some invalid email",
+      phone: wisp.random_string(12),
+      password: wisp.random_string(12),
+    )
+    |> signup_contract.request_to_json()
+
+  let req =
+    simulate.browser_request(http.Post, signup_contract.url)
+    |> simulate.json_body(body)
+
+  let resp =
+    server_test.with_permissions(next: req, ctx:, with: role.Admin)
+    |> router.handle_request(ctx)
+
+  assert resp.status == 400 as "Email needs to be valid"
+}
+
+pub fn signup_email_conflict_test() -> Nil {
+  use ctx <- server_test.with_context()
+
+  let body =
+    signup_contract.RequestBody(
+      name: wisp.random_string(12),
+      role: role.None,
+      email: seed.email,
+      phone: wisp.random_string(12),
+      password: wisp.random_string(12),
+    )
+    |> signup_contract.request_to_json()
+
+  let req =
+    simulate.browser_request(http.Post, signup_contract.url)
+    |> simulate.json_body(body)
+
+  let resp =
+    server_test.with_permissions(next: req, ctx:, with: role.Admin)
+    |> router.handle_request(ctx)
+
+  assert resp.status == 409 as "Email needs to be unique"
+}
+
+pub fn signup_phone_conflict_test() -> Nil {
+  use ctx <- server_test.with_context()
+
+  let body =
+    signup_contract.RequestBody(
+      name: wisp.random_string(12),
+      role: role.None,
+      email: wisp.random_string(12) <> "@email.com",
+      phone: seed.phone,
+      password: wisp.random_string(12),
+    )
+    |> signup_contract.request_to_json()
+
+  let req =
+    simulate.browser_request(http.Post, signup_contract.url)
+    |> simulate.json_body(body)
+
+  let resp =
+    server_test.with_permissions(next: req, ctx:, with: role.Admin)
+    |> router.handle_request(ctx)
+
+  assert resp.status == 409
+}
diff --git a/server/test/user/autocomplete_test.gleam b/server/test/user/autocomplete_test.gleam
new file mode 100644
index 0000000..29ce348
--- /dev/null
+++ b/server/test/user/autocomplete_test.gleam
@@ -0,0 +1,178 @@
+import gleam/dynamic/decode
+import gleam/http
+import gleam/json
+import gleam/list
+import gleam/uri
+import server/router
+import server/user
+import server_test as testing
+import shared/role
+import shared/user as shared_user
+import wisp
+import wisp/simulate
+
+pub fn find_by_email_test() {
+  use ctx <- testing.with_context()
+  let path = "/api/user/autocomplete"
+  let prefix = "dummy_"
+
+  let first_email = prefix <> wisp.random_string(12)
+  let assert Ok(first_dummy) =
+    user.register(
+      ctx:,
+      user_name: wisp.random_string(12),
+      user_role: role.None,
+      user_password: wisp.random_string(12),
+      user_email: first_email <> "@email.com",
+      user_phone: wisp.random_string(12),
+      is_active: True,
+    )
+
+  let second_email = prefix <> wisp.random_string(12)
+  let assert Ok(second_dummy) =
+    user.register(
+      ctx:,
+      user_name: wisp.random_string(12),
+      user_role: role.None,
+      user_password: wisp.random_string(12),
+      user_email: second_email <> "@email.com",
+      user_phone: wisp.random_string(12),
+      is_active: True,
+    )
+
+  let query =
+    uri.query_to_string([
+      #("q", "email"),
+      #("value", prefix),
+      #("limit", "2"),
+    ])
+
+  let url = path <> "?" <> query
+
+  let req = simulate.browser_request(http.Get, url)
+  let resp = router.handle_request(req, ctx)
+  assert resp.status == 401
+
+  let with_auth = testing.with_permissions(req, ctx, role.None)
+  let resp = router.handle_request(with_auth, ctx)
+  assert resp.status == 200
+
+  let body = simulate.read_body(resp)
+  let assert Ok(got) = json.parse(body, decode.list(shared_user.decoder()))
+
+  assert list.contains(got, first_dummy) && list.contains(got, second_dummy)
+    as "Server found both users"
+}
+
+pub fn find_by_email_invalid_query_test() {
+  use ctx <- testing.with_context()
+  let path = "/api/user/autocomplete"
+
+  // missing query
+  {
+    let query =
+      uri.query_to_string([
+        #("value", "dummy"),
+        #("limit", "2"),
+      ])
+
+    let url = path <> "?" <> query
+    let req = simulate.browser_request(http.Get, url)
+
+    let resp = router.handle_request(req, ctx)
+    assert resp.status == 401
+
+    let with_auth = testing.with_permissions(req, ctx, role.None)
+    let resp = router.handle_request(with_auth, ctx)
+    assert resp.status == 400
+  }
+
+  // missing value
+  {
+    let query =
+      uri.query_to_string([
+        #("q", "email"),
+        #("limit", "2"),
+      ])
+
+    let url = path <> "?" <> query
+    let req = simulate.browser_request(http.Get, url)
+
+    let resp = router.handle_request(req, ctx)
+    assert resp.status == 401
+
+    let with_auth = testing.with_permissions(req, ctx, role.None)
+    let resp = router.handle_request(with_auth, ctx)
+    assert resp.status == 400
+  }
+
+  // missing limit
+  {
+    let query =
+      uri.query_to_string([
+        #("q", "email"),
+        #("value", "dummy"),
+      ])
+
+    let url = path <> "?" <> query
+    let req = simulate.browser_request(http.Get, url)
+
+    let resp = router.handle_request(req, ctx)
+    assert resp.status == 401
+
+    let with_auth = testing.with_permissions(req, ctx, role.None)
+    let resp = router.handle_request(with_auth, ctx)
+    assert resp.status == 400
+  }
+}
+
+pub fn find_by_name_test() {
+  use ctx <- testing.with_context()
+  let path = "/api/user/autocomplete"
+  let first_name = "Dummy"
+
+  let assert Ok(first_dummy) =
+    user.register(
+      ctx:,
+      user_name: first_name <> " " <> wisp.random_string(12),
+      user_role: role.None,
+      user_password: wisp.random_string(12),
+      user_email: wisp.random_string(12) <> "@email.com",
+      user_phone: wisp.random_string(12),
+      is_active: True,
+    )
+
+  let assert Ok(second_dummy) =
+    user.register(
+      ctx:,
+      user_name: first_name <> " " <> wisp.random_string(12),
+      user_role: role.None,
+      user_password: wisp.random_string(12),
+      user_email: wisp.random_string(12) <> "@email.com",
+      user_phone: wisp.random_string(12),
+      is_active: True,
+    )
+
+  let query =
+    uri.query_to_string([
+      #("q", "name"),
+      #("value", first_name),
+      #("limit", "2"),
+    ])
+
+  let url = path <> "?" <> query
+
+  let req = simulate.browser_request(http.Get, url)
+  let resp = router.handle_request(req, ctx)
+  assert resp.status == 401
+
+  let with_auth = testing.with_permissions(req, ctx, role.None)
+  let resp = router.handle_request(with_auth, ctx)
+  assert resp.status == 200
+
+  let body = simulate.read_body(resp)
+  let assert Ok(got) = json.parse(body, decode.list(shared_user.decoder()))
+
+  assert list.contains(got, first_dummy) && list.contains(got, second_dummy)
+    as "Server found both users"
+}
diff --git a/server/test/user_test.gleam b/server/test/user_test.gleam
index 3ca4827..dc3196b 100644
--- a/server/test/user_test.gleam
+++ b/server/test/user_test.gleam
@@ -1,128 +1,16 @@
-import gleam/dynamic/decode
 import gleam/http
 import gleam/json
-import gleam/list
-import gleam/uri
 import server/router
-import server/seed
 import server/user
-import server_test
-import shared/contract/signup as signup_contract
+import server_test as testing
 import shared/role
 import shared/user as shared_user
 import wisp
 import wisp/simulate
 import youid/uuid
 
-pub fn signup_test() -> Nil {
-  use ctx <- server_test.with_context()
-
-  let body =
-    signup_contract.RequestBody(
-      name: wisp.random_string(12),
-      role: role.None,
-      email: wisp.random_string(12) <> "@email.com",
-      phone: wisp.random_string(12),
-      password: wisp.random_string(12),
-    )
-    |> signup_contract.request_to_json()
-
-  let req =
-    simulate.browser_request(http.Post, signup_contract.url)
-    |> simulate.json_body(body)
-
-  // not authenticated
-  {
-    let resp = router.handle_request(req, ctx)
-    assert resp.status == 401
-  }
-
-  // authenticated
-  {
-    let resp =
-      server_test.with_permissions(next: req, ctx:, with: role.Admin)
-      |> router.handle_request(ctx)
-
-    let body = simulate.read_body(resp)
-    assert resp.status == 201
-    let assert Ok(_) = json.parse(body, shared_user.decoder())
-  }
-}
-
-pub fn signup_invalid_email_test() -> Nil {
-  use ctx <- server_test.with_context()
-
-  let body =
-    signup_contract.RequestBody(
-      name: wisp.random_string(12),
-      role: role.None,
-      email: "some invalid email",
-      phone: wisp.random_string(12),
-      password: wisp.random_string(12),
-    )
-    |> signup_contract.request_to_json()
-
-  let req =
-    simulate.browser_request(http.Post, signup_contract.url)
-    |> simulate.json_body(body)
-
-  let resp =
-    server_test.with_permissions(next: req, ctx:, with: role.Admin)
-    |> router.handle_request(ctx)
-
-  assert resp.status == 400 as "Email needs to be valid"
-}
-
-pub fn signup_email_conflict_test() -> Nil {
-  use ctx <- server_test.with_context()
-
-  let body =
-    signup_contract.RequestBody(
-      name: wisp.random_string(12),
-      role: role.None,
-      email: seed.email,
-      phone: wisp.random_string(12),
-      password: wisp.random_string(12),
-    )
-    |> signup_contract.request_to_json()
-
-  let req =
-    simulate.browser_request(http.Post, signup_contract.url)
-    |> simulate.json_body(body)
-
-  let resp =
-    server_test.with_permissions(next: req, ctx:, with: role.Admin)
-    |> router.handle_request(ctx)
-
-  assert resp.status == 409 as "Email needs to be unique"
-}
-
-pub fn signup_phone_conflict_test() -> Nil {
-  use ctx <- server_test.with_context()
-
-  let body =
-    signup_contract.RequestBody(
-      name: wisp.random_string(12),
-      role: role.None,
-      email: wisp.random_string(12) <> "@email.com",
-      phone: seed.phone,
-      password: wisp.random_string(12),
-    )
-    |> signup_contract.request_to_json()
-
-  let req =
-    simulate.browser_request(http.Post, signup_contract.url)
-    |> simulate.json_body(body)
-
-  let resp =
-    server_test.with_permissions(next: req, ctx:, with: role.Admin)
-    |> router.handle_request(ctx)
-
-  assert resp.status == 409
-}
-
 pub fn find_by_id_test() {
-  use ctx <- server_test.with_context()
+  use ctx <- testing.with_context()
   let path = "/api/user"
 
   let assert Ok(expected) =
@@ -144,7 +32,7 @@ pub fn find_by_id_test() {
 
   let with_auth =
     simulate.browser_request(http.Get, url)
-    |> server_test.with_permissions(ctx, with: role.Admin)
+    |> testing.with_permissions(ctx, with: role.Admin)
 
   let resp = router.handle_request(with_auth, ctx)
   assert resp.status == 200
@@ -152,120 +40,5 @@ pub fn find_by_id_test() {
   let body = simulate.read_body(resp)
   let assert Ok(got) = json.parse(body, shared_user.decoder())
 
-  assert got == expected as "Found user"
-}
-
-pub fn find_by_email_test() {
-  use ctx <- server_test.with_context()
-  let path = "/api/user/autocomplete"
-  let prefix = "dummy_"
-
-  let first_email = prefix <> wisp.random_string(12)
-  let assert Ok(first_dummy) =
-    user.register(
-      ctx:,
-      user_name: wisp.random_string(12),
-      user_role: role.None,
-      user_password: wisp.random_string(12),
-      user_email: first_email <> "@email.com",
-      user_phone: wisp.random_string(12),
-      is_active: True,
-    )
-
-  let second_email = prefix <> wisp.random_string(12)
-  let assert Ok(second_dummy) =
-    user.register(
-      ctx:,
-      user_name: wisp.random_string(12),
-      user_role: role.None,
-      user_password: wisp.random_string(12),
-      user_email: second_email <> "@email.com",
-      user_phone: wisp.random_string(12),
-      is_active: True,
-    )
-
-  let query =
-    uri.query_to_string([
-      #("q", "email"),
-      #("value", prefix),
-      #("limit", "2"),
-    ])
-
-  let url = path <> "?" <> query
-
-  let req = simulate.browser_request(http.Get, url)
-  let resp = router.handle_request(req, ctx)
-  assert resp.status == 401
-
-  let with_auth = server_test.with_permissions(req, ctx, role.None)
-  let resp = router.handle_request(with_auth, ctx)
-  assert resp.status == 200
-
-  let body = simulate.read_body(resp)
-  let assert Ok(got) = json.parse(body, decode.list(shared_user.decoder()))
-
-  assert list.contains(got, first_dummy) && list.contains(got, second_dummy)
-    as "Server found both users"
-}
-
-pub fn find_by_email_invalid_query_test() {
-  use ctx <- server_test.with_context()
-  let path = "/api/user/autocomplete"
-
-  // missing query
-  {
-    let query =
-      uri.query_to_string([
-        #("value", "dummy"),
-        #("limit", "2"),
-      ])
-
-    let url = path <> "?" <> query
-    let req = simulate.browser_request(http.Get, url)
-
-    let resp = router.handle_request(req, ctx)
-    assert resp.status == 401
-
-    let with_auth = server_test.with_permissions(req, ctx, role.None)
-    let resp = router.handle_request(with_auth, ctx)
-    assert resp.status == 400
-  }
-
-  // missing value
-  {
-    let query =
-      uri.query_to_string([
-        #("q", "email"),
-        #("limit", "2"),
-      ])
-
-    let url = path <> "?" <> query
-    let req = simulate.browser_request(http.Get, url)
-
-    let resp = router.handle_request(req, ctx)
-    assert resp.status == 401
-
-    let with_auth = server_test.with_permissions(req, ctx, role.None)
-    let resp = router.handle_request(with_auth, ctx)
-    assert resp.status == 400
-  }
-
-  // missing limit
-  {
-    let query =
-      uri.query_to_string([
-        #("q", "email"),
-        #("value", "dummy"),
-      ])
-
-    let url = path <> "?" <> query
-    let req = simulate.browser_request(http.Get, url)
-
-    let resp = router.handle_request(req, ctx)
-    assert resp.status == 401
-
-    let with_auth = server_test.with_permissions(req, ctx, role.None)
-    let resp = router.handle_request(with_auth, ctx)
-    assert resp.status == 400
-  }
+  assert got == expected
 }