DeleteTable Implementation

.gitignore

@@ -11,3 +11,4 @@ __*
 *.env
 temp
 **/.DS_Store.DS_Store
+*.pem

src/table/errors/StorageErrorFactory.ts

@@ -86,4 +86,15 @@ export default class StorageErrorFactory {
       context
     );
   }
+
+  public static getTableNotFound(context: Context): StorageError {
+    return new StorageError(
+      404,
+      "TableNotFound",
+      "The table specified does not exist.",
+      context.contextID || defaultID,
+      undefined,
+      context
+    );
+  }
 }

src/table/handlers/TableHandler.ts

@@ -14,7 +14,7 @@ import {
   NO_METADATA_ACCEPT,
   RETURN_CONTENT,
   RETURN_NO_CONTENT,
-  TABLE_API_VERSION,
+  TABLE_API_VERSION
 } from "../utils/constants";
 import { newEtag } from "../utils/utils";
 import BaseHandler from "./BaseHandler";
@@ -138,23 +138,27 @@ export default class TableHandler extends BaseHandler implements ITableHandler {
   }
 
   public async delete(
-    table: string,
+    tablename: string,
     options: Models.TableDeleteMethodOptionalParams,
     context: Context
   ): Promise<Models.TableDeleteResponse> {
-    // e.g
-    // const tableCtx = new TableStorageContext(context);
-    // const accountName = tableCtx.account;
-    // const tableName = tableCtx.tableName; // Get tableName from context
-    // return {
-    //   statusCode: 204,
-    //   clientRequestId: "clientRequestId",
-    //   requestId: "requestId",
-    //   version: "version"
-    // };
+    const tableCtx = new TableStorageContext(context);
+    const accountName = tableCtx.account;
+    // currently the tableName is not coming through, so we take it from the table context
+    await this.metadataStore.deleteTable(
+      context,
+      tableCtx.tableName!,
+      accountName!
+    );
+    const response: Models.TableDeleteResponse = {
+      clientRequestId: options.requestId,
+      requestId: tableCtx.contextID,
+      version: TABLE_API_VERSION,
+      date: context.startTime,
+      statusCode: 204
+    };
 
-    // TODO
-    throw new NotImplementedError();
+    return response;
   }
 
   public async queryEntities(
@@ -341,7 +345,12 @@ export default class TableHandler extends BaseHandler implements ITableHandler {
     const id = `${protocol}://${host}/Tables(${tableName})`;
     const editLink = `Tables(${tableName})`;
 
-    await this.metadataStore.insertTableEntity(context, tableName, entity);
+    await this.metadataStore.insertTableEntity(
+      context,
+      tableName,
+      accountName!,
+      entity
+    );
 
     const response: Models.TableInsertEntityResponse = {
       clientRequestId: options.requestId,

src/table/persistence/ITableMetadataStore.ts

@@ -27,7 +27,11 @@ export type TableModel = ITtableAdditionalProperties;
 export default interface ITableMetadataStore {
   queryTable(context: Context): Promise<Models.TableResponseProperties[]>;
   createTable(context: Context, table: TableModel): Promise<void>;
-  deleteTable(context: Context, tableName: string): Promise<void>;
+  deleteTable(
+    context: Context,
+    tableName: string,
+    accountName: string
+  ): Promise<void>;
   queryTableEntities(
     context: Context,
     table: string,
@@ -60,6 +64,7 @@ export default interface ITableMetadataStore {
   insertTableEntity(
     context: Context,
     tableName: string,
+    account: string,
     entity: IEntity
   ): Promise<void>;
   getTableAccessPolicy(

src/table/persistence/LokiTableMetadataStore.ts

@@ -29,29 +29,29 @@ export default class LokiTableMetadataStore implements ITableMetadataStore {
     return this.closed;
   }
 
-  public async createTable(
-    context: Context,
-    table: TableModel
-  ): Promise<void> {
+  public async createTable(context: Context, table: TableModel): Promise<void> {
+    const tablename = this.getTableCollectionNameString(
+      table.account,
+      table.tableName
+    );
     const coll = this.db.getCollection(this.TABLE_COLLECTION);
     const doc = coll.findOne({
-      accountName: table.account,
-      name: table.tableName
+      // ToDO REMOVE: accountName: table.account,
+      tableName: tablename
     });
 
     // If the metadata exists, we will throw getTableAlreadyExists error
     if (doc) {
       throw StorageErrorFactory.getTableAlreadyExists(context);
     }
-
+    table.tableName = tablename;
     coll.insert(table);
-
-    const extentColl = this.db.getCollection(table.tableName);
+    const extentColl = this.db.getCollection(tablename);
     if (extentColl) {
       throw StorageErrorFactory.getTableAlreadyExists(context);
     }
 
-    this.db.addCollection(table.tableName, {
+    this.db.addCollection(tablename, {
       // Optimization for indexing and searching
       // https://rawgit.com/techfort/LokiJS/master/jsdoc/tutorial-Indexing%20and%20Query%20performance.html
       indices: ["ParititionKey", "RowKey"]
@@ -61,9 +61,12 @@ export default class LokiTableMetadataStore implements ITableMetadataStore {
   public async insertTableEntity(
     context: Context,
     tableName: string,
+    account: string,
     entity: IEntity
   ): Promise<void> {
-    const tableColl = this.db.getCollection(tableName);
+    const tableColl = this.db.getCollection(
+      this.getTableCollectionNameString(account, tableName)
+    );
     if (!tableColl) {
       throw StorageErrorFactory.getTableNotExist(context);
     }
@@ -90,10 +93,27 @@ export default class LokiTableMetadataStore implements ITableMetadataStore {
 
   public async deleteTable(
     context: Context,
-    tableName: string
+    name: string,
+    account: string
   ): Promise<void> {
-    // TODO    context: Context
-    throw new NotImplementedError();
+    const tablename = this.getTableCollectionNameString(account, name);
+    const tableColl = this.db.getCollection(tablename);
+    // delete the collection / table
+    if (tableColl != null) {
+      this.db.removeCollection(tablename);
+    } else {
+      throw StorageErrorFactory.getTableNotFound(context);
+    }
+    // remove table reference from collection registry
+    const coll = this.db.getCollection(this.TABLE_COLLECTION);
+    const doc = coll.findOne({
+      tableName: tablename
+    });
+    if (doc != null) {
+      coll.remove(doc);
+    } else {
+      throw StorageErrorFactory.getTableNotFound(context);
+    }
   }
 
   public async queryTableEntities(
@@ -184,7 +204,7 @@ export default class LokiTableMetadataStore implements ITableMetadataStore {
       this.db.addCollection(this.TABLE_COLLECTION, {
         // Optimization for indexing and searching
         // https://rawgit.com/techfort/LokiJS/master/jsdoc/tutorial-Indexing%20and%20Query%20performance.html
-        indices: ["accountName", "name"]
+        indices: ["accountName", "tableName"]
       }); // Optimize for find operation
     }
 
@@ -215,4 +235,10 @@ export default class LokiTableMetadataStore implements ITableMetadataStore {
 
     this.closed = true;
   }
+  private getTableCollectionNameString(
+    accountName: string,
+    tableName: string
+  ): string {
+    return accountName + tableName;
+  }
 }

tests/table/apis/table.test.ts

@@ -5,7 +5,13 @@ import { configLogger } from "../../../src/common/Logger";
 import TableConfiguration from "../../../src/table/TableConfiguration";
 import TableServer from "../../../src/table/TableServer";
 import { TABLE_API_VERSION } from "../../../src/table/utils/constants";
-import { EMULATOR_ACCOUNT_KEY, EMULATOR_ACCOUNT_NAME, getUniqueName, overrideRequest } from "../../testutils";
+import {
+  EMULATOR_ACCOUNT_KEY,
+  EMULATOR_ACCOUNT_NAME,
+  getUniqueName,
+  overrideRequest
+} from "../../testutils";
+// import { options } from "args";
 
 // Set true to enable debug log
 configLogger(false);
@@ -120,4 +126,49 @@ describe("table APIs test", () => {
     // TODO
     done();
   });
+
+  it("deleteTable that exists, @loki", done => {
+    /*
+    https://docs.microsoft.com/en-us/rest/api/storageservices/delete-table
+    */
+    requestOverride.headers = {
+      Prefer: "return-content",
+      accept: "application/json;odata=fullmetadata"
+    };
+
+    const tableToDelete = tableName + "del";
+
+    tableService.createTable(tableToDelete, (error, result, response) => {
+      if (!error) {
+        tableService.deleteTable(tableToDelete, (deleteError, deleteResult) => {
+          if (!deleteError) {
+            // no body expected, we expect 204 no content on successful deletion
+            assert.equal(deleteResult.statusCode, 204);
+          } else {
+            assert.ifError(deleteError);
+          }
+          done();
+        });
+      } else {
+        assert.fail("Test failed to create the table");
+        done();
+      }
+    });
+  });
+
+  it("deleteTable that does not exist, @loki", done => {
+    /*
+    https://docs.microsoft.com/en-us/rest/api/storageservices/delete-table
+    */
+    requestOverride.headers = {
+      accept: "application/json;"
+    };
+
+    const tableToDelete = tableName + "causeerror";
+
+    tableService.deleteTable(tableToDelete, (error, result) => {
+      assert.equal(result.statusCode, 404); // no body expected, we expect 404
+      done();
+    });
+  });
 });