dstack 0.18.40rc1__py3-none-any.whl → 0.18.42__py3-none-any.whl

tests/_internal/server/services/test_pools.py

@@ -7,11 +7,115 @@ import dstack._internal.server.services.pools as services_pools
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.instances import InstanceStatus, InstanceType, Resources
 from dstack._internal.core.models.pools import Instance
+from dstack._internal.core.models.profiles import Profile
 from dstack._internal.server.models import InstanceModel
-from dstack._internal.server.testing.common import create_project, create_user
+from dstack._internal.server.testing.common import (
+    create_instance,
+    create_pool,
+    create_project,
+    create_user,
+    get_volume,
+    get_volume_configuration,
+)
 from dstack._internal.utils.common import get_current_datetime
 
 
+class TestFilterPoolInstances:
+    # TODO: Refactor filter_pool_instances to not depend on InstanceModel and simplify tests
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
+    async def test_returns_all_instances(self, test_db, session: AsyncSession):
+        user = await create_user(session=session)
+        project = await create_project(session=session, owner=user)
+        pool = await create_pool(session=session, project=project)
+        aws_instance = await create_instance(
+            session=session,
+            project=project,
+            pool=pool,
+            backend=BackendType.AWS,
+        )
+        runpod_instance = await create_instance(
+            session=session,
+            project=project,
+            pool=pool,
+            backend=BackendType.RUNPOD,
+        )
+        instances = [aws_instance, runpod_instance]
+        res = services_pools.filter_pool_instances(
+            pool_instances=instances,
+            profile=Profile(name="test"),
+        )
+        assert res == instances
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
+    async def test_returns_multinode_instances(self, test_db, session: AsyncSession):
+        user = await create_user(session=session)
+        project = await create_project(session=session, owner=user)
+        pool = await create_pool(session=session, project=project)
+        aws_instance = await create_instance(
+            session=session,
+            project=project,
+            pool=pool,
+            backend=BackendType.AWS,
+        )
+        runpod_instance = await create_instance(
+            session=session,
+            project=project,
+            pool=pool,
+            backend=BackendType.RUNPOD,
+        )
+        instances = [aws_instance, runpod_instance]
+        res = services_pools.filter_pool_instances(
+            pool_instances=instances,
+            profile=Profile(name="test"),
+            multinode=True,
+        )
+        assert res == [aws_instance]
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
+    async def test_returns_volume_instances(self, test_db, session: AsyncSession):
+        user = await create_user(session=session)
+        project = await create_project(session=session, owner=user)
+        pool = await create_pool(session=session, project=project)
+        aws_instance = await create_instance(
+            session=session,
+            project=project,
+            pool=pool,
+            backend=BackendType.AWS,
+        )
+        runpod_instance1 = await create_instance(
+            session=session,
+            project=project,
+            pool=pool,
+            backend=BackendType.RUNPOD,
+            region="eu",
+        )
+        runpod_instance2 = await create_instance(
+            session=session,
+            project=project,
+            pool=pool,
+            backend=BackendType.RUNPOD,
+            region="us",
+        )
+        instances = [aws_instance, runpod_instance1, runpod_instance2]
+        res = services_pools.filter_pool_instances(
+            pool_instances=instances,
+            profile=Profile(name="test"),
+            volumes=[
+                [
+                    get_volume(
+                        configuration=get_volume_configuration(
+                            backend=BackendType.RUNPOD, region="us"
+                        )
+                    )
+                ]
+            ],
+        )
+        assert res == [runpod_instance2]
+
+
 class TestGenerateInstanceName:
     @pytest.mark.asyncio
     @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
@@ -66,6 +170,8 @@ class TestInstanceModelToInstance:
             created=created,
             region="eu-west-1",
             price=1.0,
+            total_blocks=1,
+            busy_blocks=0,
         )
         im = InstanceModel(
             id=instance_id,
@@ -78,6 +184,8 @@ class TestInstanceModelToInstance:
             pool=None,
             job_provisioning_data='{"ssh_proxy":null, "backend":"local","hostname":"hostname_test","region":"eu-west","price":1.0,"username":"user1","ssh_port":12345,"dockerized":false,"instance_id":"test_instance","instance_type": {"name": "instance", "resources": {"cpus": 1, "memory_mib": 512, "gpus": [], "spot": false, "disk": {"size_mib": 102400}, "description":""}}}',
             offer='{"price":"LOCAL", "price":1.0, "backend":"local", "region":"eu-west-1", "availability":"available","instance": {"name": "instance", "resources": {"cpus": 1, "memory_mib": 512, "gpus": [], "spot": false, "disk": {"size_mib": 102400}, "description":""}}}',
+            total_blocks=1,
+            busy_blocks=0,
         )
         instance = services_pools.instance_model_to_instance(im)
         assert instance == expected_instance

tests/_internal/server/services/test_runs.py

@@ -10,9 +10,9 @@ from dstack._internal.core.models.configurations import ScalingSpec, ServiceConf
 from dstack._internal.core.models.profiles import Profile
 from dstack._internal.core.models.resources import Range
 from dstack._internal.core.models.runs import JobStatus, JobTerminationReason, RunStatus
-from dstack._internal.core.models.volumes import VolumeMountPoint
 from dstack._internal.server.models import RunModel
-from dstack._internal.server.services.runs import check_can_attach_run_volumes, scale_run_replicas
+from dstack._internal.server.services.jobs import check_can_attach_job_volumes
+from dstack._internal.server.services.runs import scale_run_replicas
 from dstack._internal.server.testing.common import (
     create_job,
     create_pool,
@@ -241,19 +241,7 @@ class TestCanAttachRunVolumes:
         vol22.configuration.backend = BackendType.AWS
         vol22.configuration.region = "eu-west-2"
         volumes = [[vol11, vol12], [vol21, vol22]]
-        run_spec = get_run_spec(
-            run_name="test_run",
-            repo_id="test_repo",
-            configuration=ServiceConfiguration(
-                port=80,
-                commands=[""],
-                volumes=[
-                    VolumeMountPoint(name=["vol11", "vol12"], path="/vol1"),
-                    VolumeMountPoint(name=["vol21", "vol22"], path="/vol2"),
-                ],
-            ),
-        )
-        check_can_attach_run_volumes(run_spec, volumes)
+        check_can_attach_job_volumes(volumes)
 
     @pytest.mark.asyncio
     async def test_cannot_attach_different_mount_points_with_different_backends_regions(self):
@@ -264,20 +252,8 @@ class TestCanAttachRunVolumes:
         vol2.configuration.backend = BackendType.AWS
         vol2.configuration.region = "eu-west-2"
         volumes = [[vol1], [vol2]]
-        run_spec = get_run_spec(
-            run_name="test_run",
-            repo_id="test_repo",
-            configuration=ServiceConfiguration(
-                port=80,
-                commands=[""],
-                volumes=[
-                    VolumeMountPoint(name=["vol1"], path="/vol1"),
-                    VolumeMountPoint(name=["vol2"], path="/vol2"),
-                ],
-            ),
-        )
         with pytest.raises(ServerClientError):
-            check_can_attach_run_volumes(run_spec, volumes)
+            check_can_attach_job_volumes(volumes)
 
     @pytest.mark.asyncio
     async def test_cannot_attach_same_volume_at_different_mount_points(self):
@@ -285,17 +261,5 @@ class TestCanAttachRunVolumes:
         vol1.configuration.backend = BackendType.AWS
         vol1.configuration.region = "eu-west-1"
         volumes = [[vol1], [vol1]]
-        run_spec = get_run_spec(
-            run_name="test_run",
-            repo_id="test_repo",
-            configuration=ServiceConfiguration(
-                port=80,
-                commands=[""],
-                volumes=[
-                    VolumeMountPoint(name=["vol1"], path="/vol1"),
-                    VolumeMountPoint(name=["vol1"], path="/vol2"),
-                ],
-            ),
-        )
         with pytest.raises(ServerClientError):
-            check_can_attach_run_volumes(run_spec, volumes)
+            check_can_attach_job_volumes(volumes)

tests/_internal/utils/test_common.py

@@ -6,6 +6,7 @@ from freezegun import freeze_time
 
 from dstack._internal.utils.common import (
     concat_url_path,
+    format_duration_multiunit,
     local_time,
     make_proxy_url,
     parse_memory,
@@ -87,6 +88,26 @@ class TestPrettyDate:
         assert pretty_date(future_time) == ""
 
 
+class TestFormatDurationMultiunit:
+    @pytest.mark.parametrize(
+        ("input", "output"),
+        [
+            (0, "0s"),
+            (59, "59s"),
+            (60, "1m"),
+            (61, "1m 1s"),
+            (694861, "1w 1d 1h 1m 1s"),
+            (86401, "1d 1s"),
+        ],
+    )
+    def test(self, input: int, output: str) -> None:
+        assert format_duration_multiunit(input) == output
+
+    def test_forbids_negative(self) -> None:
+        with pytest.raises(ValueError):
+            format_duration_multiunit(-1)
+
+
 class TestParseMemory:
     @pytest.mark.parametrize(
         "memory,as_units,expected",

tests/_internal/utils/test_env.py

@@ -0,0 +1,38 @@
+import pytest
+
+from dstack._internal.utils.env import get_bool
+
+
+@pytest.mark.parametrize(
+    ["value", "expected"],
+    [
+        ["0", False],
+        ["1", True],
+        ["true", True],
+        ["True", True],
+        ["FALSE", False],
+        ["off", False],
+        ["ON", True],
+    ],
+)
+def test_get_bool_is_set(monkeypatch: pytest.MonkeyPatch, value: str, expected: bool):
+    monkeypatch.setenv("VAR", value)
+    assert get_bool("VAR") is expected
+
+
+def test_get_bool_not_set_default_not_set(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.delenv("VAR", raising=False)
+    assert get_bool("VAR") is False
+
+
+@pytest.mark.parametrize("default", [False, True])
+def test_get_bool_not_set_default_is_set(monkeypatch: pytest.MonkeyPatch, default: bool):
+    monkeypatch.delenv("VAR", raising=False)
+    assert get_bool("VAR", default) is default
+
+
+@pytest.mark.parametrize("value", ["", "2", "foo"])
+def test_get_bool_error_value(monkeypatch: pytest.MonkeyPatch, value: str):
+    monkeypatch.setenv("VAR", value)
+    with pytest.raises(ValueError, match=f"VAR={value}"):
+        assert get_bool("VAR")