def testupdate_name_v2(self, mock_request):
mock_v3_get = Path("tests/fixtures/responses/secrets/v3/get.json")
mock_v2_update_name = Path(
"tests/fixtures/responses/secrets/v2/update_name.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v3_get.open().read())),
MockResponse(
response=json.loads(mock_v2_update_name.open().read())),
]
secret = vercel.Secret.get("test-secret")
secret.update_name(name="new-name")
assert [
call(
method="GET",
url="https://api.vercel.com/v3/now/secrets/test-secret",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="PATCH",
url="https://api.vercel.com/v2/now/secrets/secret-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
json={"name": "new-name"},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_delete_v1(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/projects/v1/get.json")
mock_v1_delete = Path(
"tests/fixtures/responses/projects/v1/delete.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v1_get.open().read())),
MockResponse(response=json.loads(mock_v1_delete.open().read())),
]
project = vercel.Project.get("test-project")
project.delete()
assert [
call(
method="GET",
url="https://api.vercel.com/v1/projects/test-project",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="DELETE",
url="https://api.vercel.com/v1/projects/project-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_add_domain_v1(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/projects/v1/get.json")
mock_v1_add_domain = Path(
"tests/fixtures/responses/projects/v1/add_domain.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v1_get.open().read())),
MockResponse(
response=json.loads(mock_v1_add_domain.open().read())),
]
project = vercel.Project.get("test-project")
project.add_domain("foobar.com")
assert [
call(
method="GET",
url="https://api.vercel.com/v1/projects/test-project",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="POST",
url="https://api.vercel.com/v1/projects/project-id/alias",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
json={"domain": "foobar.com"},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_purchase_v4(self, mock_request):
mock_v4_check_price = Path(
"tests/fixtures/responses/domains/v4/check_price.json"
)
mock_v4_purchase = Path("tests/fixtures/responses/domains/v4/purchase.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v4_check_price.open().read())),
MockResponse(response=json.loads(mock_v4_purchase.open().read())),
]
checked = vercel.Domain.check_price("test.com")
checked.purchase()
assert [
call(
method="GET",
url="https://api.vercel.com/v4/domains/price",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id", "name": "test.com"},
),
call(
method="POST",
url="https://api.vercel.com/v4/domains/buy",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
json={"name": "test.com", "expectedPrice": 17},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_list_aliases_with_project_filter_v3(self, mock_request):
mock_v3_list_one = json.loads(
Path("tests/fixtures/responses/aliases/v3/list_1.json").open().
read())
mock_v3_list_two = json.loads(
Path("tests/fixtures/responses/aliases/v3/list_2.json").open().
read())
mock_v3_list_three = json.loads(
Path("tests/fixtures/responses/aliases/v3/list_3.json").open().
read())
mock_request.side_effect = [
MockResponse(mock_v3_list_one),
MockResponse(mock_v3_list_two),
MockResponse(mock_v3_list_three),
]
aliases = vercel.Alias.list_all(project_id="test-project")
assert len(aliases) == 6
assert mock_request.mock_calls == [
call(
url="https://api.vercel.com/v3/now/aliases",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"projectId": "test-project"
},
),
call(
url="https://api.vercel.com/v3/now/aliases",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"projectId": "test-project",
"since": 1464807790001,
},
),
call(
url="https://api.vercel.com/v3/now/aliases",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"projectId": "test-project",
"since": 1464807790002,
},
),
]
def test_create_dns_record_v2(self, mock_request):
mock_v4_get = Path("tests/fixtures/responses/domains/v4/get.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v4_get.open().read())),
MockResponse(response={"uid": "fake-record-id"}),
]
domain = vercel.Domain.get("example.com")
record = domain.create_dns_record(name="", type="TXT", value="something")
assert isinstance(record, vercel.DnsRecord)
assert [
call(
method="GET",
url="https://api.vercel.com/v4/domains/example.com",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="POST",
url="https://api.vercel.com/v2/domains/example.com/records",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
json={"name": "", "type": "TXT", "value": "something"},
),
] == mock_request.mock_calls
def test_delete_v4(self, mock_request):
mock_v4_get = Path("tests/fixtures/responses/domains/v4/get.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v4_get.open().read())),
MockResponse(response={}, status_code=204),
]
domain = vercel.Domain.get("example.com")
domain.delete()
assert [
call(
method="GET",
url="https://api.vercel.com/v4/domains/example.com",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="DELETE",
url="https://api.vercel.com/v4/domains/example.com",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_get_dns_record_v2(self, mock_request):
mock_v4_get = Path("tests/fixtures/responses/domains/v4/get.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v4_get.open().read())),
MockResponse(response={"uid": "fake-record-id"}),
]
domain = vercel.Domain.get("example.com")
record = domain.get_dns_record("fake-record-id")
assert isinstance(record, vercel.DnsRecord)
assert record.domain_name == "example.com"
assert record.id == "fake-record-id"
assert [
call(
method="GET",
url="https://api.vercel.com/v4/domains/example.com",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
)
] == mock_request.mock_calls
def test_cancel_v12(self, mock_request):
mock_v11_get = Path(
"tests/fixtures/responses/deployments/v11/get.json")
mock_v12_cancel = Path(
"tests/fixtures/responses/deployments/v12/cancel.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v11_get.open().read())),
MockResponse(response=json.loads(mock_v12_cancel.open().read())),
]
deployment = vercel.Deployment.get("deployment-id")
deployment.cancel()
assert [
call(
method="GET",
url="https://api.vercel.com/v11/now/deployments/deployment-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="PATCH",
url=
"https://api.vercel.com/v12/now/deployments/deployment-id/cancel",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_list_secrets_v3(self, mock_request):
mock_v3_list_one = json.loads(
Path("tests/fixtures/responses/secrets/v3/list_1.json").open().
read())
mock_v3_list_two = json.loads(
Path("tests/fixtures/responses/secrets/v3/list_2.json").open().
read())
mock_v3_list_three = json.loads(
Path("tests/fixtures/responses/secrets/v3/list_3.json").open().
read())
mock_request.side_effect = [
MockResponse(mock_v3_list_one),
MockResponse(mock_v3_list_two),
MockResponse(mock_v3_list_three),
]
secrets = vercel.Secret.list_all()
assert len(secrets) == 6
assert mock_request.mock_calls == [
call(
url="https://api.vercel.com/v3/now/secrets",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
url="https://api.vercel.com/v3/now/secrets",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"since": 1472684630000
},
),
call(
url="https://api.vercel.com/v3/now/secrets",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"since": 1472684630001
},
),
]
def test_list_all_v1(self, mock_request):
mock_v4_list_one = json.loads(
Path("tests/fixtures/responses/projects/v4/list_1.json").open().
read())
mock_v4_list_two = json.loads(
Path("tests/fixtures/responses/projects/v4/list_2.json").open().
read())
mock_v4_list_three = json.loads(
Path("tests/fixtures/responses/projects/v4/list_3.json").open().
read())
mock_request.side_effect = [
MockResponse(mock_v4_list_one),
MockResponse(mock_v4_list_two),
MockResponse(mock_v4_list_three),
]
projects = vercel.Project.list_all()
assert len(projects) == 6
assert mock_request.mock_calls == [
call(
url="https://api.vercel.com/v4/projects",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
url="https://api.vercel.com/v4/projects",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"since": 1555072968396
},
),
call(
url="https://api.vercel.com/v4/projects",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"since": 1555072968397
},
),
]
def test_list_records_v4(self, mock_request):
mock_v4_list_one = json.loads(
Path("tests/fixtures/responses/dns/v4/list_1.json").open().read())
mock_v4_list_two = json.loads(
Path("tests/fixtures/responses/dns/v4/list_2.json").open().read())
mock_v4_list_three = json.loads(
Path("tests/fixtures/responses/dns/v4/list_3.json").open().read())
mock_request.side_effect = [
MockResponse(mock_v4_list_one),
MockResponse(mock_v4_list_two),
MockResponse(mock_v4_list_three),
]
records = vercel.DnsRecord.list_records("my-domain")
assert len(records) == 6
assert mock_request.mock_calls == [
call(
url="https://api.vercel.com/v4/domains/my-domain/records",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
url="https://api.vercel.com/v4/domains/my-domain/records",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"since": 1474631619961
},
),
call(
url="https://api.vercel.com/v4/domains/my-domain/records",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"since": 1474631619962
},
),
]
def test_get_v3(self, mock_request):
mock_v3_get = Path("tests/fixtures/responses/certificates/v3/get.json")
mock_request.return_value = MockResponse(
response=json.loads(mock_v3_get.open().read()))
cert = vercel.Certificate.get("certificate-id")
assert isinstance(cert, vercel.Certificate)
assert cert.id == "certificate-id"
assert cert.cns == ["wow.example.com"]
assert cert.created == "2016-08-23T18:13:09.773Z"
assert cert.expiration == "2016-12-16T16:00:00.000Z"
assert cert.auto_renew == True
assert [
call(
method="GET",
url="https://api.vercel.com/v3/now/certs/certificate-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
)
] == mock_request.mock_calls
def test_delete_v3(self, mock_request):
mock_v3_get = Path("tests/fixtures/responses/certificates/v3/get.json")
mock_request.return_value = MockResponse(
response=json.loads(mock_v3_get.open().read()))
team = vercel.Certificate.get("certificate-id")
team.delete()
assert [
call(
method="GET",
url="https://api.vercel.com/v3/now/certs/certificate-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="DELETE",
url="https://api.vercel.com/v3/now/certs/certificate-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_create_record(self, mock_request):
mock_request.return_value = MockResponse(
response={"uid": "fake-record-id"})
record = vercel.DnsRecord.create(domain_name="test.com",
name="",
type="TXT",
value="something")
assert isinstance(record, vercel.DnsRecord)
assert [
call(
method="POST",
url="https://api.vercel.com/v2/domains/test.com/records",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
json={
"name": "",
"type": "TXT",
"value": "something"
},
)
] == mock_request.mock_calls
def test_update_v1(self, mock_request):
mock_v4_get = Path("tests/fixtures/responses/teams/v1/get.json")
mock_request.return_value = MockResponse(
response=json.loads(mock_v4_get.open().read()))
team = vercel.Team.get("my-team")
team.update(slug="new-slug", name="New Name")
assert [
call(
method="GET",
url="https://api.vercel.com/v1/teams",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"slug": "my-team"
},
),
call(
method="PATCH",
url="https://api.vercel.com/v1/teams/team-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
json={
"slug": "new-slug",
"name": "New Name"
},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_make_request_raises_vercel_error(self, mock_request):
mock_request.side_effect = [
MockResponse(
{"error": {
"code": "error_code",
"message": "Error Message"
}})
]
with pytest.raises(vercel.exceptions.VercelError) as e:
result = vercel.Resource._make_request(
url="/",
method="GET",
headers={"Content-Type": "application-json"},
params={"teamId": "team-id"},
)
assert e.code == "error_code"
assert e.message == "Error Message"
assert mock_request.mock_calls == [
call(
url="/",
method="GET",
headers={"Content-Type": "application-json"},
params={"teamId": "team-id"},
)
]
def test_get_with_id_v1(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/teams/v1/get.json")
mock_request.return_value = MockResponse(
response=json.loads(mock_v1_get.open().read()))
team = vercel.Team.get(id="team-id")
assert isinstance(team, vercel.Team)
assert team.name == "My Team"
assert team.id == "team-id"
assert team.slug == "my-team"
assert team.creator_id == "creator-id"
assert team.created == "2017-04-29T17:21:54.514Z"
assert team.avatar == None
assert mock_request.mock_calls == [
call(
method="GET",
url="https://api.vercel.com/v1/teams/team-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
)
]
def test_make_request_honors_headers_and_params(self, mock_request):
mock_request.side_effect = [MockResponse({})]
result = vercel.Resource.make_request(
method="GET",
resource="/v2/domains",
headers={"Something": "value"},
params={"Another": False},
)
assert result == {}
assert mock_request.mock_calls == [
call(
url="https://api.vercel.com/v2/domains",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
"Something": "value",
},
params={
"teamId": "fake-team-id",
"Another": False
},
)
]
def test_create_env_var_v4(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/projects/v1/get.json")
mock_v4_create_env_var = Path(
"tests/fixtures/responses/projects/v4/create_env_var.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v1_get.open().read())),
MockResponse(
response=json.loads(mock_v4_create_env_var.open().read())),
]
project = vercel.Project.get("test-project")
project.create_environment_variable(key="my-var",
value="@my-secret",
target="production")
assert [
call(
method="GET",
url="https://api.vercel.com/v1/projects/test-project",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
method="POST",
url="https://api.vercel.com/v4/projects/project-id/env",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
json={
"key": "my-var",
"value": "@my-secret",
"target": "production"
},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_invite_user_v1(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/teams/v1/get.json")
mock_v1_invite_user = Path(
"tests/fixtures/responses/teams/v1/invite_user.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v1_get.open().read())),
MockResponse(
response=json.loads(mock_v1_invite_user.open().read())),
]
team = vercel.Team.get("my-team")
team.invite_user(email="*****@*****.**", role="MEMBER")
assert mock_request.mock_calls == [
call(
method="GET",
url="https://api.vercel.com/v1/teams",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"slug": "my-team"
},
),
call(
method="POST",
url="https://api.vercel.com/v1/teams/team-id/members",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
json={
"email": "*****@*****.**",
"role": "MEMBER"
},
),
]
def test_get_v4(self, mock_request):
mock_v4_get = Path("tests/fixtures/responses/domains/v4/get.json")
mock_request.return_value = MockResponse(
response=json.loads(mock_v4_get.open().read())
)
domain = vercel.Domain.get("example.com")
assert isinstance(domain, vercel.Domain)
assert domain.name == "example.com"
assert domain.id == "domain-id"
assert domain.service_type == "external"
assert domain.ns_verified_at == None
assert domain.txt_verified_at == None
assert domain.cdn_enabled == False
assert domain.created_at == 1544658552174
assert domain.bought_at == None
assert domain.transferred_at == None
assert domain.verification_record == "verification-id"
assert domain.verified == False
assert domain.nameservers == ["ns1.nameserver.net", "ns2.nameserver.net"]
assert domain.intended_nameservers == [
"a.zeit-world.co.uk",
"c.zeit-world.org",
"d.zeit-world.com",
"f.zeit-world.net",
]
creator = domain.creator
assert isinstance(creator, vercel.Creator)
assert creator.id == "creator-id"
assert creator.username == "zeit_user"
assert creator.email == "*****@*****.**"
assert domain.suffix == False
assert domain.aliases == []
assert domain.certs == []
assert [
call(
method="GET",
url="https://api.vercel.com/v4/domains/example.com",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
)
] == mock_request.mock_calls
def test_list_members_v2(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/teams/v1/get.json")
mock_v2_list_members = json.loads(
Path("tests/fixtures/responses/teams/v2/list_members.json").open().
read())
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v1_get.open().read())),
MockResponse(mock_v2_list_members),
]
team = vercel.Team.get("team-id")
members = team.list_members()
assert len(members) == 2
assert mock_request.mock_calls == [
call(
method="GET",
url="https://api.vercel.com/v1/teams",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"slug": "team-id"
},
),
call(
url="https://api.vercel.com/v2/teams/team-id/members",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
]
def test_list_aliases_v2(self, mock_request):
mock_v11_get = Path(
"tests/fixtures/responses/deployments/v11/get.json")
mock_v2_list_one = json.loads(
Path("tests/fixtures/responses/deployments/v2/list_1.json").open().
read())
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v11_get.open().read())),
MockResponse(mock_v2_list_one),
]
deployment = vercel.Deployment.get("deployment-id")
aliases = deployment.list_aliases()
assert len(aliases) == 1
assert mock_request.mock_calls == [
call(
url="https://api.vercel.com/v11/now/deployments/deployment-id",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
call(
url=
"https://api.vercel.com/v2/now/deployments/deployment-id/aliases",
method="GET",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
]
def test_request_to_join_v1(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/teams/v1/get.json")
mock_v1_request_to_join = Path(
"tests/fixtures/responses/teams/v1/request_to_join.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v1_get.open().read())),
MockResponse(
response=json.loads(mock_v1_request_to_join.open().read())),
]
team = vercel.Team.get("my-team")
team.request_to_join(origin="import")
assert [
call(
method="GET",
url="https://api.vercel.com/v1/teams",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"slug": "my-team"
},
),
call(
method="POST",
url="https://api.vercel.com/v1/teams/team-id/request",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
json={"origin": "import"},
),
] == mock_request.mock_calls
def test_remove_user_v1(self, mock_request):
mock_v1_get = Path("tests/fixtures/responses/teams/v1/get.json")
mock_v1_remove_user = Path(
"tests/fixtures/responses/teams/v1/remove_user.json")
mock_request.side_effect = [
MockResponse(response=json.loads(mock_v1_get.open().read())),
MockResponse(
response=json.loads(mock_v1_remove_user.open().read())),
]
team = vercel.Team.get("my-team")
team.remove_user("user-id")
assert [
call(
method="GET",
url="https://api.vercel.com/v1/teams",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={
"teamId": "fake-team-id",
"slug": "my-team"
},
),
call(
method="DELETE",
url="https://api.vercel.com/v1/teams/team-id/members/user-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
),
] == mock_request.mock_calls
def test_delete_record(self, mock_request):
mock_request.return_value = MockResponse(response={})
record = vercel.DnsRecord.delete("test.com", "fake-record-id")
assert [
call(
method="DELETE",
url=
"https://api.vercel.com/v2/domains/test.com/records/fake-record-id",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
)
] == mock_request.mock_calls
def test_create_v3(self, mock_request):
mock_request.return_value = MockResponse(response={})
vercel.Certificate.create(["test.com"])
assert [
call(
method="POST",
url="https://api.vercel.com/v3/now/certs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
json={"domains": ["test.com"]},
params={"teamId": "fake-team-id"},
)
] == mock_request.mock_calls
def test_create_v1(self, mock_request):
mock_v1_create = Path(
"tests/fixtures/responses/projects/v1/create.json")
mock_request.return_value = MockResponse(
response=json.loads(mock_v1_create.open().read()))
project = vercel.Project.create("test-project")
assert isinstance(project, vercel.Project)
# Verify Project Properties
assert project.id == "project-id"
assert project.name == "test-project"
assert 1 == len(project.aliases)
alias = project.aliases[0]
assert isinstance(alias, vercel.ProjectAlias)
# Verify Alias Properties
assert alias.domain == "test-project.now.sh"
assert alias.target == "PRODUCTION"
assert alias.created_at == 1555413045188
assert alias.configured_by == "A"
assert alias.configured_changed_at == 1555413045188
assert project.account_id == "account-id"
assert project.updated_at == 1555413045188
assert project.created_at == 1555413045188
assert project.production_deployment == None
assert 0 == len(project.latest_deployments)
assert project.production_deployment == None
assert [
call(
method="POST",
url="https://api.vercel.com/v1/projects",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
json={"name": "test-project"},
)
] == mock_request.mock_calls
def test_get(self, mock_request):
mock_get = Path("tests/fixtures/responses/user/get.json")
mock_request.return_value = MockResponse(
response=json.loads(mock_get.open().read())
)
user = vercel.User.get()
assert [
call(
method="GET",
url="https://api.vercel.com/www/user",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer fake-api-token",
},
params={"teamId": "fake-team-id"},
)
] == mock_request.mock_calls
