Merge pull request #101 from facultyai/enhance-environment-client

Enhance environment client

Author: ameroueh

faculty/clients/environment.py

@@ -13,13 +13,37 @@
 # limitations under the License.
 
 
+import re
 from collections import namedtuple
+from enum import Enum
+
+from marshmallow import (
+    ValidationError,
+    fields,
+    post_load,
+    validates,
+    post_dump,
+)
+from marshmallow_enum import EnumField
+
+from faculty.clients.base import BaseClient, BaseSchema
 
-from marshmallow import fields, post_load
 
-from faculty.clients.base import BaseSchema, BaseClient
+class Constraint(Enum):
+    AT_LEAST = ">="
+    EQUAL = "=="
 
 
+Version = namedtuple("Version", ["constraint", "identifier"])
+PythonPackage = namedtuple("PythonPackage", ["name", "version"])
+Pip = namedtuple("Pip", ["extra_index_urls", "packages"])
+Conda = namedtuple("Conda", ["channels", "packages"])
+PythonEnvironment = namedtuple("PythonEnvironment", ["pip", "conda"])
+Apt = namedtuple("Apt", ["packages"])
+AptPackage = namedtuple("AptPackage", ["name"])
+Script = namedtuple("Script", ["script"])
+PythonSpecification = namedtuple("PythonSpecification", ["python2", "python3"])
+Specification = namedtuple("Specification", ["apt", "bash", "python"])
 Environment = namedtuple(
     "Environment",
     [
@@ -30,8 +54,139 @@
         "author_id",
         "created_at",
         "updated_at",
+        "specification",
     ],
 )
+EnvironmentCreationResponse = namedtuple("EnvironmentCreationResponse", ["id"])
+EnvironmentCreateUpdate = namedtuple(
+    "EnvironmentCreateUpdate", ["name", "description", "specification"]
+)
+
+VERSION_REGEX = re.compile(
+    r"^(?:\d+\!)?\d+(?:\.\d+)*(?:(?:a|b|rc)\d+)?(?:\.post\d+)?(?:\.dev\d+)?$"
+)
+
+
+class VersionSchema(BaseSchema):
+    constraint = EnumField(Constraint, by_value=True, required=True)
+    identifier = fields.String(required=True)
+
+    @validates("identifier")
+    def validate_version_format(self, data):
+        if not VERSION_REGEX.match(data):
+            raise ValidationError("Invalid version format")
+
+    @post_load
+    def make_version(self, data):
+        return Version(**data)
+
+    @post_dump
+    def dump_version(self, data):
+        self.validate_version_format(data["identifier"])
+        return data
+
+
+class VersionField(fields.Field):
+    """
+    Field that serialises/deserialises a Python package version.
+    """
+
+    def _deserialize(self, value, attr, obj, **kwargs):
+        if value == "latest":
+            return "latest"
+        else:
+            return VersionSchema().load(value)
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        if value == "latest":
+            return "latest"
+        else:
+            return VersionSchema().dump(value)
+
+
+class PythonPackageSchema(BaseSchema):
+    name = fields.String(required=True)
+    version = VersionField(required=True)
+
+    @post_load
+    def make_python_package(self, data):
+        return PythonPackage(**data)
+
+
+class PipSchema(BaseSchema):
+    extra_index_urls = fields.List(
+        fields.String(), data_key="extraIndexUrls", required=True
+    )
+    packages = fields.List(fields.Nested(PythonPackageSchema()), required=True)
+
+    @post_load
+    def make_pip(self, data):
+        return Pip(**data)
+
+
+class CondaSchema(BaseSchema):
+    channels = fields.List(fields.String(), required=True)
+    packages = fields.List(fields.Nested(PythonPackageSchema()), required=True)
+
+    @post_load
+    def make_conda(self, data):
+        return Conda(**data)
+
+
+class PythonEnvironmentSchema(BaseSchema):
+    conda = fields.Nested(CondaSchema(), required=True)
+    pip = fields.Nested(PipSchema(), required=True)
+
+    @post_load
+    def make_python_specification(self, data):
+        return PythonEnvironment(**data)
+
+
+class PythonSpecificationSchema(BaseSchema):
+    python2 = fields.Nested(
+        PythonEnvironmentSchema(), data_key="Python2", missing=None
+    )
+    python3 = fields.Nested(
+        PythonEnvironmentSchema(), data_key="Python3", missing=None
+    )
+
+    @post_load
+    def make_python(self, data):
+        return PythonSpecification(**data)
+
+
+class AptPackageSchema(BaseSchema):
+    name = fields.String(required=True)
+
+    @post_load
+    def make_apt_package(self, data):
+        return AptPackage(**data)
+
+
+class AptSchema(BaseSchema):
+    packages = fields.List(fields.Nested(AptPackageSchema()), required=True)
+
+    @post_load
+    def make_apt(self, data):
+        return Apt(**data)
+
+
+class ScriptSchema(BaseSchema):
+    script = fields.String(required=True)
+
+    @post_load
+    def make_script(self, data):
+        return Script(**data)
+
+
+class SpecificationSchema(BaseSchema):
+    apt = fields.Nested(AptSchema(), required=True)
+    bash = fields.List(fields.Nested(ScriptSchema()), required=True)
+    python = fields.Nested(PythonSpecificationSchema(), required=True)
+
+    @post_load
+    def make_specification(self, data):
+        return Specification(**data)
 
 
 class EnvironmentSchema(BaseSchema):
@@ -42,16 +197,72 @@ class EnvironmentSchema(BaseSchema):
     author_id = fields.UUID(data_key="authorId", required=True)
     created_at = fields.DateTime(data_key="createdAt", required=True)
     updated_at = fields.DateTime(data_key="updatedAt", required=True)
+    specification = fields.Nested(SpecificationSchema(), required=True)
 
     @post_load
     def make_environment(self, data):
         return Environment(**data)
 
 
+class EnvironmentCreateUpdateSchema(BaseSchema):
+    name = fields.String(required=True)
+    description = fields.String(required=True, allow_none=True)
+    specification = fields.Nested(SpecificationSchema(), required=True)
+
+    @post_load
+    def make_environment_update(self, data):
+        return EnvironmentCreateUpdate(**data)
+
+
+class EnvironmentCreationResponseSchema(BaseSchema):
+    id = fields.UUID(data_key="environmentId", required=True)
+
+    @post_load
+    def make_environment(self, data):
+        return EnvironmentCreationResponse(**data)
+
+
 class EnvironmentClient(BaseClient):
 
     SERVICE_NAME = "baskerville"
 
     def list(self, project_id):
         endpoint = "/project/{}/environment".format(project_id)
         return self._get(endpoint, EnvironmentSchema(many=True))
+
+    def get(self, project_id, environment_id):
+        endpoint = "/project/{}/environment/{}".format(
+            project_id, environment_id
+        )
+        return self._get(endpoint, EnvironmentSchema())
+
+    def update(
+        self, project_id, environment_id, name, specification, description=None
+    ):
+        content = EnvironmentCreateUpdate(
+            name=name, specification=specification, description=description
+        )
+        endpoint = "/project/{}/environment/{}".format(
+            project_id, environment_id
+        )
+        self._put_raw(
+            endpoint, json=EnvironmentCreateUpdateSchema().dump(content)
+        )
+
+    def create(self, project_id, name, specification, description=None):
+        endpoint = "/project/{}/environment".format(project_id)
+        content = EnvironmentCreateUpdate(
+            name=name, specification=specification, description=description
+        )
+        response = self._post(
+            endpoint,
+            EnvironmentCreationResponseSchema(),
+            json=EnvironmentCreateUpdateSchema().dump(content),
+        )
+        return response.id
+
+    def delete(self, project_id, environment_id):
+        endpoint = "/project/{}/environment/{}".format(
+            project_id, environment_id
+        )
+        self._delete_raw(endpoint)

tests/clients/test_environment.py

@@ -20,33 +20,362 @@
 from marshmallow import ValidationError
 
 from faculty.clients.environment import (
+    Apt,
+    AptPackage,
+    AptPackageSchema,
+    AptSchema,
+    Conda,
+    CondaSchema,
+    Constraint,
     Environment,
     EnvironmentClient,
+    EnvironmentCreateUpdate,
+    EnvironmentCreateUpdateSchema,
+    EnvironmentCreationResponse,
+    EnvironmentCreationResponseSchema,
     EnvironmentSchema,
+    Pip,
+    PipSchema,
+    PythonSpecification,
+    PythonPackage,
+    PythonPackageSchema,
+    PythonSpecificationSchema,
+    PythonEnvironment,
+    PythonEnvironmentSchema,
+    Script,
+    ScriptSchema,
+    Specification,
+    SpecificationSchema,
+    Version,
+    VersionSchema,
 )
 
+VERSION_BODY = {"constraint": "==", "identifier": "1.0.0"}
+VERSION = Version(constraint=Constraint.EQUAL, identifier="1.0.0")
+
+VERSION_BODY_LATEST = "latest"
+VERSION_LATEST = "latest"
+
+INVALID_VERSION_BODY = {"constraint": "==", "identifier": "invalid-identifier"}
+INVALID_VERSION = Version(
+    constraint=Constraint.EQUAL, identifier="invalid-identifier"
+)
+
+PYTHON_PACKAGE_BODY = {"name": "tensorflow", "version": VERSION_BODY}
+PYTHON_PACKAGE = PythonPackage(name="tensorflow", version=VERSION)
+
+PYTHON_PACKAGE_BODY_LATEST = {
+    "name": "tensorflow",
+    "version": VERSION_BODY_LATEST,
+}
+PYTHON_PACKAGE_LATEST = PythonPackage(
+    name="tensorflow", version=VERSION_LATEST
+)
+
+
+PIP_BODY = {
+    "extraIndexUrls": ["http://example.com/"],
+    "packages": [PYTHON_PACKAGE_BODY],
+}
+PIP = Pip(extra_index_urls=["http://example.com/"], packages=[PYTHON_PACKAGE])
+
+
+CONDA_BODY = {"channels": ["conda-forge"], "packages": [PYTHON_PACKAGE_BODY]}
+CONDA = Conda(channels=["conda-forge"], packages=[PYTHON_PACKAGE])
+
+PYTHON_ENVIRONMENT_BODY = {"pip": PIP_BODY, "conda": CONDA_BODY}
+PYTHON_ENVIRONMENT = PythonEnvironment(conda=CONDA, pip=PIP)
+
+APT_PACKAGE_BODY = {"name": "cuda"}
+APT_PACKAGE = AptPackage(name="cuda")
+
+APT_BODY = {"packages": [APT_PACKAGE_BODY]}
+APT = Apt(packages=[APT_PACKAGE])
+
+PYTHON_SPECIFICATION_BODY = {
+    "Python2": PYTHON_ENVIRONMENT_BODY,
+    "Python3": PYTHON_ENVIRONMENT_BODY,
+}
+PYTHON_SPECIFICATION = PythonSpecification(
+    python2=PYTHON_ENVIRONMENT, python3=PYTHON_ENVIRONMENT
+)
+
+PYTHON_SPECIFICATION_BODY_MISSING_PYTHON2 = {
+    "Python3": PYTHON_ENVIRONMENT_BODY
+}
+PYTHON_SPECIFICATION_BODY_PYTHON2_NONE = {
+    "Python2": None,
+    "Python3": PYTHON_ENVIRONMENT_BODY,
+}
+PYTHON_SPECIFICATION_PYTHON2_NONE = PythonSpecification(
+    python2=None, python3=PYTHON_ENVIRONMENT
+)
+
+PYTHON_SPECIFICATION_BODY_MISSING_PYTHON3 = {
+    "Python2": PYTHON_ENVIRONMENT_BODY
+}
+PYTHON_SPECIFICATION_BODY_PYTHON3_NONE = {
+    "Python2": PYTHON_ENVIRONMENT_BODY,
+    "Python3": None,
+}
+PYTHON_SPECIFICATION_PYTHON3_NONE = PythonSpecification(
+    python2=PYTHON_ENVIRONMENT, python3=None
+)
+
+PYTHON_SPECIFICATION_BODY_MISSING_KEYS = {}
+PYTHON_SPECIFICATION_BODY_NONE = {"Python2": None, "Python3": None}
+PYTHON_SPECIFICATION_NONE = PythonSpecification(python2=None, python3=None)
+
+SCRIPT_STR = "# Edit your script\n"
+SCRIPT_BODY = {"script": SCRIPT_STR}
+SCRIPT = Script(script=SCRIPT_STR)
+
+SPECIFICATION_BODY = {
+    "apt": APT_BODY,
+    "bash": [SCRIPT_BODY],
+    "python": PYTHON_SPECIFICATION_BODY,
+}
+SPECIFICATION = Specification(
+    apt=APT, bash=[SCRIPT], python=PYTHON_SPECIFICATION
+)
 
 PROJECT_ID = uuid.uuid4()
+ENVIRONMENT_ID = uuid.uuid4()
+AUTHOR_ID = uuid.uuid4()
+NAME = "Test environment"
+DESCRIPTION = "Environment description"
 
+ENVIRONMENT_BODY = {
+    "environmentId": str(ENVIRONMENT_ID),
+    "projectId": str(PROJECT_ID),
+    "name": NAME,
+    "description": DESCRIPTION,
+    "authorId": str(AUTHOR_ID),
+    "createdAt": "2018-10-03T04:20:00Z",
+    "updatedAt": "2018-11-03T04:21:15Z",
+    "specification": SPECIFICATION_BODY,
+}
 ENVIRONMENT = Environment(
-    id=uuid.uuid4(),
+    id=ENVIRONMENT_ID,
     project_id=PROJECT_ID,
-    name="Test Environment",
-    description="Environment description",
-    author_id=uuid.uuid4(),
+    name=NAME,
+    description=DESCRIPTION,
+    author_id=AUTHOR_ID,
     created_at=datetime.datetime(2018, 10, 3, 4, 20, 0, 0, tzinfo=UTC),
     updated_at=datetime.datetime(2018, 11, 3, 4, 21, 15, 0, tzinfo=UTC),
+    specification=SPECIFICATION,
 )
 
-ENVIRONMENT_BODY = {
-    "environmentId": str(ENVIRONMENT.id),
-    "projectId": str(PROJECT_ID),
-    "name": ENVIRONMENT.name,
-    "description": ENVIRONMENT.description,
-    "authorId": str(ENVIRONMENT.author_id),
-    "createdAt": "2018-10-03T04:20:00Z",
-    "updatedAt": "2018-11-03T04:21:15Z",
+ENVIRONMENT_CREATION_RESPONSE_BODY = {"environmentId": str(ENVIRONMENT_ID)}
+ENVIRONMENT_CREATION_RESPONSE = EnvironmentCreationResponse(id=ENVIRONMENT_ID)
+
+ENVIRONMENT_CREATE_UPDATE_BODY = {
+    "name": NAME,
+    "description": DESCRIPTION,
+    "specification": SPECIFICATION_BODY,
+}
+ENVIRONMENT_CREATE_UPDATE = EnvironmentCreateUpdate(
+    name=NAME, description=DESCRIPTION, specification=SPECIFICATION
+)
+ENVIRONMENT_CREATE_UPDATE_BODY_NO_DESCRIPTION = {
+    "name": NAME,
+    "description": None,
+    "specification": SPECIFICATION_BODY,
 }
+ENVIRONMENT_CREATE_UPDATE_NO_DESCRIPTION = EnvironmentCreateUpdate(
+    name=NAME, description=None, specification=SPECIFICATION
+)
+
+
+def test_version_schema_load():
+    data = VersionSchema().load(VERSION_BODY)
+    assert data == VERSION
+
+
+def test_version_schema_dump():
+    data = VersionSchema().dump(VERSION)
+    assert data == VERSION_BODY
+
+
+def test_version_schema_load_invalid():
+    with pytest.raises(ValidationError):
+        VersionSchema().load(INVALID_VERSION_BODY)
+
+
+def test_version_schema_dump_invalid():
+    with pytest.raises(ValidationError):
+        VersionSchema().dump(INVALID_VERSION)
+
+
+@pytest.mark.parametrize(
+    "body, expected",
+    [
+        (PYTHON_PACKAGE_BODY, PYTHON_PACKAGE),
+        (PYTHON_PACKAGE_BODY_LATEST, PYTHON_PACKAGE_LATEST),
+    ],
+)
+def test_python_package_schema_load(body, expected):
+    data = PythonPackageSchema().load(body)
+    assert data == expected
+
+
+@pytest.mark.parametrize(
+    "object, expected",
+    [
+        (PYTHON_PACKAGE, PYTHON_PACKAGE_BODY),
+        (PYTHON_PACKAGE_LATEST, PYTHON_PACKAGE_BODY_LATEST),
+    ],
+)
+def test_python_package_schema_dump(object, expected):
+    data = PythonPackageSchema().dump(object)
+    assert data == expected
+
+
+def test_pip_schema_load():
+    data = PipSchema().load(PIP_BODY)
+    assert data == PIP
+
+
+def test_pip_schema_dump():
+    data = PipSchema().dump(PIP)
+    assert data == PIP_BODY
+
+
+def test_conda_schema_load():
+    data = CondaSchema().load(CONDA_BODY)
+    assert data == CONDA
+
+
+def test_conda_schema_dump():
+    data = CondaSchema().dump(CONDA)
+    assert data == CONDA_BODY
+
+
+def test_python_environment_schema_load():
+    data = PythonEnvironmentSchema().load(PYTHON_ENVIRONMENT_BODY)
+    assert data == PYTHON_ENVIRONMENT
+
+
+def test_python_environment_schema_dump():
+    data = PythonEnvironmentSchema().dump(PYTHON_ENVIRONMENT)
+    assert data == PYTHON_ENVIRONMENT_BODY
+
+
+def test_apt_package_schema_load():
+    data = AptPackageSchema().load(APT_PACKAGE_BODY)
+    assert data == APT_PACKAGE
+
+
+def test_apt_package_schema_dump():
+    data = AptPackageSchema().dump(APT_PACKAGE)
+    assert data == APT_PACKAGE_BODY
+
+
+def test_apt_schema_load():
+    data = AptSchema().load(APT_BODY)
+    assert data == APT
+
+
+def test_apt_schema_dump():
+    data = AptSchema().dump(APT)
+    assert data == APT_BODY
+
+
+@pytest.mark.parametrize(
+    "body, expected",
+    [
+        (PYTHON_SPECIFICATION_BODY, PYTHON_SPECIFICATION),
+        (
+            PYTHON_SPECIFICATION_BODY_MISSING_PYTHON2,
+            PYTHON_SPECIFICATION_PYTHON2_NONE,
+        ),
+        (
+            PYTHON_SPECIFICATION_BODY_MISSING_PYTHON3,
+            PYTHON_SPECIFICATION_PYTHON3_NONE,
+        ),
+        (PYTHON_SPECIFICATION_BODY_MISSING_KEYS, PYTHON_SPECIFICATION_NONE),
+    ],
+)
+def test_python_specification_schema_load(body, expected):
+    data = PythonSpecificationSchema().load(body)
+    assert data == expected
+
+
+@pytest.mark.parametrize(
+    "object, expected",
+    [
+        (PYTHON_SPECIFICATION, PYTHON_SPECIFICATION_BODY),
+        (
+            PYTHON_SPECIFICATION_PYTHON2_NONE,
+            PYTHON_SPECIFICATION_BODY_PYTHON2_NONE,
+        ),
+        (
+            PYTHON_SPECIFICATION_PYTHON3_NONE,
+            PYTHON_SPECIFICATION_BODY_PYTHON3_NONE,
+        ),
+        (PYTHON_SPECIFICATION_NONE, PYTHON_SPECIFICATION_BODY_NONE),
+    ],
+)
+def test_python_specification_schema_dump(object, expected):
+    data = PythonSpecificationSchema().dump(object)
+    assert data == expected
+
+
+def test_script_schema_load():
+    data = ScriptSchema().load(SCRIPT_BODY)
+    assert data == SCRIPT
+
+
+def test_script_schema_dump():
+    data = ScriptSchema().dump(SCRIPT)
+    assert data == SCRIPT_BODY
+
+
+def test_specification_schema_load():
+    data = SpecificationSchema().load(SPECIFICATION_BODY)
+    assert data == SPECIFICATION
+
+
+def test_specification_schema_dump():
+    data = SpecificationSchema().dump(SPECIFICATION)
+    assert data == SPECIFICATION_BODY
+
+
+@pytest.mark.parametrize(
+    "body, expected",
+    [
+        (ENVIRONMENT_CREATE_UPDATE_BODY, ENVIRONMENT_CREATE_UPDATE),
+        (
+            ENVIRONMENT_CREATE_UPDATE_BODY_NO_DESCRIPTION,
+            ENVIRONMENT_CREATE_UPDATE_NO_DESCRIPTION,
+        ),
+    ],
+)
+def test_environment_create_update_schema_load(body, expected):
+    data = EnvironmentCreateUpdateSchema().load(body)
+    assert data == expected
+
+
+@pytest.mark.parametrize(
+    "object, expected",
+    [
+        (ENVIRONMENT_CREATE_UPDATE, ENVIRONMENT_CREATE_UPDATE_BODY),
+        (
+            ENVIRONMENT_CREATE_UPDATE_NO_DESCRIPTION,
+            ENVIRONMENT_CREATE_UPDATE_BODY_NO_DESCRIPTION,
+        ),
+    ],
+)
+def test_environment_create_update_schema_dump(object, expected):
+    data = EnvironmentCreateUpdateSchema().dump(object)
+    assert data == expected
+
+
+def test_environment_creation_response_schema():
+    data = EnvironmentCreationResponseSchema().load(
+        ENVIRONMENT_CREATION_RESPONSE_BODY
+    )
+    assert data == ENVIRONMENT_CREATION_RESPONSE
 
 
 def test_environment_schema():
@@ -70,3 +399,76 @@ def test_environment_client_list(mocker):
     EnvironmentClient._get.assert_called_once_with(
         "/project/{}/environment".format(PROJECT_ID), schema_mock.return_value
     )
+
+
+def test_environment_client_get(mocker):
+    mocker.patch.object(EnvironmentClient, "_get", return_value=ENVIRONMENT)
+    schema_mock = mocker.patch("faculty.clients.environment.EnvironmentSchema")
+
+    client = EnvironmentClient(mocker.Mock())
+    assert client.get(PROJECT_ID, ENVIRONMENT_ID) == ENVIRONMENT
+
+    schema_mock.assert_called_once_with()
+    EnvironmentClient._get.assert_called_once_with(
+        "/project/{}/environment/{}".format(PROJECT_ID, ENVIRONMENT_ID),
+        schema_mock.return_value,
+    )
+
+
+def test_environment_client_update(mocker):
+    mocker.patch.object(EnvironmentClient, "_put_raw")
+    mocker.patch.object(
+        EnvironmentCreateUpdateSchema,
+        "dump",
+        return_value=ENVIRONMENT_CREATE_UPDATE_BODY,
+    )
+
+    client = EnvironmentClient(mocker.Mock())
+    client.update(PROJECT_ID, ENVIRONMENT_ID, NAME, SPECIFICATION, DESCRIPTION)
+
+    EnvironmentCreateUpdateSchema.dump.assert_called_once_with(
+        ENVIRONMENT_CREATE_UPDATE
+    )
+    EnvironmentClient._put_raw.assert_called_once_with(
+        "/project/{}/environment/{}".format(PROJECT_ID, ENVIRONMENT_ID),
+        json=ENVIRONMENT_CREATE_UPDATE_BODY,
+    )
+
+
+def test_environment_client_create(mocker):
+    mocker.patch.object(
+        EnvironmentClient, "_post", return_value=ENVIRONMENT_CREATION_RESPONSE
+    )
+    mocker.patch.object(
+        EnvironmentCreateUpdateSchema,
+        "dump",
+        return_value=ENVIRONMENT_CREATE_UPDATE_BODY,
+    )
+    schema_mock = mocker.patch(
+        "faculty.clients.environment.EnvironmentCreationResponseSchema"
+    )
+
+    client = EnvironmentClient(mocker.Mock())
+    assert (
+        client.create(PROJECT_ID, NAME, SPECIFICATION, description=DESCRIPTION)
+        == ENVIRONMENT_CREATION_RESPONSE.id
+    )
+    EnvironmentCreateUpdateSchema.dump.assert_called_once_with(
+        ENVIRONMENT_CREATE_UPDATE
+    )
+    EnvironmentClient._post.assert_called_once_with(
+        "/project/{}/environment".format(PROJECT_ID),
+        schema_mock.return_value,
+        json=ENVIRONMENT_CREATE_UPDATE_BODY,
+    )
+
+
+def test_environment_client_delete(mocker):
+    mocker.patch.object(EnvironmentClient, "_delete_raw", return_value=None)
+
+    client = EnvironmentClient(mocker.Mock())
+    client.delete(PROJECT_ID, ENVIRONMENT_ID)
+
+    EnvironmentClient._delete_raw.assert_called_once_with(
+        "/project/{}/environment/{}".format(PROJECT_ID, ENVIRONMENT_ID)
+    )