azure-mock 2.7.0 → 2.8.0

package/dist/index.js

@@ -1,18 +1,7 @@
 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;
+//#region src/store/MockContainerDatabase.ts
+const MockContainerDatabase = /* @__PURE__ */ new Map();
 
 //#endregion
 //#region ../shared/dist/index.js
@@ -44,31 +33,18 @@ const exhaustiveGuard = (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);
-};
+//#region src/util/getAzureErrorXml.ts
+/**
+* Generates a standard Azure Storage error XML response body.
+* @param errorCode The official Azure error code (e.g., "BlobNotFound").
+* @param errorMessage The user-friendly error message.
+* @returns A formatted XML string.
+*/
+const getAzureErrorXml = (errorCode, errorMessage) => html`<?xml version="1.0" encoding="utf-8"?>
+    <Error>
+      <code>${errorCode}</code>
+      <Message>${errorMessage}</Message>
+    </Error>`;
 
 //#endregion
 //#region ../../node_modules/.pnpm/@typespec+ts-http-runtime@0.2.3/node_modules/@typespec/ts-http-runtime/dist/browser/httpHeaders.js
@@ -394,6 +370,110 @@ const toWebResourceLike = (request) => ({
 	withCredentials: request.withCredentials
 });
 
+//#endregion
+//#region src/models/MockBlobBatchClient.ts
+var MockBlobBatchClient = class {
+	url;
+	constructor(url) {
+		this.url = url;
+	}
+	/**
+	* Simulates the deletion of multiple blobs in a single batch request.
+	* It iterates through the requested deletions, removes existing blobs from the
+	* underlying MockContainerDatabase, and builds a response object that reports
+	* which deletions succeeded and which failed (e.g. for blobs that didn't exist).
+	*/
+	deleteBlobs(urls, credential, _options) {
+		const subResponses = [];
+		let subResponsesSucceededCount = 0;
+		let subResponsesFailedCount = 0;
+		for (const url of urls) {
+			const urlParts = new URL(url);
+			const pathSegments = urlParts.pathname.split("/").filter(Boolean);
+			if (pathSegments.length < 2) {
+				const errorCode = "InvalidUri";
+				const statusMessage = "Invalid blob URL format.";
+				subResponses.push({
+					_request: {
+						credential,
+						url: this.url
+					},
+					bodyAsText: getAzureErrorXml(errorCode, statusMessage),
+					errorCode,
+					headers: toHttpHeadersLike(createHttpHeaders()),
+					status: 400,
+					statusMessage
+				});
+				subResponsesFailedCount++;
+			}
+			const containerName = pathSegments[0];
+			const blobName = pathSegments.slice(1).join("/");
+			const container = this.getContainer(containerName);
+			if (container.has(blobName)) {
+				container.delete(blobName);
+				subResponses.push({
+					_request: {
+						credential,
+						url: this.url
+					},
+					headers: toHttpHeadersLike(createHttpHeaders()),
+					status: 202,
+					statusMessage: "Accepted"
+				});
+				subResponsesSucceededCount++;
+			} else {
+				const errorCode = "BlobNotFound";
+				const statusMessage = "The specified blob does not exist.";
+				subResponses.push({
+					_request: {
+						credential,
+						url: this.url
+					},
+					bodyAsText: getAzureErrorXml(errorCode, statusMessage),
+					errorCode,
+					headers: toHttpHeadersLike(createHttpHeaders()),
+					status: 404,
+					statusMessage
+				});
+				subResponsesFailedCount++;
+			}
+		}
+		return Promise.resolve({
+			_response: {
+				headers: toHttpHeadersLike(createHttpHeaders({
+					"content-type": "multipart/mixed",
+					"x-ms-request-id": crypto.randomUUID()
+				})),
+				parsedHeaders: {},
+				request: toWebResourceLike(createPipelineRequest({ url: this.url })),
+				status: 202
+			},
+			subResponses,
+			subResponsesFailedCount,
+			subResponsesSucceededCount
+		});
+	}
+	getContainer(containerName) {
+		let container = MockContainerDatabase.get(containerName);
+		if (!container) {
+			container = /* @__PURE__ */ new Map();
+			MockContainerDatabase.set(containerName, container);
+		}
+		return container;
+	}
+};
+
+//#endregion
+//#region src/models/MockRestError.ts
+var MockRestError = class extends Error {
+	statusCode;
+	constructor(message, statusCode) {
+		super(message);
+		this.name = "MockRestError";
+		this.statusCode = statusCode;
+	}
+};
+
 //#endregion
 //#region ../../node_modules/.pnpm/@azure+storage-blob@12.27.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/policies/RequestPolicy.js
 /**
@@ -508,17 +588,24 @@ var AnonymousCredential = class extends Credential {
 };
 
 //#endregion
-//#region src/models/MockBlockBlobClient.ts
-var MockBlockBlobClient = class {
-	containerClient;
+//#region src/models/MockBlobClient.ts
+var MockBlobClient = class {
+	connectionString;
+	containerName;
 	credential = new AnonymousCredential();
 	name;
 	url;
-	get containerName() {
-		return this.containerClient.containerName;
+	get container() {
+		let container = MockContainerDatabase.get(this.containerName);
+		if (!container) {
+			container = /* @__PURE__ */ new Map();
+			MockContainerDatabase.set(this.containerName, container);
+		}
+		return container;
 	}
-	constructor(_connectionString, containerClient, blobName) {
-		this.containerClient = containerClient;
+	constructor(connectionString, containerName, blobName) {
+		this.connectionString = connectionString;
+		this.containerName = containerName;
 		this.name = blobName;
 		this.url = `https://mockaccount.blob.core.windows.net/${this.containerName}/${this.name}`;
 	}
@@ -528,21 +615,18 @@ var MockBlockBlobClient = class {
 	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: {
+		if (!this.container.has(this.name)) throw new MockRestError("The specified blob does not exist.", 404);
+		this.container.delete(this.name);
+		return Promise.resolve({ _response: {
 			headers: toHttpHeadersLike(createHttpHeaders()),
 			parsedHeaders: {},
 			request: toWebResourceLike(createPipelineRequest({ url: "" })),
 			status: 200
-		} }));
+		} });
 	}
 	deleteIfExists() {
 		throw new Error("Method not implemented.");
@@ -551,8 +635,8 @@ var MockBlockBlobClient = class {
 		throw new Error("Method not implemented.");
 	}
 	download() {
-		const buffer = this.containerClient.blobs.get(this.name);
-		return new Promise((resolve) => resolve({
+		const buffer = this.container.get(this.name);
+		return Promise.resolve({
 			_response: {
 				headers: toHttpHeadersLike(createHttpHeaders()),
 				parsedHeaders: {},
@@ -560,12 +644,12 @@ var MockBlockBlobClient = class {
 				status: buffer ? 200 : 404
 			},
 			readableStreamBody: buffer ? Readable.from(buffer) : void 0
-		}));
+		});
 	}
 	downloadToBuffer() {
-		const data = this.containerClient.blobs.get(this.name);
+		const data = this.container.get(this.name);
 		if (!data) throw new MockRestError("The specified blob does not exist.", 404);
-		return new Promise((resolve) => resolve(Buffer.from(data)));
+		return Promise.resolve(Buffer.from(data));
 	}
 	downloadToFile() {
 		throw new Error("Method not implemented.");
@@ -597,9 +681,6 @@ var MockBlockBlobClient = class {
 	getBlockBlobClient() {
 		throw new Error("Method not implemented.");
 	}
-	getBlockList() {
-		throw new Error("Method not implemented.");
-	}
 	getPageBlobClient() {
 		throw new Error("Method not implemented.");
 	}
@@ -609,9 +690,6 @@ var MockBlockBlobClient = class {
 	getTags() {
 		throw new Error("Method not implemented.");
 	}
-	query() {
-		throw new Error("Method not implemented.");
-	}
 	setAccessTier() {
 		throw new Error("Method not implemented.");
 	}
@@ -630,23 +708,74 @@ var MockBlockBlobClient = class {
 	setTags() {
 		throw new Error("Method not implemented.");
 	}
-	stageBlock() {
+	syncCopyFromURL() {
 		throw new Error("Method not implemented.");
 	}
-	stageBlockFromURL() {
+	undelete() {
 		throw new Error("Method not implemented.");
 	}
-	syncCopyFromURL() {
+	withSnapshot() {
 		throw new Error("Method not implemented.");
 	}
-	syncUploadFromURL() {
+	withVersion() {
 		throw new Error("Method not implemented.");
 	}
-	undelete() {
+};
+
+//#endregion
+//#region src/util/isReadableStream.ts
+const isReadableStream = (value) => value instanceof Readable;
+
+//#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 src/models/MockBlockBlobClient.ts
+var MockBlockBlobClient = class extends MockBlobClient {
+	commitBlockList() {
+		throw new Error("Method not implemented.");
+	}
+	getBlockList() {
+		throw new Error("Method not implemented.");
+	}
+	query() {
+		throw new Error("Method not implemented.");
+	}
+	stageBlock() {
+		throw new Error("Method not implemented.");
+	}
+	stageBlockFromURL() {
+		throw new Error("Method not implemented.");
+	}
+	syncUploadFromURL() {
 		throw new Error("Method not implemented.");
 	}
 	async upload(body, _contentLength) {
-		this.containerClient.blobs.set(this.name, await bodyToBuffer(body));
+		this.container.set(this.name, await bodyToBuffer(body));
 		return { _response: {
 			headers: toHttpHeadersLike(createHttpHeaders()),
 			parsedHeaders: {},
@@ -666,12 +795,6 @@ var MockBlockBlobClient = class {
 	uploadStream() {
 		throw new Error("Method not implemented.");
 	}
-	withSnapshot() {
-		throw new Error("Method not implemented.");
-	}
-	withVersion() {
-		throw new Error("Method not implemented.");
-	}
 };
 
 //#endregion
@@ -706,11 +829,20 @@ const getBlobPrefixXml = (name) => html`<BlobPrefix><Name>${name}</Name></BlobPr
 * const content = await blockBlobClient.downloadToBuffer();
 */
 var MockContainerClient = class {
-	blobs = /* @__PURE__ */ new Map();
+	connectionString;
 	containerName;
 	credential = new AnonymousCredential();
 	url;
-	constructor(_connectionString, containerName) {
+	get container() {
+		let container = MockContainerDatabase.get(this.containerName);
+		if (!container) {
+			container = /* @__PURE__ */ new Map();
+			MockContainerDatabase.set(this.containerName, container);
+		}
+		return container;
+	}
+	constructor(connectionString, containerName) {
+		this.connectionString = connectionString;
 		this.containerName = containerName;
 		this.url = `https://mockaccount.blob.core.windows.net/${this.containerName}`;
 	}
@@ -757,16 +889,16 @@ var MockContainerClient = class {
 		throw new Error("Method not implemented.");
 	}
 	getBlobBatchClient() {
-		throw new Error("Method not implemented.");
+		return new MockBlobBatchClient(this.url);
 	}
-	getBlobClient() {
-		throw new Error("Method not implemented.");
+	getBlobClient(blobName) {
+		return new MockBlockBlobClient(this.connectionString, this.containerName, blobName);
 	}
 	getBlobLeaseClient() {
 		throw new Error("Method not implemented.");
 	}
 	getBlockBlobClient(blobName) {
-		return new MockBlockBlobClient("", this, blobName);
+		return new MockBlockBlobClient(this.connectionString, this.containerName, blobName);
 	}
 	getPageBlobClient() {
 		throw new Error("Method not implemented.");
@@ -789,13 +921,13 @@ var MockContainerClient = class {
 					allBlobPrefixes.push({ name: blobHierarchyItem.name });
 					allBlobPrefixXml.push(getBlobPrefixXml(blobHierarchyItem.name));
 				}
-				if (allBlobItems.length > 0 || allBlobPrefixes.length > 0) yield await new Promise((resolve) => resolve({
+				if (allBlobItems.length > 0 || allBlobPrefixes.length > 0) yield await Promise.resolve({
 					_response: {
 						bodyAsText: html`<?xml version="1.0" encoding="utf8"?>
-                    <EnumerationResults ServiceEndpoint="" ContainerName="${this.containerName}">
-                      <Blobs>${allBlobItemXml.join("")}${allBlobPrefixXml.join("")}</Blobs>
-                      <NextMarker />
-                    </EnumerationResults>`,
+                  <EnumerationResults ServiceEndpoint="" ContainerName="${this.containerName}">
+                    <Blobs>${allBlobItemXml.join("")}${allBlobPrefixXml.join("")}</Blobs>
+                    <NextMarker />
+                  </EnumerationResults>`,
 						headers: toHttpHeadersLike(createHttpHeaders()),
 						parsedBody: {
 							containerName: this.containerName,
@@ -813,7 +945,7 @@ var MockContainerClient = class {
 					prefix: options?.prefix ?? "",
 					segment: { blobItems: allBlobItems },
 					serviceEndpoint: ""
-				}));
+				});
 			}.bind(this)(),
 			next: blobHierarchyItemIterator.next.bind(blobHierarchyItemIterator),
 			[Symbol.asyncIterator]() {
@@ -831,13 +963,13 @@ var MockContainerClient = class {
 					allBlobItems.push(blobItem);
 					allBlobItemXml.push(getBlobItemXml(blobItem));
 				}
-				if (allBlobItems.length > 0) yield await new Promise((resolve) => resolve({
+				if (allBlobItems.length > 0) yield await Promise.resolve({
 					_response: {
 						bodyAsText: html`<?xml version="1.0" encoding="utf8"?>
-                    <EnumerationResults ServiceEndpoint="" ContainerName="${this.containerName}">
-                      <Blobs>${allBlobItemXml.join("")}</Blobs>
-                      <NextMarker />
-                    </EnumerationResults>`,
+                  <EnumerationResults ServiceEndpoint="" ContainerName="${this.containerName}">
+                    <Blobs>${allBlobItemXml.join("")}</Blobs>
+                    <NextMarker />
+                  </EnumerationResults>`,
 						headers: toHttpHeadersLike(createHttpHeaders()),
 						parsedBody: {
 							containerName: this.containerName,
@@ -855,7 +987,7 @@ var MockContainerClient = class {
 					prefix: "",
 					segment: { blobItems: allBlobItems },
 					serviceEndpoint: ""
-				}));
+				});
 			}.bind(this)(),
 			next: blobItemIterator.next.bind(blobItemIterator),
 			[Symbol.asyncIterator]() {
@@ -880,7 +1012,7 @@ var MockContainerClient = class {
 		const prefix = options?.prefix ?? "";
 		const uniqueSubprefixes = /* @__PURE__ */ new Set();
 		const blobsInCurrentLevel = [];
-		for (const [name, buffer] of this.blobs.entries()) {
+		for (const [name, buffer] of this.container.entries()) {
 			if (!name.startsWith(prefix)) continue;
 			const nameAfterPrefix = name.slice(prefix.length);
 			const delimiterIndex = nameAfterPrefix.indexOf(delimiter);
@@ -903,17 +1035,17 @@ var MockContainerClient = class {
 				uniqueSubprefixes.add(subprefix);
 			}
 		}
-		for (const prefixName of [...uniqueSubprefixes].sort()) yield await new Promise((resolve) => resolve({
+		for (const prefixName of [...uniqueSubprefixes].sort()) yield await Promise.resolve({
 			kind: "prefix",
 			name: prefixName
-		}));
-		for (const blobItem of blobsInCurrentLevel) yield await new Promise((resolve) => resolve({
+		});
+		for (const blobItem of blobsInCurrentLevel) yield await Promise.resolve({
 			kind: "blob",
 			...blobItem
-		}));
+		});
 	}
 	async *getBlobItemIterator() {
-		for (const [name, buffer] of this.blobs.entries()) yield await new Promise((resolve) => resolve({
+		for (const [name, buffer] of this.container.entries()) yield await Promise.resolve({
 			deleted: false,
 			name,
 			properties: {
@@ -926,10 +1058,14 @@ var MockContainerClient = class {
 				leaseStatus: "unlocked"
 			},
 			snapshot: ""
-		}));
+		});
 	}
 };
 
+//#endregion
+//#region src/store/MockTableDatabase.ts
+const MockTableDatabase = /* @__PURE__ */ new Map();
+
 //#endregion
 //#region src/models/MockTableClient.ts
 /**
@@ -942,31 +1078,38 @@ var MockContainerClient = class {
 * const entity = await mockTableClient.getEntity("partitionKey", "rowKey");
 */
 var MockTableClient = class {
-	entities = /* @__PURE__ */ new Map();
 	tableName;
 	url;
+	get table() {
+		let table = MockTableDatabase.get(this.tableName);
+		if (!table) {
+			table = /* @__PURE__ */ new Map();
+			MockTableDatabase.set(this.tableName, table);
+		}
+		return table;
+	}
 	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);
+		if (this.table.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({
+		this.table.set(key, storedEntity);
+		return Promise.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({}));
+		if (!this.table.has(key)) throw new MockRestError("The specified resource does not exist.", 404);
+		this.table.delete(key);
+		return Promise.resolve({});
 	}
 	deleteTable() {
 		throw new Error("Method not implemented.");
@@ -976,24 +1119,24 @@ var MockTableClient = class {
 	}
 	getEntity(partitionKey, rowKey) {
 		const key = this.getCompositeKey(partitionKey, rowKey);
-		const entity = this.entities.get(key);
+		const entity = this.table.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));
+		return Promise.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),
+				if (allEntitiesWithMetadata.length > 0) yield await Promise.resolve(allEntitiesWithMetadata);
+			}(this.table),
 			next: () => async function* (entities) {
 				for (const entity of entities.values()) {
 					const entityWithMetadata = withMetadata(entity);
-					yield await new Promise((resolve) => resolve(entityWithMetadata));
+					yield await Promise.resolve(entityWithMetadata);
 				}
-			}(this.entities).next(),
+			}(this.table).next(),
 			[Symbol.asyncIterator]() {
 				return this;
 			}
@@ -1007,26 +1150,26 @@ var MockTableClient = class {
 	}
 	updateEntity(entity, mode = "Merge") {
 		const key = this.getCompositeKey(entity.partitionKey, entity.rowKey);
-		const existingEntity = this.entities.get(key);
+		const existingEntity = this.table.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({
+		this.table.set(key, newEntityWithMetadata);
+		return Promise.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);
+		const existingEntity = this.table.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({
+		this.table.set(key, newEntity);
+		return Promise.resolve({
 			date: /* @__PURE__ */ new Date(),
 			etag: newEntity.etag
-		}));
+		});
 	}
 	getCompositeKey(partitionKey, rowKey) {
 		return `${partitionKey}${ID_SEPARATOR}${rowKey}`;
@@ -1036,11 +1179,11 @@ var MockTableClient = class {
 			...entity,
 			...entityToMerge
 		});
-		this.entities.set(key, mergedEntityWithMetadata);
-		return new Promise((resolve) => resolve({
+		this.table.set(key, mergedEntityWithMetadata);
+		return Promise.resolve({
 			date: /* @__PURE__ */ new Date(),
 			etag: mergedEntityWithMetadata.etag
-		}));
+		});
 	}
 	withMetadata(entity) {
 		return {
@@ -1051,4 +1194,4 @@ var MockTableClient = class {
 };
 
 //#endregion
-export { MockBlockBlobClient, MockContainerClient, MockRestError, MockTableClient, bodyToBuffer, getBlobItemXml, getBlobPrefixXml, isReadableStream, toWebResourceLike };
+export { MockBlobBatchClient, MockBlobClient, MockBlockBlobClient, MockContainerClient, MockContainerDatabase, MockRestError, MockTableClient, MockTableDatabase, bodyToBuffer, getAzureErrorXml, getBlobItemXml, getBlobPrefixXml, isReadableStream, toWebResourceLike };