dstack 0.18.43__py3-none-any.whl → 0.19.0__py3-none-any.whl

tests/_internal/cli/services/configurators/test_profile.py

@@ -5,7 +5,7 @@ from dstack._internal.cli.services.profile import (
     apply_profile_args,
     register_profile_args,
 )
-from dstack._internal.core.models.profiles import Profile, ProfileRetryPolicy, SpotPolicy
+from dstack._internal.core.models.profiles import Profile, ProfileRetry, SpotPolicy
 
 
 class TestProfileArgs:
@@ -51,21 +51,21 @@ class TestProfileArgs:
         assert profile.dict() == modified.dict()
 
     def test_retry(self):
-        profile = Profile(name="test")
-        profile.retry_policy = ProfileRetryPolicy(retry=True)
+        profile = Profile(name="test", retry=None)
         modified, _ = apply_args(profile, ["--retry"])
+        profile.retry = True
         assert profile.dict() == modified.dict()
 
     def test_no_retry(self):
-        profile = Profile(name="test", retry_policy=ProfileRetryPolicy(retry=True, duration=3600))
+        profile = Profile(name="test", retry=None)
         modified, _ = apply_args(profile, ["--no-retry"])
-        profile.retry_policy.retry = False
+        profile.retry = False
         assert profile.dict() == modified.dict()
 
     def test_retry_duration(self):
         profile = Profile(name="test")
         modified, _ = apply_args(profile, ["--retry-duration", "1h"])
-        profile.retry_policy = ProfileRetryPolicy(retry=True, duration=3600)
+        profile.retry = ProfileRetry(on_events=None, duration="1h")
         assert profile.dict() == modified.dict()
 
 

tests/_internal/core/backends/aws/test_configurator.py

@@ -0,0 +1,35 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.backends.aws.configurator import AWSConfigurator
+from dstack._internal.core.backends.aws.models import AWSAccessKeyCreds, AWSBackendConfigWithCreds
+from dstack._internal.core.errors import (
+    BackendAuthError,
+    BackendInvalidCredentialsError,
+)
+
+
+class TestAWSConfigurator:
+    def test_validate_config_valid(self):
+        config = AWSBackendConfigWithCreds(
+            creds=AWSAccessKeyCreds(access_key="valid", secret_key="valid"), regions=["us-west-1"]
+        )
+        with (
+            patch("dstack._internal.core.backends.aws.auth.authenticate"),
+            patch("dstack._internal.core.backends.aws.compute.get_vpc_id_subnet_id_or_error"),
+        ):
+            AWSConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = AWSBackendConfigWithCreds(
+            creds=AWSAccessKeyCreds(access_key="invalid", secret_key="invalid"),
+            regions=["us-west-1"],
+        )
+        with (
+            patch("dstack._internal.core.backends.aws.auth.authenticate") as authenticate_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            authenticate_mock.side_effect = BackendAuthError()
+            AWSConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "access_key"], ["creds", "secret_key"]]

tests/_internal/core/backends/aws/test_resources.py

@@ -3,6 +3,7 @@ from unittest.mock import Mock
 
 import pytest
 
+from dstack._internal.core.backends.aws.models import AWSOSImage, AWSOSImageConfig
 from dstack._internal.core.backends.aws.resources import (
     _is_valid_tag_key,
     _is_valid_tag_value,
@@ -10,7 +11,6 @@ from dstack._internal.core.backends.aws.resources import (
     validate_tags,
 )
 from dstack._internal.core.errors import BackendError, ComputeResourceNotFoundError
-from dstack._internal.core.models.backends.aws import AWSOSImage, AWSOSImageConfig
 
 
 class TestIsValidTagKey:

tests/_internal/core/backends/azure/test_configurator.py

@@ -0,0 +1,61 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from dstack._internal.core.backends.azure.configurator import AzureConfigurator
+from dstack._internal.core.backends.azure.models import (
+    AzureBackendConfigWithCreds,
+    AzureClientCreds,
+)
+from dstack._internal.core.errors import (
+    BackendAuthError,
+    BackendInvalidCredentialsError,
+)
+
+
+class TestAzureConfigurator:
+    def test_validate_config_valid(self):
+        config = AzureBackendConfigWithCreds(
+            creds=AzureClientCreds(
+                tenant_id="valid",
+                client_id="valid",
+                client_secret="valid",
+            ),
+            tenant_id="ten1",
+            subscription_id="sub1",
+            regions=["eastus"],
+        )
+        with (
+            patch("dstack._internal.core.backends.azure.auth.authenticate") as authenticate_mock,
+            patch("azure.mgmt.subscription.SubscriptionClient") as SubscriptionClientMock,
+        ):
+            authenticate_mock.return_value = Mock(), Mock()
+            subcription_client_mock = SubscriptionClientMock.return_value
+            subcription_client_mock.tenants.list.return_value = [Mock(tenant_id="ten1")]
+            subcription_client_mock.subscriptions.list.return_value = [
+                Mock(subscription_id="sub1")
+            ]
+            AzureConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = AzureBackendConfigWithCreds(
+            creds=AzureClientCreds(
+                tenant_id="invalid",
+                client_id="invalid",
+                client_secret="invalid",
+            ),
+            tenant_id="invalid",
+            subscription_id="invalid",
+            regions=["eastus"],
+        )
+        with (
+            patch("dstack._internal.core.backends.azure.auth.authenticate") as mock_authenticate,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            mock_authenticate.side_effect = BackendAuthError()
+            AzureConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [
+            ["creds", "tenant_id"],
+            ["creds", "client_id"],
+            ["creds", "client_secret"],
+        ]

tests/_internal/core/backends/cudo/test_configurator.py

@@ -0,0 +1,37 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.backends.cudo.configurator import CudoConfigurator
+from dstack._internal.core.backends.cudo.models import CudoBackendConfigWithCreds, CudoCreds
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestCudoConfigurator:
+    def test_validate_config_valid(self):
+        config = CudoBackendConfigWithCreds(
+            creds=CudoCreds(api_key="valid"),
+            project_id="project1",
+            regions=["no-luster-1"],
+        )
+        with patch(
+            "dstack._internal.core.backends.cudo.api_client.CudoApiClient.validate_api_key"
+        ) as validate_mock:
+            validate_mock.return_value = True
+            CudoConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = CudoBackendConfigWithCreds(
+            creds=CudoCreds(api_key="invalid"),
+            project_id="project1",
+            regions=["no-luster-1"],
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.cudo.api_client.CudoApiClient.validate_api_key"
+            ) as validate_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            validate_mock.return_value = False
+            CudoConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "api_key"]]

tests/_internal/core/backends/datacrunch/test_configurator.py

@@ -0,0 +1,17 @@
+from dstack._internal.core.backends.datacrunch.configurator import (
+    DataCrunchConfigurator,
+)
+from dstack._internal.core.backends.datacrunch.models import (
+    DataCrunchBackendConfigWithCreds,
+    DataCrunchCreds,
+)
+
+
+class TestDataCrunchConfigurator:
+    def test_validate_config_valid(self):
+        config = DataCrunchBackendConfigWithCreds(
+            creds=DataCrunchCreds(client_id="valid", client_secret="valid"),
+            regions=["FIN-01"],
+        )
+        # Currently no validation is implemented
+        DataCrunchConfigurator().validate_config(config, default_creds_enabled=True)

tests/_internal/core/backends/gcp/test_configurator.py

@@ -0,0 +1,42 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from dstack._internal.core.backends.gcp.configurator import GCPConfigurator
+from dstack._internal.core.backends.gcp.models import (
+    GCPBackendConfigWithCreds,
+    GCPServiceAccountCreds,
+)
+from dstack._internal.core.errors import (
+    BackendAuthError,
+    BackendInvalidCredentialsError,
+)
+
+
+class TestGCPConfigurator:
+    def test_validate_config_valid(self):
+        config = GCPBackendConfigWithCreds(
+            creds=GCPServiceAccountCreds(data="valid", filename="-"),
+            project_id="valid-project",
+            regions=["us-west1"],
+        )
+        with (
+            patch("dstack._internal.core.backends.gcp.auth.authenticate") as authenticate_mock,
+            patch("dstack._internal.core.backends.gcp.resources.check_vpc"),
+        ):
+            authenticate_mock.return_value = Mock(), Mock()
+            GCPConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = GCPBackendConfigWithCreds(
+            creds=GCPServiceAccountCreds(data="invalid", filename="-"),
+            project_id="invalid-project",
+            regions=["us-west1"],
+        )
+        with (
+            patch("dstack._internal.core.backends.gcp.auth.authenticate") as authenticate_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            authenticate_mock.side_effect = BackendAuthError()
+            GCPConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "data"]]

tests/_internal/core/backends/kubernetes/test_configurator.py

@@ -0,0 +1,43 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from dstack._internal.core.backends.kubernetes.configurator import (
+    KubernetesConfigurator,
+)
+from dstack._internal.core.backends.kubernetes.models import (
+    KubeconfigConfig,
+    KubernetesBackendConfigWithCreds,
+    KubernetesNetworkingConfig,
+)
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestKubernetesConfigurator:
+    def test_validate_config_valid(self):
+        config = KubernetesBackendConfigWithCreds(
+            kubeconfig=KubeconfigConfig(data="valid", filename="-"),
+            networking=KubernetesNetworkingConfig(ssh_host=None, ssh_port=None),
+        )
+        with patch(
+            "dstack._internal.core.backends.kubernetes.utils.get_api_from_config_data"
+        ) as get_api_mock:
+            api_mock = Mock()
+            api_mock.list_node.return_value = Mock()
+            get_api_mock.return_value = api_mock
+            KubernetesConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_config(self):
+        config = KubernetesBackendConfigWithCreds(
+            kubeconfig=KubeconfigConfig(data="invalid", filename="-"),
+            networking=KubernetesNetworkingConfig(ssh_host=None, ssh_port=None),
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.kubernetes.utils.get_api_from_config_data"
+            ) as get_api_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            get_api_mock.side_effect = Exception("Invalid config")
+            KubernetesConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["kubeconfig"]]

tests/_internal/core/backends/lambdalabs/test_configurator.py

@@ -0,0 +1,38 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.backends.lambdalabs.configurator import LambdaConfigurator
+from dstack._internal.core.backends.lambdalabs.models import (
+    LambdaBackendConfigWithCreds,
+    LambdaCreds,
+)
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestLambdaConfigurator:
+    def test_validate_config_valid(self):
+        config = LambdaBackendConfigWithCreds(
+            creds=LambdaCreds(api_key="valid"),
+            regions=["us-east-1"],
+        )
+        with patch(
+            "dstack._internal.core.backends.lambdalabs.api_client.LambdaAPIClient.validate_api_key"
+        ) as validate_mock:
+            validate_mock.return_value = True
+            LambdaConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = LambdaBackendConfigWithCreds(
+            creds=LambdaCreds(api_key="invalid"),
+            regions=["us-east-1"],
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.lambdalabs.api_client.LambdaAPIClient.validate_api_key"
+            ) as validate_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            validate_mock.return_value = False
+            LambdaConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "api_key"]]

tests/_internal/core/backends/oci/test_configurator.py

@@ -0,0 +1,55 @@
+from unittest.mock import Mock, patch
+
+import pytest
+from oci.exceptions import ClientError
+
+from dstack._internal.core.backends.oci.configurator import OCIConfigurator
+from dstack._internal.core.backends.oci.models import (
+    OCIBackendConfigWithCreds,
+    OCIClientCreds,
+)
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestOCIConfigurator:
+    def test_validate_config_valid(self):
+        config = OCIBackendConfigWithCreds(
+            creds=OCIClientCreds(
+                user="valid_user",
+                tenancy="valid_tenancy",
+                key_content="valid_key",
+                key_file=None,
+                pass_phrase=None,
+                fingerprint="valid_fingerprint",
+                region="us-ashburn-1",
+            ),
+            regions=["us-ashburn-1"],
+        )
+        with patch(
+            "dstack._internal.core.backends.oci.configurator.get_subscribed_regions"
+        ) as regions_mock:
+            regions_mock.return_value = Mock(names=["us-ashburn-1"])
+            OCIConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = OCIBackendConfigWithCreds(
+            creds=OCIClientCreds(
+                user="invalid_user",
+                tenancy="invalid_tenancy",
+                key_content="invalid_key",
+                key_file=None,
+                pass_phrase=None,
+                fingerprint="invalid_fingerprint",
+                region="us-ashburn-1",
+            ),
+            regions=["us-ashburn-1"],
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.oci.configurator.get_subscribed_regions"
+            ) as regions_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            regions_mock.side_effect = ClientError("Invalid credentials")
+            OCIConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds"]]

tests/_internal/core/backends/runpod/test_configurator.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.backends.runpod.configurator import RunpodConfigurator
+from dstack._internal.core.backends.runpod.models import RunpodBackendConfigWithCreds, RunpodCreds
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestRunpodConfigurator:
+    def test_validate_config_valid(self):
+        config = RunpodBackendConfigWithCreds(
+            creds=RunpodCreds(api_key="valid"),
+        )
+        with patch(
+            "dstack._internal.core.backends.runpod.api_client.RunpodApiClient.validate_api_key"
+        ) as validate_mock:
+            validate_mock.return_value = True
+            RunpodConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = RunpodBackendConfigWithCreds(
+            creds=RunpodCreds(api_key="invalid"),
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.runpod.api_client.RunpodApiClient.validate_api_key"
+            ) as validate_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            validate_mock.return_value = False
+            RunpodConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "api_key"]]

tests/_internal/core/backends/tensordock/test_configurator.py

@@ -0,0 +1,38 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.backends.tensordock.configurator import (
+    TensorDockConfigurator,
+)
+from dstack._internal.core.backends.tensordock.models import (
+    TensorDockBackendConfigWithCreds,
+    TensorDockCreds,
+)
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestTensorDockConfigurator:
+    def test_validate_config_valid(self):
+        config = TensorDockBackendConfigWithCreds(
+            creds=TensorDockCreds(api_key="valid", api_token="valid"),
+        )
+        with patch(
+            "dstack._internal.core.backends.tensordock.api_client.TensorDockAPIClient.auth_test"
+        ) as auth_test_mock:
+            auth_test_mock.return_value = True
+            TensorDockConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = TensorDockBackendConfigWithCreds(
+            creds=TensorDockCreds(api_key="invalid", api_token="invalid"),
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.tensordock.api_client.TensorDockAPIClient.auth_test"
+            ) as auth_test_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            auth_test_mock.return_value = False
+            TensorDockConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "api_key"], ["creds", "api_token"]]

tests/_internal/core/backends/vastai/test_configurator.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.backends.vastai.configurator import VastAIConfigurator
+from dstack._internal.core.backends.vastai.models import VastAIBackendConfigWithCreds, VastAICreds
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestVastAIConfigurator:
+    def test_validate_config_valid(self):
+        config = VastAIBackendConfigWithCreds(
+            creds=VastAICreds(api_key="valid"),
+        )
+        with patch(
+            "dstack._internal.core.backends.vastai.api_client.VastAIAPIClient.auth_test"
+        ) as auth_test_mock:
+            auth_test_mock.return_value = True
+            VastAIConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = VastAIBackendConfigWithCreds(
+            creds=VastAICreds(api_key="invalid"),
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.vastai.api_client.VastAIAPIClient.auth_test"
+            ) as auth_test_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            auth_test_mock.return_value = False
+            VastAIConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "api_key"]]

tests/_internal/core/backends/vultr/test_configurator.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.backends.vultr.configurator import VultrConfigurator
+from dstack._internal.core.backends.vultr.models import VultrBackendConfigWithCreds, VultrCreds
+from dstack._internal.core.errors import BackendInvalidCredentialsError
+
+
+class TestVultrConfigurator:
+    def test_validate_config_valid(self):
+        config = VultrBackendConfigWithCreds(
+            creds=VultrCreds(api_key="valid"),
+        )
+        with patch(
+            "dstack._internal.core.backends.vultr.api_client.VultrApiClient.validate_api_key"
+        ) as validate_mock:
+            validate_mock.return_value = True
+            VultrConfigurator().validate_config(config, default_creds_enabled=True)
+
+    def test_validate_config_invalid_creds(self):
+        config = VultrBackendConfigWithCreds(
+            creds=VultrCreds(api_key="invalid"),
+        )
+        with (
+            patch(
+                "dstack._internal.core.backends.vultr.api_client.VultrApiClient.validate_api_key"
+            ) as validate_mock,
+            pytest.raises(BackendInvalidCredentialsError) as exc_info,
+        ):
+            validate_mock.return_value = False
+            VultrConfigurator().validate_config(config, default_creds_enabled=True)
+        assert exc_info.value.fields == [["creds", "api_key"]]

tests/_internal/server/background/tasks/test_process_gateways.py

@@ -8,6 +8,7 @@ from dstack._internal.core.models.gateways import GatewayProvisioningData, Gatew
 from dstack._internal.server.background.tasks.process_gateways import process_submitted_gateways
 from dstack._internal.server.testing.common import (
     AsyncContextManager,
+    ComputeMockSpec,
     create_backend,
     create_gateway,
     create_project,
@@ -37,6 +38,7 @@ class TestProcessSubmittedGateways:
             m.return_value = (backend, aws)
             pool_add.return_value = MagicMock()
             pool_add.return_value.client.return_value = MagicMock(AsyncContextManager())
+            aws.compute.return_value = Mock(spec=ComputeMockSpec)
             aws.compute.return_value.create_gateway.return_value = GatewayProvisioningData(
                 instance_id="i-1234567890",
                 ip_address="2.2.2.2",
@@ -68,6 +70,7 @@ class TestProcessSubmittedGateways:
         ) as m:
             aws = Mock()
             m.return_value = (backend, aws)
+            aws.compute.return_value = Mock(spec=ComputeMockSpec)
             aws.compute.return_value.create_gateway.side_effect = BackendError("Some error")
             await process_submitted_gateways()
             m.assert_called_once()
@@ -99,6 +102,7 @@ class TestProcessSubmittedGateways:
             aws = Mock()
             m.return_value = (backend, aws)
             connect_to_gateway_with_retry_mock.return_value = None
+            aws.compute.return_value = Mock(spec=ComputeMockSpec)
             aws.compute.return_value.create_gateway.return_value = GatewayProvisioningData(
                 instance_id="i-1234567890",
                 ip_address="2.2.2.2",