import { expect } from "chai";

import * as nock from "nock";

import { identityOrigin, hostingApiOrigin } from "../api";

import { FirebaseError } from "../error";

import * as hostingApi from "./api";

const TEST_CHANNELS_RESPONSE = {

channels: [

// domain exists in TEST_GET_DOMAINS_RESPONSE

{ url: "https://my-site--ch1-4iyrl1uo.web.app" },

// domain does not exist in TEST_GET_DOMAINS_RESPONSE

// we assume this domain was manually removed by

// the user from the identity api

{ url: "https://my-site--ch2-ygd8582v.web.app" },

],

};

const TEST_GET_DOMAINS_RESPONSE = {

authorizedDomains: [

"localhost",

"randomurl.com",

"my-site--ch1-4iyrl1uo.web.app",

// domain that should be removed

"my-site--expiredchannel-difhyc76.web.app",

],

};

const EXPECTED_DOMAINS_RESPONSE = ["localhost", "randomurl.com", "my-site--ch1-4iyrl1uo.web.app"];

const PROJECT_ID = "test-project";

const SITE = "my-site";

const SITE_DOMAINS_API = `/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/domains`;

// reuse domains from EXPECTED_DOMAINS_RESPONSE

const GET_SITE_DOMAINS_BODY = EXPECTED_DOMAINS_RESPONSE.map((domain) => ({

site: `projects/${PROJECT_ID}/sites/${SITE}`,

domainName: domain,

updateTime: "2023-01-11T15:28:08.980038900Z",

provisioning: [

{

certStatus: "CERT_ACTIVE",

dnsStatus: "DNS_MATCH",

expectedIps: ["0.0.0.0"],

},

],

status: "DOMAIN_ACTIVE",

}));

describe("hosting", () => {

describe("getChannel", () => {

afterEach(nock.cleanAll);

it("should make the API request for a channel", async () => {

const CHANNEL_ID = "my-channel";

const CHANNEL = { name: "my-channel" };

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`)

.reply(200, CHANNEL);

const res = await hostingApi.getChannel(PROJECT_ID, SITE, CHANNEL_ID);

expect(res).to.deep.equal({ name: "my-channel" });

expect(nock.isDone()).to.be.true;

});

it("should return null if there's no channel", async () => {

const CHANNEL_ID = "my-channel";

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`)

.reply(404, {});

const res = await hostingApi.getChannel(PROJECT_ID, SITE, CHANNEL_ID);

expect(res).to.deep.equal(null);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const CHANNEL_ID = "my-channel";

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`)

.reply(500, { error: "server boo-boo" });

await expect(

hostingApi.getChannel(PROJECT_ID, SITE, CHANNEL_ID),

).to.eventually.be.rejectedWith(FirebaseError, /server boo-boo/);

expect(nock.isDone()).to.be.true;

});

});

describe("listChannels", () => {

afterEach(nock.cleanAll);

it("should make a single API requests to list a small number of channels", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query({ pageToken: "", pageSize: 10 })

.reply(200, { channels: [{ name: "channel01" }] });

const res = await hostingApi.listChannels(PROJECT_ID, SITE);

expect(res).to.deep.equal([{ name: "channel01" }]);

expect(nock.isDone()).to.be.true;

});

it("should return 0 channels if none are returned", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query({ pageToken: "", pageSize: 10 })

.reply(200, {});

const res = await hostingApi.listChannels(PROJECT_ID, SITE);

expect(res).to.deep.equal([]);

expect(nock.isDone()).to.be.true;

});

it("should make multiple API requests to list channels", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query({ pageToken: "", pageSize: 10 })

.reply(200, { channels: [{ name: "channel01" }], nextPageToken: "02" });

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query({ pageToken: "02", pageSize: 10 })

.reply(200, { channels: [{ name: "channel02" }] });

const res = await hostingApi.listChannels(PROJECT_ID, SITE);

expect(res).to.deep.equal([{ name: "channel01" }, { name: "channel02" }]);

expect(nock.isDone()).to.be.true;

});

it("should return an error if there's no channel", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query({ pageToken: "", pageSize: 10 })

.reply(404, {});

await expect(hostingApi.listChannels(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/could not find channels/,

);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query({ pageToken: "", pageSize: 10 })

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.listChannels(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("createChannel", () => {

afterEach(nock.cleanAll);

it("should make the API request to create a channel", async () => {

const CHANNEL_ID = "my-channel";

const CHANNEL = { name: "my-channel" };

nock(hostingApiOrigin())

.post(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`, { ttl: "604800s" })

.query({ channelId: CHANNEL_ID })

.reply(201, CHANNEL);

const res = await hostingApi.createChannel(PROJECT_ID, SITE, CHANNEL_ID);

expect(res).to.deep.equal(CHANNEL);

expect(nock.isDone()).to.be.true;

});

it("should let us customize the TTL", async () => {

const CHANNEL_ID = "my-channel";

const CHANNEL = { name: "my-channel" };

const TTL = "60s";

nock(hostingApiOrigin())

.post(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`, { ttl: TTL })

.query({ channelId: CHANNEL_ID })

.reply(201, CHANNEL);

const res = await hostingApi.createChannel(PROJECT_ID, SITE, CHANNEL_ID, 60_000);

expect(res).to.deep.equal(CHANNEL);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const CHANNEL_ID = "my-channel";

nock(hostingApiOrigin())

.post(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`, { ttl: "604800s" })

.query({ channelId: CHANNEL_ID })

.reply(500, { error: "server boo-boo" });

await expect(

hostingApi.createChannel(PROJECT_ID, SITE, CHANNEL_ID),

).to.eventually.be.rejectedWith(FirebaseError, /server boo-boo/);

expect(nock.isDone()).to.be.true;

});

});

describe("updateChannelTtl", () => {

afterEach(nock.cleanAll);

it("should make the API request to update a channel", async () => {

const CHANNEL_ID = "my-channel";

const CHANNEL = { name: "my-channel" };

nock(hostingApiOrigin())

.patch(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`, {

ttl: "604800s",

})

.query({ updateMask: "ttl" })

.reply(201, CHANNEL);

const res = await hostingApi.updateChannelTtl(PROJECT_ID, SITE, CHANNEL_ID);

expect(res).to.deep.equal(CHANNEL);

expect(nock.isDone()).to.be.true;

});

it("should let us customize the TTL", async () => {

const CHANNEL_ID = "my-channel";

const CHANNEL = { name: "my-channel" };

const TTL = "60s";

nock(hostingApiOrigin())

.patch(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`, { ttl: TTL })

.query({ updateMask: "ttl" })

.reply(201, CHANNEL);

const res = await hostingApi.updateChannelTtl(PROJECT_ID, SITE, CHANNEL_ID, 60_000);

expect(res).to.deep.equal(CHANNEL);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const CHANNEL_ID = "my-channel";

nock(hostingApiOrigin())

.patch(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`, {

ttl: "604800s",

})

.query({ updateMask: "ttl" })

.reply(500, { error: "server boo-boo" });

await expect(

hostingApi.updateChannelTtl(PROJECT_ID, SITE, CHANNEL_ID),

).to.eventually.be.rejectedWith(FirebaseError, /server boo-boo/);

expect(nock.isDone()).to.be.true;

});

});

describe("deleteChannel", () => {

afterEach(nock.cleanAll);

it("should make the API request to delete a channel", async () => {

const CHANNEL_ID = "my-channel";

const CHANNEL = { name: "my-channel" };

nock(hostingApiOrigin())

.delete(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`)

.reply(204, CHANNEL);

const res = await hostingApi.deleteChannel(PROJECT_ID, SITE, CHANNEL_ID);

expect(res).to.be.undefined;

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const CHANNEL_ID = "my-channel";

nock(hostingApiOrigin())

.delete(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${CHANNEL_ID}`)

.reply(500, { error: "server boo-boo" });

await expect(

hostingApi.deleteChannel(PROJECT_ID, SITE, CHANNEL_ID),

).to.eventually.be.rejectedWith(FirebaseError, /server boo-boo/);

expect(nock.isDone()).to.be.true;

});

});

describe("createVersion", () => {

afterEach(nock.cleanAll);

it("should make the API requests to create a version", async () => {

const VERSION = { status: "CREATED" } as const;

const FULL_NAME = `projects/-/sites/${SITE}/versions/my-new-version`;

nock(hostingApiOrigin())

.post(`/v1beta1/projects/-/sites/${SITE}/versions`, VERSION)

.reply(200, { name: FULL_NAME });

const res = await hostingApi.createVersion(SITE, VERSION);

expect(res).to.deep.equal(FULL_NAME);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const VERSION = { status: "CREATED" } as const;

nock(hostingApiOrigin())

.post(`/v1beta1/projects/-/sites/${SITE}/versions`, VERSION)

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.createVersion(SITE, VERSION)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("updateVersion", () => {

afterEach(nock.cleanAll);

it("should make the API requests to update a version", async () => {

const VERSION = { status: "FINALIZED" } as const;

nock(hostingApiOrigin())

.patch(`/v1beta1/projects/-/sites/${SITE}/versions/my-version`, VERSION)

.query({ updateMask: "status" })

.reply(200, VERSION);

const res = await hostingApi.updateVersion(SITE, "my-version", VERSION);

expect(res).to.deep.equal(VERSION);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const VERSION = { status: "FINALIZED" } as const;

nock(hostingApiOrigin())

.patch(`/v1beta1/projects/-/sites/${SITE}/versions/my-version`, VERSION)

.query({ updateMask: "status" })

.reply(500, { error: "server boo-boo" });

await expect(

hostingApi.updateVersion(SITE, "my-version", VERSION),

).to.eventually.be.rejectedWith(FirebaseError, /server boo-boo/);

expect(nock.isDone()).to.be.true;

});

});

describe("listVersions", () => {

afterEach(nock.cleanAll);

const VERSION_1: hostingApi.Version = {

name: `projects/-/sites/${SITE}/versions/v1`,

status: "FINALIZED",

config: {},

createTime: "now",

createUser: {

email: "inlined@google.com",

},

fileCount: 0,

versionBytes: 0,

};

const VERSION_2 = {

...VERSION_1,

name: `projects/-/sites/${SITE}/versions/v2`,

};

it("returns no versions if no versions are returned", async () => {

nock(hostingApiOrigin()).get(`/v1beta1/projects/-/sites/${SITE}/versions`).reply(200, {});

nock(hostingApiOrigin());

const versions = await hostingApi.listVersions(SITE);

expect(versions).deep.equals([]);

expect(nock.isDone()).to.be.true;

});

it("returns a single page of versions", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/-/sites/${SITE}/versions`)

.reply(200, { versions: [VERSION_1] });

nock(hostingApiOrigin());

const versions = await hostingApi.listVersions(SITE);

expect(versions).deep.equals([VERSION_1]);

expect(nock.isDone()).to.be.true;

});

it("paginates through many versions", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/-/sites/${SITE}/versions`)

.reply(200, { versions: [VERSION_1], nextPageToken: "page2" });

nock(hostingApiOrigin())

.get(`/v1beta1/projects/-/sites/${SITE}/versions?pageToken=page2`)

.reply(200, { versions: [VERSION_2] });

const versions = await hostingApi.listVersions(SITE);

expect(versions).deep.equals([VERSION_1, VERSION_2]);

expect(nock.isDone()).to.be.true;

});

it("handles errors", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/-/sites/${SITE}/versions`)

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.listVersions(SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("cloneVersion", () => {

afterEach(nock.cleanAll);

it("should make the API requests to clone a version", async () => {

const SOURCE_VERSION = "my-version";

const VERSION = { name: "my-new-version" };

nock(hostingApiOrigin())

.post(`/v1beta1/projects/-/sites/${SITE}/versions:clone`, {

sourceVersion: SOURCE_VERSION,

finalize: false,

})

.reply(200, { name: `projects/${PROJECT_ID}/operations/op` });

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/operations/op`)

.reply(200, {

name: `projects/${PROJECT_ID}/operations/op`,

done: true,

response: VERSION,

});

const res = await hostingApi.cloneVersion(SITE, SOURCE_VERSION);

expect(res).to.deep.equal(VERSION);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const SOURCE_VERSION = "my-version";

nock(hostingApiOrigin())

.post(`/v1beta1/projects/-/sites/${SITE}/versions:clone`, {

sourceVersion: SOURCE_VERSION,

finalize: false,

})

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.cloneVersion(SITE, SOURCE_VERSION)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("createRelease", () => {

afterEach(nock.cleanAll);

it("should make the API request to create a release", async () => {

const CHANNEL_ID = "my-channel";

const RELEASE = { name: "my-new-release" };

const VERSION = "version";

const VERSION_NAME = `sites/${SITE}/versions/${VERSION}`;

nock(hostingApiOrigin())

.post(`/v1beta1/projects/-/sites/${SITE}/channels/${CHANNEL_ID}/releases`)

.query({ versionName: VERSION_NAME })

.reply(201, RELEASE);

const res = await hostingApi.createRelease(SITE, CHANNEL_ID, VERSION_NAME);

expect(res).to.deep.equal(RELEASE);

expect(nock.isDone()).to.be.true;

});

it("should include a message, if provided", async () => {

const CHANNEL_ID = "my-channel";

const RELEASE = { name: "my-new-release" };

const VERSION = "version";

const VERSION_NAME = `sites/${SITE}/versions/${VERSION}`;

const MESSAGE = "yo dawg";

nock(hostingApiOrigin())

.post(`/v1beta1/projects/-/sites/${SITE}/channels/${CHANNEL_ID}/releases`, {

message: MESSAGE,

})

.query({ versionName: VERSION_NAME })

.reply(201, RELEASE);

const res = await hostingApi.createRelease(SITE, CHANNEL_ID, VERSION_NAME, {

message: MESSAGE,

});

expect(res).to.deep.equal(RELEASE);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

const CHANNEL_ID = "my-channel";

const VERSION = "VERSION";

const VERSION_NAME = `sites/${SITE}/versions/${VERSION}`;

nock(hostingApiOrigin())

.post(`/v1beta1/projects/-/sites/${SITE}/channels/${CHANNEL_ID}/releases`)

.query({ versionName: VERSION_NAME })

.reply(500, { error: "server boo-boo" });

await expect(

hostingApi.createRelease(SITE, CHANNEL_ID, VERSION_NAME),

).to.eventually.be.rejectedWith(FirebaseError, /server boo-boo/);

expect(nock.isDone()).to.be.true;

});

});

describe("getSite", () => {

afterEach(nock.cleanAll);

it("should make the API request for a channel", async () => {

const SITE_BODY = { name: "my-site" };

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.reply(200, SITE_BODY);

const res = await hostingApi.getSite(PROJECT_ID, SITE);

expect(res).to.deep.equal(SITE_BODY);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the site doesn't exist", async () => {

nock(hostingApiOrigin()).get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`).reply(404, {});

await expect(hostingApi.getSite(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/could not find site/,

);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.getSite(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("listSites", () => {

afterEach(nock.cleanAll);

it("should make a single API requests to list a small number of sites", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites`)

.query({ pageToken: "", pageSize: 10 })

.reply(200, { sites: [{ name: "site01" }] });

const res = await hostingApi.listSites(PROJECT_ID);

expect(res).to.deep.equal([{ name: "site01" }]);

expect(nock.isDone()).to.be.true;

});

it("should return no sites if none are returned", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites`)

.query({ pageToken: "", pageSize: 10 })

.reply(200, {});

const res = await hostingApi.listSites(PROJECT_ID);

expect(res).to.deep.equal([]);

expect(nock.isDone()).to.be.true;

});

it("should make multiple API requests to list sites", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites`)

.query({ pageToken: "", pageSize: 10 })

.reply(200, { sites: [{ name: "site01" }], nextPageToken: "02" });

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites`)

.query({ pageToken: "02", pageSize: 10 })

.reply(200, { sites: [{ name: "site02" }] });

const res = await hostingApi.listSites(PROJECT_ID);

expect(res).to.deep.equal([{ name: "site01" }, { name: "site02" }]);

expect(nock.isDone()).to.be.true;

});

it("should return an error if there's no site", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites`)

.query({ pageToken: "", pageSize: 10 })

.reply(404, {});

await expect(hostingApi.listSites(PROJECT_ID)).to.eventually.be.rejectedWith(

FirebaseError,

/could not find sites/,

);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites`)

.query({ pageToken: "", pageSize: 10 })

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.listSites(PROJECT_ID)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("createSite", () => {

afterEach(nock.cleanAll);

it("should make the API request to create a channel", async () => {

const SITE_BODY = { name: "my-new-site" };

nock(hostingApiOrigin())

.post(`/v1beta1/projects/${PROJECT_ID}/sites`, { appId: "" })

.query({ siteId: SITE })

.reply(201, SITE_BODY);

const res = await hostingApi.createSite(PROJECT_ID, SITE);

expect(res).to.deep.equal(SITE_BODY);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

nock(hostingApiOrigin())

.post(`/v1beta1/projects/${PROJECT_ID}/sites`, { appId: "" })

.query({ siteId: SITE })

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.createSite(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("updateSite", () => {

const SITE_OBJ: hostingApi.Site = {

name: "my-site",

defaultUrl: "",

appId: "foo",

labels: {},

};

afterEach(nock.cleanAll);

it("should make the API request to update a site", async () => {

nock(hostingApiOrigin())

.patch(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.query({ updateMask: "appId" })

.reply(201, SITE_OBJ);

const res = await hostingApi.updateSite(PROJECT_ID, SITE_OBJ, ["appId"]);

expect(res).to.deep.equal(SITE_OBJ);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

nock(hostingApiOrigin())

.patch(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.query({ updateMask: "appId" })

.reply(500, { error: "server boo-boo" });

await expect(

hostingApi.updateSite(PROJECT_ID, SITE_OBJ, ["appId"]),

).to.eventually.be.rejectedWith(FirebaseError, /server boo-boo/);

expect(nock.isDone()).to.be.true;

});

});

describe("deleteSite", () => {

afterEach(nock.cleanAll);

it("should make the API request to delete a site", async () => {

nock(hostingApiOrigin())

.delete(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.reply(201, {});

const res = await hostingApi.deleteSite(PROJECT_ID, SITE);

expect(res).to.be.undefined;

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

nock(hostingApiOrigin())

.delete(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.reply(500, { error: "server boo-boo" });

await expect(hostingApi.deleteSite(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("getCleanDomains", () => {

afterEach(() => {

nock.cleanAll();

});

it("should return the list of expected auth domains after syncing", async () => {

// mock listChannels response

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query(() => true)

.reply(200, TEST_CHANNELS_RESPONSE);

// mock getAuthDomains response

nock(identityOrigin())

.get(`/admin/v2/projects/${PROJECT_ID}/config`)

.reply(200, TEST_GET_DOMAINS_RESPONSE);

const res = await hostingApi.getCleanDomains(PROJECT_ID, SITE);

expect(res).to.deep.equal(EXPECTED_DOMAINS_RESPONSE);

expect(nock.isDone()).to.be.true;

});

it("should not remove sites that are similarly named", async () => {

// mock listChannels response

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels`)

.query(() => true)

.reply(200, {

channels: [

{ url: "https://my-site--ch1-4iyrl1uo.web.app" },

{ url: "https://my-site--ch2-ygd8582v.web.app" },

],

});

// mock getAuthDomains response

nock(identityOrigin())

.get(`/admin/v2/projects/${PROJECT_ID}/config`)

.reply(200, {

authorizedDomains: [

"localhost",

"randomurl.com",

"my-site--ch1-4iyrl1uo.web.app",

"my-site--expiredchannel-difhyc76.web.app",

"backendof-my-site--some-abcd1234.web.app",

],

});

const res = await hostingApi.getCleanDomains(PROJECT_ID, SITE);

expect(res).to.deep.equal([

"localhost",

"randomurl.com",

"my-site--ch1-4iyrl1uo.web.app",

"backendof-my-site--some-abcd1234.web.app",

]);

expect(nock.isDone()).to.be.true;

});

});

describe("getSiteDomains", () => {

afterEach(nock.cleanAll);

it("should get the site domains", async () => {

nock(hostingApiOrigin()).get(SITE_DOMAINS_API).reply(200, { domains: GET_SITE_DOMAINS_BODY });

const res = await hostingApi.getSiteDomains(PROJECT_ID, SITE);

expect(res).to.deep.equal(GET_SITE_DOMAINS_BODY);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the site doesn't exist", async () => {

nock(hostingApiOrigin()).get(SITE_DOMAINS_API).reply(404, {});

await expect(hostingApi.getSiteDomains(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/could not find site/,

);

expect(nock.isDone()).to.be.true;

});

it("should throw an error if the server returns an error", async () => {

nock(hostingApiOrigin()).get(SITE_DOMAINS_API).reply(500, { error: "server boo-boo" });

await expect(hostingApi.getSiteDomains(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/server boo-boo/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("getAllSiteDomains", () => {

afterEach(nock.cleanAll);

it("should get the site domains", async () => {

nock(hostingApiOrigin()).get(SITE_DOMAINS_API).reply(200, { domains: GET_SITE_DOMAINS_BODY });

const GET_SITE_BODY = {

name: `projects/${PROJECT_ID}/sites/${SITE}`,

defaultUrl: EXPECTED_DOMAINS_RESPONSE[0],

type: "DEFAULT_SITE",

};

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.reply(200, GET_SITE_BODY);

const allDomainsPlusWebAppAndFirebaseApp = [

...EXPECTED_DOMAINS_RESPONSE,

`${SITE}.web.app`,

`${SITE}.firebaseapp.com`,

];

expect(await hostingApi.getAllSiteDomains(PROJECT_ID, SITE)).to.have.members(

allDomainsPlusWebAppAndFirebaseApp,

);

});

it("should throw an error if the site doesn't exist", async () => {

nock(hostingApiOrigin()).get(SITE_DOMAINS_API).reply(404, {});

nock(hostingApiOrigin()).get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`).reply(404, {});

await expect(hostingApi.getAllSiteDomains(PROJECT_ID, SITE)).to.eventually.be.rejectedWith(

FirebaseError,

/could not find site/,

);

expect(nock.isDone()).to.be.true;

});

});

describe("getDeploymentDomain", () => {

afterEach(nock.cleanAll);

it("should get the default site domain when hostingChannel is omitted", async () => {

const defaultDomain = EXPECTED_DOMAINS_RESPONSE[EXPECTED_DOMAINS_RESPONSE.length - 1];

const defaultUrl = `https://${defaultDomain}`;

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.reply(200, { defaultUrl });

expect(await hostingApi.getDeploymentDomain(PROJECT_ID, SITE)).to.equal(defaultDomain);

});

it("should get the default site domain when hostingChannel is undefined", async () => {

const defaultDomain = EXPECTED_DOMAINS_RESPONSE[EXPECTED_DOMAINS_RESPONSE.length - 1];

const defaultUrl = `https://${defaultDomain}`;

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`)

.reply(200, { defaultUrl });

expect(await hostingApi.getDeploymentDomain(PROJECT_ID, SITE, undefined)).to.equal(

defaultDomain,

);

});

it("should get the channel domain", async () => {

const channelId = "my-channel";

const channelDomain = `${PROJECT_ID}--${channelId}-123123.web.app`;

const channel = { url: `https://${channelDomain}` };

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${channelId}`)

.reply(200, channel);

expect(await hostingApi.getDeploymentDomain(PROJECT_ID, SITE, channelId)).to.equal(

channelDomain,

);

});

it("should return null if channel not found", async () => {

const channelId = "my-channel";

nock(hostingApiOrigin())

.get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}/channels/${channelId}`)

.reply(404, {});

expect(await hostingApi.getDeploymentDomain(PROJECT_ID, SITE, channelId)).to.be.null;

});

it("should return null if site not found", async () => {

nock(hostingApiOrigin()).get(`/v1beta1/projects/${PROJECT_ID}/sites/${SITE}`).reply(404, {});

expect(await hostingApi.getDeploymentDomain(PROJECT_ID, SITE)).to.be.null;

});

});

});

describe("normalizeName", () => {

const tests = [

{ in: "happy-path", out: "happy-path" },

{ in: "feature/branch", out: "feature-branch" },

{ in: "featuRe/Branch", out: "featuRe-Branch" },

{ in: "what/are:you_thinking", out: "what-are-you-thinking" },

{ in: "happyBranch", out: "happyBranch" },

{ in: "happy:branch", out: "happy-branch" },

{ in: "happy_branch", out: "happy-branch" },

{ in: "happy#branch", out: "happy-branch" },

];

for (const t of tests) {

it(`should handle the normalization of ${t.in}`, () => {

expect(hostingApi.normalizeName(t.in)).to.equal(t.out);

});

}

});