@kwiz/node 1.0.15 → 1.0.17

package/src/axios.ts

@@ -1,45 +1,45 @@
-import { isNullOrEmptyString } from "@kwiz/common";
-import { AxiosError, AxiosRequestConfig } from "axios";
-import { Agent, globalAgent } from "https";
-
-type axiosConfigOptions = {
-    contantType?: "application/json" | "application/json; odata=nometadata" | "application/xml";
-}
-export function getAxiosConfigBearer(token: string, options?: axiosConfigOptions) {
-    return getAxiosConfig(`Bearer ${token}`, options);
-}
-
-export function getAxiosConfig(token?: string, options?: axiosConfigOptions) {
-    //allow self sign ssl certificates
-    globalAgent.options.rejectUnauthorized = false;
-    const config: AxiosRequestConfig<any> = {
-        httpAgent: new Agent({
-            rejectUnauthorized: false
-        }),
-        headers: {}
-    };
-
-    if (!isNullOrEmptyString(token))
-        config.headers!.Authorization = token;
-
-    if (options) {
-        if (!isNullOrEmptyString(options.contantType)) {
-            config.headers!["Content-Type"] = options.contantType;
-            config.headers!["Accept"] = options.contantType;
-        }
-    }
-    return config;
-}
-
-export function getAxiosErrorData(error: AxiosError) {
-    let code = error.code || "Unknown";
-    let errorMessage = error.message || "Unspecified error";
-    if (error && error.response && error.response.data && error.response.data["odata.error"]) {
-        let errorData: { code: string; message: { value: string; }; } = error.response.data["odata.error"];
-        if (errorData.message && errorData.message.value)
-            errorMessage = errorData.message.value;
-        if (errorData && errorData.code)
-            code = errorData.code;
-    }
-    return { code: code, message: errorMessage };
+import { isNullOrEmptyString } from "@kwiz/common";
+import { AxiosError, AxiosRequestConfig } from "axios";
+import { Agent, globalAgent } from "https";
+
+type axiosConfigOptions = {
+    contantType?: "application/json" | "application/json; odata=nometadata" | "application/xml";
+}
+export function getAxiosConfigBearer(token: string, options?: axiosConfigOptions) {
+    return getAxiosConfig(`Bearer ${token}`, options);
+}
+
+export function getAxiosConfig(token?: string, options?: axiosConfigOptions) {
+    //allow self sign ssl certificates
+    globalAgent.options.rejectUnauthorized = false;
+    const config: AxiosRequestConfig<any> = {
+        httpAgent: new Agent({
+            rejectUnauthorized: false
+        }),
+        headers: {}
+    };
+
+    if (!isNullOrEmptyString(token))
+        config.headers!.Authorization = token;
+
+    if (options) {
+        if (!isNullOrEmptyString(options.contantType)) {
+            config.headers!["Content-Type"] = options.contantType;
+            config.headers!["Accept"] = options.contantType;
+        }
+    }
+    return config;
+}
+
+export function getAxiosErrorData(error: AxiosError) {
+    let code = error.code || "Unknown";
+    let errorMessage = error.message || "Unspecified error";
+    if (error && error.response && error.response.data && error.response.data["odata.error"]) {
+        let errorData: { code: string; message: { value: string; }; } = error.response.data["odata.error"];
+        if (errorData.message && errorData.message.value)
+            errorMessage = errorData.message.value;
+        if (errorData && errorData.code)
+            code = errorData.code;
+    }
+    return { code: code, message: errorMessage };
 }

package/src/exports-index.ts

@@ -3,3 +3,4 @@ export * from './auth/exports-index';
 export * from './graph/exports-index';
 export * from './storage/exports-index';
 export * from './axios';
+export * from './get-with-cache';

package/src/get-with-cache.ts

@@ -0,0 +1,38 @@
+import { IDictionary, isNullOrUndefined } from "@kwiz/common";
+
+const $$cache: IDictionary<{ expires: Date; value: any }> = {};
+
+export async function getWithCache<T>(worker: () => Promise<{ success: boolean; value: T }>, info: {
+    /** seconds */
+    successCacheDuration: number;
+    /** seconds */
+    failedCacheDuration?: number;
+    /** must be unique for your call! function name, and parameters */
+    cacheKey: string;
+    forceRefresh?: boolean;
+}) {
+    const now = new Date();
+    //purge old values
+    Object.keys($$cache).forEach(key => {
+        if ($$cache[key].expires < now) delete $$cache[key];
+    });
+
+    let cached = info.forceRefresh ? null : $$cache[info.cacheKey];
+
+    if (isNullOrUndefined(cached)) {
+        const result = await worker();
+        if (result.success) {
+            $$cache[info.cacheKey] = {
+                expires: new Date(new Date().getTime() + info.successCacheDuration * 1000),
+                value: result.value
+            };
+        }
+        else if (info.failedCacheDuration > 0) {
+            $$cache[info.cacheKey] = {
+                expires: new Date(new Date().getTime() + info.failedCacheDuration * 1000),
+                value: result.value
+            };
+        }
+    }
+    return $$cache[info.cacheKey].value;
+}

package/src/graph/graph.ts

@@ -1,18 +1,18 @@
-import { AuthContextType, ITenantInfo, isNullOrUndefined } from "@kwiz/common";
-import { GetMSALToken } from "../auth/msal";
-import { getAxiosConfigBearer } from "../axios";
-
-/** "https://graph.microsoft.com" */
-export const graphScope = "https://graph.microsoft.com";
-
-var auth: AuthContextType = null;
-export function ConfigureGraphAuth(config?: AuthContextType) {
-    auth = config;
-}
-export async function getAxiosConfigGraph(tenantInfo: ITenantInfo, clearCache?: boolean) {
-    if (isNullOrUndefined(auth)) throw Error("Call ConfigureGraphAuth first");
-
-    // secret or certificate supported
-    let token = await GetMSALToken(tenantInfo, graphScope, auth, clearCache);
-    return getAxiosConfigBearer(token);
+import { AuthContextType, ITenantInfo, isNullOrUndefined } from "@kwiz/common";
+import { GetMSALToken } from "../auth/msal";
+import { getAxiosConfigBearer } from "../axios";
+
+/** "https://graph.microsoft.com" */
+export const graphScope = "https://graph.microsoft.com";
+
+var auth: AuthContextType = null;
+export function ConfigureGraphAuth(config?: AuthContextType) {
+    auth = config;
+}
+export async function getAxiosConfigGraph(tenantInfo: ITenantInfo, clearCache?: boolean) {
+    if (isNullOrUndefined(auth)) throw Error("Call ConfigureGraphAuth first");
+
+    // secret or certificate supported
+    let token = await GetMSALToken(tenantInfo, graphScope, auth, clearCache);
+    return getAxiosConfigBearer(token);
 }

package/src/index.ts

@@ -1 +1 @@
-export * from "./exports-index";
+export * from "./exports-index";

package/src/storage/common.ts

@@ -1,15 +1,15 @@
-import { isNullOrEmptyString } from "@kwiz/common";
-import axios from "axios";
-
-export async function IsAzuriteRunning() {
-    let responseServer = "";
-    try {
-        //make a request for http://127.0.0.1:10000/ expect response headers "Server" to contain "Azurite"
-        const result = await axios.get("http://127.0.0.1:10000/");
-        responseServer = result.headers.server;
-    } catch (e) {
-        responseServer = e.response && e.response.headers && e.response.headers.server;
-    }
-
-    return isNullOrEmptyString(responseServer) ? false : responseServer.toLowerCase().indexOf("azurite") >= 0;
-}
+import { isNullOrEmptyString } from "@kwiz/common";
+import axios from "axios";
+
+export async function IsAzuriteRunning() {
+    let responseServer = "";
+    try {
+        //make a request for http://127.0.0.1:10000/ expect response headers "Server" to contain "Azurite"
+        const result = await axios.get("http://127.0.0.1:10000/");
+        responseServer = result.headers.server;
+    } catch (e) {
+        responseServer = e.response && e.response.headers && e.response.headers.server;
+    }
+
+    return isNullOrEmptyString(responseServer) ? false : responseServer.toLowerCase().indexOf("azurite") >= 0;
+}

package/src/storage/odata.ts

@@ -1,87 +1,87 @@
-import { isNullOrEmptyArray, isNullOrEmptyString, isNullOrUndefined } from "@kwiz/common";
-
-export enum ODataOperators {
-    equal = "eq",
-    notEqual = "ne",
-    greater = "gt",
-    greaterOrEqual = "ge",
-    less = "lt",
-    lessOrEqual = "le",
-    contains = "in",
-    startswith = "startswith"
-}
-export enum ODataJoinOperators {
-    and = "and",
-    or = "or"
-}
-
-export interface IOdataFilter<DataType> {
-    property: keyof DataType;
-    operator: ODataOperators;
-    value: string | Date | number | boolean;
-    not?: boolean;
-}
-export interface IOdataFilterStatement<DataType> {
-    filters: (IOdataFilter<DataType> | IOdataFilterStatement<DataType>)[];
-    /** default: or */
-    join?: ODataJoinOperators;
-    not?: boolean;
-}
-function isIOdataFilter<DataType>(f: IOdataFilter<DataType> | IOdataFilterStatement<DataType>): f is IOdataFilter<DataType> {
-    if (typeof (f as IOdataFilter<DataType>).property === "string")
-        return true;
-    return false;
-}
-function isIOdataFilterStatement<DataType>(f: IOdataFilter<DataType> | IOdataFilterStatement<DataType>): f is IOdataFilter<DataType> {
-    if (typeof (f as IOdataFilterStatement<DataType>).filters === "object" && Array.isArray((f as IOdataFilterStatement<DataType>).filters))
-        return true;
-    return false;
-}
-
-enum TableStorageKnownColumns {
-    partitionKey = "PartitionKey",
-    rowKey = "RowKey"
-}
-
-function getPropNameForFilter(prop: string | number | symbol) {
-    return TableStorageKnownColumns[prop] || prop as string;
-}
-function getOdataFilterStatement<DataType>(filter: IOdataFilter<DataType>) {
-    let filterValue = isNullOrUndefined(filter.value)
-        ? `null`
-        : typeof filter.value === "string"
-            ? `'${filter.value.replace(/'/g, "''")}'`
-            : filter.value instanceof Date
-                ? `'${filter.value.toISOString()}'`
-                : `${filter.value}`;
-
-    if (filter.operator === ODataOperators.startswith)
-        return `${filter.not ? 'not ' : ''}${filter.operator}(${getPropNameForFilter(filter.property)}, ${filterValue})`;
-    return `${filter.not ? 'not ' : ''}${getPropNameForFilter(filter.property)} ${filter.operator} ${filterValue}`;
-}
-
-export function getOdataFilter<DataType>(statement: IOdataFilterStatement<DataType>) {
-    if (isNullOrUndefined(statement) || isNullOrEmptyArray(statement.filters)) return "";
-    if (isNullOrEmptyString(statement.join)) statement.join = ODataJoinOperators.or;
-
-    let filterStatements: string[] = [];
-    statement.filters.forEach(filter => {
-        if (isIOdataFilter(filter)) {
-            filterStatements.push(getOdataFilterStatement<DataType>(filter));
-        }
-        else {
-            let subStatement = getOdataFilter(filter);
-            if (!isNullOrEmptyString(subStatement))
-                filterStatements.push(subStatement);
-        }
-    });
-    if (filterStatements.length === 0) return "";
-
-    let result = "";
-    if (filterStatements.length === 1) result = filterStatements[0];
-    else if (filterStatements.length > 1) {
-        result = `(${filterStatements.join(` ${statement.join} `)})`;
-    }
-
-    return `${statement.not ? '(not ' : ''}${result}${statement.not ? ')' : ''}`;
+import { isNullOrEmptyArray, isNullOrEmptyString, isNullOrUndefined } from "@kwiz/common";
+
+export enum ODataOperators {
+    equal = "eq",
+    notEqual = "ne",
+    greater = "gt",
+    greaterOrEqual = "ge",
+    less = "lt",
+    lessOrEqual = "le",
+    contains = "in",
+    startswith = "startswith"
+}
+export enum ODataJoinOperators {
+    and = "and",
+    or = "or"
+}
+
+export interface IOdataFilter<DataType> {
+    property: keyof DataType;
+    operator: ODataOperators;
+    value: string | Date | number | boolean;
+    not?: boolean;
+}
+export interface IOdataFilterStatement<DataType> {
+    filters: (IOdataFilter<DataType> | IOdataFilterStatement<DataType>)[];
+    /** default: or */
+    join?: ODataJoinOperators;
+    not?: boolean;
+}
+function isIOdataFilter<DataType>(f: IOdataFilter<DataType> | IOdataFilterStatement<DataType>): f is IOdataFilter<DataType> {
+    if (typeof (f as IOdataFilter<DataType>).property === "string")
+        return true;
+    return false;
+}
+function isIOdataFilterStatement<DataType>(f: IOdataFilter<DataType> | IOdataFilterStatement<DataType>): f is IOdataFilter<DataType> {
+    if (typeof (f as IOdataFilterStatement<DataType>).filters === "object" && Array.isArray((f as IOdataFilterStatement<DataType>).filters))
+        return true;
+    return false;
+}
+
+enum TableStorageKnownColumns {
+    partitionKey = "PartitionKey",
+    rowKey = "RowKey"
+}
+
+function getPropNameForFilter(prop: string | number | symbol) {
+    return TableStorageKnownColumns[prop] || prop as string;
+}
+function getOdataFilterStatement<DataType>(filter: IOdataFilter<DataType>) {
+    let filterValue = isNullOrUndefined(filter.value)
+        ? `null`
+        : typeof filter.value === "string"
+            ? `'${filter.value.replace(/'/g, "''")}'`
+            : filter.value instanceof Date
+                ? `'${filter.value.toISOString()}'`
+                : `${filter.value}`;
+
+    if (filter.operator === ODataOperators.startswith)
+        return `${filter.not ? 'not ' : ''}${filter.operator}(${getPropNameForFilter(filter.property)}, ${filterValue})`;
+    return `${filter.not ? 'not ' : ''}${getPropNameForFilter(filter.property)} ${filter.operator} ${filterValue}`;
+}
+
+export function getOdataFilter<DataType>(statement: IOdataFilterStatement<DataType>) {
+    if (isNullOrUndefined(statement) || isNullOrEmptyArray(statement.filters)) return "";
+    if (isNullOrEmptyString(statement.join)) statement.join = ODataJoinOperators.or;
+
+    let filterStatements: string[] = [];
+    statement.filters.forEach(filter => {
+        if (isIOdataFilter(filter)) {
+            filterStatements.push(getOdataFilterStatement<DataType>(filter));
+        }
+        else {
+            let subStatement = getOdataFilter(filter);
+            if (!isNullOrEmptyString(subStatement))
+                filterStatements.push(subStatement);
+        }
+    });
+    if (filterStatements.length === 0) return "";
+
+    let result = "";
+    if (filterStatements.length === 1) result = filterStatements[0];
+    else if (filterStatements.length > 1) {
+        result = `(${filterStatements.join(` ${statement.join} `)})`;
+    }
+
+    return `${statement.not ? '(not ' : ''}${result}${statement.not ? ')' : ''}`;
 }

package/src/storage/table-storage.test.js

@@ -1,135 +1,135 @@
-import assert from 'assert/strict';
-import test from 'node:test';
-import { IsAzuriteRunning } from "./common";
-import { ODataOperators } from "./odata";
-import { ConfigureTableStorage, Table, addItem, ensureTable } from "./table-storage";
-
-test('testTableStorage', async t => {
-    if (!(await IsAzuriteRunning())) {
-        console.log('Skipping table-storage tests - azurite is not running.');
-        return;
-    }
-    //configure storage
-    ConfigureTableStorage({ connectionString: "UseDevelopmentStorage=true" });
-
-    const tableName = "TestTable";
-    const table = new Table(tableName, {
-        getKeys: p => p,
-        transform: {
-            load: v => ({ ...v, schedule: JSON.parse(v.schedule) }),
-            save: v => ({ ...v, schedule: JSON.stringify(v.schedule) })
-        }
-    });
-    const partitionKey = "PK1";
-    const partitionKey2 = "PK2";
-    const rowKey1 = "0b8612bb-377d-4897-be8f-a532a1ad3e73|d2e32b93-c096-431c-8a79-fcce9a4d7bce";
-    const rowKey2 = "0b8612bb-377d-4897-be8f-a532a1ad3e73|cd24aa15-0d03-4892-bb46-af32e5fb9361";
-    //start fresh
-    let result = await table.delete();
-    //don't test this - it might have a table to delete and might not... depending if cleanup didn't work last run
-    //await t.test("Delete table", t => assert.strictEqual(result, true));
-
-    //provoke table name not allowed
-    result = await ensureTable("T2");
-    await t.test("Table name not allowed", t => assert.strictEqual(result, false));
-
-    //create table
-    result = await table.ensure();
-    await t.test("Create table", t => assert.strictEqual(result, true));
-
-    //provoke table already exists
-    result = await table.ensure();
-    await t.test("Ensure existing table", t => assert.strictEqual(result, true));
-
-    //add item
-    result = await table.addItem({
-        partitionKey: partitionKey,
-        rowKey: rowKey1,
-        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
-        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
-        nextUTC: "2023010105",
-        schedule: { days: 4, hours: [1, 2, 3] }
-    });
-    await t.test("Create item 1", t => assert.strictEqual(result, true));
-
-    result = await table.addItem({
-        partitionKey: partitionKey,
-        rowKey: rowKey2,
-        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
-        action: "fab4094b-c000-4ff4-bb52-0f8538b2bc49",
-        nextUTC: "2023010105",
-        schedule: { days: 4, hours: [1, 2, 3] }
-    });
-    await t.test("Create item 2", t => assert.strictEqual(result, true));
-
-    result = await table.addItem({
-        partitionKey: partitionKey2,
-        rowKey: rowKey1,
-        list: "b98211e2-809a-4761-b928-559eddc28dfc",
-        action: "d20196e5-feb9-4202-bd03-718b49bf029e",
-        nextUTC: "2023010105",
-        schedule: { days: 4, hours: [1, 2, 3] }
-    });
-    await t.test("Create item in second partition", t => assert.strictEqual(result, true));
-
-    //provoke add second item with same key
-    result = await table.addItem({
-        partitionKey: partitionKey,
-        rowKey: rowKey1,
-        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
-        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
-        nextUTC: "2023010105",
-        schedule: { days: 4, hours: [1, 2, 3] }
-    });
-    await t.test("Create item with existing key", t => assert.strictEqual(result, false));
-
-    //provoke add second item with same key
-    result = await table.upsertItem({
-        partitionKey: partitionKey,
-        rowKey: rowKey1,
-        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
-        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
-        nextUTC: "2023020202",
-        schedule: { days: 4, hours: [1, 2, 3] }
-    });
-    await t.test("Update item 1", t => assert.strictEqual(result, true));
-
-    //provoke add item to table that does not exist
-    result = await addItem(tableName + "DoeNotExist", {
-        partitionKey: partitionKey,
-        rowKey: rowKey1,
-        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
-        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
-        nextUTC: "2023020202",
-        schedule: { days: 4, hours: [1, 2, 3] }
-    });
-    await t.test("Create item in table that does not exist", t => assert.strictEqual(result, false));
-
-    let allItems = await table.getItems();
-    await t.test("Get items", t => assert.strictEqual(allItems.length, 3));
-
-    //find items by partition
-    let partitionItems = await table.getItems({
-        filterStatment: {
-            filters: [
-                {
-                    property: "partitionKey",
-                    operator: ODataOperators.equal,
-                    value: partitionKey
-                }
-            ]
-        }
-    });
-
-    await t.test("Get items with filter", t => assert.strictEqual(partitionItems.length, 2));
-    await t.test("Update values", t => assert.strictEqual(partitionItems[1].nextUTC, "2023020202"));
-
-    let deleteResult = await table.deleteItem({ partitionKey: partitionKey, rowKey: rowKey1 });
-    await t.test("delete item", t => assert.strictEqual(deleteResult, true));
-    deleteResult = await table.deleteItem({ partitionKey: partitionKey, rowKey: rowKey1 });
-    await t.test("delete item that was already deleted", t => assert.strictEqual(deleteResult, true));
-
-    //cleanup
-    result = await table.delete();
-    await t.test("Delete table", t => assert.strictEqual(result, true));
+import assert from 'assert/strict';
+import test from 'node:test';
+import { IsAzuriteRunning } from "./common";
+import { ODataOperators } from "./odata";
+import { ConfigureTableStorage, Table, addItem, ensureTable } from "./table-storage";
+
+test('testTableStorage', async t => {
+    if (!(await IsAzuriteRunning())) {
+        console.log('Skipping table-storage tests - azurite is not running.');
+        return;
+    }
+    //configure storage
+    ConfigureTableStorage({ connectionString: "UseDevelopmentStorage=true" });
+
+    const tableName = "TestTable";
+    const table = new Table(tableName, {
+        getKeys: p => p,
+        transform: {
+            load: v => ({ ...v, schedule: JSON.parse(v.schedule) }),
+            save: v => ({ ...v, schedule: JSON.stringify(v.schedule) })
+        }
+    });
+    const partitionKey = "PK1";
+    const partitionKey2 = "PK2";
+    const rowKey1 = "0b8612bb-377d-4897-be8f-a532a1ad3e73|d2e32b93-c096-431c-8a79-fcce9a4d7bce";
+    const rowKey2 = "0b8612bb-377d-4897-be8f-a532a1ad3e73|cd24aa15-0d03-4892-bb46-af32e5fb9361";
+    //start fresh
+    let result = await table.delete();
+    //don't test this - it might have a table to delete and might not... depending if cleanup didn't work last run
+    //await t.test("Delete table", t => assert.strictEqual(result, true));
+
+    //provoke table name not allowed
+    result = await ensureTable("T2");
+    await t.test("Table name not allowed", t => assert.strictEqual(result, false));
+
+    //create table
+    result = await table.ensure();
+    await t.test("Create table", t => assert.strictEqual(result, true));
+
+    //provoke table already exists
+    result = await table.ensure();
+    await t.test("Ensure existing table", t => assert.strictEqual(result, true));
+
+    //add item
+    result = await table.addItem({
+        partitionKey: partitionKey,
+        rowKey: rowKey1,
+        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
+        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
+        nextUTC: "2023010105",
+        schedule: { days: 4, hours: [1, 2, 3] }
+    });
+    await t.test("Create item 1", t => assert.strictEqual(result, true));
+
+    result = await table.addItem({
+        partitionKey: partitionKey,
+        rowKey: rowKey2,
+        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
+        action: "fab4094b-c000-4ff4-bb52-0f8538b2bc49",
+        nextUTC: "2023010105",
+        schedule: { days: 4, hours: [1, 2, 3] }
+    });
+    await t.test("Create item 2", t => assert.strictEqual(result, true));
+
+    result = await table.addItem({
+        partitionKey: partitionKey2,
+        rowKey: rowKey1,
+        list: "b98211e2-809a-4761-b928-559eddc28dfc",
+        action: "d20196e5-feb9-4202-bd03-718b49bf029e",
+        nextUTC: "2023010105",
+        schedule: { days: 4, hours: [1, 2, 3] }
+    });
+    await t.test("Create item in second partition", t => assert.strictEqual(result, true));
+
+    //provoke add second item with same key
+    result = await table.addItem({
+        partitionKey: partitionKey,
+        rowKey: rowKey1,
+        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
+        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
+        nextUTC: "2023010105",
+        schedule: { days: 4, hours: [1, 2, 3] }
+    });
+    await t.test("Create item with existing key", t => assert.strictEqual(result, false));
+
+    //provoke add second item with same key
+    result = await table.upsertItem({
+        partitionKey: partitionKey,
+        rowKey: rowKey1,
+        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
+        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
+        nextUTC: "2023020202",
+        schedule: { days: 4, hours: [1, 2, 3] }
+    });
+    await t.test("Update item 1", t => assert.strictEqual(result, true));
+
+    //provoke add item to table that does not exist
+    result = await addItem(tableName + "DoeNotExist", {
+        partitionKey: partitionKey,
+        rowKey: rowKey1,
+        list: "1bd32599-375e-4c98-9e1c-ce9dd2f2e17d",
+        action: "6b964dd7-6e62-42f6-89e4-5e79d6b6cbb0",
+        nextUTC: "2023020202",
+        schedule: { days: 4, hours: [1, 2, 3] }
+    });
+    await t.test("Create item in table that does not exist", t => assert.strictEqual(result, false));
+
+    let allItems = await table.getItems();
+    await t.test("Get items", t => assert.strictEqual(allItems.length, 3));
+
+    //find items by partition
+    let partitionItems = await table.getItems({
+        filterStatment: {
+            filters: [
+                {
+                    property: "partitionKey",
+                    operator: ODataOperators.equal,
+                    value: partitionKey
+                }
+            ]
+        }
+    });
+
+    await t.test("Get items with filter", t => assert.strictEqual(partitionItems.length, 2));
+    await t.test("Update values", t => assert.strictEqual(partitionItems[1].nextUTC, "2023020202"));
+
+    let deleteResult = await table.deleteItem({ partitionKey: partitionKey, rowKey: rowKey1 });
+    await t.test("delete item", t => assert.strictEqual(deleteResult, true));
+    deleteResult = await table.deleteItem({ partitionKey: partitionKey, rowKey: rowKey1 });
+    await t.test("delete item that was already deleted", t => assert.strictEqual(deleteResult, true));
+
+    //cleanup
+    result = await table.delete();
+    await t.test("Delete table", t => assert.strictEqual(result, true));
 });