Added test for create_instance

src/dstack/_internal/server/routers/runs.py

@@ -109,7 +109,7 @@ async def create_instance(
             requirements=body.requirements,
         )
     except ComputeError as e:
-        raise ServerClientError(str(e))
+        raise ServerClientError(msg=str(e))
 
     if instance is None:
         raise ServerClientError(msg="Failed to create an instance")

src/dstack/_internal/server/services/runs.py

@@ -204,9 +204,6 @@ async def create_instance(
         project, profile, requirements, exclude_not_available=True
     )
 
-    if not offers:
-        return
-
     # Backends doesn't suppport create_instance
     backend_types = set((backend.TYPE for backend, _ in offers))
     if all(
@@ -218,6 +215,9 @@ async def create_instance(
             f"Backends {backends} doesn't support create_intance. Try to select other backends"
         )
 
+    if not offers:
+        return
+
     user_ssh_key = ssh_key
     project_ssh_key = SSHKey(
         public=project.ssh_public_key.strip(),

src/tests/_internal/server/routers/test_runs.py

@@ -823,3 +823,56 @@ async def test_create_instance(self, test_db, session: AsyncSession):
                 "price": 1.0,
             }
             assert result == expected
+
+    @pytest.mark.asyncio
+    async def test_backend_does_not_support_create_instance(self, test_db, session: AsyncSession):
+        user = await create_user(session=session, global_role=GlobalRole.USER)
+        project = await create_project(session=session, owner=user)
+        await add_project_member(
+            session=session, project=project, user=user, project_role=ProjectRole.USER
+        )
+        request = CreateInstanceRequest(
+            pool_name=DEFAULT_POOL_NAME,
+            profile=Profile(name="test_profile"),
+            requirements=Requirements(resources=ResourcesSpec(cpu=1)),
+            ssh_key=SSHKey(public="test_public_key"),
+        )
+
+        with patch(
+            "dstack._internal.server.services.runs.get_run_plan_by_requirements"
+        ) as run_plan_by_req:
+            offers = InstanceOfferWithAvailability(
+                backend=BackendType.AZURE,
+                instance=InstanceType(
+                    name="instance",
+                    resources=Resources(cpus=1, memory_mib=512, spot=False, gpus=[]),
+                ),
+                region="eu",
+                price=1.0,
+                availability=InstanceAvailability.AVAILABLE,
+            )
+
+            backend = Mock()
+            backend.TYPE = BackendType.AZURE
+            backend.compute.return_value.get_offers.return_value = [offers]
+            backend.compute.return_value.create_instance.side_effect = NotImplementedError()
+            run_plan_by_req.return_value = [(backend, offers)]
+
+            response = client.post(
+                f"/api/project/{project.name}/runs/create_instance",
+                headers=get_auth_headers(user.token),
+                json=request.dict(),
+            )
+
+            assert response.status_code == 400
+
+            result = response.json()
+            expected = {
+                "detail": [
+                    {
+                        "msg": "Backends azure doesn't support create_intance. Try to select other backends",
+                        "code": "error",
+                    }
+                ]
+            }
+            assert result == expected