azure-mock 2.7.0

package/dist/index.js

@@ -0,0 +1,1054 @@
+import { Readable } from "node:stream";
+
+//#region src/models/MockRestError.ts
+var MockRestError = class extends Error {
+	statusCode;
+	constructor(message, statusCode) {
+		super(message);
+		this.name = "MockRestError";
+		this.statusCode = statusCode;
+	}
+};
+
+//#endregion
+//#region src/util/isReadableStream.ts
+const isReadableStream = (value) => value instanceof Readable;
+
+//#endregion
+//#region ../shared/dist/index.js
+var InvalidOperationError = class extends Error {
+	constructor(operation, name, message) {
+		super(`Invalid operation: ${operation}, name: ${name}, ${message}`);
+		this.name = "InvalidOperationError";
+	}
+};
+let Operation = /* @__PURE__ */ function(Operation$1) {
+	Operation$1["Create"] = "Create";
+	Operation$1["Delete"] = "Delete";
+	Operation$1["Push"] = "Push";
+	Operation$1["Read"] = "Read";
+	Operation$1["Update"] = "Update";
+	return Operation$1;
+}({});
+const css = String.raw;
+const html = String.raw;
+const ID_SEPARATOR = "|";
+const streamToText = async (readable) => {
+	readable.setEncoding("utf8");
+	let data = "";
+	for await (const chunk of readable) data += chunk.toString();
+	return data;
+};
+const exhaustiveGuard = (value) => {
+	throw new InvalidOperationError(Operation.Read, exhaustiveGuard.name, JSON.stringify(value));
+};
+
+//#endregion
+//#region src/util/bodyToBuffer.ts
+const bodyToBuffer = async (body) => {
+	if (body === null) return Buffer.alloc(0);
+	else if (typeof body === "string") return Buffer.from(body);
+	else if (body instanceof ArrayBuffer) return Buffer.from(body);
+	else if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+	else if (typeof body === "function") {
+		const streamOrBlob = body();
+		return bodyToBuffer(streamOrBlob);
+	} else if (body instanceof Blob) {
+		const arrayBuffer = await body.arrayBuffer();
+		return Buffer.from(arrayBuffer);
+	} else if (isReadableStream(body)) return Buffer.from(await streamToText(body));
+	else if (body instanceof ReadableStream) {
+		const reader = body.getReader();
+		const chunks = [];
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			else chunks.push(value);
+		}
+		return Buffer.concat(chunks);
+	} else if (body instanceof FormData) throw new Error("FormData is not supported in this mock implementation.");
+	else exhaustiveGuard(body);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.2.3/node_modules/@typespec/ts-http-runtime/dist/browser/httpHeaders.js
+function normalizeName(name) {
+	return name.toLowerCase();
+}
+function* headerIterator(map) {
+	for (const entry of map.values()) yield [entry.name, entry.value];
+}
+var HttpHeadersImpl = class {
+	constructor(rawHeaders) {
+		this._headersMap = /* @__PURE__ */ new Map();
+		if (rawHeaders) for (const headerName of Object.keys(rawHeaders)) this.set(headerName, rawHeaders[headerName]);
+	}
+	/**
+	* Set a header in this collection with the provided name and value. The name is
+	* case-insensitive.
+	* @param name - The name of the header to set. This value is case-insensitive.
+	* @param value - The value of the header to set.
+	*/
+	set(name, value) {
+		this._headersMap.set(normalizeName(name), {
+			name,
+			value: String(value).trim()
+		});
+	}
+	/**
+	* Get the header value for the provided header name, or undefined if no header exists in this
+	* collection with the provided name.
+	* @param name - The name of the header. This value is case-insensitive.
+	*/
+	get(name) {
+		var _a$1;
+		return (_a$1 = this._headersMap.get(normalizeName(name))) === null || _a$1 === void 0 ? void 0 : _a$1.value;
+	}
+	/**
+	* Get whether or not this header collection contains a header entry for the provided header name.
+	* @param name - The name of the header to set. This value is case-insensitive.
+	*/
+	has(name) {
+		return this._headersMap.has(normalizeName(name));
+	}
+	/**
+	* Remove the header with the provided headerName.
+	* @param name - The name of the header to remove.
+	*/
+	delete(name) {
+		this._headersMap.delete(normalizeName(name));
+	}
+	/**
+	* Get the JSON object representation of this HTTP header collection.
+	*/
+	toJSON(options = {}) {
+		const result = {};
+		if (options.preserveCase) for (const entry of this._headersMap.values()) result[entry.name] = entry.value;
+		else for (const [normalizedName, entry] of this._headersMap) result[normalizedName] = entry.value;
+		return result;
+	}
+	/**
+	* Get the string representation of this HTTP header collection.
+	*/
+	toString() {
+		return JSON.stringify(this.toJSON({ preserveCase: true }));
+	}
+	/**
+	* Iterate over tuples of header [name, value] pairs.
+	*/
+	[Symbol.iterator]() {
+		return headerIterator(this._headersMap);
+	}
+};
+/**
+* Creates an object that satisfies the `HttpHeaders` interface.
+* @param rawHeaders - A simple object representing initial headers
+*/
+function createHttpHeaders$1(rawHeaders) {
+	return new HttpHeadersImpl(rawHeaders);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.2.3/node_modules/@typespec/ts-http-runtime/dist/browser/util/uuidUtils.common.js
+/**
+* Generated Universally Unique Identifier
+*
+* @returns RFC4122 v4 UUID.
+*/
+function generateUUID() {
+	let uuid = "";
+	for (let i = 0; i < 32; i++) {
+		const randomNumber = Math.floor(Math.random() * 16);
+		if (i === 12) uuid += "4";
+		else if (i === 16) uuid += randomNumber & 3 | 8;
+		else uuid += randomNumber.toString(16);
+		if (i === 7 || i === 11 || i === 15 || i === 19) uuid += "-";
+	}
+	return uuid;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.2.3/node_modules/@typespec/ts-http-runtime/dist/browser/util/uuidUtils.js
+var _a;
+const uuidFunction = typeof ((_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === "function" ? globalThis.crypto.randomUUID.bind(globalThis.crypto) : generateUUID;
+/**
+* Generated Universally Unique Identifier
+*
+* @returns RFC4122 v4 UUID.
+*/
+function randomUUID() {
+	return uuidFunction();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.2.3/node_modules/@typespec/ts-http-runtime/dist/browser/pipelineRequest.js
+var PipelineRequestImpl = class {
+	constructor(options) {
+		var _a$1, _b, _c, _d, _e, _f, _g;
+		this.url = options.url;
+		this.body = options.body;
+		this.headers = (_a$1 = options.headers) !== null && _a$1 !== void 0 ? _a$1 : createHttpHeaders$1();
+		this.method = (_b = options.method) !== null && _b !== void 0 ? _b : "GET";
+		this.timeout = (_c = options.timeout) !== null && _c !== void 0 ? _c : 0;
+		this.multipartBody = options.multipartBody;
+		this.formData = options.formData;
+		this.disableKeepAlive = (_d = options.disableKeepAlive) !== null && _d !== void 0 ? _d : false;
+		this.proxySettings = options.proxySettings;
+		this.streamResponseStatusCodes = options.streamResponseStatusCodes;
+		this.withCredentials = (_e = options.withCredentials) !== null && _e !== void 0 ? _e : false;
+		this.abortSignal = options.abortSignal;
+		this.onUploadProgress = options.onUploadProgress;
+		this.onDownloadProgress = options.onDownloadProgress;
+		this.requestId = options.requestId || randomUUID();
+		this.allowInsecureConnection = (_f = options.allowInsecureConnection) !== null && _f !== void 0 ? _f : false;
+		this.enableBrowserStreams = (_g = options.enableBrowserStreams) !== null && _g !== void 0 ? _g : false;
+		this.requestOverrides = options.requestOverrides;
+		this.authSchemes = options.authSchemes;
+	}
+};
+/**
+* Creates a new pipeline request with the given options.
+* This method is to allow for the easy setting of default values and not required.
+* @param options - The options to create the request with.
+*/
+function createPipelineRequest$1(options) {
+	return new PipelineRequestImpl(options);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.21.0/node_modules/@azure/core-rest-pipeline/dist/browser/httpHeaders.js
+/**
+* Creates an object that satisfies the `HttpHeaders` interface.
+* @param rawHeaders - A simple object representing initial headers
+*/
+function createHttpHeaders(rawHeaders) {
+	return createHttpHeaders$1(rawHeaders);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-rest-pipeline@1.21.0/node_modules/@azure/core-rest-pipeline/dist/browser/pipelineRequest.js
+/**
+* Creates a new pipeline request with the given options.
+* This method is to allow for the easy setting of default values and not required.
+* @param options - The options to create the request with.
+*/
+function createPipelineRequest(options) {
+	return createPipelineRequest$1(options);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+core-http-compat@2.3.0/node_modules/@azure/core-http-compat/dist/browser/util.js
+const originalRequestSymbol = Symbol("Original PipelineRequest");
+const originalClientRequestSymbol = Symbol.for("@azure/core-client original request");
+/**
+* Converts HttpHeaders from core-rest-pipeline to look like
+* HttpHeaders from core-http.
+* @param headers - HttpHeaders from core-rest-pipeline
+* @returns HttpHeaders as they looked in core-http
+*/
+function toHttpHeadersLike(headers) {
+	return new HttpHeaders(headers.toJSON({ preserveCase: true }));
+}
+/**
+* A collection of HttpHeaders that can be sent with a HTTP request.
+*/
+function getHeaderKey(headerName) {
+	return headerName.toLowerCase();
+}
+/**
+* A collection of HTTP header key/value pairs.
+*/
+var HttpHeaders = class HttpHeaders {
+	constructor(rawHeaders) {
+		this._headersMap = {};
+		if (rawHeaders) for (const headerName in rawHeaders) this.set(headerName, rawHeaders[headerName]);
+	}
+	/**
+	* Set a header in this collection with the provided name and value. The name is
+	* case-insensitive.
+	* @param headerName - The name of the header to set. This value is case-insensitive.
+	* @param headerValue - The value of the header to set.
+	*/
+	set(headerName, headerValue) {
+		this._headersMap[getHeaderKey(headerName)] = {
+			name: headerName,
+			value: headerValue.toString()
+		};
+	}
+	/**
+	* Get the header value for the provided header name, or undefined if no header exists in this
+	* collection with the provided name.
+	* @param headerName - The name of the header.
+	*/
+	get(headerName) {
+		const header = this._headersMap[getHeaderKey(headerName)];
+		return !header ? void 0 : header.value;
+	}
+	/**
+	* Get whether or not this header collection contains a header entry for the provided header name.
+	*/
+	contains(headerName) {
+		return !!this._headersMap[getHeaderKey(headerName)];
+	}
+	/**
+	* Remove the header with the provided headerName. Return whether or not the header existed and
+	* was removed.
+	* @param headerName - The name of the header to remove.
+	*/
+	remove(headerName) {
+		const result = this.contains(headerName);
+		delete this._headersMap[getHeaderKey(headerName)];
+		return result;
+	}
+	/**
+	* Get the headers that are contained this collection as an object.
+	*/
+	rawHeaders() {
+		return this.toJson({ preserveCase: true });
+	}
+	/**
+	* Get the headers that are contained in this collection as an array.
+	*/
+	headersArray() {
+		const headers = [];
+		for (const headerKey in this._headersMap) headers.push(this._headersMap[headerKey]);
+		return headers;
+	}
+	/**
+	* Get the header names that are contained in this collection.
+	*/
+	headerNames() {
+		const headerNames = [];
+		const headers = this.headersArray();
+		for (let i = 0; i < headers.length; ++i) headerNames.push(headers[i].name);
+		return headerNames;
+	}
+	/**
+	* Get the header values that are contained in this collection.
+	*/
+	headerValues() {
+		const headerValues = [];
+		const headers = this.headersArray();
+		for (let i = 0; i < headers.length; ++i) headerValues.push(headers[i].value);
+		return headerValues;
+	}
+	/**
+	* Get the JSON object representation of this HTTP header collection.
+	*/
+	toJson(options = {}) {
+		const result = {};
+		if (options.preserveCase) for (const headerKey in this._headersMap) {
+			const header = this._headersMap[headerKey];
+			result[header.name] = header.value;
+		}
+		else for (const headerKey in this._headersMap) {
+			const header = this._headersMap[headerKey];
+			result[getHeaderKey(header.name)] = header.value;
+		}
+		return result;
+	}
+	/**
+	* Get the string representation of this HTTP header collection.
+	*/
+	toString() {
+		return JSON.stringify(this.toJson({ preserveCase: true }));
+	}
+	/**
+	* Create a deep clone/copy of this HttpHeaders collection.
+	*/
+	clone() {
+		const resultPreservingCasing = {};
+		for (const headerKey in this._headersMap) {
+			const header = this._headersMap[headerKey];
+			resultPreservingCasing[header.name] = header.value;
+		}
+		return new HttpHeaders(resultPreservingCasing);
+	}
+};
+
+//#endregion
+//#region src/util/toWebResourceLike.ts
+const toWebResourceLike = (request) => ({
+	abortSignal: request.abortSignal,
+	agent: request.agent,
+	body: request.body,
+	clone: () => {
+		throw new Error("Cannot clone a non-proxied WebResourceLike");
+	},
+	formData: request.formData,
+	headers: toHttpHeadersLike(request.headers),
+	keepAlive: request.disableKeepAlive,
+	method: request.method,
+	onDownloadProgress: request.onDownloadProgress,
+	onUploadProgress: request.onUploadProgress,
+	prepare: () => {
+		throw new Error("WebResourceLike.prepare() is not supported by @azure/core-http-compat");
+	},
+	proxySettings: request.proxySettings,
+	requestId: request.headers.get("x-ms-client-request-id") ?? request.requestId,
+	requestOverrides: request.requestOverrides,
+	streamResponseStatusCodes: request.streamResponseStatusCodes,
+	timeout: request.timeout,
+	url: request.url,
+	validateRequestProperties: () => {},
+	withCredentials: request.withCredentials
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+storage-blob@12.27.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/policies/RequestPolicy.js
+/**
+* The base class from which all request policies derive.
+*/
+var BaseRequestPolicy = class {
+	/**
+	* The main method to implement that manipulates a request/response.
+	*/
+	constructor(_nextPolicy, _options) {
+		this._nextPolicy = _nextPolicy;
+		this._options = _options;
+	}
+	/**
+	* Get whether or not a log with the provided log level should be logged.
+	* @param logLevel - The log level of the log that will be logged.
+	* @returns Whether or not a log with the provided log level should be logged.
+	*/
+	shouldLog(logLevel) {
+		return this._options.shouldLog(logLevel);
+	}
+	/**
+	* Attempt to log the provided message to the provided logger. If no logger was provided or if
+	* the log level does not meat the logger's threshold, then nothing will be logged.
+	* @param logLevel - The log level of this log.
+	* @param message - The message of this log.
+	*/
+	log(logLevel, message) {
+		this._options.log(logLevel, message);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+storage-blob@12.27.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/policies/CredentialPolicy.js
+/**
+* Credential policy used to sign HTTP(S) requests before sending. This is an
+* abstract class.
+*/
+var CredentialPolicy = class extends BaseRequestPolicy {
+	/**
+	* Sends out request.
+	*
+	* @param request -
+	*/
+	sendRequest(request) {
+		return this._nextPolicy.sendRequest(this.signRequest(request));
+	}
+	/**
+	* Child classes must implement this method with request signing. This method
+	* will be executed in {@link sendRequest}.
+	*
+	* @param request -
+	*/
+	signRequest(request) {
+		return request;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+storage-blob@12.27.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/policies/AnonymousCredentialPolicy.js
+/**
+* AnonymousCredentialPolicy is used with HTTP(S) requests that read public resources
+* or for use with Shared Access Signatures (SAS).
+*/
+var AnonymousCredentialPolicy = class extends CredentialPolicy {
+	/**
+	* Creates an instance of AnonymousCredentialPolicy.
+	* @param nextPolicy -
+	* @param options -
+	*/
+	constructor(nextPolicy, options) {
+		super(nextPolicy, options);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+storage-blob@12.27.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/credentials/Credential.js
+/**
+* Credential is an abstract class for Azure Storage HTTP requests signing. This
+* class will host an credentialPolicyCreator factory which generates CredentialPolicy.
+*/
+var Credential = class {
+	/**
+	* Creates a RequestPolicy object.
+	*
+	* @param _nextPolicy -
+	* @param _options -
+	*/
+	create(_nextPolicy, _options) {
+		throw new Error("Method should be implemented in children classes.");
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@azure+storage-blob@12.27.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/credentials/AnonymousCredential.js
+/**
+* AnonymousCredential provides a credentialPolicyCreator member used to create
+* AnonymousCredentialPolicy objects. AnonymousCredentialPolicy is used with
+* HTTP(S) requests that read public resources or for use with Shared Access
+* Signatures (SAS).
+*/
+var AnonymousCredential = class extends Credential {
+	/**
+	* Creates an {@link AnonymousCredentialPolicy} object.
+	*
+	* @param nextPolicy -
+	* @param options -
+	*/
+	create(nextPolicy, options) {
+		return new AnonymousCredentialPolicy(nextPolicy, options);
+	}
+};
+
+//#endregion
+//#region src/models/MockBlockBlobClient.ts
+var MockBlockBlobClient = class {
+	containerClient;
+	credential = new AnonymousCredential();
+	name;
+	url;
+	get containerName() {
+		return this.containerClient.containerName;
+	}
+	constructor(_connectionString, containerClient, blobName) {
+		this.containerClient = containerClient;
+		this.name = blobName;
+		this.url = `https://mockaccount.blob.core.windows.net/${this.containerName}/${this.name}`;
+	}
+	abortCopyFromURL() {
+		throw new Error("Method not implemented.");
+	}
+	beginCopyFromURL() {
+		throw new Error("Method not implemented.");
+	}
+	commitBlockList() {
+		throw new Error("Method not implemented.");
+	}
+	createSnapshot() {
+		throw new Error("Method not implemented.");
+	}
+	delete() {
+		if (!this.containerClient.blobs.has(this.name)) throw new MockRestError("The specified blob does not exist.", 404);
+		this.containerClient.blobs.delete(this.name);
+		return new Promise((resolve) => resolve({ _response: {
+			headers: toHttpHeadersLike(createHttpHeaders()),
+			parsedHeaders: {},
+			request: toWebResourceLike(createPipelineRequest({ url: "" })),
+			status: 200
+		} }));
+	}
+	deleteIfExists() {
+		throw new Error("Method not implemented.");
+	}
+	deleteImmutabilityPolicy() {
+		throw new Error("Method not implemented.");
+	}
+	download() {
+		const buffer = this.containerClient.blobs.get(this.name);
+		return new Promise((resolve) => resolve({
+			_response: {
+				headers: toHttpHeadersLike(createHttpHeaders()),
+				parsedHeaders: {},
+				request: toWebResourceLike(createPipelineRequest({ url: "" })),
+				status: buffer ? 200 : 404
+			},
+			readableStreamBody: buffer ? Readable.from(buffer) : void 0
+		}));
+	}
+	downloadToBuffer() {
+		const data = this.containerClient.blobs.get(this.name);
+		if (!data) throw new MockRestError("The specified blob does not exist.", 404);
+		return new Promise((resolve) => resolve(Buffer.from(data)));
+	}
+	downloadToFile() {
+		throw new Error("Method not implemented.");
+	}
+	exists() {
+		throw new Error("Method not implemented.");
+	}
+	generateSasStringToSign() {
+		throw new Error("Method not implemented.");
+	}
+	generateSasUrl() {
+		throw new Error("Method not implemented.");
+	}
+	generateUserDelegationSasStringToSign() {
+		throw new Error("Method not implemented.");
+	}
+	generateUserDelegationSasUrl() {
+		throw new Error("Method not implemented.");
+	}
+	getAccountInfo() {
+		throw new Error("Method not implemented.");
+	}
+	getAppendBlobClient() {
+		throw new Error("Method not implemented.");
+	}
+	getBlobLeaseClient() {
+		throw new Error("Method not implemented.");
+	}
+	getBlockBlobClient() {
+		throw new Error("Method not implemented.");
+	}
+	getBlockList() {
+		throw new Error("Method not implemented.");
+	}
+	getPageBlobClient() {
+		throw new Error("Method not implemented.");
+	}
+	getProperties() {
+		throw new Error("Method not implemented.");
+	}
+	getTags() {
+		throw new Error("Method not implemented.");
+	}
+	query() {
+		throw new Error("Method not implemented.");
+	}
+	setAccessTier() {
+		throw new Error("Method not implemented.");
+	}
+	setHTTPHeaders() {
+		throw new Error("Method not implemented.");
+	}
+	setImmutabilityPolicy() {
+		throw new Error("Method not implemented.");
+	}
+	setLegalHold() {
+		throw new Error("Method not implemented.");
+	}
+	setMetadata() {
+		throw new Error("Method not implemented.");
+	}
+	setTags() {
+		throw new Error("Method not implemented.");
+	}
+	stageBlock() {
+		throw new Error("Method not implemented.");
+	}
+	stageBlockFromURL() {
+		throw new Error("Method not implemented.");
+	}
+	syncCopyFromURL() {
+		throw new Error("Method not implemented.");
+	}
+	syncUploadFromURL() {
+		throw new Error("Method not implemented.");
+	}
+	undelete() {
+		throw new Error("Method not implemented.");
+	}
+	async upload(body, _contentLength) {
+		this.containerClient.blobs.set(this.name, await bodyToBuffer(body));
+		return { _response: {
+			headers: toHttpHeadersLike(createHttpHeaders()),
+			parsedHeaders: {},
+			request: toWebResourceLike(createPipelineRequest({ url: "" })),
+			status: 201
+		} };
+	}
+	uploadBrowserData() {
+		throw new Error("Method not implemented.");
+	}
+	uploadData() {
+		throw new Error("Method not implemented.");
+	}
+	uploadFile() {
+		throw new Error("Method not implemented.");
+	}
+	uploadStream() {
+		throw new Error("Method not implemented.");
+	}
+	withSnapshot() {
+		throw new Error("Method not implemented.");
+	}
+	withVersion() {
+		throw new Error("Method not implemented.");
+	}
+};
+
+//#endregion
+//#region src/util/getBlobItemXml.ts
+const getBlobItemXml = ({ name, properties }) => html`<Blob>
+    <Name>${name}</Name>
+    <Properties>
+      <Last-Modified>${properties.lastModified.toUTCString()}</Last-Modified>
+      <Etag>${properties.etag}</Etag>
+      <Content-Length>${properties.contentLength}</Content-Length>
+      <Content-Type>${properties.contentType}</Content-Type>
+      <BlobType>BlockBlob</BlobType>
+      <LeaseStatus>unlocked</LeaseStatus>
+      <LeaseState>available</LeaseState>
+    </Properties>
+  </Blob>`;
+
+//#endregion
+//#region src/util/getBlobPrefixXml.ts
+const getBlobPrefixXml = (name) => html`<BlobPrefix><Name>${name}</Name></BlobPrefix>`;
+
+//#endregion
+//#region src/models/MockContainerClient.ts
+/**
+* An in-memory mock of the Azure ContainerClient.
+* It uses a Map to simulate blob storage.
+*
+* @example
+* const mockContainerClient = new MockContainerClient("", "hello world");
+* const blockBlobClient = mockContainerClient.getBlockBlobClient("hello world.txt");
+* await blockBlobClient.upload("hello world", 11);
+* const content = await blockBlobClient.downloadToBuffer();
+*/
+var MockContainerClient = class {
+	blobs = /* @__PURE__ */ new Map();
+	containerName;
+	credential = new AnonymousCredential();
+	url;
+	constructor(_connectionString, containerName) {
+		this.containerName = containerName;
+		this.url = `https://mockaccount.blob.core.windows.net/${this.containerName}`;
+	}
+	create() {
+		throw new Error("Method not implemented.");
+	}
+	createIfNotExists() {
+		throw new Error("Method not implemented.");
+	}
+	delete() {
+		throw new Error("Method not implemented.");
+	}
+	deleteBlob() {
+		throw new Error("Method not implemented.");
+	}
+	deleteIfExists() {
+		throw new Error("Method not implemented.");
+	}
+	exists() {
+		throw new Error("Method not implemented.");
+	}
+	findBlobsByTags() {
+		throw new Error("Method not implemented.");
+	}
+	generateSasStringToSign() {
+		throw new Error("Method not implemented.");
+	}
+	generateSasUrl() {
+		throw new Error("Method not implemented.");
+	}
+	generateUserDelegationSasStringToSign() {
+		throw new Error("Method not implemented.");
+	}
+	generateUserDelegationSasUrl() {
+		throw new Error("Method not implemented.");
+	}
+	getAccessPolicy() {
+		throw new Error("Method not implemented.");
+	}
+	getAccountInfo() {
+		throw new Error("Method not implemented.");
+	}
+	getAppendBlobClient() {
+		throw new Error("Method not implemented.");
+	}
+	getBlobBatchClient() {
+		throw new Error("Method not implemented.");
+	}
+	getBlobClient() {
+		throw new Error("Method not implemented.");
+	}
+	getBlobLeaseClient() {
+		throw new Error("Method not implemented.");
+	}
+	getBlockBlobClient(blobName) {
+		return new MockBlockBlobClient("", this, blobName);
+	}
+	getPageBlobClient() {
+		throw new Error("Method not implemented.");
+	}
+	getProperties() {
+		throw new Error("Method not implemented.");
+	}
+	listBlobsByHierarchy(delimiter, options) {
+		const blobHierarchyItemIterator = this.getBlobHierarchyItemIterator(delimiter, options);
+		return {
+			byPage: () => async function* () {
+				const allBlobItems = [];
+				const allBlobItemXml = [];
+				const allBlobPrefixes = [];
+				const allBlobPrefixXml = [];
+				for await (const blobHierarchyItem of blobHierarchyItemIterator) if (blobHierarchyItem.kind === "blob") {
+					allBlobItems.push(blobHierarchyItem);
+					allBlobItemXml.push(getBlobItemXml(blobHierarchyItem));
+				} else {
+					allBlobPrefixes.push({ name: blobHierarchyItem.name });
+					allBlobPrefixXml.push(getBlobPrefixXml(blobHierarchyItem.name));
+				}
+				if (allBlobItems.length > 0 || allBlobPrefixes.length > 0) yield await new Promise((resolve) => resolve({
+					_response: {
+						bodyAsText: html`<?xml version="1.0" encoding="utf8"?>
+                    <EnumerationResults ServiceEndpoint="" ContainerName="${this.containerName}">
+                      <Blobs>${allBlobItemXml.join("")}${allBlobPrefixXml.join("")}</Blobs>
+                      <NextMarker />
+                    </EnumerationResults>`,
+						headers: toHttpHeadersLike(createHttpHeaders()),
+						parsedBody: {
+							containerName: this.containerName,
+							marker: "",
+							prefix: options?.prefix ?? "",
+							segment: { blobItems: allBlobItems },
+							serviceEndpoint: ""
+						},
+						parsedHeaders: {},
+						request: toWebResourceLike(createPipelineRequest({ url: "" })),
+						status: 200
+					},
+					containerName: this.containerName,
+					marker: "",
+					prefix: options?.prefix ?? "",
+					segment: { blobItems: allBlobItems },
+					serviceEndpoint: ""
+				}));
+			}.bind(this)(),
+			next: blobHierarchyItemIterator.next.bind(blobHierarchyItemIterator),
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+	listBlobsFlat() {
+		const blobItemIterator = this.getBlobItemIterator();
+		return {
+			byPage: () => async function* () {
+				const allBlobItems = [];
+				const allBlobItemXml = [];
+				for await (const blobItem of blobItemIterator) {
+					allBlobItems.push(blobItem);
+					allBlobItemXml.push(getBlobItemXml(blobItem));
+				}
+				if (allBlobItems.length > 0) yield await new Promise((resolve) => resolve({
+					_response: {
+						bodyAsText: html`<?xml version="1.0" encoding="utf8"?>
+                    <EnumerationResults ServiceEndpoint="" ContainerName="${this.containerName}">
+                      <Blobs>${allBlobItemXml.join("")}</Blobs>
+                      <NextMarker />
+                    </EnumerationResults>`,
+						headers: toHttpHeadersLike(createHttpHeaders()),
+						parsedBody: {
+							containerName: this.containerName,
+							marker: "",
+							prefix: "",
+							segment: { blobItems: allBlobItems },
+							serviceEndpoint: ""
+						},
+						parsedHeaders: {},
+						request: toWebResourceLike(createPipelineRequest({ url: "" })),
+						status: 200
+					},
+					containerName: this.containerName,
+					marker: "",
+					prefix: "",
+					segment: { blobItems: allBlobItems },
+					serviceEndpoint: ""
+				}));
+			}.bind(this)(),
+			next: blobItemIterator.next.bind(blobItemIterator),
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+	setAccessPolicy() {
+		throw new Error("Method not implemented.");
+	}
+	setMetadata() {
+		throw new Error("Method not implemented.");
+	}
+	async uploadBlockBlob(blobName, body, contentLength) {
+		const blockBlobClient = this.getBlockBlobClient(blobName);
+		return {
+			blockBlobClient,
+			response: await blockBlobClient.upload(body, contentLength)
+		};
+	}
+	async *getBlobHierarchyItemIterator(delimiter, options) {
+		const prefix = options?.prefix ?? "";
+		const uniqueSubprefixes = /* @__PURE__ */ new Set();
+		const blobsInCurrentLevel = [];
+		for (const [name, buffer] of this.blobs.entries()) {
+			if (!name.startsWith(prefix)) continue;
+			const nameAfterPrefix = name.slice(prefix.length);
+			const delimiterIndex = nameAfterPrefix.indexOf(delimiter);
+			if (delimiterIndex === -1) blobsInCurrentLevel.push({
+				deleted: false,
+				name,
+				properties: {
+					blobType: "BlockBlob",
+					contentLength: buffer.length,
+					contentType: "application/octet-stream",
+					etag: `"${crypto.randomUUID()}"`,
+					lastModified: /* @__PURE__ */ new Date(),
+					leaseState: "available",
+					leaseStatus: "unlocked"
+				},
+				snapshot: ""
+			});
+			else {
+				const subprefix = `${prefix}${nameAfterPrefix.slice(0, delimiterIndex + delimiter.length)}`;
+				uniqueSubprefixes.add(subprefix);
+			}
+		}
+		for (const prefixName of [...uniqueSubprefixes].sort()) yield await new Promise((resolve) => resolve({
+			kind: "prefix",
+			name: prefixName
+		}));
+		for (const blobItem of blobsInCurrentLevel) yield await new Promise((resolve) => resolve({
+			kind: "blob",
+			...blobItem
+		}));
+	}
+	async *getBlobItemIterator() {
+		for (const [name, buffer] of this.blobs.entries()) yield await new Promise((resolve) => resolve({
+			deleted: false,
+			name,
+			properties: {
+				blobType: "BlockBlob",
+				contentLength: buffer.length,
+				contentType: "application/octet-stream",
+				etag: `"${crypto.randomUUID()}"`,
+				lastModified: /* @__PURE__ */ new Date(),
+				leaseState: "available",
+				leaseStatus: "unlocked"
+			},
+			snapshot: ""
+		}));
+	}
+};
+
+//#endregion
+//#region src/models/MockTableClient.ts
+/**
+* An in-memory mock of the Azure TableClient.
+* It uses a Map to simulate table storage and correctly implements the TableClient interface.
+*
+* @example
+* const mockTableClient = new MockTableClient("", "hello world");
+* await mockTableClient.createEntity({ partitionKey: "partitionKey", rowKey: "rowKey" });
+* const entity = await mockTableClient.getEntity("partitionKey", "rowKey");
+*/
+var MockTableClient = class {
+	entities = /* @__PURE__ */ new Map();
+	tableName;
+	url;
+	constructor(_url, tableName) {
+		this.tableName = tableName;
+		this.url = `https://mockaccount.table.core.windows.net/${this.tableName}`;
+	}
+	createEntity(entity) {
+		const key = this.getCompositeKey(entity.partitionKey, entity.rowKey);
+		if (this.entities.has(key)) throw new MockRestError("The specified entity already exists.", 409);
+		const storedEntity = this.withMetadata(entity);
+		this.entities.set(key, storedEntity);
+		return new Promise((resolve) => resolve({
+			date: /* @__PURE__ */ new Date(),
+			etag: storedEntity.etag
+		}));
+	}
+	createTable() {
+		throw new Error("Method not implemented.");
+	}
+	deleteEntity(partitionKey, rowKey) {
+		const key = this.getCompositeKey(partitionKey, rowKey);
+		if (!this.entities.has(key)) throw new MockRestError("The specified resource does not exist.", 404);
+		this.entities.delete(key);
+		return new Promise((resolve) => resolve({}));
+	}
+	deleteTable() {
+		throw new Error("Method not implemented.");
+	}
+	getAccessPolicy() {
+		throw new Error("Method not implemented.");
+	}
+	getEntity(partitionKey, rowKey) {
+		const key = this.getCompositeKey(partitionKey, rowKey);
+		const entity = this.entities.get(key);
+		if (!entity) throw new MockRestError("The specified resource does not exist.", 404);
+		const entityWithMetadata = this.withMetadata(entity);
+		return new Promise((resolve) => resolve(entityWithMetadata));
+	}
+	listEntities() {
+		const withMetadata = this.withMetadata.bind(this);
+		return {
+			byPage: () => async function* (entities) {
+				const allEntitiesWithMetadata = [...entities.values()].map(withMetadata);
+				if (allEntitiesWithMetadata.length > 0) yield await new Promise((resolve) => resolve(allEntitiesWithMetadata));
+			}(this.entities),
+			next: () => async function* (entities) {
+				for (const entity of entities.values()) {
+					const entityWithMetadata = withMetadata(entity);
+					yield await new Promise((resolve) => resolve(entityWithMetadata));
+				}
+			}(this.entities).next(),
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+	setAccessPolicy() {
+		throw new Error("Method not implemented.");
+	}
+	submitTransaction() {
+		throw new Error("Method not implemented.");
+	}
+	updateEntity(entity, mode = "Merge") {
+		const key = this.getCompositeKey(entity.partitionKey, entity.rowKey);
+		const existingEntity = this.entities.get(key);
+		if (!existingEntity) throw new MockRestError("The specified resource does not exist.", 404);
+		else if (mode === "Merge") return this.mergeEntity(key, existingEntity, entity);
+		const newEntityWithMetadata = this.withMetadata(entity);
+		this.entities.set(key, newEntityWithMetadata);
+		return new Promise((resolve) => resolve({
+			date: /* @__PURE__ */ new Date(),
+			etag: newEntityWithMetadata.etag
+		}));
+	}
+	upsertEntity(entity, mode = "Merge") {
+		const key = this.getCompositeKey(entity.partitionKey, entity.rowKey);
+		const existingEntity = this.entities.get(key);
+		if (existingEntity && mode === "Merge") return this.mergeEntity(key, existingEntity, entity);
+		const newEntity = this.withMetadata(entity);
+		this.entities.set(key, newEntity);
+		return new Promise((resolve) => resolve({
+			date: /* @__PURE__ */ new Date(),
+			etag: newEntity.etag
+		}));
+	}
+	getCompositeKey(partitionKey, rowKey) {
+		return `${partitionKey}${ID_SEPARATOR}${rowKey}`;
+	}
+	mergeEntity(key, entity, entityToMerge) {
+		const mergedEntityWithMetadata = this.withMetadata({
+			...entity,
+			...entityToMerge
+		});
+		this.entities.set(key, mergedEntityWithMetadata);
+		return new Promise((resolve) => resolve({
+			date: /* @__PURE__ */ new Date(),
+			etag: mergedEntityWithMetadata.etag
+		}));
+	}
+	withMetadata(entity) {
+		return {
+			...entity,
+			etag: `W/"datetime'${(/* @__PURE__ */ new Date()).toISOString()}'"`
+		};
+	}
+};
+
+//#endregion
+export { MockBlockBlobClient, MockContainerClient, MockRestError, MockTableClient, bodyToBuffer, getBlobItemXml, getBlobPrefixXml, isReadableStream, toWebResourceLike };