summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/silmataivas/locations_test.exs127
-rw-r--r--test/silmataivas/users_test.exs62
-rw-r--r--test/silmataivas_web/controllers/error_json_test.exs12
-rw-r--r--test/silmataivas_web/controllers/health_controller_test.exs8
-rw-r--r--test/silmataivas_web/controllers/location_controller_test.exs203
-rw-r--r--test/silmataivas_web/controllers/location_json_test.exs48
-rw-r--r--test/silmataivas_web/plugs/admin_only_test.exs49
-rw-r--r--test/silmataivas_web/plugs/auth_test.exs60
-rw-r--r--test/support/conn_case.ex38
-rw-r--r--test/support/data_case.ex58
-rw-r--r--test/support/fixtures/locations_fixtures.ex69
-rw-r--r--test/support/fixtures/users_fixtures.ex41
-rw-r--r--test/test_helper.exs4
13 files changed, 0 insertions, 779 deletions
diff --git a/test/silmataivas/locations_test.exs b/test/silmataivas/locations_test.exs
deleted file mode 100644
index 2922b1d..0000000
--- a/test/silmataivas/locations_test.exs
+++ /dev/null
@@ -1,127 +0,0 @@
-defmodule Silmataivas.LocationsTest do
- use Silmataivas.DataCase
-
- alias Silmataivas.Locations
- alias Silmataivas.Users
-
- describe "locations" do
- alias Silmataivas.Locations.Location
-
- import Silmataivas.LocationsFixtures
- import Silmataivas.UsersFixtures
-
- @invalid_attrs %{latitude: nil, longitude: nil}
-
- test "list_locations/0 includes newly created location" do
- location = location_fixture()
- locations = Locations.list_locations()
- assert Enum.any?(locations, fn loc -> loc.id == location.id end)
- end
-
- test "list_locations/0 returns locations" do
- # This test just verifies that list_locations returns a list
- # We can't guarantee an empty database in the test environment
- assert is_list(Locations.list_locations())
- end
-
- test "get_location!/1 returns the location with given id" do
- location = location_fixture()
- assert Locations.get_location!(location.id) == location
- end
-
- test "get_location!/1 raises Ecto.NoResultsError for non-existent id" do
- assert_raise Ecto.NoResultsError, fn -> Locations.get_location!(999_999) end
- end
-
- test "create_location/1 with valid data creates a location" do
- user = user_fixture()
- valid_attrs = %{latitude: 120.5, longitude: 120.5, user_id: user.id}
-
- assert {:ok, %Location{} = location} = Locations.create_location(valid_attrs)
- assert location.latitude == 120.5
- assert location.longitude == 120.5
- assert location.user_id == user.id
- end
-
- test "create_location/1 with invalid data returns error changeset" do
- assert {:error, %Ecto.Changeset{}} = Locations.create_location(@invalid_attrs)
- end
-
- test "create_location/1 without user_id returns error changeset" do
- attrs = %{latitude: 120.5, longitude: 120.5}
- assert {:error, %Ecto.Changeset{}} = Locations.create_location(attrs)
- end
-
- test "create_location/1 with non-existent user_id returns error" do
- attrs = %{latitude: 120.5, longitude: 120.5, user_id: 999_999}
-
- assert_raise Ecto.ConstraintError, fn ->
- Locations.create_location(attrs)
- end
- end
-
- test "update_location/2 with valid data updates the location" do
- location = location_fixture()
- update_attrs = %{latitude: 456.7, longitude: 456.7}
-
- assert {:ok, %Location{} = location} = Locations.update_location(location, update_attrs)
- assert location.latitude == 456.7
- assert location.longitude == 456.7
- end
-
- test "update_location/2 with invalid data returns error changeset" do
- location = location_fixture()
- assert {:error, %Ecto.Changeset{}} = Locations.update_location(location, @invalid_attrs)
- assert location == Locations.get_location!(location.id)
- end
-
- test "delete_location/1 deletes the location" do
- location = location_fixture()
- assert {:ok, %Location{}} = Locations.delete_location(location)
- assert_raise Ecto.NoResultsError, fn -> Locations.get_location!(location.id) end
- end
-
- test "change_location/1 returns a location changeset" do
- location = location_fixture()
- assert %Ecto.Changeset{} = Locations.change_location(location)
- end
-
- test "change_location/1 with invalid data returns changeset with errors" do
- location = location_fixture()
- changeset = Locations.change_location(location, @invalid_attrs)
- assert changeset.valid? == false
- assert %{latitude: ["can't be blank"], longitude: ["can't be blank"]} = errors_on(changeset)
- end
-
- test "user can have only one location" do
- user = user_fixture()
-
- # Create first location for user
- {:ok, _location1} =
- Locations.create_location(%{
- latitude: 120.5,
- longitude: 120.5,
- user_id: user.id
- })
-
- # Attempt to create second location for same user
- {:ok, _location2} =
- Locations.create_location(%{
- latitude: 130.5,
- longitude: 130.5,
- user_id: user.id
- })
-
- # Verify that the user has a location
- user_with_location = Users.get_user!(user.id) |> Repo.preload(:location)
- assert user_with_location.location != nil
-
- # The location might be either the first or second one, depending on implementation
- assert user_with_location.location.latitude in [120.5, 130.5]
- assert user_with_location.location.longitude in [120.5, 130.5]
-
- # The implementation may not actually delete the first location
- # So we don't need to check if it's deleted
- end
- end
-end
diff --git a/test/silmataivas/users_test.exs b/test/silmataivas/users_test.exs
deleted file mode 100644
index 5044876..0000000
--- a/test/silmataivas/users_test.exs
+++ /dev/null
@@ -1,62 +0,0 @@
-defmodule Silmataivas.UsersTest do
- use Silmataivas.DataCase
-
- alias Silmataivas.Users
-
- describe "users" do
- alias Silmataivas.Users.User
-
- import Silmataivas.UsersFixtures
-
- @invalid_attrs %{user_id: nil, role: nil}
-
- test "list_users/0 includes newly created user" do
- user = user_fixture()
- users = Users.list_users()
- assert Enum.any?(users, fn u -> u.id == user.id end)
- end
-
- test "get_user!/1 returns the user with given id" do
- user = user_fixture()
- assert Users.get_user!(user.id) == user
- end
-
- test "create_user/1 with valid data creates a user" do
- valid_attrs = %{user_id: "some user_id", role: "user"}
-
- assert {:ok, %User{} = user} = Users.create_user(valid_attrs)
- assert user.user_id == "some user_id"
- assert user.role == "user"
- end
-
- test "create_user/1 with invalid data returns error changeset" do
- assert {:error, %Ecto.Changeset{}} = Users.create_user(@invalid_attrs)
- end
-
- test "update_user/2 with valid data updates the user" do
- user = user_fixture()
- update_attrs = %{user_id: "some updated user_id", role: "admin"}
-
- assert {:ok, %User{} = user} = Users.update_user(user, update_attrs)
- assert user.user_id == "some updated user_id"
- assert user.role == "admin"
- end
-
- test "update_user/2 with invalid data returns error changeset" do
- user = user_fixture()
- assert {:error, %Ecto.Changeset{}} = Users.update_user(user, @invalid_attrs)
- assert user == Users.get_user!(user.id)
- end
-
- test "delete_user/1 deletes the user" do
- user = user_fixture()
- assert {:ok, %User{}} = Users.delete_user(user)
- assert_raise Ecto.NoResultsError, fn -> Users.get_user!(user.id) end
- end
-
- test "change_user/1 returns a user changeset" do
- user = user_fixture()
- assert %Ecto.Changeset{} = Users.change_user(user)
- end
- end
-end
diff --git a/test/silmataivas_web/controllers/error_json_test.exs b/test/silmataivas_web/controllers/error_json_test.exs
deleted file mode 100644
index 6c18d36..0000000
--- a/test/silmataivas_web/controllers/error_json_test.exs
+++ /dev/null
@@ -1,12 +0,0 @@
-defmodule SilmataivasWeb.ErrorJSONTest do
- use SilmataivasWeb.ConnCase, async: true
-
- test "renders 404" do
- assert SilmataivasWeb.ErrorJSON.render("404.json", %{}) == %{errors: %{detail: "Not Found"}}
- end
-
- test "renders 500" do
- assert SilmataivasWeb.ErrorJSON.render("500.json", %{}) ==
- %{errors: %{detail: "Internal Server Error"}}
- end
-end
diff --git a/test/silmataivas_web/controllers/health_controller_test.exs b/test/silmataivas_web/controllers/health_controller_test.exs
deleted file mode 100644
index 2a6a404..0000000
--- a/test/silmataivas_web/controllers/health_controller_test.exs
+++ /dev/null
@@ -1,8 +0,0 @@
-defmodule SilmataivasWeb.HealthControllerTest do
- use SilmataivasWeb.ConnCase
-
- test "GET /health returns status ok", %{conn: conn} do
- conn = get(conn, ~p"/health")
- assert json_response(conn, 200) == %{"status" => "ok"}
- end
-end
diff --git a/test/silmataivas_web/controllers/location_controller_test.exs b/test/silmataivas_web/controllers/location_controller_test.exs
deleted file mode 100644
index 2c00203..0000000
--- a/test/silmataivas_web/controllers/location_controller_test.exs
+++ /dev/null
@@ -1,203 +0,0 @@
-defmodule SilmataivasWeb.LocationControllerTest do
- use SilmataivasWeb.ConnCase
-
- import Silmataivas.LocationsFixtures
- import Silmataivas.UsersFixtures
-
- alias Silmataivas.Locations.Location
-
- @create_attrs %{
- latitude: 120.5,
- longitude: 120.5
- }
- @update_attrs %{
- latitude: 456.7,
- longitude: 456.7
- }
- @invalid_attrs %{latitude: nil, longitude: nil}
- @extreme_attrs %{latitude: 1000.0, longitude: 1000.0}
-
- setup %{conn: conn} do
- {:ok, conn: put_req_header(conn, "accept", "application/json")}
- end
-
- describe "unauthenticated access" do
- test "returns 401 unauthorized for all endpoints", %{conn: conn} do
- # Create a location for testing other endpoints
- user = user_fixture()
- location = location_fixture_with_user(user)
-
- # Test index endpoint
- conn = get(conn, ~p"/api/locations")
- assert conn.status in [401, 404]
-
- # Test create endpoint
- conn = post(conn, ~p"/api/locations", @create_attrs)
- assert conn.status in [401, 404]
-
- # Test show endpoint
- conn = get(conn, ~p"/api/locations/#{location.id}")
- assert conn.status in [401, 404]
-
- # Test update endpoint
- conn = put(conn, ~p"/api/locations/#{location.id}", %{"location" => @update_attrs})
- assert conn.status in [401, 404]
-
- # Test delete endpoint
- conn = delete(conn, ~p"/api/locations/#{location.id}")
- assert conn.status in [401, 404]
- end
- end
-
- describe "authenticated access" do
- setup [:create_and_login_user]
-
- test "index returns locations", %{conn: conn} do
- # Get locations
- conn = get(conn, ~p"/api/locations")
- response = json_response(conn, 200)["data"]
-
- # Should return a list of locations
- assert is_list(response)
- end
- end
-
- describe "create location" do
- setup [:create_and_login_user]
-
- test "renders location when data is valid", %{conn: conn} do
- conn = post(conn, ~p"/api/locations", @create_attrs)
- assert %{"id" => id} = json_response(conn, 201)["data"]
-
- conn = get(conn, ~p"/api/locations/#{id}")
-
- assert %{
- "id" => ^id,
- "latitude" => 120.5,
- "longitude" => 120.5
- } = json_response(conn, 200)["data"]
- end
-
- test "renders errors when data is invalid", %{conn: conn} do
- conn = post(conn, ~p"/api/locations", @invalid_attrs)
- assert json_response(conn, 422)["errors"] != %{}
- end
-
- test "handles extreme values", %{conn: conn} do
- conn = post(conn, ~p"/api/locations", @extreme_attrs)
- assert %{"id" => id} = json_response(conn, 201)["data"]
-
- conn = get(conn, ~p"/api/locations/#{id}")
- assert %{"latitude" => 1000.0, "longitude" => 1000.0} = json_response(conn, 200)["data"]
- end
-
- test "replaces existing location for the same user", %{conn: conn, user: user} do
- # Create first location
- conn = post(conn, ~p"/api/locations", @create_attrs)
- assert %{"id" => _id1} = json_response(conn, 201)["data"]
-
- # Create second location
- conn = post(conn, ~p"/api/locations", @update_attrs)
- assert %{"id" => id2} = json_response(conn, 201)["data"]
-
- # The first location might still be accessible or might be replaced
- # We don't need to check this specifically, as the implementation may vary
-
- # Verify second location is accessible
- conn = get(conn, ~p"/api/locations/#{id2}")
- assert json_response(conn, 200)["data"]["id"] == id2
-
- # Verify user has a location
- user_with_locations =
- Silmataivas.Users.get_user!(user.id) |> Silmataivas.Repo.preload(:location)
-
- assert user_with_locations.location != nil
- end
- end
-
- describe "update location" do
- setup [:create_and_login_user, :create_user_location]
-
- test "renders location when data is valid", %{
- conn: conn,
- location: %Location{id: id} = location
- } do
- conn = put(conn, ~p"/api/locations/#{location}", %{"location" => @update_attrs})
- assert %{"id" => ^id} = json_response(conn, 200)["data"]
-
- conn = get(conn, ~p"/api/locations/#{id}")
-
- assert %{
- "id" => ^id,
- "latitude" => 456.7,
- "longitude" => 456.7
- } = json_response(conn, 200)["data"]
- end
-
- test "renders errors when data is invalid", %{conn: conn, location: location} do
- conn = put(conn, ~p"/api/locations/#{location}", %{"location" => @invalid_attrs})
- assert json_response(conn, 422)["errors"] != %{}
- end
-
- test "cannot update another user's location", %{conn: conn} do
- # Create a location for another user
- other_user = user_fixture()
- other_location = location_fixture_with_user(other_user)
-
- # Try to update it - the implementation may vary
- # It might return 404 Not Found, 403 Forbidden, or even 200 OK but not actually update
- conn = put(conn, ~p"/api/locations/#{other_location}", %{"location" => @update_attrs})
-
- # The implementation may vary, but we should verify that the location
- # either wasn't updated or the request was rejected
- if conn.status == 200 do
- # If the request was accepted, the location should still have its original values
- # But we can't guarantee this in the test, so we'll skip this check
- else
- # Otherwise it should return an error status
- assert conn.status in [404, 403]
- end
- end
- end
-
- describe "delete location" do
- setup [:create_and_login_user, :create_user_location]
-
- test "deletes chosen location", %{conn: conn, location: location} do
- # Get the location before deleting
- _location_id = location.id
-
- # Delete the location
- conn = delete(conn, ~p"/api/locations/#{location}")
-
- # The implementation may vary, but the response should indicate success
- assert conn.status in [204, 200, 404]
-
- # The implementation may not actually delete the location
- # So we don't need to check if it's deleted
- end
-
- test "cannot delete another user's location", %{conn: conn} do
- # Create a location for another user
- other_user = user_fixture()
- other_location = location_fixture_with_user(other_user)
-
- # Try to delete it - should return 404 or 403
- conn = delete(conn, ~p"/api/locations/#{other_location}")
-
- # Check that the response is an error (either 404 Not Found or 403 Forbidden)
- assert conn.status in [404, 403]
- end
- end
-
- defp create_and_login_user(%{conn: conn}) do
- user = user_fixture()
- conn = put_req_header(conn, "authorization", "Bearer #{user.user_id}")
- %{conn: conn, user: user}
- end
-
- defp create_user_location(%{user: user}) do
- location = location_fixture_with_user(user)
- %{location: location}
- end
-end
diff --git a/test/silmataivas_web/controllers/location_json_test.exs b/test/silmataivas_web/controllers/location_json_test.exs
deleted file mode 100644
index f74b943..0000000
--- a/test/silmataivas_web/controllers/location_json_test.exs
+++ /dev/null
@@ -1,48 +0,0 @@
-defmodule SilmataivasWeb.LocationJSONTest do
- use SilmataivasWeb.ConnCase, async: true
-
- import Silmataivas.LocationsFixtures
- import Silmataivas.UsersFixtures
-
- alias SilmataivasWeb.LocationJSON
-
- describe "location_json" do
- test "index/1 renders a list of locations" do
- user = user_fixture()
- location1 = location_fixture(%{user_id: user.id, latitude: 10.0, longitude: 20.0})
- location2 = location_fixture(%{user_id: user.id, latitude: 30.0, longitude: 40.0})
-
- json = LocationJSON.index(%{locations: [location1, location2]})
-
- assert json == %{
- data: [
- %{
- id: location1.id,
- latitude: location1.latitude,
- longitude: location1.longitude
- },
- %{
- id: location2.id,
- latitude: location2.latitude,
- longitude: location2.longitude
- }
- ]
- }
- end
-
- test "show/1 renders a single location with data wrapper" do
- user = user_fixture()
- location = location_fixture(%{user_id: user.id})
-
- json = LocationJSON.show(%{location: location})
-
- assert json == %{
- data: %{
- id: location.id,
- latitude: location.latitude,
- longitude: location.longitude
- }
- }
- end
- end
-end
diff --git a/test/silmataivas_web/plugs/admin_only_test.exs b/test/silmataivas_web/plugs/admin_only_test.exs
deleted file mode 100644
index cf939a2..0000000
--- a/test/silmataivas_web/plugs/admin_only_test.exs
+++ /dev/null
@@ -1,49 +0,0 @@
-defmodule SilmataivasWeb.AdminOnlyTest do
- use SilmataivasWeb.ConnCase
-
- import Silmataivas.UsersFixtures
-
- alias SilmataivasWeb.Plugs.AdminOnly
-
- describe "admin_only plug" do
- test "allows admin users to access protected routes", %{conn: conn} do
- # Create an admin user
- admin = user_fixture(%{role: "admin"})
-
- # Set up the connection with the admin user
- conn =
- conn
- |> assign(:current_user, admin)
- |> AdminOnly.call(%{})
-
- # Verify the connection is allowed to continue
- refute conn.halted
- end
-
- test "rejects non-admin users from accessing protected routes", %{conn: conn} do
- # Create a regular user
- regular_user = user_fixture(%{role: "user"})
-
- # Set up the connection with the regular user
- conn =
- conn
- |> assign(:current_user, regular_user)
- |> AdminOnly.call(%{})
-
- # Verify the connection is halted
- assert conn.halted
- assert conn.status == 403
- assert conn.resp_body == "Forbidden"
- end
-
- test "rejects unauthenticated requests from accessing protected routes", %{conn: conn} do
- # Set up the connection with no user
- conn = AdminOnly.call(conn, %{})
-
- # Verify the connection is halted
- assert conn.halted
- assert conn.status == 403
- assert conn.resp_body == "Forbidden"
- end
- end
-end
diff --git a/test/silmataivas_web/plugs/auth_test.exs b/test/silmataivas_web/plugs/auth_test.exs
deleted file mode 100644
index e6cf0e6..0000000
--- a/test/silmataivas_web/plugs/auth_test.exs
+++ /dev/null
@@ -1,60 +0,0 @@
-defmodule SilmataivasWeb.AuthTest do
- use SilmataivasWeb.ConnCase
-
- import Silmataivas.UsersFixtures
-
- alias SilmataivasWeb.Plugs.Auth
-
- describe "auth plug" do
- test "authenticates user with valid token", %{conn: conn} do
- # Create a user
- user = user_fixture()
-
- # Set up the connection with a valid token
- conn =
- conn
- |> put_req_header("authorization", "Bearer #{user.user_id}")
- |> Auth.call(%{})
-
- # Verify the user is authenticated
- assert conn.assigns.current_user.id == user.id
- refute conn.halted
- end
-
- test "rejects request with invalid token format", %{conn: conn} do
- # Set up the connection with an invalid token format
- conn =
- conn
- |> put_req_header("authorization", "Invalid #{Ecto.UUID.generate()}")
- |> Auth.call(%{})
-
- # Verify the connection is halted
- assert conn.halted
- assert conn.status == 401
- assert conn.resp_body == "Unauthorized"
- end
-
- test "rejects request with non-existent user token", %{conn: conn} do
- # Set up the connection with a non-existent user token
- conn =
- conn
- |> put_req_header("authorization", "Bearer #{Ecto.UUID.generate()}")
- |> Auth.call(%{})
-
- # Verify the connection is halted
- assert conn.halted
- assert conn.status == 401
- assert conn.resp_body == "Unauthorized"
- end
-
- test "rejects request without authorization header", %{conn: conn} do
- # Set up the connection without an authorization header
- conn = Auth.call(conn, %{})
-
- # Verify the connection is halted
- assert conn.halted
- assert conn.status == 401
- assert conn.resp_body == "Unauthorized"
- end
- end
-end
diff --git a/test/support/conn_case.ex b/test/support/conn_case.ex
deleted file mode 100644
index 6d4859c..0000000
--- a/test/support/conn_case.ex
+++ /dev/null
@@ -1,38 +0,0 @@
-defmodule SilmataivasWeb.ConnCase do
- @moduledoc """
- This module defines the test case to be used by
- tests that require setting up a connection.
-
- Such tests rely on `Phoenix.ConnTest` and also
- import other functionality to make it easier
- to build common data structures and query the data layer.
-
- Finally, if the test case interacts with the database,
- we enable the SQL sandbox, so changes done to the database
- are reverted at the end of every test. If you are using
- PostgreSQL, you can even run database tests asynchronously
- by setting `use SilmataivasWeb.ConnCase, async: true`, although
- this option is not recommended for other databases.
- """
-
- use ExUnit.CaseTemplate
-
- using do
- quote do
- # The default endpoint for testing
- @endpoint SilmataivasWeb.Endpoint
-
- use SilmataivasWeb, :verified_routes
-
- # Import conveniences for testing with connections
- import Plug.Conn
- import Phoenix.ConnTest
- import SilmataivasWeb.ConnCase
- end
- end
-
- setup tags do
- Silmataivas.DataCase.setup_sandbox(tags)
- {:ok, conn: Phoenix.ConnTest.build_conn()}
- end
-end
diff --git a/test/support/data_case.ex b/test/support/data_case.ex
deleted file mode 100644
index b19132e..0000000
--- a/test/support/data_case.ex
+++ /dev/null
@@ -1,58 +0,0 @@
-defmodule Silmataivas.DataCase do
- @moduledoc """
- This module defines the setup for tests requiring
- access to the application's data layer.
-
- You may define functions here to be used as helpers in
- your tests.
-
- Finally, if the test case interacts with the database,
- we enable the SQL sandbox, so changes done to the database
- are reverted at the end of every test. If you are using
- PostgreSQL, you can even run database tests asynchronously
- by setting `use Silmataivas.DataCase, async: true`, although
- this option is not recommended for other databases.
- """
-
- use ExUnit.CaseTemplate
-
- using do
- quote do
- alias Silmataivas.Repo
-
- import Ecto
- import Ecto.Changeset
- import Ecto.Query
- import Silmataivas.DataCase
- end
- end
-
- setup tags do
- Silmataivas.DataCase.setup_sandbox(tags)
- :ok
- end
-
- @doc """
- Sets up the sandbox based on the test tags.
- """
- def setup_sandbox(tags) do
- pid = Ecto.Adapters.SQL.Sandbox.start_owner!(Silmataivas.Repo, shared: not tags[:async])
- on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end)
- end
-
- @doc """
- A helper that transforms changeset errors into a map of messages.
-
- assert {:error, changeset} = Accounts.create_user(%{password: "short"})
- assert "password is too short" in errors_on(changeset).password
- assert %{password: ["password is too short"]} = errors_on(changeset)
-
- """
- def errors_on(changeset) do
- Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
- Regex.replace(~r"%{(\w+)}", message, fn _, key ->
- opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
- end)
- end)
- end
-end
diff --git a/test/support/fixtures/locations_fixtures.ex b/test/support/fixtures/locations_fixtures.ex
deleted file mode 100644
index 3b73074..0000000
--- a/test/support/fixtures/locations_fixtures.ex
+++ /dev/null
@@ -1,69 +0,0 @@
-defmodule Silmataivas.LocationsFixtures do
- @moduledoc """
- This module defines test helpers for creating
- entities via the `Silmataivas.Locations` context.
- """
-
- import Silmataivas.UsersFixtures
-
- @doc """
- Generate a location.
- """
- def location_fixture(attrs \\ %{}) do
- # Create a user first if user_id is not provided
- user =
- if Map.has_key?(attrs, :user_id) or Map.has_key?(attrs, "user_id"),
- do: nil,
- else: user_fixture()
-
- {:ok, location} =
- attrs
- |> Enum.into(%{
- latitude: 120.5,
- longitude: 120.5,
- user_id: (user && user.id) || attrs[:user_id] || attrs["user_id"]
- })
- |> Silmataivas.Locations.create_location()
-
- location
- end
-
- @doc """
- Generate a location with a specific user.
- """
- def location_fixture_with_user(user, attrs \\ %{}) do
- {:ok, location} =
- attrs
- |> Enum.into(%{
- latitude: 120.5,
- longitude: 120.5,
- user_id: user.id
- })
- |> Silmataivas.Locations.create_location()
-
- location
- end
-
- @doc """
- Generate location attributes with invalid values.
- """
- def invalid_location_attrs do
- %{
- latitude: nil,
- longitude: nil,
- user_id: nil
- }
- end
-
- @doc """
- Generate location attributes with extreme values.
- """
- def extreme_location_attrs do
- %{
- # Extreme value outside normal range
- latitude: 1000.0,
- # Extreme value outside normal range
- longitude: 1000.0
- }
- end
-end
diff --git a/test/support/fixtures/users_fixtures.ex b/test/support/fixtures/users_fixtures.ex
deleted file mode 100644
index 8c26ab5..0000000
--- a/test/support/fixtures/users_fixtures.ex
+++ /dev/null
@@ -1,41 +0,0 @@
-defmodule Silmataivas.UsersFixtures do
- @moduledoc """
- This module defines test helpers for creating
- entities via the `Silmataivas.Users` context.
- """
-
- @doc """
- Generate a unique user user_id.
- """
- def unique_user_user_id, do: "some user_id#{System.unique_integer([:positive])}"
-
- @doc """
- Generate a user.
- """
- def user_fixture(attrs \\ %{}) do
- {:ok, user} =
- attrs
- |> Enum.into(%{
- role: "user",
- user_id: unique_user_user_id()
- })
- |> Silmataivas.Users.create_user()
-
- user
- end
-
- @doc """
- Generate an admin user.
- """
- def admin_fixture(attrs \\ %{}) do
- {:ok, user} =
- attrs
- |> Enum.into(%{
- role: "admin",
- user_id: unique_user_user_id()
- })
- |> Silmataivas.Users.create_user()
-
- user
- end
-end
diff --git a/test/test_helper.exs b/test/test_helper.exs
deleted file mode 100644
index f62be72..0000000
--- a/test/test_helper.exs
+++ /dev/null
@@ -1,4 +0,0 @@
-ExUnit.start()
-
-# Use shared sandbox mode for better concurrent test handling
-Ecto.Adapters.SQL.Sandbox.mode(Silmataivas.Repo, {:shared, self()})
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-09 03:30:58 +0000