) {
const path = "/" + offerLink;
const id = Base.parseLink(offerLink).objectBody.id.toLowerCase();
return Base.ResponseOrCallback(callback, await this.read(path, "offers", id, undefined, {}));
}
- /**
- * Lists all offers.
- * @memberof DocumentClient
- * @instance
- * @param {FeedOptions} [options] - The feed options.
- * @returns {QueryIterator} - An instance of queryIterator to handle reading feed.
- */
public readOffers(options?: FeedOptions) {
return this.queryOffers(undefined, options);
}
- /**
- * Lists all offers that satisfy a query.
- * @memberof DocumentClient
- * @instance
- * @param {SqlQuerySpec | string} query - A SQL query.
- * @param {FeedOptions} [options] - The feed options.
- * @returns {QueryIterator} - An instance of QueryIterator to handle reading feed.
- */
public queryOffers(query: string | SqlQuerySpec, options?: FeedOptions) {
return new QueryIterator(this, query, options, (innerOptions) => {
return this.queryFeed(
@@ -2731,133 +1934,6 @@ export class DocumentClient extends DocumentClientBase {
}
}
-/**
- * The request options
- * @typedef {Object} RequestOptions - \
- * Options that can be specified for a requested issued to the Azure Cosmos DB servers.
- * @property {object} [accessCondition] - \
- * Conditions Associated with the request.
- * @property {string} accessCondition.type - \
- * Conditional HTTP method header type (IfMatch or IfNoneMatch).
- * @property {string} accessCondition.condition - \
- * Conditional HTTP method header value (the _etag field from the last version you read).
- * @property {string} [consistencyLevel] - \
- * Consistency level required by the client.
- * @property {boolean} [disableRUPerMinuteUsage] - \
- * DisableRUPerMinuteUsage is used to enable/disable Request Units(RUs)/minute capacity to \
- * serve the request if regular provisioned RUs/second is exhausted.
- * @property {boolean} [enableScriptLogging] - \
- * Enables or disables logging in JavaScript stored procedures.
- * @property {string} [indexingDirective] - \
- * Specifies indexing directives (index, do not index .. etc).
- * @property {boolean} [offerEnableRUPerMinuteThroughput] - \
- * Represents Request Units(RU)/Minute throughput is enabled/disabled for a collection \
- * in the Azure Cosmos DB database service.
- * @property {number} [offerThroughput] - \
- * The offer throughput provisioned for a collection in measurement of Requests-per-Unit \
- * in the Azure Cosmos DB database service.
- * @property {string} [offerType] - Offer type when creating document collections.
- * This option is only valid when creating a document collection.
- * @property {string} [partitionKey] - \
- * Specifies a partition key definition for a particular path in the Azure Cosmos DB database service.
- * @property {boolean} [populateQuotaInfo] - \
- * Enables/disables getting document collection quota related stats for document collection read requests.
- * @property {string} [postTriggerInclude] - \
- * Indicates what is the post trigger to be invoked after the operation.
- * @property {string} [preTriggerInclude] - \
- * Indicates what is the pre trigger to be invoked before the operation.
- * @property {number} [resourceTokenExpirySeconds] - \
- * Expiry time (in seconds) for resource token associated with permission (applicable only for requests on permissions).
- * @property {string} [sessionToken] - Token for use with Session consistency.
- */
-
-export interface RequestOptions {
- accessCondition?: {
- type: string;
- condition: string;
- };
- consistencyLevel?: string;
- disableRUPerMinuteUsage?: boolean;
- enableScriptLogging?: boolean;
- indexingDirective?: string;
- offerEnableRUPerMinuteThroughput?: boolean;
- offerThroughput?: number;
- offerType?: string;
- partitionKey?: PartitionKey;
- populateQuotaInfo?: boolean;
- postTriggerInclude?: string | string[];
- preTriggerInclude?: string | string[];
- resourceTokenExpirySeconds?: number;
- sessionToken?: string;
- initialHeaders?: IHeaders;
- urlConnection?: string;
- skipGetPartitionKeyDefinition?: boolean;
- disableAutomaticIdGeneration?: boolean;
-}
-
-/**
- * The feed options
- * @typedef {Object} FeedOptions - \
- * The feed options and query methods.
- * @property {string} [continuation] - Opaque token for continuing the enumeration.
- * @property {boolean} [disableRUPerMinuteUsage] - \
- * DisableRUPerMinuteUsage is used to enable/disable Request Units(RUs)/minute capacity to serve the \
- * request if regular provisioned RUs/second is exhausted.
- * @property {boolean} [enableCrossPartitionQuery] - \
- * A value indicating whether users are enabled to send more than one request to execute the query \
- * in the Azure Cosmos DB database service.
- * More than one request is necessary if the query is not scoped to single partition key value.
- * @property {boolean} [populateQueryMetrics] - Whether to populate the query metrics.
- * @property {boolean} [enableScanInQuery] - \
- * Allow scan on the queries which couldn't be served as indexing was opted out on the requested paths.
- * @property {number} [maxDegreeOfParallelism] - \
- * The maximum number of concurrent operations that run client side during parallel query execution \
- * in the Azure Cosmos DB database service. Negative values make the system automatically decides the \
- * number of concurrent operations to run.
- * @property {number} [maxItemCount] - \
- * Max number of items to be returned in the enumeration operation.
- * @property {string} [partitionKey] - \
- * Specifies a partition key definition for a particular path in the Azure Cosmos DB database service.
- * @property {string} [sessionToken] - Token for use with Session consistency.
- */
-export interface FeedOptions {
- continuation?: string;
- disableRUPerMinuteUsage?: boolean;
- enableCrossPartitionQuery?: boolean;
- populateQueryMetrics?: boolean;
- enableScanInQuery?: boolean;
- maxDegreeOfParallelism?: number;
- maxItemCount?: number;
- partitionKey?: string;
- sessionToken?: string;
- initialHeaders?: IHeaders;
- a_im?: string;
- accessCondition?: any; // TODO: any
-}
-
-/**
- * The media options
- * @typedef {Object} MediaOptions - Options associated with upload media.
- * @property {string} [slug] - HTTP Slug header value.
- * @property {string} [contentType=application/octet-stream] - HTTP ContentType header value.
- *
- */
-export interface MediaOptions {
- initialHeaders?: IHeaders;
- slug?: string;
- contentType?: string;
-}
-
-/**
- * The callback to execute after the request execution.
- * @callback RequestCallback
- * @param {object} error - Will contain error information if an error occurs, undefined otherwise.
- * @param {number} error.code - The response code corresponding to the error.
- * @param {string} error.body - A string represents the error information.
- * @param {Object} resource - An object that represents the requested resource \
- * (Db, collection, document ... etc) if no error happens.
- * @param {object} responseHeaders - An object that contain the response headers.
- */
export interface RequestCallback {
error?: RequestError;
resource: any; // TODO: any
@@ -2897,44 +1973,3 @@ export interface Options {
contentType?: string;
a_im?: string;
}
-
-/**
- * The Indexing Policy represents the indexing policy configuration for a collection.
- * @typedef {Object} IndexingPolicy
- * @property {boolean} automatic - Specifies whether automatic indexing is enabled for a collection.
- * In automatic indexing, documents can be explicitly excluded from indexing using {@link RequestOptions}.
- * In manual indexing, documents can be explicitly included.
- * @property {string} indexingMode - The indexing mode (consistent or lazy) {@link IndexingMode}.
- * @property {Array} IncludedPaths - An array of {@link IncludedPath} represents the paths to be \
- * included for indexing.
- * @property {Array} ExcludedPaths - An array of {@link ExcludedPath} represents the paths to be \
- * excluded from indexing.
- *
- */
-
-/**
- * Included path.
- *
- * @typedef {Object} IncludedPath
- * @property {Array} Indexes - An array of {@link Indexes}.
- * @property {string} Path - Path to be indexed.
- *
- */
-
-/**
- * Index specification.
- *
- * @typedef {Object} Indexes
- * @property {string} Kind - The index kind {@link IndexKind}.
- * @property {string} DataType - The data type {@link DataType}.
- * @property {number} Precision - The precision.
- *
- */
-
-/**
- * Excluded path.
- *
- * @typedef {Object} ExcludedPath
- * @property {string} Path - Path to be indexed.
- *
- */
diff --git a/src/documents/IndexingPolicy.ts b/src/documents/IndexingPolicy.ts
new file mode 100644
index 0000000..552ea0a
--- /dev/null
+++ b/src/documents/IndexingPolicy.ts
@@ -0,0 +1,23 @@
+import { IndexingMode } from ".";
+import { DataType, IndexKind } from "./documents";
+
+export interface IndexingPolicy {
+ /** The indexing mode (consistent or lazy) {@link IndexingMode}. */
+ indexingMode?: IndexingMode;
+ automatic?: boolean;
+ /** An array of {@link IncludedPath} represents the paths to be included for indexing. */
+ includedPaths?: IndexedPath[];
+ /** An array of {@link IncludedPath} represents the paths to be excluded for indexing. */
+ excludedPaths?: IndexedPath[];
+}
+
+export interface IndexedPath {
+ path: string;
+ indexes?: Index[];
+}
+
+export interface Index {
+ kind: IndexKind;
+ dataType: DataType;
+ precision?: number;
+}
diff --git a/src/documents/PartitionKeyDefinition.ts b/src/documents/PartitionKeyDefinition.ts
new file mode 100644
index 0000000..cc6c2c4
--- /dev/null
+++ b/src/documents/PartitionKeyDefinition.ts
@@ -0,0 +1,6 @@
+import { PartitionKind } from "./documents";
+
+export interface PartitionKeyDefinition {
+ paths: string[];
+ kind: PartitionKind;
+}
diff --git a/src/documents/documents.ts b/src/documents/documents.ts
index 40c3e9f..723730d 100644
--- a/src/documents/documents.ts
+++ b/src/documents/documents.ts
@@ -1,11 +1,11 @@
import { Point, Range } from "../range";
-import { RetryOptions } from "../retry";
+import { PartitionKeyDefinition } from "./PartitionKeyDefinition";
export interface Document {
[key: string]: any;
}
-export type PartitionKey = Point | Range;
+export type PartitionKey = PartitionKeyDefinition | Point | Range;
/**
* Represents the consistency levels supported for Azure Cosmos DB client operations.
@@ -42,11 +42,11 @@ export enum ConsistencyLevel {
* @enum {string}
* @property Consistent
Index is updated synchronously with a create or update operation.
* With consistent indexing, query behavior is the same as the default consistency \
- * level for the collection. The index is
+ * level for the container. The index is
* always kept up to date with the data.
* @property Lazy Index is updated asynchronously with respect to a create or update operation.
* With lazy indexing, queries are eventually consistent. The index is updated when the \
- * collection is idle.
+ * container is idle.
*/
export enum IndexingMode {
Consistent = "consistent",
diff --git a/src/documents/index.ts b/src/documents/index.ts
index 69ea643..4423b8e 100644
--- a/src/documents/index.ts
+++ b/src/documents/index.ts
@@ -1,3 +1,5 @@
export * from "./documents";
export * from "./DatabaseAccount";
export * from "./ConnectionPolicy";
+export * from "./IndexingPolicy";
+export * from "./PartitionKeyDefinition";
diff --git a/src/globalEndpointManager.ts b/src/globalEndpointManager.ts
index 0a68b07..a2d25c2 100644
--- a/src/globalEndpointManager.ts
+++ b/src/globalEndpointManager.ts
@@ -1,6 +1,5 @@
import * as url from "url";
import { Constants } from "./common";
-import { DocumentClient } from "./documentclient";
import { DocumentClientBase } from "./DocumentClientBase";
import { DatabaseAccount, LocationsType } from "./documents";
diff --git a/src/index.ts b/src/index.ts
index 4ac045c..a7aea06 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,13 +1,17 @@
import * as DocumentBase from "./documents";
-export { DocumentClient, DocumentClient as CosmosClient } from "./documentclient";
+export { DocumentClient } from "./documentclient";
export { DocumentBase, DocumentBase as AzureDocuments };
export { Range, RangePartitionResolver } from "./range";
export { HashPartitionResolver } from "./hash";
export { Constants, UriFactory } from "./common";
export { Base } from "./base";
export { RetryOptions } from "./retry";
-export { Response } from "./request";
+export { Response, RequestOptions, FeedOptions, MediaOptions, ErrorResponse } from "./request/";
export { IHeaders } from "./queryExecutionContext";
export { QueryIterator } from "./queryIterator";
+
+export {CosmosClient} from "./CosmosClient";
+export {CosmosClientOptions} from "./CosmosClientOptions";
+export * from "./client/";
diff --git a/src/queryExecutionContext/EndpointComponent/AggregateEndpointComponent.ts b/src/queryExecutionContext/EndpointComponent/AggregateEndpointComponent.ts
index b00f2a2..641665e 100644
--- a/src/queryExecutionContext/EndpointComponent/AggregateEndpointComponent.ts
+++ b/src/queryExecutionContext/EndpointComponent/AggregateEndpointComponent.ts
@@ -1,5 +1,5 @@
import { IHeaders } from "..";
-import { Response } from "../../request";
+import { Response } from "../../request/request";
import { AverageAggregator, CountAggregator, MaxAggregator, MinAggregator, SumAggregator } from "../Aggregators";
import { IExecutionContext } from "../IExecutionContext";
import { IEndpointComponent } from "./IEndpointComponent";
diff --git a/src/queryExecutionContext/EndpointComponent/IEndpointComponent.ts b/src/queryExecutionContext/EndpointComponent/IEndpointComponent.ts
index 2ab7aed..f412804 100644
--- a/src/queryExecutionContext/EndpointComponent/IEndpointComponent.ts
+++ b/src/queryExecutionContext/EndpointComponent/IEndpointComponent.ts
@@ -1,5 +1,4 @@
-import { IHeaders } from "..";
-import { Response } from "../../request";
+import { Response } from "../../request/request";
export interface IEndpointComponent {
nextItem: () => Promise>;
diff --git a/src/queryExecutionContext/EndpointComponent/OrderByEndpointComponent.ts b/src/queryExecutionContext/EndpointComponent/OrderByEndpointComponent.ts
index 472c728..ef4643a 100644
--- a/src/queryExecutionContext/EndpointComponent/OrderByEndpointComponent.ts
+++ b/src/queryExecutionContext/EndpointComponent/OrderByEndpointComponent.ts
@@ -1,5 +1,4 @@
-import { IHeaders } from "..";
-import { Response } from "../../request";
+import { Response } from "../../request/request";
import { IExecutionContext } from "../IExecutionContext";
import { IEndpointComponent } from "./IEndpointComponent";
diff --git a/src/queryExecutionContext/EndpointComponent/TopEndpointComponent.ts b/src/queryExecutionContext/EndpointComponent/TopEndpointComponent.ts
index 5e64d74..dc17066 100644
--- a/src/queryExecutionContext/EndpointComponent/TopEndpointComponent.ts
+++ b/src/queryExecutionContext/EndpointComponent/TopEndpointComponent.ts
@@ -1,5 +1,4 @@
-import { IHeaders } from "..";
-import { Response } from "../../request";
+import { Response } from "../../request/request";
import { IExecutionContext } from "../IExecutionContext";
import { IEndpointComponent } from "./IEndpointComponent";
diff --git a/src/queryExecutionContext/IExecutionContext.ts b/src/queryExecutionContext/IExecutionContext.ts
index 61e82f9..2d6add1 100644
--- a/src/queryExecutionContext/IExecutionContext.ts
+++ b/src/queryExecutionContext/IExecutionContext.ts
@@ -1,5 +1,4 @@
-import { IHeaders } from ".";
-import { Response } from "../request";
+import { Response } from "../request/request";
export interface IExecutionContext {
nextItem: () => Promise>;
diff --git a/src/queryExecutionContext/IHeaders.ts b/src/queryExecutionContext/IHeaders.ts
new file mode 100644
index 0000000..9394a64
--- /dev/null
+++ b/src/queryExecutionContext/IHeaders.ts
@@ -0,0 +1,3 @@
+export interface IHeaders {
+ [key: string]: string | boolean | number;
+}
diff --git a/src/queryExecutionContext/defaultQueryExecutionContext.ts b/src/queryExecutionContext/defaultQueryExecutionContext.ts
index 2f6ce4d..b12ce42 100644
--- a/src/queryExecutionContext/defaultQueryExecutionContext.ts
+++ b/src/queryExecutionContext/defaultQueryExecutionContext.ts
@@ -1,5 +1,4 @@
-import { IExecutionContext, IHeaders } from ".";
-import { Base } from "../base";
+import { IExecutionContext } from ".";
import { Constants } from "../common";
import { DocumentClient } from "../documentclient";
import { ClientSideMetrics, QueryMetrics } from "../queryMetrics";
diff --git a/src/queryExecutionContext/documentProducer.ts b/src/queryExecutionContext/documentProducer.ts
index 851e6c3..341fc06 100644
--- a/src/queryExecutionContext/documentProducer.ts
+++ b/src/queryExecutionContext/documentProducer.ts
@@ -3,7 +3,7 @@ import { FetchFunctionCallback, SqlQuerySpec } from ".";
import { Base } from "../base";
import { Constants, StatusCodes, SubStatusCodes } from "../common";
import { DocumentClient } from "../documentclient";
-import { Response } from "../request";
+import { Response } from "../request/request";
import { DefaultQueryExecutionContext } from "./defaultQueryExecutionContext";
import { FetchResult, FetchResultType } from "./FetchResult";
import { HeaderUtils, IHeaders } from "./headerUtils";
diff --git a/src/queryExecutionContext/orderByQueryExecutionContext.ts b/src/queryExecutionContext/orderByQueryExecutionContext.ts
index faaf015..749cea0 100644
--- a/src/queryExecutionContext/orderByQueryExecutionContext.ts
+++ b/src/queryExecutionContext/orderByQueryExecutionContext.ts
@@ -1,4 +1,3 @@
-import * as assert from "assert";
import {
DocumentProducer,
IExecutionContext,
diff --git a/src/queryExecutionContext/parallelQueryExecutionContext.ts b/src/queryExecutionContext/parallelQueryExecutionContext.ts
index deaa547..23cc0f5 100644
--- a/src/queryExecutionContext/parallelQueryExecutionContext.ts
+++ b/src/queryExecutionContext/parallelQueryExecutionContext.ts
@@ -1,14 +1,11 @@
-import * as assert from "assert";
import {
DocumentProducer,
- HeaderUtils,
IExecutionContext,
ParallelQueryExecutionContextBase,
PartitionedQueryExecutionContextInfo,
} from ".";
-import { Constants } from "../common";
import { DocumentClient } from "../documentclient";
-import { InMemoryCollectionRoutingMap, PARITIONKEYRANGE } from "../routing";
+import { PARITIONKEYRANGE } from "../routing";
export class ParallelQueryExecutionContext extends ParallelQueryExecutionContextBase implements IExecutionContext {
/**
diff --git a/src/queryExecutionContext/parallelQueryExecutionContextBase.ts b/src/queryExecutionContext/parallelQueryExecutionContextBase.ts
index 4b32e50..add667d 100644
--- a/src/queryExecutionContext/parallelQueryExecutionContextBase.ts
+++ b/src/queryExecutionContext/parallelQueryExecutionContextBase.ts
@@ -14,7 +14,7 @@ import {
} from ".";
import { Constants, StatusCodes, SubStatusCodes } from "../common";
import { DocumentClient } from "../documentclient";
-import { Response } from "../request";
+import { Response } from "../request/request";
import { InMemoryCollectionRoutingMap, PARITIONKEYRANGE, QueryRange, SmartRoutingMapProvider } from "../routing";
export enum ParallelQueryExecutionContextBaseStates {
@@ -153,7 +153,6 @@ export abstract class ParallelQueryExecutionContextBase implements IExecutionCon
} catch (err) {
this._mergeWithActiveResponseHeaders(err.headers);
this.err = err;
- throw err;
} finally {
parallelismSem.leave();
this._decrementInitiationLock();
@@ -297,7 +296,7 @@ export abstract class ParallelQueryExecutionContextBase implements IExecutionCon
}
};
// Invoke the recursive function to get the ball rolling
- checkAndEnqueueDocumentProducers(replacementDocumentProducers);
+ await checkAndEnqueueDocumentProducers(replacementDocumentProducers);
} catch (err) {
this.err = err;
throw err;
@@ -455,7 +454,7 @@ export abstract class ParallelQueryExecutionContextBase implements IExecutionCon
// invoke the callback on the item
return resolve({result: item, headers: this._getAndResetActiveResponseHeaders()});
};
- this._repairExecutionContextIfNeeded(ifCallback, elseCallback);
+ this._repairExecutionContextIfNeeded(ifCallback, elseCallback).catch(reject);
});
});
}
@@ -494,7 +493,7 @@ export abstract class ParallelQueryExecutionContextBase implements IExecutionCon
return resolve(documentProducer.current());
};
- this._repairExecutionContextIfNeeded(ifCallback, elseCallback);
+ this._repairExecutionContextIfNeeded(ifCallback, elseCallback).catch(reject);
} finally {
this.sem.leave();
}
diff --git a/src/queryExecutionContext/pipelinedQueryExecutionContext.ts b/src/queryExecutionContext/pipelinedQueryExecutionContext.ts
index f53bc9f..baf2d7d 100644
--- a/src/queryExecutionContext/pipelinedQueryExecutionContext.ts
+++ b/src/queryExecutionContext/pipelinedQueryExecutionContext.ts
@@ -9,7 +9,7 @@ import {
PartitionedQueryExecutionContextInfoParser,
} from ".";
import { DocumentClient } from "../documentclient";
-import { Response } from "../request";
+import { Response } from "../request/request";
import {
AggregateEndpointComponent,
IEndpointComponent,
diff --git a/src/queryExecutionContext/proxyQueryExecutionContext.ts b/src/queryExecutionContext/proxyQueryExecutionContext.ts
index f210edc..19ddd86 100644
--- a/src/queryExecutionContext/proxyQueryExecutionContext.ts
+++ b/src/queryExecutionContext/proxyQueryExecutionContext.ts
@@ -10,7 +10,7 @@ import {
} from ".";
import { StatusCodes, SubStatusCodes } from "../common";
import { DocumentClient } from "../documentclient";
-import { Response } from "../request";
+import { Response } from "../request/request";
export class ProxyQueryExecutionContext implements IExecutionContext {
private queryExecutionContext: IExecutionContext;
diff --git a/src/queryIterator.ts b/src/queryIterator.ts
index a34e981..7444abf 100644
--- a/src/queryIterator.ts
+++ b/src/queryIterator.ts
@@ -1,5 +1,3 @@
-import { Base } from ".";
-import { Constants } from "./common";
import { DocumentClient } from "./documentclient";
import {
FetchFunctionCallback,
@@ -8,12 +6,11 @@ import {
ProxyQueryExecutionContext,
SqlQuerySpec,
} from "./queryExecutionContext";
-import { Response } from "./request";
+import { FeedOptions } from "./request/FeedOptions";
+import { Response } from "./request/request";
-export type QueryIteratorCallback = (err: any, elements?: any, headers?: IHeaders) => boolean | void;
-
-export class QueryIterator {
- private toArrayTempResources: any[];
+export class QueryIterator {
+ private toArrayTempResources: T[]; // TODO
private toArrayLastResHeaders: IHeaders;
private queryExecutionContext: IExecutionContext;
/**
@@ -32,7 +29,7 @@ export class QueryIterator {
constructor(
private documentclient: DocumentClient,
private query: SqlQuerySpec | string,
- private options: any, // TODO: any options
+ private options: FeedOptions, // TODO: any options
private fetchFunctions: FetchFunctionCallback | FetchFunctionCallback[],
private resourceLink?: string | string[]) {
@@ -52,9 +49,15 @@ export class QueryIterator {
* Note: the last element the callback will be called on will be undefined.
* If the callback explicitly returned false, the loop gets stopped.
*/
- public forEach(callback: QueryIteratorCallback) {
+ public async *forEach(): AsyncIterable> {
this.reset();
- this._forEachImplementation(callback);
+ while (this.queryExecutionContext.hasMoreResults()) {
+ const result = await this.queryExecutionContext.nextItem();
+ if (result.result === undefined) {
+ return;
+ }
+ yield result;
+ }
}
/**
@@ -64,13 +67,8 @@ export class QueryIterator {
* @param {callback} callback - Function to execute for each element. \
* the function takes two parameters error, element.
*/
- public async nextItem(callback?: QueryIteratorCallback): Promise> {
- try {
- const p = await this.queryExecutionContext.nextItem();
- return Base.ResponseOrCallback(callback, p);
- } catch (err) {
- Base.ThrowOrCallback(callback, err);
- }
+ public async nextItem(): Promise> {
+ return this.queryExecutionContext.nextItem();
}
/**
@@ -80,13 +78,8 @@ export class QueryIterator {
* @param {callback} callback - Function to execute for the current element. \
* the function takes two parameters error, element.
*/
- public async current(callback?: QueryIteratorCallback) {
- try {
- const p = await this.queryExecutionContext.current();
- return Base.ResponseOrCallback(callback, p);
- } catch (err) {
- Base.ThrowOrCallback(callback, err);
- }
+ public async current(): Promise> {
+ return this.queryExecutionContext.current();
}
/**
@@ -98,7 +91,7 @@ export class QueryIterator {
* @instance
* @returns {Boolean} true if there is other elements to process in the QueryIterator.
*/
- public hasMoreResults() {
+ public hasMoreResults(): boolean {
return this.queryExecutionContext.hasMoreResults();
}
@@ -108,15 +101,13 @@ export class QueryIterator {
* @instance
* @param {callback} callback - Function execute on the feed response, takes two parameters error, resourcesList
*/
- public async toArray(callback?: QueryIteratorCallback): Promise> {
- try {
- this.reset();
- this.toArrayTempResources = [];
- const p = await this._toArrayImplementation();
- return Base.ResponseOrCallback(callback, p);
- } catch (err) {
- Base.ThrowOrCallback(callback, err);
+ public async toArray(): Promise> {
+ if (arguments.length !== 0) {
+ throw new Error("toArray takes no arguments");
}
+ this.reset();
+ this.toArrayTempResources = [];
+ return this._toArrayImplementation();
}
/**
@@ -125,13 +116,8 @@ export class QueryIterator {
* @instance
* @param {callback} callback - Function execute on the feed response, takes two parameters error, resourcesList
*/
- public async executeNext(callback?: QueryIteratorCallback) {
- try {
- const p = await this.queryExecutionContext.fetchMore();
- return Base.ResponseOrCallback(callback, p);
- } catch (err) {
- Base.ThrowOrCallback(callback, err);
- }
+ public async executeNext(): Promise> {
+ return this.queryExecutionContext.fetchMore();
}
/**
@@ -144,48 +130,20 @@ export class QueryIterator {
}
/** @ignore */
- private async _toArrayImplementation(): Promise> {
- try {
+ private async _toArrayImplementation(): Promise> {
+ while (this.queryExecutionContext.hasMoreResults()) {
const { result, headers } = await this.queryExecutionContext.nextItem();
// concatinate the results and fetch more
this.toArrayLastResHeaders = headers;
if (result === undefined) {
-
// no more results
- return { result: this.toArrayTempResources, headers: this.toArrayLastResHeaders };
+ break;
}
this.toArrayTempResources.push(result);
-
- return this._toArrayImplementation();
- } catch (err) {
- throw err;
- }
- }
-
- /** @ignore */
- private async _forEachImplementation(
- callback: QueryIteratorCallback) { // TODO: any error
- try {
- const { result, headers } = await this.queryExecutionContext.nextItem();
- if (result === undefined) {
- // no more results. This is last iteration
- return callback(undefined, undefined, headers);
- }
-
- if (callback(undefined, result, headers) === false) {
- // callback instructed to stop further iteration
- return;
- }
-
- // recursively call itself to iterate to the remaining elements
- setImmediate(() => {
- this._forEachImplementation(callback);
- });
- } catch (err) {
- throw err;
}
+ return { result: this.toArrayTempResources, headers: this.toArrayLastResHeaders };
}
/** @ignore */
diff --git a/src/range/Range.ts b/src/range/Range.ts
index 3c41e0a..2f8ad84 100644
--- a/src/range/Range.ts
+++ b/src/range/Range.ts
@@ -1,3 +1,4 @@
+import { PartitionKey } from "../documents";
export type CompareFunction = (x: Point , y: Point) => number;
@@ -113,7 +114,7 @@ export class Range {
// tslint:disable-next-line:variable-name
public static _isRange = Range.isRange;
- public static isRange(pointOrRange: Point | Range) {
+ public static isRange(pointOrRange: Point | Range | PartitionKey) {
if (pointOrRange === undefined) {
return false;
}
diff --git a/src/request/ErrorResponse.ts b/src/request/ErrorResponse.ts
new file mode 100644
index 0000000..44342a6
--- /dev/null
+++ b/src/request/ErrorResponse.ts
@@ -0,0 +1,11 @@
+import { IHeaders } from "..";
+
+export interface ErrorResponse {
+ code?: number;
+ substatus?: number;
+ body?: any;
+ headers?: IHeaders;
+ activityId?: string;
+ retryAfterInMilliseconds?: number;
+ [key: string]: any;
+}
diff --git a/src/request/FeedOptions.ts b/src/request/FeedOptions.ts
new file mode 100644
index 0000000..99c97b1
--- /dev/null
+++ b/src/request/FeedOptions.ts
@@ -0,0 +1,40 @@
+import { IHeaders } from "..";
+
+/**
+ * The feed options
+ * @typedef {Object} FeedOptions - \
+ * The feed options and query methods.
+ * @property {string} [continuation] - Opaque token for continuing the enumeration.
+ * @property {boolean} [disableRUPerMinuteUsage] - \
+ * DisableRUPerMinuteUsage is used to enable/disable Request Units(RUs)/minute capacity to serve the \
+ * request if regular provisioned RUs/second is exhausted.
+ * @property {boolean} [enableCrossPartitionQuery] - \
+ * A value indicating whether users are enabled to send more than one request to execute the query \
+ * in the Azure Cosmos DB database service.
+ * More than one request is necessary if the query is not scoped to single partition key value.
+ * @property {boolean} [enableScanInQuery] - \
+ * Allow scan on the queries which couldn't be served as indexing was opted out on the requested paths.
+ * @property {number} [maxDegreeOfParallelism] - \
+ * The maximum number of concurrent operations that run client side during parallel query execution \
+ * in the Azure Cosmos DB database service. Negative values make the system automatically decides the \
+ * number of concurrent operations to run.
+ * @property {number} [maxItemCount] - \
+ * Max number of items to be returned in the enumeration operation.
+ * @property {string} [partitionKey] - \
+ * Specifies a partition key definition for a particular path in the Azure Cosmos DB database service.
+ * @property {string} [sessionToken] - Token for use with Session consistency.
+ */
+export interface FeedOptions {
+ continuation?: string;
+ disableRUPerMinuteUsage?: boolean;
+ enableCrossPartitionQuery?: boolean;
+ enableScanInQuery?: boolean;
+ maxDegreeOfParallelism?: number;
+ maxItemCount?: number;
+ partitionKey?: string;
+ sessionToken?: string;
+ initialHeaders?: IHeaders;
+ a_im?: string;
+ accessCondition?: any; // TODO: any
+ populateQueryMetrics?: boolean;
+}
diff --git a/src/request/MediaOptions.ts b/src/request/MediaOptions.ts
new file mode 100644
index 0000000..5e7f6f0
--- /dev/null
+++ b/src/request/MediaOptions.ts
@@ -0,0 +1,14 @@
+import { IHeaders } from "..";
+
+/**
+ * The media options
+ * @typedef {Object} MediaOptions - Options associated with upload media.
+ * @property {string} [slug] - HTTP Slug header value.
+ * @property {string} [contentType=application/octet-stream] - HTTP ContentType header value.
+ *
+ */
+export interface MediaOptions {
+ initialHeaders?: IHeaders;
+ slug?: string;
+ contentType?: string;
+}
diff --git a/src/request/RequestOptions.ts b/src/request/RequestOptions.ts
new file mode 100644
index 0000000..d85076a
--- /dev/null
+++ b/src/request/RequestOptions.ts
@@ -0,0 +1,66 @@
+import { IHeaders } from "..";
+import { PartitionKey } from "../documents";
+
+/**
+ * The request options
+ * @typedef {Object} RequestOptions - \
+ * Options that can be specified for a requested issued to the Azure Cosmos DB servers.
+ * @property {object} [accessCondition] - \
+ * Conditions Associated with the request.
+ * @property {string} accessCondition.type - \
+ * Conditional HTTP method header type (IfMatch or IfNoneMatch).
+ * @property {string} accessCondition.condition - \
+ * Conditional HTTP method header value (the _etag field from the last version you read).
+ * @property {string} [consistencyLevel] - \
+ * Consistency level required by the client.
+ * @property {boolean} [disableRUPerMinuteUsage] - \
+ * DisableRUPerMinuteUsage is used to enable/disable Request Units(RUs)/minute capacity to \
+ * serve the request if regular provisioned RUs/second is exhausted.
+ * @property {boolean} [enableScriptLogging] - \
+ * Enables or disables logging in JavaScript stored procedures.
+ * @property {string} [indexingDirective] - \
+ * Specifies indexing directives (index, do not index .. etc).
+ * @property {boolean} [offerEnableRUPerMinuteThroughput] - \
+ * Represents Request Units(RU)/Minute throughput is enabled/disabled for a container \
+ * in the Azure Cosmos DB database service.
+ * @property {number} [offerThroughput] - \
+ * The offer throughput provisioned for a container in measurement of Requests-per-Unit \
+ * in the Azure Cosmos DB database service.
+ * @property {string} [offerType] - Offer type when creating document containers.
+ * This option is only valid when creating a document container.
+ * @property {string} [partitionKey] - \
+ * Specifies a partition key definition for a particular path in the Azure Cosmos DB database service.
+ * @property {boolean} [populateQuotaInfo] - \
+ * Enables/disables getting document container quota related stats for document container read requests.
+ * @property {string} [postTriggerInclude] - \
+ * Indicates what is the post trigger to be invoked after the operation.
+ * @property {string} [preTriggerInclude] - \
+ * Indicates what is the pre trigger to be invoked before the operation.
+ * @property {number} [resourceTokenExpirySeconds] - \
+ * Expiry time (in seconds) for resource token associated with permission (applicable only for requests on permissions).
+ * @property {string} [sessionToken] - Token for use with Session consistency.
+ */
+
+export interface RequestOptions {
+ accessCondition?: {
+ type: string;
+ condition: string;
+ };
+ consistencyLevel?: string;
+ disableRUPerMinuteUsage?: boolean;
+ enableScriptLogging?: boolean;
+ indexingDirective?: string;
+ offerEnableRUPerMinuteThroughput?: boolean;
+ offerThroughput?: number;
+ offerType?: string;
+ partitionKey?: PartitionKey;
+ populateQuotaInfo?: boolean;
+ postTriggerInclude?: string | string[];
+ preTriggerInclude?: string | string[];
+ resourceTokenExpirySeconds?: number;
+ sessionToken?: string;
+ initialHeaders?: IHeaders;
+ urlConnection?: string;
+ skipGetPartitionKeyDefinition?: boolean;
+ disableAutomaticIdGeneration?: boolean;
+}
diff --git a/src/request/Response.ts b/src/request/Response.ts
new file mode 100644
index 0000000..255a676
--- /dev/null
+++ b/src/request/Response.ts
@@ -0,0 +1,6 @@
+import { IHeaders } from "..";
+
+export interface Response {
+ headers?: IHeaders;
+ result?: T;
+}
diff --git a/src/request/index.ts b/src/request/index.ts
new file mode 100644
index 0000000..64d8333
--- /dev/null
+++ b/src/request/index.ts
@@ -0,0 +1,6 @@
+export { ErrorResponse } from "./ErrorResponse";
+export { FeedOptions } from "./FeedOptions";
+export { MediaOptions } from "./MediaOptions";
+export { RequestHandler } from "./request";
+export { RequestOptions } from "./RequestOptions";
+export { Response } from "./Response";
diff --git a/src/request.ts b/src/request/request.ts
similarity index 94%
rename from src/request.ts
rename to src/request/request.ts
index 3f626e6..ba952c0 100644
--- a/src/request.ts
+++ b/src/request/request.ts
@@ -4,21 +4,17 @@ import { Socket } from "net";
import * as querystring from "querystring";
import { Stream } from "stream";
import * as url from "url";
-import { Constants } from "./common";
-import { ConnectionPolicy, MediaReadMode } from "./documents";
-import { GlobalEndpointManager } from "./globalEndpointManager";
-import { IHeaders } from "./queryExecutionContext";
-import { Body, RetryUtility } from "./retry";
+import { Constants } from "../common";
+import { ConnectionPolicy, MediaReadMode } from "../documents";
+import { GlobalEndpointManager } from "../globalEndpointManager";
+import { IHeaders } from "../queryExecutionContext";
+import { Body, RetryUtility } from "../retry";
-export interface ErrorResponse {
- code?: number;
- substatus?: number;
- body?: any;
- headers?: IHeaders;
- activityId?: string;
- retryAfterInMilliseconds?: number;
- [key: string]: any;
-}
+import { ErrorResponse } from "./ErrorResponse";
+export { ErrorResponse }; // Should refactor this out
+
+import { Response } from "./Response";
+export { Response }; // Should refactor this out
const isBrowser = new Function("try {return this===window;}catch(e){ return false;}");
@@ -49,11 +45,6 @@ function bodyFromData(data: Stream | Buffer | string | object) {
function parse(urlString: string) { return url.parse(urlString); }
-export interface Response {
- headers?: IHeaders;
- result?: T;
-}
-
function createRequestObject(
connectionPolicy: ConnectionPolicy,
requestOptions: RequestOptions,
diff --git a/src/retry/endpointDiscoveryRetryPolicy.ts b/src/retry/endpointDiscoveryRetryPolicy.ts
index 28f3d7e..7d82b03 100644
--- a/src/retry/endpointDiscoveryRetryPolicy.ts
+++ b/src/retry/endpointDiscoveryRetryPolicy.ts
@@ -1,6 +1,6 @@
import { Constants, StatusCodes } from "../common";
import { GlobalEndpointManager } from "../globalEndpointManager";
-import { ErrorResponse } from "../request";
+import { ErrorResponse } from "../request/request";
/**
* This class implements the retry policy for endpoint discovery.
diff --git a/src/retry/resourceThrottleRetryPolicy.ts b/src/retry/resourceThrottleRetryPolicy.ts
index 0ff04bd..2b474f2 100644
--- a/src/retry/resourceThrottleRetryPolicy.ts
+++ b/src/retry/resourceThrottleRetryPolicy.ts
@@ -1,5 +1,5 @@
import { StatusCodes } from "../common";
-import { ErrorResponse } from "../request";
+import { ErrorResponse } from "../request/request";
/**
* This class implements the resource throttle retry policy for requests.
diff --git a/src/retry/sessionReadRetryPolicy.ts b/src/retry/sessionReadRetryPolicy.ts
index f37163f..3697e82 100644
--- a/src/retry/sessionReadRetryPolicy.ts
+++ b/src/retry/sessionReadRetryPolicy.ts
@@ -2,7 +2,7 @@
import { Base } from "../base";
import { Constants, StatusCodes, SubStatusCodes } from "../common";
import { GlobalEndpointManager } from "../globalEndpointManager";
-import { ErrorResponse } from "../request";
+import { ErrorResponse } from "../request/request";
/**
* This class implements the retry policy for session consistent reads.
diff --git a/src/routing/inMemoryCollectionRoutingMap.ts b/src/routing/inMemoryCollectionRoutingMap.ts
index f31acc1..791d925 100644
--- a/src/routing/inMemoryCollectionRoutingMap.ts
+++ b/src/routing/inMemoryCollectionRoutingMap.ts
@@ -1,6 +1,7 @@
import * as assert from "assert";
import * as bs from "binary-search-bounds"; // TODO: missing types
import { Constants } from "../common";
+import { Range } from "../range";
import { QueryRange } from "./QueryRange";
export class InMemoryCollectionRoutingMap {
diff --git a/src/routing/partitionKeyRangeCache.ts b/src/routing/partitionKeyRangeCache.ts
index f0c79c3..a4c054e 100644
--- a/src/routing/partitionKeyRangeCache.ts
+++ b/src/routing/partitionKeyRangeCache.ts
@@ -1,5 +1,6 @@
import * as semaphore from "semaphore";
import { Base } from "../base";
+import { QueryIterator } from "../queryIterator";
import { CollectionRoutingMapFactory, InMemoryCollectionRoutingMap, QueryRange } from "./";
export class PartitionKeyRangeCache {
@@ -35,14 +36,13 @@ export class PartitionKeyRangeCache {
if (collectionRoutingMap === undefined) {
// attempt to consturct collection routing map
collectionRoutingMap = await new Promise((resolve, reject) => {
- const semaphorizedFuncCollectionMapInstantiator = () => {
+ const semaphorizedFuncCollectionMapInstantiator = async () => {
let crm: InMemoryCollectionRoutingMap = this.collectionRoutingMapByCollectionId[collectionId];
if (crm === undefined) {
- const partitionKeyRangesIterator = this.documentclient.readPartitionKeyRanges(collectionLink);
- partitionKeyRangesIterator.toArray((err: Error, resources: any[]) => { // TODO: Promisification
- if (err) {
- return reject(err);
- }
+ try {
+ const partitionKeyRangesIterator: QueryIterator =
+ this.documentclient.readPartitionKeyRanges(collectionLink);
+ const { result: resources } = await partitionKeyRangesIterator.toArray();
crm = CollectionRoutingMapFactory.createCompleteRoutingMap(
resources.map((r) => [r, true]),
@@ -51,7 +51,10 @@ export class PartitionKeyRangeCache {
this.collectionRoutingMapByCollectionId[collectionId] = crm;
this.sem.leave();
resolve(crm);
- });
+ } catch (err) {
+ this.sem.leave();
+ reject(err);
+ }
} else {
// sanity gaurd
diff --git a/src/routing/smartRoutingMapProvider.ts b/src/routing/smartRoutingMapProvider.ts
index e0b799b..a76611c 100644
--- a/src/routing/smartRoutingMapProvider.ts
+++ b/src/routing/smartRoutingMapProvider.ts
@@ -1,7 +1,6 @@
import * as assert from "assert";
-import * as util from "util";
import { Constants } from "../common";
-import { CollectionRoutingMapFactory, InMemoryCollectionRoutingMap, PartitionKeyRangeCache, QueryRange } from "./";
+import { PartitionKeyRangeCache, QueryRange } from "./";
export const PARITIONKEYRANGE = Constants.PartitionKeyRange;
diff --git a/src/test/common/MockQueryIterator.ts b/src/test/common/MockQueryIterator.ts
index c1ad7a2..ef8caac 100644
--- a/src/test/common/MockQueryIterator.ts
+++ b/src/test/common/MockQueryIterator.ts
@@ -1,6 +1,6 @@
export class MockedQueryIterator {
constructor(private results: any) { }
- public toArray(callback: any) {
- callback(undefined, this.results);
+ public async toArray() {
+ return {result: this.results};
}
}
diff --git a/src/test/common/TestData.ts b/src/test/common/TestData.ts
index f87f2a2..964c9d6 100644
--- a/src/test/common/TestData.ts
+++ b/src/test/common/TestData.ts
@@ -1,3 +1,4 @@
+/** @hidden */
export class TestData {
public numberOfDocuments: number;
public field: string;
diff --git a/src/test/common/TestHelpers.ts b/src/test/common/TestHelpers.ts
index cfaf7d8..43f6b1b 100644
--- a/src/test/common/TestHelpers.ts
+++ b/src/test/common/TestHelpers.ts
@@ -1,12 +1,15 @@
import * as assert from "assert";
-import { DocumentBase, DocumentClient, Response } from "../../";
+import {
+ Container, CosmosClient,
+ Database, DatabaseDefinition, Item, RequestOptions, Response,
+} from "../../";
+import { ContainerDefinition, PermissionDefinition, User, UserDefinition } from "../../client";
+/** @hidden */
export class TestHelpers {
- public static async removeAllDatabases(host: string, masterKey: string) {
+ public static async removeAllDatabases(client: CosmosClient) {
try {
- const client = new DocumentClient(host, { masterKey });
- const { result: databases } = await client.readDatabases().toArray();
-
+ const { result: databases } = await client.databases.readAll().toArray();
const length = databases.length;
if (length === 0) {
@@ -14,7 +17,8 @@ export class TestHelpers {
}
const count = 0;
- await Promise.all(databases.map>(async (database) => client.deleteDatabase(database._self)));
+ await Promise.all(databases.map>>(
+ async (database: DatabaseDefinition) => client.databases.get(database.id).delete()));
} catch (err) {
// TODO: remove console logging for errors and add ts-lint flag back
console.log("An error occured", err);
@@ -23,97 +27,28 @@ export class TestHelpers {
}
}
- public static getDatabaseLink(isNameBasedLink: boolean, db: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id;
- } else {
- return db._self;
- }
+ public static async getTestDatabase(client: CosmosClient, testName: string) {
+ const entropy = Math.floor(Math.random() * 10000);
+ const id = `${testName.replace(" ", "").substring(0, 30)}${entropy}`;
+ await client.databases.create({ id });
+ return client.databases.get(id);
}
- public static getCollectionLink(isNameBasedLink: boolean, db: any, coll: any) {
- if (!(db && coll)) {
- throw new Error("db and coll must be set");
- }
-
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id;
- } else {
- return coll._self;
- }
+ public static async getTestContainer(
+ client: CosmosClient, testName: string, containerDef?: ContainerDefinition, options?: RequestOptions) {
+ const db = await TestHelpers.getTestDatabase(client, testName);
+ const entropy = Math.floor(Math.random() * 10000);
+ const id = `${testName.replace(" ", "").substring(0, 30)}${entropy}`;
+ await db.containers.create({ ...containerDef, ...{ id } }, options);
+ return db.containers.get(id);
}
- public static getUserLink(isNameBasedLink: boolean, db: any, user: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/users/" + user.id;
- } else {
- return user._self;
- }
- }
-
- public static getDocumentLink(isNameBasedLink: boolean, db: any, coll: any, doc: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/docs/" + doc.id;
- } else {
- return doc._self;
- }
- }
-
- public static getAttachmentLink(isNameBasedLink: boolean, db: any, coll: any, doc: any, attachment: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/docs/" + doc.id + "/attachments/" + attachment.id;
- } else {
- return attachment._self;
- }
- }
-
- public static getPermissionLink(isNameBasedLink: boolean, db: any, user: any, permission: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/users/" + user.id + "/permissions/" + permission.id;
- } else {
- return permission._self;
- }
- }
-
- public static getTriggerLink(isNameBasedLink: boolean, db: any, coll: any, trigger: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/triggers/" + trigger.id;
- } else {
- return trigger._self;
- }
- }
-
- public static getUserDefinedFunctionLink(isNameBasedLink: boolean, db: any, coll: any, udf: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/udfs/" + udf.id;
- } else {
- return udf._self;
- }
- }
-
- public static getStoredProcedureLink(isNameBasedLink: boolean, db: any, coll: any, sproc: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/sprocs/" + sproc.id;
- } else {
- return sproc._self;
- }
- }
-
- public static getConflictLink(isNameBasedLink: boolean, db: any, coll: any, conflict: any) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/conflicts/" + conflict.id;
- } else {
- return conflict._self;
- }
- }
-
- public static async bulkInsertDocuments(
- client: DocumentClient, isNameBased: boolean, db: any, collection: any, documents: any) {
+ public static async bulkInsertItems(
+ container: Container, documents: any[]) {
const returnedDocuments = [];
for (const doc of documents) {
try {
- const { result: document } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), doc);
+ const { result: document } = await container.items.create(doc);
returnedDocuments.push(document);
} catch (err) {
throw err;
@@ -122,9 +57,8 @@ export class TestHelpers {
return returnedDocuments;
}
- public static async bulkReadDocuments(
- client: DocumentClient, isNameBased: boolean, db: any,
- collection: any, documents: any[], partitionKey: string) {
+ public static async bulkReadItems(
+ container: Container, documents: any[], partitionKey: string) {
for (const document of documents) {
try {
const options = (partitionKey && document.hasOwnProperty(partitionKey))
@@ -132,8 +66,7 @@ export class TestHelpers {
: { partitionKey: {} };
// TODO: should we block or do all requests in parallel?
- const { result: doc } = await client.readDocument(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), options);
+ const { result: doc } = await container.items.get(document.id).read(options);
assert.equal(JSON.stringify(doc), JSON.stringify(document));
} catch (err) {
throw err;
@@ -141,15 +74,12 @@ export class TestHelpers {
}
}
- public static async bulkReplaceDocuments(
- client: DocumentClient, isNameBased: boolean, db: any,
- collection: any, documents: any[], partitionKey: string): Promise {
+ public static async bulkReplaceItems(
+ container: Container, documents: any[]): Promise {
const returnedDocuments: any[] = [];
for (const document of documents) {
try {
- const { result: doc } =
- await client.replaceDocument(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), document);
+ const { result: doc } = await container.items.get(document.id).replace(document);
const expectedModifiedDocument = JSON.parse(JSON.stringify(document));
delete expectedModifiedDocument._etag;
delete expectedModifiedDocument._ts;
@@ -165,44 +95,40 @@ export class TestHelpers {
return returnedDocuments;
}
- public static async bulkDeleteDocuments(
- client: DocumentClient, isNameBased: boolean, db: any,
- collection: any, documents: any[], partitionKey: string): Promise {
+ public static async bulkDeleteItems(
+ container: Container, documents: any[], partitionKeyPropertyName: string): Promise {
for (const document of documents) {
try {
- const options = (partitionKey && document.hasOwnProperty(partitionKey))
- ? { partitionKey: document[partitionKey] }
+ const options = (partitionKeyPropertyName && document.hasOwnProperty(partitionKeyPropertyName))
+ ? { partitionKey: document[partitionKeyPropertyName] }
: { partitionKey: {} };
- const { result } = await client.deleteDocument(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), options);
+ const { result } = await container.items.get(document.id).delete(options);
} catch (err) {
throw err;
}
}
}
- public static async bulkQueryDocumentsWithPartitionKey(
- client: DocumentClient, isNameBased: boolean,
- db: any, collection: any, documents: any[], partitionKey: any): Promise {
+ public static async bulkQueryItemsWithPartitionKey(
+ container: Container, documents: any[], partitionKeyPropertyName: any): Promise {
for (const document of documents) {
try {
- if (!document.hasOwnProperty(partitionKey)) {
+ if (!document.hasOwnProperty(partitionKeyPropertyName)) {
continue;
}
const querySpec = {
- query: "SELECT * FROM root r WHERE r." + partitionKey + "=@key",
+ query: "SELECT * FROM root r WHERE r." + partitionKeyPropertyName + "=@key",
parameters: [
{
name: "@key",
- value: document[partitionKey],
+ value: document[partitionKeyPropertyName],
},
],
};
- const { result: results } = await client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySpec).toArray();
+ const { result: results } = await container.items.query(querySpec).toArray();
assert.equal(results.length, 1, "Expected exactly 1 document");
assert.equal(JSON.stringify(results[0]), JSON.stringify(document));
} catch (err) {
@@ -211,167 +137,116 @@ export class TestHelpers {
}
}
- // Document
- public static async createOrUpsertDocument(
- collectionLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ // Item
+ public static async createOrUpsertItem(
+ container: Container, body: any, options: RequestOptions, isUpsertTest: boolean) {
if (isUpsertTest) {
- return client.upsertDocument(collectionLink, body, options);
+ return container.items.upsert(body, options);
} else {
- return client.createDocument(collectionLink, body, options);
+ return container.items.create(body, options);
}
}
- public static async replaceOrUpsertDocument(
- collectionLink: string, documentLink: string, body: any,
- options: any, client: DocumentClient, isUpsertTest: boolean) {
+ public static async replaceOrUpsertItem(
+ container: Container, body: any, options: RequestOptions, isUpsertTest: boolean) {
if (isUpsertTest) {
- return client.upsertDocument(collectionLink, body, options);
+ return container.items.upsert(body, options);
} else {
- return client.replaceDocument(documentLink, body, options);
- }
- }
-
- // Attachment
- public static async createOrUpsertAttachment(
- documentLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
- if (isUpsertTest) {
- return client.upsertAttachment(documentLink, body, options);
- } else {
- return client.createAttachment(documentLink, body, options);
- }
- }
-
- public static replaceOrUpsertAttachment(
- documentLink: string, attachmentLink: string, body: any,
- options: any, client: DocumentClient, isUpsertTest: boolean): Promise> {
- if (isUpsertTest) {
- return client.upsertAttachment(documentLink, body, options);
- } else {
- return client.replaceAttachment(attachmentLink, body, options);
+ return container.items.get(body.id).replace(body, options);
}
}
// User
public static createOrUpsertUser(
- databaseLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ database: Database, body: any, options: any,
+ isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertUser(databaseLink, body, options);
+ return database.users.upsert(body, options);
} else {
- return client.createUser(databaseLink, body, options);
+ return database.users.create(body, options);
}
}
public static replaceOrUpsertUser(
- databaseLink: string, userLink: string, body: any,
- options: any, client: DocumentClient, isUpsertTest: boolean): Promise> {
+ database: Database, body: any,
+ options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertUser(databaseLink, body, options);
+ return database.users.upsert(body, options);
} else {
- return client.replaceUser(userLink, body, options);
+ return database.users.get(body.id).replace(body, options);
}
}
// Permission
public static createOrUpsertPermission(
- userLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ user: User, body: any, options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertPermission(userLink, body, options);
+ return user.permissions.upsert(body, options);
} else {
- return client.createPermission(userLink, body, options);
+ return user.permissions.create(body, options);
}
}
public static replaceOrUpsertPermission(
- userLink: string, permissionLink: string, body: any,
- options: any, client: DocumentClient, isUpsertTest: boolean): Promise> {
+ user: User, body: any,
+ options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertPermission(userLink, body, options);
+ return user.permissions.upsert(body, options);
} else {
- return client.replacePermission(permissionLink, body, options);
+ return user.permissions.get(body.id).replace(body, options);
}
}
// Trigger
public static createOrUpsertTrigger(
- collectionLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ container: Container, body: any, options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertTrigger(collectionLink, body, options);
+ return container.triggers.upsert(body, options);
} else {
- return client.createTrigger(collectionLink, body, options);
+ return container.triggers.create(body, options);
}
}
public static replaceOrUpsertTrigger(
- collectionLink: string, triggerLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ container: Container, body: any, options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertTrigger(collectionLink, body, options);
+ return container.triggers.upsert(body, options);
} else {
- return client.replaceTrigger(triggerLink, body, options);
+ return container.triggers.get(body.id).replace(body, options);
}
}
// User Defined Function
public static createOrUpsertUserDefinedFunction(
- collectionLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ container: Container, body: any, options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertUserDefinedFunction(collectionLink, body, options);
+ return container.userDefinedFunctions.upsert(body, options);
} else {
- return client.createUserDefinedFunction(collectionLink, body, options);
+ return container.userDefinedFunctions.create(body, options);
}
}
public static replaceOrUpsertUserDefinedFunction(
- collectionLink: string, udfLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ container: Container, body: any, options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertUserDefinedFunction(collectionLink, body, options);
+ return container.userDefinedFunctions.upsert(body, options);
} else {
- return client.replaceUserDefinedFunction(udfLink, body, options);
+ return container.userDefinedFunctions.get(body.id).replace(body, options);
}
}
// Stored Procedure
public static createOrUpsertStoredProcedure(
- collectionLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ container: Container, body: any, options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertStoredProcedure(collectionLink, body, options);
+ return container.storedProcedures.upsert(body, options);
} else {
- return client.createStoredProcedure(collectionLink, body, options);
+ return container.storedProcedures.create(body, options);
}
}
public static replaceOrUpsertStoredProcedure(
- collectionLink: string, sprocLink: string, body: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
+ container: Container, body: any, options: any, isUpsertTest: boolean): Promise> {
if (isUpsertTest) {
- return client.upsertStoredProcedure(collectionLink, body, options);
+ return container.storedProcedures.upsert(body, options);
} else {
- return client.replaceStoredProcedure(sprocLink, body, options);
- }
- }
-
- // Attachment and Upload Media
- public static createOrUpsertAttachmentAndUploadMedia(
- documentLink: string, readableStream: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
- if (isUpsertTest) {
- return client.upsertAttachmentAndUploadMedia(documentLink, readableStream, options);
- } else {
- return client.createAttachmentAndUploadMedia(documentLink, readableStream, options);
- }
- }
-
- public static updateOrUpsertMedia(
- documentLink: string, mediaLink: string, readableStream: any, options: any,
- client: DocumentClient, isUpsertTest: boolean): Promise> {
- if (isUpsertTest) {
- return client.upsertAttachmentAndUploadMedia(documentLink, readableStream, options);
- } else {
- return client.updateMedia(mediaLink, readableStream, options);
+ return container.storedProcedures.get(body.id).replace(body, options);
}
}
}
diff --git a/src/test/common/setup.ts b/src/test/common/setup.ts
new file mode 100644
index 0000000..4d5fe77
--- /dev/null
+++ b/src/test/common/setup.ts
@@ -0,0 +1,9 @@
+process.on("unhandledRejection", (error) => {
+ if (error.body) {
+ try {
+ error.body = JSON.parse(error.body);
+ } catch (err) { /* NO OP */ }
+ }
+ console.error(new Error("Unhandled exception found"));
+ console.error(JSON.stringify(error, null, " "));
+});
diff --git a/src/test/functional/HashPartitionResolver.spec.ts b/src/test/functional/HashPartitionResolver.spec.ts
index 003e328..bf52057 100644
--- a/src/test/functional/HashPartitionResolver.spec.ts
+++ b/src/test/functional/HashPartitionResolver.spec.ts
@@ -1,89 +1,65 @@
import * as assert from "assert";
import * as Stream from "stream";
import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
+ CosmosClient, HashPartitionResolver,
} from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
// TODO: should fix long lines
// tslint:disable:max-line-length
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({
+ endpoint,
+ auth: { masterKey },
+});
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
- // remove all databases from the endpoint before each test
beforeEach(async function () {
this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ // remove all databases from the endpoint before each test
+ await TestHelpers.removeAllDatabases(client);
});
describe("HashPartitionResolver", function () {
- const test = async function (useUpsert: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- const getPartitionResolver = function (collectionLink1: any, collectionLink2: any) {
- return new HashPartitionResolver("id", [collectionLink1, collectionLink2]);
- };
- const querySpec = {
- query: "SELECT * FROM root",
- };
+ it.skip("CRUD operations", async function () {
+ // TODO Figure out how/if we should expose partition resolver
- const { result: db } = await client.createDatabase({ id: "database" });
- const { result: collection1 } = await client.createCollection(db._self, { id: "sample coll 1" });
- const { result: collection2 } = await client.createCollection(db._self, { id: "sample coll 2" });
- const resolver = getPartitionResolver(collection1._self, collection2._self);
- client.partitionResolvers["foo"] = resolver;
+ // const getPartitionResolver = function (containerLink1: any, collectionLink2: any) {
+ // return new HashPartitionResolver("id", [collectionLink1, collectionLink2]);
+ // };
+ // const querySpec = {
+ // query: "SELECT * FROM root",
+ // };
- const { result: doc1 } = await client.createDocument("foo", { id: "sample doc 1" });
- const { result: doc2 } = await client.createDocument("foo", { id: "sample doc 2" });
- const { result: doc3 } = await client.createDocument("foo", { id: "sample doc 11" });
- const { result: docs1 } = await client.queryDocuments(
- "foo", querySpec/*, { resolverPartitionKey: resolver.getPartitionKey(doc1) }*/).toArray();
- const d1 = docs1.filter(function (d) { return (d.id === doc1.id); });
- assert(d1, "doc1 not found");
- assert.strictEqual(d1.length, 1);
- const { result: docs2 } = await client.queryDocuments(
- "foo", querySpec/*, { resolverPartitionKey: resolver.getPartitionKey(doc2) }*/).toArray(); // TODO: I don't think this setting actually does anything
- const d2 = docs2.filter(function (d) { return (d.id === doc2.id); });
- assert(d2, "doc2 not found");
- assert.strictEqual(d2.length, 1);
- const { result: docs3 } = await client.queryDocuments(
- "foo", querySpec/*, { resolverPartitionKey: resolver.getPartitionKey(doc3) }*/).toArray();
- const d3 = docs3.filter(function (d) { return (d.id === doc3.id); });
- assert(d3, "doc3 not found");
- assert.strictEqual(d3.length, 1);
- } catch (err) {
- throw err;
- }
- };
+ // const { result: db } = await client.databases.create({ id: "database" });
+ // const { result: collection1 } = await client.databases.getDatabase(db.id).containers.create({ id: "sample coll 1" });
+ // const { result: collection2 } = await client.databases.getDatabase(db.id).containers.create({ id: "sample coll 2" });
+ // const resolver = getPartitionResolver(collection1.id, collection2.id);
+ // client.documentClient.partitionResolvers["foo"] = resolver;
- it("CRUD operations", async function () {
- try {
- await test(false);
- } catch (err) {
- throw err;
- }
- });
- it("CRUD operations with upsert", async function () {
- try {
- await test(true);
- } catch (err) {
- throw err;
- }
+ // const { result: doc1 } = await client.createDocument("foo", { id: "sample doc 1" });
+ // const { result: doc2 } = await client.createDocument("foo", { id: "sample doc 2" });
+ // const { result: doc3 } = await client.createDocument("foo", { id: "sample doc 11" });
+ // const { result: docs1 } = await client.queryDocuments(
+ // "foo", querySpec/*, { resolverPartitionKey: resolver.getPartitionKey(doc1) }*/).toArray();
+ // const d1 = docs1.filter(function (d) { return (d.id === doc1.id); });
+ // assert(d1, "doc1 not found");
+ // assert.strictEqual(d1.length, 1);
+ // const { result: docs2 } = await client.queryDocuments(
+ // "foo", querySpec/*, { resolverPartitionKey: resolver.getPartitionKey(doc2) }*/).toArray(); // TODO: I don't think this setting actually does anything
+ // const d2 = docs2.filter(function (d) { return (d.id === doc2.id); });
+ // assert(d2, "doc2 not found");
+ // assert.strictEqual(d2.length, 1);
+ // const { result: docs3 } = await client.queryDocuments(
+ // "foo", querySpec/*, { resolverPartitionKey: resolver.getPartitionKey(doc3) }*/).toArray();
+ // const d3 = docs3.filter(function (d) { return (d.id === doc3.id); });
+ // assert(d3, "doc3 not found");
+ // assert.strictEqual(d3.length, 1);
});
});
});
diff --git a/src/test/functional/attachment.spec.ts b/src/test/functional/attachment.spec.ts
deleted file mode 100644
index 6ed9e52..0000000
--- a/src/test/functional/attachment.spec.ts
+++ /dev/null
@@ -1,414 +0,0 @@
-import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
-import testConfig from "./../common/_testConfig";
-import { TestHelpers } from "./../common/TestHelpers";
-
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
-const masterKey = testConfig.masterKey;
-
-describe("NodeJS CRUD Tests", function () {
- this.timeout(process.env.MOCHA_TIMEOUT || 10000);
- // remove all databases from the endpoint before each test
- beforeEach(async function () {
- this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
- });
- describe("Validate Attachment CRUD", function () {
-
- beforeEach(async function () {
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
- });
-
- const createReadableStream = function (firstChunk?: any, secondChunk?: any) { // TODO: any
- const readableStream = new Stream.Readable();
- let chunkCount = 0;
- readableStream._read = function (n) {
- if (chunkCount === 0) {
- this.push(firstChunk || "first chunk ");
- } else if (chunkCount === 1) {
- this.push(secondChunk || "second chunk");
- } else {
- this.push(null);
- }
- chunkCount++;
- };
-
- return readableStream;
- };
-
- const readMediaResponse = function (response: any): Promise { // TODO: any
- return new Promise((resolve, reject) => {
- let data = "";
- response.on("data", function (chunk: any) {
- data += chunk;
- });
- response.on("end", function () {
- if (response.statusCode >= 300) {
- return reject({ code: response.statusCode, body: data });
- }
-
- return resolve(data);
- });
- });
- };
-
- const attachmentCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
-
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
- // create document
- const { result: document } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- { id: "sample document", foo: "bar", key: "value" });
-
- // list all attachments
- const { result: attachments } = await client.readAttachments(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document)).toArray();
- assert(Array.isArray(attachments), "Value should be an array");
-
- const initialCount = attachments.length;
- const validMediaOptions = { slug: "attachment name", contentType: "application/text" };
- const invalidMediaOptions = { slug: "attachment name", contentType: "junt/test" };
- let contentStream = createReadableStream();
-
- // create attachment with invalid content-type
- try {
- const { result: badCreate } = await TestHelpers.createOrUpsertAttachmentAndUploadMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), contentStream, invalidMediaOptions, client, isUpsertTest);
- assert.fail("Must fail to create attachment");
- } catch (err) {
- assert(err !== undefined, "create attachment should return error on invalid mediatypes");
- const badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode);
- }
- contentStream = createReadableStream();
-
- // create streamed attachment with valid content-type
- const { result: validAttachment } = await TestHelpers.createOrUpsertAttachmentAndUploadMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), contentStream, validMediaOptions, client, isUpsertTest);
- assert.equal(validAttachment.id, "attachment name",
- "name of created attachment should be the same as the one in the request");
- contentStream = createReadableStream();
-
- // create colliding attachment
- try {
- const content2 = "bug";
- const { result: attachment } = await client.createAttachmentAndUploadMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), contentStream, validMediaOptions);
- assert.fail("Must fail to create colliding attachment");
- } catch (err) {
- assert(err !== undefined, "create conflicting attachment should return error on conflicting names");
- const conflictErrorCode = 409;
- assert.equal(err.code, conflictErrorCode);
- }
- contentStream = createReadableStream();
-
- // create attachment with media link
- const dynamicAttachment = {
- id: "dynamic attachment",
- media: "http:// xstore.",
- MediaType: "Book",
- Author: "My Book Author",
- Title: "My Book Title",
- contentType: "application/text",
- };
- const { result: attachmentWithMediaLink } = await TestHelpers.createOrUpsertAttachment(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), dynamicAttachment, undefined, client, isUpsertTest);
- assert.equal(attachmentWithMediaLink.MediaType, "Book", "invalid media type");
- assert.equal(attachmentWithMediaLink.Author, "My Book Author", "invalid property value");
-
- // list all attachments
- const { result: attachments2 } = await client.readAttachments(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document)).toArray();
- assert.equal(attachments2.length, initialCount + 2, "number of attachments should've increased by 2");
- attachmentWithMediaLink.Author = "new author";
-
- // replace the attachment
- const { result: replacedAttachment } = await TestHelpers.replaceOrUpsertAttachment(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- TestHelpers.getAttachmentLink(isNameBased, db, collection, document, attachmentWithMediaLink),
- attachmentWithMediaLink, undefined, client, isUpsertTest);
- assert.equal(replacedAttachment.MediaType, "Book", "invalid media type");
- assert.equal(replacedAttachment.Author, "new author", "invalid property value");
-
- // read attachment media
- const { result: mediaResponse } = await client.readMedia(validAttachment.media);
- assert.equal(mediaResponse, "first chunk second chunk");
- contentStream = createReadableStream("modified first chunk ", "modified second chunk");
-
- // update attachment media
- const { result: updatedMediaResult } = await TestHelpers.updateOrUpsertMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- validAttachment.media, contentStream, validMediaOptions, client, isUpsertTest);
-
- // read attachment media after update
- // read media buffered
- const { result: mediaResponse2 } = await client.readMedia(validAttachment.media);
- assert.equal(mediaResponse2, "modified first chunk modified second chunk");
-
- // read media streamed
- client.connectionPolicy.MediaReadMode = DocumentBase.MediaReadMode.Streamed;
- const { result: mediaResponseStreamed } = await client.readMedia(validAttachment.media);
- const mediaResult = await readMediaResponse(mediaResponseStreamed);
- assert.equal(mediaResult, "modified first chunk modified second chunk");
-
- // share attachment with a second document
- const { result: document2 } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "document 2" });
- const secondAttachment = { id: validAttachment.id, contentType: validAttachment.contentType, media: validAttachment.media };
- const { result: attachment2 } = await TestHelpers.createOrUpsertAttachment(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document2),
- secondAttachment, undefined, client, isUpsertTest);
- assert.equal(validAttachment.id, attachment2.id, "name mismatch");
- assert.equal(validAttachment.media, attachment2.media, "media mismatch");
- assert.equal(validAttachment.contentType, attachment2.contentType, "contentType mismatch");
-
- // deleting attachment
- const { result: deletedAttachment } = await client.deleteAttachment(
- TestHelpers.getAttachmentLink(isNameBased, db, collection, document, validAttachment));
-
- // read attachments after deletion
- try {
- const { result: attachment } = await client.readAttachment(
- TestHelpers.getAttachmentLink(isNameBased, db, collection, document, validAttachment));
- assert.fail("Must fail to read attachment after deletion");
- } catch (err) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- }
- } catch (err) {
- throw err;
- }
- };
-
- const attachmentCRUDOverMultiplePartitionsTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
-
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const partitionKey = "id";
- const collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash },
- };
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 });
- // create document
- const { result: document } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "sample document", foo: "bar", key: "value" });
- const sampleDocumentPartitionKeyValue = document[partitionKey];
- // list all attachments
- const { result: attachments } = await client.readAttachments(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), { partitionKey: sampleDocumentPartitionKeyValue }).toArray();
- assert(Array.isArray(attachments), "Value should be an array");
- const initialCount = attachments.length;
- const validMediaOptions = { slug: "attachment name", contentType: "application/text", partitionKey: document[partitionKey] };
- const invalidMediaOptions = { slug: "attachment name", contentType: "junt/test", partitionKey: document[partitionKey] };
-
- // create attachment with invalid content-type
- let contentStream = createReadableStream();
- try {
- const { result: badUpdate } = await TestHelpers.createOrUpsertAttachmentAndUploadMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- contentStream, invalidMediaOptions, client, isUpsertTest);
- assert.fail("Must fail to insert attachment with invalid content-type");
- } catch (err) {
- assert(err !== undefined, "create attachment should return error on invalid mediatypes");
- const badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode);
- }
- contentStream = createReadableStream();
-
- // create streamed attachment with valid content-type
- const { result: validAttachment } = await TestHelpers.createOrUpsertAttachmentAndUploadMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- contentStream, validMediaOptions, client, isUpsertTest);
- assert.equal(validAttachment.id, "attachment name", "name of created attachment should be the same as the one in the request");
- contentStream = createReadableStream();
-
- // create colliding attachment
- try {
- const content2 = "bug";
- const { result: badCreate } = await client.createAttachmentAndUploadMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), contentStream, validMediaOptions);
- assert.fail("create conflicting attachment should return error on conflicting names");
- } catch (err) {
- const conflictErrorCode = 409;
- assert.equal(err.code, conflictErrorCode);
- contentStream = createReadableStream();
- }
-
- // create attachment with media link
- const dynamicAttachment = {
- id: "dynamic attachment",
- media: "http://xstore.",
- MediaType: "Book",
- Author: "My Book Author",
- Title: "My Book Title",
- contentType: "application/text",
- };
- const { result: attachmentWithMediaLink } = await TestHelpers.createOrUpsertAttachment(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- dynamicAttachment, { partitionKey: sampleDocumentPartitionKeyValue }, client, isUpsertTest);
- assert.equal(attachmentWithMediaLink.MediaType, "Book", "invalid media type");
- assert.equal(attachmentWithMediaLink.Author, "My Book Author", "invalid property value");
-
- // list all attachments
- const { result: attachments2 } = await client.readAttachments(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document), { partitionKey: document[partitionKey] }).toArray();
- assert.equal(attachments2.length, initialCount + 2, "number of attachments should've increased by 2");
- attachmentWithMediaLink.Author = "new author";
-
- // replace the attachment
- const { result: replacedAttachment } = await TestHelpers.replaceOrUpsertAttachment(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- TestHelpers.getAttachmentLink(isNameBased, db, collection, document, attachmentWithMediaLink),
- attachmentWithMediaLink, { partitionKey: sampleDocumentPartitionKeyValue }, client, isUpsertTest);
- assert.equal(replacedAttachment.MediaType, "Book", "invalid media type");
- assert.equal(replacedAttachment.Author, "new author", "invalid property value");
-
- // read attachment media
- const { result: mediaResponse } = await client.readMedia(validAttachment.media);
- assert.equal(mediaResponse, "first chunk second chunk");
- contentStream = createReadableStream("modified first chunk ", "modified second chunk");
-
- // update attachment media
- const { result: mediaResult } = await TestHelpers.updateOrUpsertMedia(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- validAttachment.media, contentStream, validMediaOptions, client, isUpsertTest);
-
- // read attachment media after update
- // read media buffered
- const { result: mediaResponseAfterUpdate } = await client.readMedia(validAttachment.media);
- assert.equal(mediaResponseAfterUpdate, "modified first chunk modified second chunk");
-
- // read media streamed
- client.connectionPolicy.MediaReadMode = DocumentBase.MediaReadMode.Streamed;
- const { result: mediaResponseStreamed } = await client.readMedia(validAttachment.media);
- const mediaResultStreamed = await readMediaResponse(mediaResponseStreamed);
- assert.equal(mediaResultStreamed, "modified first chunk modified second chunk");
-
- // share attachment with a second document
- const { result: document2 } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "document 2" });
- const secondDocumentPartitionKeyValue = document2[partitionKey];
- const secondAttachment = { id: validAttachment.id, contentType: validAttachment.contentType, media: validAttachment.media };
- const { result: attachment2 } = await TestHelpers.createOrUpsertAttachment(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document2),
- secondAttachment, { partitionKey: secondDocumentPartitionKeyValue }, client, isUpsertTest);
- assert.equal(validAttachment.id, attachment2.id, "name mismatch");
- assert.equal(validAttachment.media, attachment2.media, "media mismatch");
- assert.equal(validAttachment.contentType, attachment2.contentType, "contentType mismatch");
- const createdAttachment = attachment2;
-
- // deleting attachment
- const { result: attachment } = await client.deleteAttachment(
- TestHelpers.getAttachmentLink(isNameBased, db, collection, document2, createdAttachment), { partitionKey: secondDocumentPartitionKeyValue });
-
- // read attachments after deletion
- try {
- const { result: badRead } = await client.readAttachment(
- TestHelpers.getAttachmentLink(isNameBased, db, collection, document2, createdAttachment), { partitionKey: secondDocumentPartitionKeyValue });
- assert.fail("Must fail to read after deletion");
- } catch (err) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- }
- } catch (err) {
- throw err;
- }
-
- };
-
- it("nativeApi Should do attachment CRUD operations successfully name based", async function () {
- try {
- await attachmentCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do attachment CRUD operations successfully rid based", async function () {
- try {
- await attachmentCRUDTest(false, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do attachment CRUD operations successfully name based with upsert", async function () {
- try {
- await attachmentCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do attachment CRUD operations successfully rid based with upsert", async function () {
- try {
- await attachmentCRUDTest(false, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully name based", async function () {
- try {
- await attachmentCRUDOverMultiplePartitionsTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully rid based", async function () {
- try {
- await attachmentCRUDOverMultiplePartitionsTest(false, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully name based with upsert", async function () {
- try {
- await attachmentCRUDOverMultiplePartitionsTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully rid based with upsert", async function () {
- try {
- await attachmentCRUDOverMultiplePartitionsTest(false, true);
- } catch (err) {
- throw err;
- }
- });
- });
-});
diff --git a/src/test/functional/authorization.spec.ts b/src/test/functional/authorization.spec.ts
index d6403eb..c3fea0c 100644
--- a/src/test/functional/authorization.spec.ts
+++ b/src/test/functional/authorization.spec.ts
@@ -1,21 +1,10 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { CosmosClient, DocumentBase } from "../../";
+import { PermissionDefinition } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
describe("NodeJS CRUD Tests", function () {
@@ -23,240 +12,202 @@ describe("NodeJS CRUD Tests", function () {
// remove all databases from the endpoint before each test
beforeEach(async function () {
this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(new CosmosClient({ endpoint, auth: { masterKey } }));
});
+
describe("Validate Authorization", function () {
- const setupEntities = async function (isNameBased: boolean, isUpsertTest: boolean, client: CosmosClient) {
- try {
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection1
- const { result: collection1 } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
- // create document1
- const { result: document1 } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection1), { id: "coll1doc1", foo: "bar", key: "value" });
- // create document 2
- const { result: document2 } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection1), { id: "coll1doc2", foo: "bar2", key: "value2" });
- // create attachment
- const dynamicAttachment = {
- id: "dynamic attachment",
- media: "http://xstore.",
- MediaType: "Book",
- Author: "My Book Author",
- Title: "My Book Title",
- contentType: "application/text",
- };
- const { result: attachment } = await client.createAttachment(
- TestHelpers.getDocumentLink(isNameBased, db, collection1, document1), dynamicAttachment);
- // create collection 2
- const { result: collection2 } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection2" });
- // create user1
- const { result: user1 } = await client.createUser(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "user1" });
- let permission = { id: "permission On Coll1", permissionMode: DocumentBase.PermissionMode.Read, resource: collection1._self };
- // create permission for collection1
- const { result: permissionOnColl1 } = await TestHelpers.createOrUpsertPermission(
- TestHelpers.getUserLink(isNameBased, db, user1), permission, undefined, client, isUpsertTest);
- assert(permissionOnColl1._token !== undefined, "permission token is invalid");
- permission = { id: "permission On Doc1", permissionMode: DocumentBase.PermissionMode.All, resource: document2._self };
- // create permission for document 2
- const { result: permissionOnDoc2 } = await TestHelpers.createOrUpsertPermission(
- TestHelpers.getUserLink(isNameBased, db, user1), permission, undefined, client, isUpsertTest);
- assert(permissionOnDoc2._token !== undefined, "permission token is invalid");
- // create user 2
- const { result: user2 } = await client.createUser(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "user2" });
- permission = { id: "permission On coll2", permissionMode: DocumentBase.PermissionMode.All, resource: collection2._self };
- // create permission on collection 2
- const { result: permissionOnColl2 } = await TestHelpers.createOrUpsertPermission(
- TestHelpers.getUserLink(isNameBased, db, user2), permission, undefined, client, isUpsertTest);
- const entities = {
- db,
- coll1: collection1,
- coll2: collection2,
- doc1: document1,
- doc2: document2,
- user1,
- user2,
- attachment,
- permissionOnColl1,
- permissionOnDoc2,
- permissionOnColl2,
- };
+ const setupEntities = async function (isUpsertTest: boolean, client: CosmosClient) {
+ // create database
+ const { result: db } = await client.databases.create({ id: "Validate Authorization database" });
+ // create container1
+ const { result: container1 } = await client.databases.get(db.id)
+ .containers.create({ id: "Validate Authorization container" });
+ // create document1
+ const { result: document1 } = await client.databases.get(db.id)
+ .containers.get(container1.id)
+ .items.create({ id: "coll1doc1", foo: "bar", key: "value" });
+ // create document 2
+ const { result: document2 } = await client.databases.get(db.id)
+ .containers.get(container1.id)
+ .items.create({ id: "coll1doc2", foo: "bar2", key: "value2" });
- return entities;
- } catch (err) {
- throw err;
- }
+ // create container 2
+ const { result: container2 } = await client.databases.get(db.id)
+ .containers.create({ id: "sample container2" });
+
+ // create user1
+ const { result: user1 } = await client.databases.get(db.id)
+ .users.create({ id: "user1" });
+ let permission = {
+ id: "permission On Coll1",
+ permissionMode: DocumentBase.PermissionMode.Read,
+ resource: (container1 as any)._self,
+ }; // TODO: any rid stuff
+ // create permission for container1
+ const { result: permissionOnColl1 } = await TestHelpers.createOrUpsertPermission(
+ client.databases.get(db.id).users.get(user1.id), permission, undefined, isUpsertTest);
+ assert((permissionOnColl1 as any)._token !== undefined, "permission token is invalid");
+ permission = {
+ id: "permission On Doc1",
+ permissionMode: DocumentBase.PermissionMode.All,
+ resource: (document2 as any)._self, // TODO: any rid
+ };
+ // create permission for document 2
+ const { result: permissionOnDoc2 } = await TestHelpers.createOrUpsertPermission(
+ client.databases.get(db.id).users.get(user1.id), permission, undefined, isUpsertTest);
+ assert((permissionOnDoc2 as any)._token !== undefined, "permission token is invalid"); // TODO: any rid
+
+ // create user 2
+ const { result: user2 } = await client.databases.get(db.id)
+ .users.create({ id: "user2" });
+ permission = {
+ id: "permission On coll2",
+ permissionMode: DocumentBase.PermissionMode.All,
+ resource: (container2 as any)._self, // TODO: any rid
+ };
+ // create permission on container 2
+ const { result: permissionOnColl2 } = await TestHelpers.createOrUpsertPermission(
+ client.databases.get(db.id).users.get(user2.id), permission, undefined, isUpsertTest);
+ const entities = {
+ db,
+ coll1: container1,
+ coll2: container2,
+ doc1: document1,
+ doc2: document2,
+ user1,
+ user2,
+ permissionOnColl1,
+ permissionOnDoc2,
+ permissionOnColl2,
+ };
+
+ return entities;
};
- const authorizationCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+ const authorizationCRUDTest = async function (isUpsertTest: boolean) {
try {
- try {
- const badclient = new CosmosClient(host, undefined);
- const { result: databases } = await badclient.readDatabases().toArray();
- assert.fail("Must fail");
- } catch (err) {
- assert(err !== undefined, "error should not be undefined");
- const unauthorizedErrorCode = 401;
- assert.equal(err.code, unauthorizedErrorCode, "error code should be equal to 401");
- }
-
- const client = new CosmosClient(host, { masterKey });
-
- // setup entities
- const entities = await setupEntities(isNameBased, isUpsertTest, client);
- const resourceTokens: any = {};
- if (isNameBased) {
- resourceTokens[entities.coll1.id] = entities.permissionOnColl1._token;
- resourceTokens[entities.doc1.id] = entities.permissionOnColl1._token;
- } else {
- resourceTokens[entities.coll1._rid] = entities.permissionOnColl1._token;
- resourceTokens[entities.doc1._rid] = entities.permissionOnColl1._token;
- }
-
- const col1Client = new CosmosClient(host, { resourceTokens });
- const coll1Link = TestHelpers.getCollectionLink(isNameBased, entities.db, entities.coll1);
-
- // 1. Success-- Use Col1 Permission to Read
- const { result: successColl1 } = await col1Client.readCollection(coll1Link);
- assert(successColl1 !== undefined, "error reading collection");
-
- // 2. Failure-- Use Col1 Permission to delete
- try {
- const { result: result } = await col1Client.deleteCollection(coll1Link);
- assert.fail("must fail if no permission");
- } catch (err) {
- assert(err !== undefined, "expected to fail, no permission to delete");
- assert.equal(err.code, 403, "Must return a code for not authorized");
- }
-
- // 3. Success-- Use Col1 Permission to Read All Docs
- const { result: successDocuments } = await col1Client.readDocuments(coll1Link).toArray();
- assert(successDocuments !== undefined, "error reading documents");
- assert.equal(successDocuments.length, 2, "Expected 2 Documents to be succesfully read");
-
- // 4. Success-- Use Col1 Permission to Read Col1Doc1
- const doc1Link = TestHelpers.getDocumentLink(isNameBased, entities.db, entities.coll1, entities.doc1);
- const { result: successDoc } = await col1Client.readDocument(doc1Link);
- assert(successDoc !== undefined, "error reading document");
- assert.equal(successDoc.id, entities.doc1.id, "Expected to read children using parent permissions");
-
- const col2Client = new CosmosClient(host, { permissionFeed: [entities.permissionOnColl2] });
- const doc = { id: "new doc", CustomProperty1: "BBBBBB", customProperty2: 1000 };
- const { result: successDoc2 } = await TestHelpers.createOrUpsertDocument(entities.coll2._self, doc, undefined, col2Client, isUpsertTest);
- assert(successDoc2 !== undefined, "error creating document");
- assert.equal(successDoc2.CustomProperty1, doc.CustomProperty1, "document should have been created successfully");
+ const badclient = new CosmosClient({ endpoint, auth: undefined });
+ const { result: databases } = await badclient.databases.readAll().toArray();
+ assert.fail("Must fail");
} catch (err) {
- throw err;
+ assert(err !== undefined, "error should not be undefined");
+ const unauthorizedErrorCode = 401;
+ assert.equal(err.code, unauthorizedErrorCode, "error code should be equal to 401");
}
+
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
+
+ // setup entities
+ // TODO: should move this out of this test and into before/etc.
+ const entities = await setupEntities(isUpsertTest, client);
+ const resourceTokens: any = {};
+ resourceTokens[entities.coll1.id] = (entities.permissionOnColl1 as any)._token;
+ resourceTokens[entities.doc1.id] = (entities.permissionOnColl1 as any)._token;
+
+ const col1Client = new CosmosClient({ endpoint, auth: { resourceTokens } });
+
+ // 1. Success-- Use Col1 Permission to Read
+ const { result: successColl1 } = await col1Client.databases.get(entities.db.id)
+ .containers.get(entities.coll1.id).read();
+ assert(successColl1 !== undefined, "error reading container");
+
+ // 2. Failure-- Use Col1 Permission to delete
+ try {
+ await col1Client.databases.get(entities.db.id)
+ .containers.get(entities.coll1.id).delete();
+ assert.fail("must fail if no permission");
+ } catch (err) {
+ assert(err !== undefined, "expected to fail, no permission to delete");
+ assert.equal(err.code, 403, "Must return a code for not authorized");
+ }
+
+ // 3. Success-- Use Col1 Permission to Read All Docs
+ const { result: successDocuments } = await col1Client.databases.get(entities.db.id)
+ .containers.get(entities.coll1.id)
+ .items.readAll().toArray();
+ assert(successDocuments !== undefined, "error reading documents");
+ assert.equal(successDocuments.length, 2, "Expected 2 Documents to be succesfully read");
+
+ // 4. Success-- Use Col1 Permission to Read Col1Doc1
+ const { result: successDoc } = await col1Client.databases.get(entities.db.id)
+ .containers.get(entities.coll1.id)
+ .items.get(entities.doc1.id).read();
+ assert(successDoc !== undefined, "error reading document");
+ assert.equal(successDoc.id, entities.doc1.id, "Expected to read children using parent permissions");
+
+ // TODO: Permission Feed uses RID right now
+ /*
+ const col2Client = new CosmosClient({
+ endpoint,
+ auth: { permissionFeed: [entities.permissionOnColl2] },
+ });
+ const doc = { id: "new doc", CustomProperty1: "BBBBBB", customProperty2: 1000 };
+ const col2Container = await col2Client.databases.getDatabase(entities.db.id)
+ .containers.getContainer(entities.coll2.id);
+ const { result: successDoc2 } = await TestHelpers.createOrUpsertItem(
+ col2Container, doc, undefined, isUpsertTest);
+ assert(successDoc2 !== undefined, "error creating document");
+ assert.equal(successDoc2.CustomProperty1, doc.CustomProperty1,
+ "document should have been created successfully");
+ */
};
- const authorizationCRUDOverMultiplePartitionsTest = async function (isNameBased: boolean) {
+ const authorizationCRUDOverMultiplePartitionsTest = async function () {
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
+ // create database
+ // create container
+ const partitionKey = "key";
+ const containerDefinition = {
+ id: "coll1",
+ partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash },
+ };
+ const container = await TestHelpers.getTestContainer(
+ client, "authorization CRUD multiple partitons", containerDefinition);
+ // create user
+ const { result: userDef } = await container.database.users.create({ id: "user1" });
+ const user = container.database.users.get(userDef.id);
+
+ const key = 1;
+ const permissionDefinition: PermissionDefinition = {
+ id: "permission1",
+ permissionMode: DocumentBase.PermissionMode.All,
+ resource: container.url,
+ resourcePartitionKey: [key],
+ };
+
+ // create permission
+ const { result: permission } = await user.permissions.create(permissionDefinition);
+ assert((permission as any)._token !== undefined, "permission token is invalid");
+ const resourceTokens: any = {};
+ resourceTokens[container.id] = (permission as any)._token;
+
+ const restrictedClient = new CosmosClient({ endpoint, auth: { resourceTokens } });
+ await restrictedClient
+ .databases.get(container.database.id)
+ .containers.get(container.id)
+ .items.create({ id: "document1", key: 1 });
try {
- const client = new CosmosClient(host, { masterKey });
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const partitionKey = "key";
- const collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash },
- };
- const { result: coll } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 });
- // create user
- const { result: user } = await client.createUser(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "user1" });
-
- const key = 1;
- const permissionDefinition = {
- id: "permission1",
- permissionMode: DocumentBase.PermissionMode.All,
- resource: TestHelpers.getCollectionLink(isNameBased, db, coll),
- resourcePartitionKey: [key],
- };
- // create permission
- const { result: permission } = await client.createPermission(
- TestHelpers.getUserLink(isNameBased, db, user), permissionDefinition);
- assert(permission._token !== undefined, "permission token is invalid");
- const resourceTokens: any = {};
- if (isNameBased) {
- resourceTokens[coll.id] = permission._token;
- } else {
- resourceTokens[coll._rid] = permission._token;
- }
-
- const restrictedClient = new CosmosClient(host, { resourceTokens });
-
- const { result: document } = await restrictedClient.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, coll), { id: "document1", key: 1 });
- try {
- const { result: baddocument } = await restrictedClient.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, coll), { id: "document2", key: 2 });
- assert.fail("Must throw unauthorized on read");
- } catch (err) {
- const unauthorizedErrorCode = 403;
- assert.equal(err.code, unauthorizedErrorCode);
- }
+ await restrictedClient
+ .databases.get(container.database.id)
+ .containers.get(container.id)
+ .items.create({ id: "document2", key: 2 });
+ assert.fail("Must throw unauthorized on read");
} catch (err) {
- throw err;
+ const unauthorizedErrorCode = 403;
+ assert.equal(err.code, unauthorizedErrorCode);
}
};
it("nativeApi Should do authorization successfully name based", async function () {
- try {
- await authorizationCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do authorization successfully rid based", async function () {
- try {
- await authorizationCRUDTest(false, false);
- } catch (err) {
- throw err;
- }
+ await authorizationCRUDTest(false);
});
it("nativeApi Should do authorization successfully name based with upsert", async function () {
- try {
- await authorizationCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do authorization successfully rid based with upsert", async function () {
- try {
- await authorizationCRUDTest(false, true);
- } catch (err) {
- throw err;
- }
+ await authorizationCRUDTest(true);
});
it("nativeApi Should do authorization over multiple partitions successfully name based", async function () {
- try {
- await authorizationCRUDOverMultiplePartitionsTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do authorization over multiple partitions successfully rid based", async function () {
- try {
- await authorizationCRUDOverMultiplePartitionsTest(false);
- } catch (err) {
- throw err;
- }
+ await authorizationCRUDOverMultiplePartitionsTest();
});
});
});
diff --git a/src/test/functional/client.spec.ts b/src/test/functional/client.spec.ts
index 5fd8142..4d150e3 100644
--- a/src/test/functional/client.spec.ts
+++ b/src/test/functional/client.spec.ts
@@ -1,22 +1,13 @@
import * as assert from "assert";
-import * as Stream from "stream";
import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
+ CosmosClient, DocumentBase,
} from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({endpoint, auth: {masterKey}});
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
@@ -24,22 +15,23 @@ describe("NodeJS CRUD Tests", function () {
beforeEach(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
} catch (err) {
throw err;
}
});
// TODO: disabled tests need to get fixed or deleted
- describe.skip("Validate client request timeout", function () {
+ describe("Validate client request timeout", function () {
it("nativeApi Client Should throw exception", async function () {
const connectionPolicy = new DocumentBase.ConnectionPolicy();
- // making timeout 5 ms to make sure it will throw(create database request takes 10ms-15ms to finish on emulator)
- connectionPolicy.RequestTimeout = 5;
- const client = new CosmosClient(host, { masterKey }, connectionPolicy);
+ // making timeout 5 ms to make sure it will throw
+ // (create database request takes 10ms-15ms to finish on emulator)
+ connectionPolicy.RequestTimeout = 1;
+ const failFailClient = new CosmosClient({endpoint, auth: { masterKey }, connectionPolicy});
// create database
try {
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ await failFailClient.databases.create({ id: "client test database" });
assert.fail("Must throw when trying to connect to database");
} catch (err) {
assert.equal(err.code, "ECONNRESET", "client should throw exception");
diff --git a/src/test/functional/collection.spec.ts b/src/test/functional/collection.spec.ts
deleted file mode 100644
index 05e1d6e..0000000
--- a/src/test/functional/collection.spec.ts
+++ /dev/null
@@ -1,481 +0,0 @@
-import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
-import testConfig from "./../common/_testConfig";
-import { TestHelpers } from "./../common/TestHelpers";
-
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
-const masterKey = testConfig.masterKey;
-
-describe("NodeJS CRUD Tests", function () {
- this.timeout(process.env.MOCHA_TIMEOUT || 10000);
- // remove all databases from the endpoint before each test
- beforeEach(async function () {
- this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
- });
-
- describe("Validate Collection CRUD", function () {
- const collectionCRUDTest = async function (isNameBased: boolean, hasPartitionKey: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- const { result: emptyColls } = await client.readCollections(
- TestHelpers.getDatabaseLink(isNameBased, db)).toArray();
- assert(Array.isArray(emptyColls), "Value should be an array");
- // create a collection
- const beforeCreateCollectionsCount = emptyColls.length;
- const collectionDefinition: any = {
- id: "sample collection",
- indexingPolicy: { indexingMode: "Consistent" },
- };
-
- if (hasPartitionKey) {
- collectionDefinition.partitionKey = { paths: ["/id"], kind: DocumentBase.PartitionKind.Hash };
- }
-
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition);
- assert.equal(collectionDefinition.id, collection.id);
- assert.equal("consistent", collection.indexingPolicy.indexingMode);
- assert.equal(JSON.stringify(collection.partitionKey),
- JSON.stringify(collectionDefinition.partitionKey));
- // read collections after creation
- const { result: collections } = await client.readCollections(
- TestHelpers.getDatabaseLink(isNameBased, db)).toArray();
-
- assert.equal(collections.length, beforeCreateCollectionsCount + 1,
- "create should increase the number of collections");
- // query collections
- const querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: collectionDefinition.id,
- },
- ],
- };
- const { result: results } = await client.queryCollections(
- TestHelpers.getDatabaseLink(isNameBased, db), querySpec).toArray();
- assert(results.length > 0, "number of results for the query should be > 0");
-
- // Replacing indexing policy is allowed.
- collection.indexingPolicy.indexingMode = "Lazy";
- const { result: replacedCollection } = await client.replaceCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection), collection);
- assert.equal("lazy", replacedCollection.indexingPolicy.indexingMode);
-
- // Replacing partition key is not allowed.
- try {
- collection.partitionKey = { paths: ["/key"], kind: DocumentBase.PartitionKind.Hash };
- const { result: badUpdate } = await client.replaceCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection), collection);
- assert.fail("Replacing paritionkey must throw");
- } catch (err) {
- const badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode,
- "response should return error code " + badRequestErrorCode);
- } finally {
- collection.partitionKey = collectionDefinition.partitionKey; // Resume partition key
- }
- // Replacing id is not allowed.
- try {
- collection.id = "try_to_replace_id";
- const { result: badUpdate } = await client.replaceCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection), collection);
- assert.fail("Replacing collection id must throw");
- } catch (err) {
- if (isNameBased) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- } else {
- const badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode, "response should return error code 400");
- }
- }
-
- // read collection
- collection.id = collectionDefinition.id; // Resume Id.
- const { result: readcollection } = await client.readCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection));
- assert.equal(collectionDefinition.id, readcollection.id);
- // delete collection
- const { result: res } = await client.deleteCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection));
- // read collection after deletion
- try {
- const { result: deletedcollection } = await client.readCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection));
- } catch (err) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- }
- } catch (err) {
- throw err;
- }
- };
-
- const badPartitionKeyDefinitionTest = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create a collection
- const collectionDefinition = {
- id: "sample collection",
- indexingPolicy: { indexingMode: "Consistent" },
- partitionKey: { paths: "/id", kind: DocumentBase.PartitionKind.Hash },
- };
-
- try {
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition);
- } catch (err) {
- assert.equal(err.code, 400);
- }
- } catch (err) {
- throw err;
- }
- };
-
- it("nativeApi Should do collection CRUD operations successfully name based", async function () {
- try {
- await collectionCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do collection CRUD operations successfully rid based", async function () {
- try {
- await collectionCRUDTest(false, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do elastic collection CRUD operations successfully name based", async function () {
- try {
- await collectionCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do elastic collection CRUD operations successfully rid based", async function () {
- try {
- await collectionCRUDTest(false, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Collection with bad partition key definition name based", async function () {
- try {
- await badPartitionKeyDefinitionTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Collection with bad partition key definition name based", async function () {
- try {
- await badPartitionKeyDefinitionTest(false);
- } catch (err) {
- throw err;
- }
- });
- });
-
- describe("Validate collection indexing policy", function () {
- const indexPolicyTest = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
-
- // create collection
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
-
- assert.equal(collection.indexingPolicy.indexingMode, DocumentBase.IndexingMode.Consistent, "default indexing mode should be consistent");
- const lazyCollectionDefinition = { id: "lazy collection", indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Lazy } };
- await client.deleteCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection));
-
- const { result: lazyCollection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), lazyCollectionDefinition);
-
- assert.equal(lazyCollection.indexingPolicy.indexingMode, DocumentBase.IndexingMode.Lazy, "indexing mode should be lazy");
- const consistentCollectionDefinition = { id: "lazy collection", indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Consistent } };
- await client.deleteCollection(
- TestHelpers.getCollectionLink(isNameBased, db, lazyCollection));
- const { result: consistentCollection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), consistentCollectionDefinition);
- assert.equal(collection.indexingPolicy.indexingMode, DocumentBase.IndexingMode.Consistent, "indexing mode should be consistent");
- const collectionDefinition = {
- id: "CollectionWithIndexingPolicy",
- indexingPolicy: {
- automatic: true,
- indexingMode: DocumentBase.IndexingMode.Consistent,
- includedPaths: [
- {
- path: "/",
- indexes: [
- {
- kind: DocumentBase.IndexKind.Hash,
- dataType: DocumentBase.DataType.Number,
- precision: 2,
- },
- ],
- },
- ],
- excludedPaths: [
- {
- path: "/\"systemMetadata\"/*",
- },
- ],
- },
-
- };
-
- const { result: coll } = await client.deleteCollection(
- TestHelpers.getCollectionLink(isNameBased, db, consistentCollection));
- const { result: collectionWithIndexingPolicy } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition);
-
- // Two included paths.
- assert.equal(1, collectionWithIndexingPolicy.indexingPolicy.includedPaths.length, "Unexpected includedPaths length");
- // The first included path is what we created.
- assert.equal("/", collectionWithIndexingPolicy.indexingPolicy.includedPaths[0].path);
- assert(collectionWithIndexingPolicy.indexingPolicy.includedPaths[0].indexes.length > 1); // Backend adds a default index
- assert.equal(DocumentBase.IndexKind.Hash, collectionWithIndexingPolicy.indexingPolicy.includedPaths[0].indexes[0].kind);
- // The second included path is a timestamp index created by the server.
-
- // And one excluded path.
- assert.equal(1, collectionWithIndexingPolicy.indexingPolicy.excludedPaths.length, "Unexpected excludedPaths length");
- assert.equal("/\"systemMetadata\"/*", collectionWithIndexingPolicy.indexingPolicy.excludedPaths[0].path);
- } catch (err) {
- throw err;
- }
-
- };
-
- it("nativeApi Should create collection with correct indexing policy name based", async function () {
- try {
- await indexPolicyTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should create collection with correct indexing policy rid based", async function () {
- try {
- await indexPolicyTest(false);
- } catch (err) {
- throw err;
- }
- });
-
- const checkDefaultIndexingPolicyPaths = function (indexingPolicy: any) {
- // no excluded paths.
- assert.equal(0, indexingPolicy["excludedPaths"].length);
- // included paths should be 1 "/".
- assert.equal(1, indexingPolicy["includedPaths"].length);
-
- let rootIncludedPath: any = null;
- if (indexingPolicy["includedPaths"][0]["path"] === "/*") {
- rootIncludedPath = indexingPolicy["includedPaths"][0];
- }
-
- assert(rootIncludedPath); // root path should exist.
-
- // In the root path, there should be one HashIndex for Strings, and one RangeIndex for Numbers.
- assert.equal(2, rootIncludedPath["indexes"].length);
-
- let hashIndex: any = null;
- let rangeIndex: any = null;
-
- for (let i = 0; i < 2; ++i) {
- if (rootIncludedPath["indexes"][i]["kind"] === "Hash") {
- hashIndex = rootIncludedPath["indexes"][i];
- } else if (rootIncludedPath["indexes"][i]["kind"] === "Range") {
- rangeIndex = rootIncludedPath["indexes"][i];
- }
- }
-
- assert(hashIndex);
- assert.equal("String", hashIndex["dataType"]);
- assert(rangeIndex);
- assert.equal("Number", rangeIndex["dataType"]);
- };
-
- const defaultIndexingPolicyTest = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection with no indexing policy specified.
- const collectionDefinition01 = { id: "TestCreateDefaultPolicy01" };
- const { result: collectionNoIndexPolicy } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition01);
- checkDefaultIndexingPolicyPaths(collectionNoIndexPolicy["indexingPolicy"]);
-
- // create collection with partial policy specified.
- const collectionDefinition02 = {
- id: "TestCreateDefaultPolicy02",
- indexingPolicy: {
- indexingMode: "Lazy",
- automatic: true,
- },
- };
-
- const { result: collectionWithPartialPolicy } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition02);
- checkDefaultIndexingPolicyPaths(collectionWithPartialPolicy["indexingPolicy"]);
-
- // create collection with default policy.
- const collectionDefinition03 = {
- id: "TestCreateDefaultPolicy03",
- indexingPolicy: {},
- };
- const { result: collectionDefaultPolicy } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition03);
- checkDefaultIndexingPolicyPaths(collectionDefaultPolicy["indexingPolicy"]);
-
- // create collection with indexing policy missing indexes.
- const collectionDefinition04 = {
- id: "TestCreateDefaultPolicy04",
- indexingPolicy: {
- includedPaths: [
- {
- path: "/*",
- },
- ],
- },
- };
- const { result: collectionMissingIndexes } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition04);
- checkDefaultIndexingPolicyPaths(collectionMissingIndexes["indexingPolicy"]);
-
- // create collection with indexing policy missing precision.
- const collectionDefinition05 = {
- id: "TestCreateDefaultPolicy05",
- indexingPolicy: {
- includedPaths: [
- {
- path: "/*",
- indexes: [
- {
- kind: "Hash",
- dataType: "String",
- },
- {
- kind: "Range",
- dataType: "Number",
- },
- ],
- },
- ],
- },
- };
- const { result: collectionMissingPrecision } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition05);
- checkDefaultIndexingPolicyPaths(collectionMissingPrecision["indexingPolicy"]);
- } catch (err) {
- throw err;
- }
- };
-
- it("nativeApi Should create collection with default indexing policy name based", async function () {
- try {
- await defaultIndexingPolicyTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should create collection with default indexing policy rid based", async function () {
- try {
- await defaultIndexingPolicyTest(false);
- } catch (err) {
- throw err;
- }
- });
- });
-
- describe("Validate response headers", function () {
- const createThenReadCollection = async function (isNameBased: boolean, client: CosmosClient, db: any, body: any) {
- try {
- const { result: createdCollection, headers } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), body);
- const response = await client.readCollection(
- TestHelpers.getCollectionLink(isNameBased, db, createdCollection));
- return response;
- } catch (err) {
- throw err;
- }
- };
-
- const indexProgressHeadersTest = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- const { result: db } = await client.createDatabase({ id: "sample database" });
- const { headers: headers1 } = await createThenReadCollection(isNameBased, client, db, { id: "consistent_coll" });
- assert.notEqual(headers1[Constants.HttpHeaders.IndexTransformationProgress], undefined);
- assert.equal(headers1[Constants.HttpHeaders.LazyIndexingProgress], undefined);
-
- const lazyCollectionDefinition = {
- id: "lazy_coll",
- indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Lazy },
- };
- const { headers: headers2 } = await createThenReadCollection(isNameBased, client, db, lazyCollectionDefinition);
- assert.notEqual(headers2[Constants.HttpHeaders.IndexTransformationProgress], undefined);
- assert.notEqual(headers2[Constants.HttpHeaders.LazyIndexingProgress], undefined);
-
- const noneCollectionDefinition = {
- id: "none_coll",
- indexingPolicy: { indexingMode: DocumentBase.IndexingMode.None, automatic: false },
- };
- const { headers: headers3 } = await createThenReadCollection(isNameBased, client, db, noneCollectionDefinition);
- assert.notEqual(headers3[Constants.HttpHeaders.IndexTransformationProgress], undefined);
- assert.equal(headers3[Constants.HttpHeaders.LazyIndexingProgress], undefined);
- } catch (err) {
- throw err;
- }
- };
-
- it("nativeApi Validate index progress headers name based", async function () {
- try {
- await indexProgressHeadersTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Validate index progress headers rid based", async function () {
- try {
- await indexProgressHeadersTest(false);
- } catch (err) {
- throw err;
- }
- });
- });
-});
diff --git a/src/test/functional/container.spec.ts b/src/test/functional/container.spec.ts
new file mode 100644
index 0000000..9a72e9c
--- /dev/null
+++ b/src/test/functional/container.spec.ts
@@ -0,0 +1,433 @@
+import * as assert from "assert";
+import {
+ Constants, CosmosClient, DocumentBase,
+} from "../../";
+import { Container, ContainerDefinition, Database } from "../../client";
+import { DataType, Index, IndexedPath, IndexingMode, IndexingPolicy, IndexKind } from "../../documents";
+import testConfig from "./../common/_testConfig";
+import { TestHelpers } from "./../common/TestHelpers";
+
+const endpoint = testConfig.host;
+const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
+
+describe("NodeJS CRUD Tests", function () {
+ this.timeout(process.env.MOCHA_TIMEOUT || 10000);
+ // remove all databases from the endpoint before each test
+ beforeEach(async function () {
+ this.timeout(10000);
+ try {
+ await TestHelpers.removeAllDatabases(client);
+ } catch (err) {
+ throw err;
+ }
+ });
+
+ describe("Validate Container CRUD", function () {
+ const containerCRUDTest = async function (hasPartitionKey: boolean) {
+ try {
+ // create database
+ const database = await TestHelpers.getTestDatabase(client, "Validate Container CRUD");
+
+ // create a container
+ const containerDefinition: ContainerDefinition = {
+ id: "sample container",
+ indexingPolicy: { indexingMode: IndexingMode.Consistent },
+ };
+
+ if (hasPartitionKey) {
+ containerDefinition.partitionKey = { paths: ["/id"], kind: DocumentBase.PartitionKind.Hash };
+ }
+
+ const { result: containerDef } = await database.containers.create(containerDefinition);
+ const container = database.containers.get(containerDef.id);
+ assert.equal(containerDefinition.id, containerDef.id);
+ assert.equal("consistent", containerDef.indexingPolicy.indexingMode);
+ assert.equal(JSON.stringify(containerDef.partitionKey),
+ JSON.stringify(containerDefinition.partitionKey));
+ // read containers after creation
+ const { result: containers } = await database.containers.readAll().toArray();
+
+ assert.equal(containers.length, 1, "create should increase the number of containers");
+ // query containers
+ const querySpec = {
+ query: "SELECT * FROM root r WHERE r.id=@id",
+ parameters: [
+ {
+ name: "@id",
+ value: containerDefinition.id,
+ },
+ ],
+ };
+ const { result: results } = await database.containers.query(querySpec).toArray();
+ assert(results.length > 0, "number of results for the query should be > 0");
+
+ // Replacing indexing policy is allowed.
+ containerDef.indexingPolicy.indexingMode = IndexingMode.Lazy;
+ const { result: replacedContainer } = await container.replace(containerDef);
+ assert.equal("lazy", replacedContainer.indexingPolicy.indexingMode);
+
+ // Replacing partition key is not allowed.
+ try {
+ containerDef.partitionKey = { paths: ["/key"], kind: DocumentBase.PartitionKind.Hash };
+ await container.replace(containerDef);
+ assert.fail("Replacing paritionkey must throw");
+ } catch (err) {
+ const badRequestErrorCode = 400;
+ assert.equal(err.code, badRequestErrorCode,
+ "response should return error code " + badRequestErrorCode);
+ } finally {
+ containerDef.partitionKey = containerDefinition.partitionKey; // Resume partition key
+ }
+ // Replacing id is not allowed.
+ try {
+ containerDef.id = "try_to_replace_id";
+ await container.replace(containerDef);
+ assert.fail("Replacing container id must throw");
+ } catch (err) {
+ const notFoundErrorCode = 400;
+ assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
+ }
+
+ // read container
+ containerDef.id = containerDefinition.id; // Resume Id.
+ const { result: readcontainer } = await container.read();
+ assert.equal(containerDefinition.id, readcontainer.id);
+
+ // delete container
+ await container.delete();
+
+ // read container after deletion
+ try {
+ await container.read();
+ assert.fail("Must fail to read container after delete");
+ } catch (err) {
+ const notFoundErrorCode = 404;
+ assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
+ }
+ } catch (err) {
+ throw err;
+ }
+ };
+
+ const badPartitionKeyDefinitionTest = async function (isNameBased: boolean) {
+ try {
+ // create database
+ const database = await TestHelpers.getTestDatabase(client, "container CRUD bad partition key");
+
+ // create a container
+ const badPartitionKeyDefinition: any = {
+ paths: "/id", // This is invalid. Must be an array.
+ kind: DocumentBase.PartitionKind.Hash,
+ };
+
+ const containerDefinition: ContainerDefinition = {
+ id: "sample container",
+ indexingPolicy: { indexingMode: IndexingMode.Consistent },
+ partitionKey: badPartitionKeyDefinition, // This is invalid, forced using type coersion
+ };
+
+ try {
+ await database.containers.create(containerDefinition);
+ } catch (err) {
+ assert.equal(err.code, 400);
+ }
+ } catch (err) {
+ throw err;
+ }
+ };
+
+ it("nativeApi Should do container CRUD operations successfully name based", async function () {
+ try {
+ await containerCRUDTest(false);
+ } catch (err) {
+ throw err;
+ }
+ });
+
+ it("nativeApi Should do elastic container CRUD operations successfully name based", async function () {
+ try {
+ await containerCRUDTest(true);
+ } catch (err) {
+ throw err;
+ }
+ });
+
+ it("nativeApi container with bad partition key definition name based", async function () {
+ try {
+ await badPartitionKeyDefinitionTest(true);
+ } catch (err) {
+ throw err;
+ }
+ });
+
+ it("nativeApi container with bad partition key definition name based", async function () {
+ try {
+ await badPartitionKeyDefinitionTest(false);
+ } catch (err) {
+ throw err;
+ }
+ });
+ });
+
+ describe("Validate container indexing policy", function () {
+ const indexPolicyTest = async function () {
+ try {
+ // create database
+ const { result: dbdef } = await client.databases.create({ id: "container test database" });
+ const database = client.databases.get(dbdef.id);
+
+ // create container
+ const { result: containerDef } = await database.containers.create({ id: "container test container" });
+ const container = database.containers.get(containerDef.id);
+
+ assert.equal(containerDef.indexingPolicy.indexingMode,
+ DocumentBase.IndexingMode.Consistent, "default indexing mode should be consistent");
+ await container.delete();
+
+ const lazyContainerDefinition: ContainerDefinition = {
+ id: "lazy container",
+ indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Lazy },
+ };
+
+ const { result: lazyContainerDef } = await database.containers.create(lazyContainerDefinition);
+ const lazyContainer = database.containers.get(lazyContainerDef.id);
+
+ assert.equal(lazyContainerDef.indexingPolicy.indexingMode,
+ DocumentBase.IndexingMode.Lazy, "indexing mode should be lazy");
+
+ await lazyContainer.delete();
+
+ const consistentcontainerDefinition: ContainerDefinition = {
+ id: "lazy container",
+ indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Consistent },
+ };
+ const { result: consistentContainerDef } =
+ await database.containers.create(consistentcontainerDefinition);
+ const consistentContainer = database.containers.get(consistentContainerDef.id);
+ assert.equal(containerDef.indexingPolicy.indexingMode,
+ DocumentBase.IndexingMode.Consistent, "indexing mode should be consistent");
+ await consistentContainer.delete();
+
+ const containerDefinition: ContainerDefinition = {
+ id: "containerWithIndexingPolicy",
+ indexingPolicy: {
+ automatic: true,
+ indexingMode: DocumentBase.IndexingMode.Consistent,
+ includedPaths: [
+ {
+ path: "/",
+ indexes: [
+ {
+ kind: DocumentBase.IndexKind.Hash,
+ dataType: DocumentBase.DataType.Number,
+ precision: 2,
+ },
+ ],
+ },
+ ],
+ excludedPaths: [
+ {
+ path: "/\"systemMetadata\"/*",
+ },
+ ],
+ },
+
+ };
+
+ const { result: containerWithIndexingPolicyDef } =
+ await database.containers.create(containerDefinition);
+
+ // Two included paths.
+ assert.equal(1, containerWithIndexingPolicyDef.indexingPolicy.includedPaths.length,
+ "Unexpected includedPaths length");
+ // The first included path is what we created.
+ assert.equal("/", containerWithIndexingPolicyDef.indexingPolicy.includedPaths[0].path);
+ // Backend adds a default index
+ assert(containerWithIndexingPolicyDef.indexingPolicy.includedPaths[0].indexes.length > 1);
+ assert.equal(DocumentBase.IndexKind.Hash,
+ containerWithIndexingPolicyDef.indexingPolicy.includedPaths[0].indexes[0].kind);
+ // The second included path is a timestamp index created by the server.
+
+ // And one excluded path.
+ assert.equal(1, containerWithIndexingPolicyDef.indexingPolicy.excludedPaths.length,
+ "Unexpected excludedPaths length");
+ assert.equal("/\"systemMetadata\"/*",
+ containerWithIndexingPolicyDef.indexingPolicy.excludedPaths[0].path);
+ } catch (err) {
+ throw err;
+ }
+
+ };
+
+ it("nativeApi Should create container with correct indexing policy name based", async function () {
+ try {
+ await indexPolicyTest();
+ } catch (err) {
+ throw err;
+ }
+ });
+
+ const checkDefaultIndexingPolicyPaths = function (indexingPolicy: IndexingPolicy) {
+ // no excluded paths.
+ assert.equal(0, indexingPolicy["excludedPaths"].length);
+ // included paths should be 1 "/".
+ assert.equal(1, indexingPolicy["includedPaths"].length);
+
+ let rootIncludedPath: IndexedPath = null;
+ if (indexingPolicy["includedPaths"][0]["path"] === "/*") {
+ rootIncludedPath = indexingPolicy["includedPaths"][0];
+ }
+
+ assert(rootIncludedPath); // root path should exist.
+
+ // In the root path, there should be one HashIndex for Strings, and one RangeIndex for Numbers.
+ assert.equal(2, rootIncludedPath["indexes"].length);
+
+ let hashIndex: Index = null;
+ let rangeIndex: Index = null;
+
+ for (let i = 0; i < 2; ++i) {
+ if (rootIncludedPath["indexes"][i]["kind"] === "Hash") {
+ hashIndex = rootIncludedPath["indexes"][i];
+ } else if (rootIncludedPath["indexes"][i]["kind"] === "Range") {
+ rangeIndex = rootIncludedPath["indexes"][i];
+ }
+ }
+
+ assert(hashIndex);
+ assert.equal("String", hashIndex["dataType"]);
+ assert(rangeIndex);
+ assert.equal("Number", rangeIndex["dataType"]);
+ };
+
+ const defaultIndexingPolicyTest = async function () {
+ try {
+ // create database
+ const { result: dbdef } = await client.databases.create({ id: "container test database" });
+ const database = client.databases.get(dbdef.id);
+
+ // create container with no indexing policy specified.
+ const containerDefinition01: ContainerDefinition = { id: "TestCreateDefaultPolicy01" };
+ const { result: containerNoIndexPolicyDef } = await database.containers.create(containerDefinition01);
+ checkDefaultIndexingPolicyPaths(containerNoIndexPolicyDef["indexingPolicy"]);
+
+ // create container with partial policy specified.
+ const containerDefinition02: ContainerDefinition = {
+ id: "TestCreateDefaultPolicy02",
+ indexingPolicy: {
+ indexingMode: IndexingMode.Lazy,
+ automatic: true,
+ },
+ };
+
+ const { result: containerWithPartialPolicyDef } =
+ await database.containers.create(containerDefinition02);
+ checkDefaultIndexingPolicyPaths((containerWithPartialPolicyDef as any)["indexingPolicy"]);
+
+ // create container with default policy.
+ const containerDefinition03 = {
+ id: "TestCreateDefaultPolicy03",
+ indexingPolicy: {},
+ };
+ const { result: containerDefaultPolicy } = await database.containers.create(containerDefinition03);
+ checkDefaultIndexingPolicyPaths((containerDefaultPolicy as any)["indexingPolicy"]);
+
+ // create container with indexing policy missing indexes.
+ const containerDefinition04 = {
+ id: "TestCreateDefaultPolicy04",
+ indexingPolicy: {
+ includedPaths: [
+ {
+ path: "/*",
+ },
+ ],
+ },
+ };
+ const { result: containerMissingIndexes } = await database.containers.create(containerDefinition04);
+ checkDefaultIndexingPolicyPaths((containerMissingIndexes as any)["indexingPolicy"]);
+
+ // create container with indexing policy missing precision.
+ const containerDefinition05 = {
+ id: "TestCreateDefaultPolicy05",
+ indexingPolicy: {
+ includedPaths: [
+ {
+ path: "/*",
+ indexes: [
+ {
+ kind: IndexKind.Hash,
+ dataType: DataType.String,
+ },
+ {
+ kind: IndexKind.Range,
+ dataType: DataType.Number,
+ },
+ ],
+ },
+ ],
+ },
+ };
+ const { result: containerMissingPrecision } = await database.containers.create(containerDefinition05);
+ checkDefaultIndexingPolicyPaths((containerMissingPrecision as any)["indexingPolicy"]);
+ } catch (err) {
+ throw err;
+ }
+ };
+
+ it("nativeApi Should create container with default indexing policy name based", async function () {
+ try {
+ await defaultIndexingPolicyTest();
+ } catch (err) {
+ throw err;
+ }
+ });
+ });
+
+ describe("Validate response headers", function () {
+ const createThenReadcontainer = async function (database: Database, body: ContainerDefinition) {
+ try {
+ const { result: createdcontainer, headers } = await database.containers.create(body);
+ const response = await database.containers.get(createdcontainer.id).read();
+ return response;
+ } catch (err) {
+ throw err;
+ }
+ };
+
+ const indexProgressHeadersTest = async function () {
+ try {
+ const database = await TestHelpers.getTestDatabase(client, "Validate response headers");
+ const { headers: headers1 } = await createThenReadcontainer(database, { id: "consistent_coll" });
+ assert.notEqual(headers1[Constants.HttpHeaders.IndexTransformationProgress], undefined);
+ assert.equal(headers1[Constants.HttpHeaders.LazyIndexingProgress], undefined);
+
+ const lazyContainerDefinition = {
+ id: "lazy_coll",
+ indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Lazy },
+ };
+ const { headers: headers2 } = await createThenReadcontainer(database, lazyContainerDefinition);
+ assert.notEqual(headers2[Constants.HttpHeaders.IndexTransformationProgress], undefined);
+ assert.notEqual(headers2[Constants.HttpHeaders.LazyIndexingProgress], undefined);
+
+ const noneContainerDefinition = {
+ id: "none_coll",
+ indexingPolicy: { indexingMode: DocumentBase.IndexingMode.None, automatic: false },
+ };
+ const { headers: headers3 } = await createThenReadcontainer(database, noneContainerDefinition);
+ assert.notEqual(headers3[Constants.HttpHeaders.IndexTransformationProgress], undefined);
+ assert.equal(headers3[Constants.HttpHeaders.LazyIndexingProgress], undefined);
+ } catch (err) {
+ throw err;
+ }
+ };
+
+ it("nativeApi Validate index progress headers name based", async function () {
+ try {
+ await indexProgressHeadersTest();
+ } catch (err) {
+ throw err;
+ }
+ });
+ });
+});
diff --git a/src/test/functional/database.spec.ts b/src/test/functional/database.spec.ts
index 1d858da..8b7a50a 100644
--- a/src/test/functional/database.spec.ts
+++ b/src/test/functional/database.spec.ts
@@ -1,22 +1,11 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { CosmosClient } from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({endpoint, auth: { masterKey}});
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
@@ -24,26 +13,27 @@ describe("NodeJS CRUD Tests", function () {
beforeEach(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
} catch (err) {
throw err;
}
});
describe("Validate Database CRUD", async function () {
- const databaseCRUDTest = async function (isNameBased: boolean) {
+ const databaseCRUDTest = async function () {
try {
- const client = new CosmosClient(host, { masterKey });
// read databases
- const { result: databases } = await client.readDatabases().toArray();
+ const { result: databases } = await client.databases.readAll().toArray();
assert.equal(databases.constructor, Array, "Value should be an array");
+
// create a database
const beforeCreateDatabasesCount = databases.length;
- const databaseDefinition = { id: "sample database" };
- const { result: db } = await client.createDatabase(databaseDefinition);
+ const databaseDefinition = { id: "database test database" };
+ const { result: db } = await client.databases.create(databaseDefinition);
assert.equal(db.id, databaseDefinition.id);
+
// read databases after creation
- const { result: databases2 } = await client.readDatabases().toArray();
+ const { result: databases2 } = await client.databases.readAll().toArray();
assert.equal(databases2.length, beforeCreateDatabasesCount + 1,
"create should increase the number of databases");
// query databases
@@ -56,15 +46,14 @@ describe("NodeJS CRUD Tests", function () {
},
],
};
- const { result: results } = await client.queryDatabases(querySpec).toArray();
+ const { result: results } = await client.databases.query(querySpec).toArray();
assert(results.length > 0, "number of results for the query should be > 0");
// delete database
- const { result: res } = await client.deleteDatabase(TestHelpers.getDatabaseLink(isNameBased, db));
+ await client.databases.get(db.id).delete();
try {
// read database after deletion
- const { result: database3 } =
- await client.readDatabase(TestHelpers.getDatabaseLink(isNameBased, db));
+ await client.databases.get(db.id).read();
assert.fail("Read database on non-existent database should fail");
} catch (err) {
const notFoundErrorCode = 404;
@@ -77,28 +66,19 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should do database CRUD operations successfully name based", async function () {
try {
- await databaseCRUDTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do database CRUD operations successfully rid based", async function () {
- try {
- await databaseCRUDTest(false);
+ await databaseCRUDTest();
} catch (err) {
throw err;
}
});
});
+ // TODO: These are unit tests, not e2e tests like above, so maybe should seperate these.
describe("Validate Id validation", function () {
- const client = new CosmosClient(host, { masterKey });
-
it("nativeApi Should fail on ends with a space", async function () {
// Id shoudn't end with a space.
try {
- const { result: db } = await client.createDatabase({ id: "id_ends_with_space " });
+ const { result: db } = await client.databases.create({ id: "id_ends_with_space " });
assert.fail("Must throw if id ends with a space");
} catch (err) {
assert.equal("Id ends with a space.", err.message);
@@ -108,7 +88,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeAPI Should fail on contains '/'", async function() {
// Id shoudn't contain "/".
try {
- const { result: db } = await client.createDatabase({ id: "id_with_illegal/_char" });
+ const { result: db } = await client.databases.create({ id: "id_with_illegal/_char" });
assert.fail("Must throw if id has illegal characters");
} catch (err) {
assert.equal("Id contains illegal chars.", err.message);
@@ -118,7 +98,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeAPI Should fail on contains '\\'", async function() {
// Id shoudn't contain "\\".
try {
- const { result: db } = await client.createDatabase({ id: "id_with_illegal\\_char" });
+ const { result: db } = await client.databases.create({ id: "id_with_illegal\\_char" });
assert.fail("Must throw if id contains illegal characters");
} catch (err) {
assert.equal("Id contains illegal chars.", err.message);
@@ -128,7 +108,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeAPI Should fail on contains '?'", async function() {
// Id shoudn't contain "?".
try {
- const { result: db } = await client.createDatabase({ id: "id_with_illegal?_?char" });
+ const { result: db } = await client.databases.create({ id: "id_with_illegal?_?char" });
assert.fail("Must throw if id contains illegal characters");
} catch (err) {
assert.equal("Id contains illegal chars.", err.message);
@@ -139,7 +119,7 @@ describe("NodeJS CRUD Tests", function () {
// Id shoudn't contain "#".
try {
- const { result: db } = await client.createDatabase({ id: "id_with_illegal#_char" });
+ const { result: db } = await client.databases.create({ id: "id_with_illegal#_char" });
assert.fail("Must throw if id contains illegal characters");
} catch (err) {
assert.equal("Id contains illegal chars.", err.message);
diff --git a/src/test/functional/databaseaccount.spec.ts b/src/test/functional/databaseaccount.spec.ts
index e8c676e..0251a98 100644
--- a/src/test/functional/databaseaccount.spec.ts
+++ b/src/test/functional/databaseaccount.spec.ts
@@ -1,22 +1,11 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { CosmosClient } from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
@@ -24,20 +13,20 @@ describe("NodeJS CRUD Tests", function () {
beforeEach(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
} catch (err) {
throw err;
}
});
describe("validate database account functionality", function () {
- const databaseAccountTest = async function (isNameBased: boolean) {
+ const databaseAccountTest = async function () {
try {
- const client = new CosmosClient(host, { masterKey });
const { result: databaseAccount, headers } = await client.getDatabaseAccount();
assert.equal(databaseAccount.DatabasesLink, "/dbs/");
assert.equal(databaseAccount.MediaLink, "/media/");
- assert.equal(databaseAccount.MaxMediaStorageUsageInMB, headers["x-ms-max-media-storage-usage-mb"]); // TODO: should use constants here
+ assert.equal(databaseAccount.MaxMediaStorageUsageInMB,
+ headers["x-ms-max-media-storage-usage-mb"]); // TODO: should use constants here
assert.equal(databaseAccount.CurrentMediaStorageUsageInMB, headers["x-ms-media-storage-usage-mb"]);
assert(databaseAccount.ConsistencyPolicy !== undefined);
} catch (err) {
@@ -47,15 +36,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should get database account successfully name based", async function () {
try {
- await databaseAccountTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should get database account successfully rid based", async function () {
- try {
- await databaseAccountTest(false);
+ await databaseAccountTest();
} catch (err) {
throw err;
}
diff --git a/src/test/functional/document.spec.ts b/src/test/functional/item.spec.ts
similarity index 51%
rename from src/test/functional/document.spec.ts
rename to src/test/functional/item.spec.ts
index 84f975b..bd964a6 100644
--- a/src/test/functional/document.spec.ts
+++ b/src/test/functional/item.spec.ts
@@ -1,21 +1,14 @@
import * as assert from "assert";
-import * as Stream from "stream";
import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
+ Container,
+ CosmosClient,
+ Database,
+ DocumentBase,
} from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
describe("NodeJS CRUD Tests", function () {
@@ -24,49 +17,49 @@ describe("NodeJS CRUD Tests", function () {
beforeEach(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(new CosmosClient({ endpoint, auth: { masterKey } }));
} catch (err) {
throw err;
}
});
describe("Validate Document CRUD", function () {
- const documentCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+ const documentCRUDTest = async function (isUpsertTest: boolean) {
try {
- const client = new CosmosClient(host, { masterKey });
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
// create database
- const { result: db } = await client.createDatabase({ id: "sample 中文 database" });
- // create collection
- const { result: collection } =
- await client.createCollection("dbs/sample 中文 database", { id: "sample collection" });
- // read documents
- const { result: documents } = await client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- assert(Array.isArray(documents), "Value should be an array");
- // create a document
- const beforeCreateDocumentsCount = documents.length;
- const documentDefinition = {
+ const { result: dbdef } = await client.databases.create({ id: "sample 中文 database" });
+ const db: Database = client.databases.get(dbdef.id);
+ // create container
+ const { result: containerdef } =
+ await db.containers.create({ id: "sample container" });
+ const container: Container = db.containers.get(containerdef.id);
+
+ // read items
+ const { result: items } = await container.items.readAll().toArray();
+ assert(Array.isArray(items), "Value should be an array");
+
+ // create an item
+ const beforeCreateDocumentsCount = items.length;
+ const itemDefinition = {
name: "sample document",
foo: "bar",
key: "value",
replace: "new property",
};
try {
- const { result: badUpdate } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), documentDefinition,
- { disableAutomaticIdGeneration: true }, client, isUpsertTest);
+ await TestHelpers.createOrUpsertItem(container, itemDefinition,
+ { disableAutomaticIdGeneration: true }, isUpsertTest);
assert.fail("id generation disabled must throw with invalid id");
} catch (err) {
assert(err !== undefined, "should throw an error because automatic id generation is disabled");
}
- const { result: document } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- documentDefinition, undefined, client, isUpsertTest);
- assert.equal(document.name, documentDefinition.name);
+ const { result: document } = await TestHelpers.createOrUpsertItem(
+ container, itemDefinition, undefined, isUpsertTest);
+ assert.equal(document.name, itemDefinition.name);
assert(document.id !== undefined);
// read documents after creation
- const { result: documents2 } = await client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
+ const { result: documents2 } = await container.items.readAll().toArray();
assert.equal(documents2.length, beforeCreateDocumentsCount + 1,
"create should increase the number of documents");
// query documents
@@ -79,36 +72,29 @@ describe("NodeJS CRUD Tests", function () {
},
],
};
- const { result: results } = await client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySpec).toArray();
+ const { result: results } = await container.items.query(querySpec).toArray();
assert(results.length > 0, "number of results for the query should be > 0");
- const { result: results2 } = await client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
+ const { result: results2 } = await container.items.query(
querySpec, { enableScanInQuery: true }).toArray();
assert(results2.length > 0, "number of results for the query should be > 0");
// replace document
document.name = "replaced document";
document.foo = "not bar";
- const { result: replacedDocument } = await TestHelpers.replaceOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- TestHelpers.getDocumentLink(isNameBased, db, collection, document),
- document, undefined, client, isUpsertTest);
+ const { result: replacedDocument } = await TestHelpers.replaceOrUpsertItem(
+ container, document, undefined, isUpsertTest);
assert.equal(replacedDocument.name, "replaced document", "document name property should change");
assert.equal(replacedDocument.foo, "not bar", "property should have changed");
assert.equal(document.id, replacedDocument.id, "document id should stay the same");
// read document
- const { result: document2 } = await client.readDocument(
- TestHelpers.getDocumentLink(isNameBased, db, collection, replacedDocument));
+ const { result: document2 } = await container.items.get(replacedDocument.id).read();
assert.equal(replacedDocument.id, document.id);
// delete document
- const { result: res } = await client.deleteDocument(
- TestHelpers.getDocumentLink(isNameBased, db, collection, replacedDocument));
+ const { result: res } = await container.items.get(replacedDocument.id).delete();
// read documents after deletion
try {
- const { result: document3 } = await client.readDocument(
- TestHelpers.getDocumentLink(isNameBased, db, collection, document));
+ const { result: document3 } = await container.items.get(replacedDocument.id).read();
assert.fail("must throw if document doesn't exist");
} catch (err) {
const notFoundErrorCode = 404;
@@ -119,23 +105,23 @@ describe("NodeJS CRUD Tests", function () {
}
};
- const documentCRUDMultiplePartitionsTest = async function (isNameBased: boolean) {
+ const documentCRUDMultiplePartitionsTest = async function () {
try {
- const client = new CosmosClient(host, { masterKey });
+ const client = new CosmosClient({endpoint, auth: { masterKey }});
// create database
- const { result: db } = await client.createDatabase({ id: "db1" });
-
+ const { result: dbdef } = await client.databases.create({ id: "db1" });
+ const db = client.databases.get(dbdef.id);
const partitionKey = "key";
- // create collection
- const collectionDefinition = {
+ // create container
+ const containerDefinition = {
id: "coll1",
partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash },
};
- const { result: collection } =
- await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 });
+ const { result: containerdef } =
+ await db.containers.create(containerDefinition, { offerThroughput: 12000 });
+ const container = db.containers.get(containerdef.id);
const documents = [
{ id: "document1" },
@@ -147,16 +133,14 @@ describe("NodeJS CRUD Tests", function () {
];
let returnedDocuments =
- await TestHelpers.bulkInsertDocuments(client, isNameBased, db, collection, documents);
+ await TestHelpers.bulkInsertItems(container, documents);
assert.equal(returnedDocuments.length, documents.length);
returnedDocuments.sort(function (doc1, doc2) {
return doc1.id.localeCompare(doc2.id);
});
- await TestHelpers.bulkReadDocuments(
- client, isNameBased, db, collection, returnedDocuments, partitionKey);
- const { result: successDocuments } = await client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
+ await TestHelpers.bulkReadItems(container, returnedDocuments, partitionKey);
+ const { result: successDocuments } = await container.items.readAll().toArray();
assert(successDocuments !== undefined, "error reading documents");
assert.equal(successDocuments.length, returnedDocuments.length,
"Expected " + returnedDocuments.length + " documents to be succesfully read");
@@ -168,17 +152,14 @@ describe("NodeJS CRUD Tests", function () {
returnedDocuments.forEach(function (document) { ++document.prop; });
const newReturnedDocuments =
- await TestHelpers.bulkReplaceDocuments(client, isNameBased, db,
- collection, returnedDocuments, partitionKey);
+ await TestHelpers.bulkReplaceItems(container, returnedDocuments);
returnedDocuments = newReturnedDocuments;
- await TestHelpers.bulkQueryDocumentsWithPartitionKey(client, isNameBased, db,
- collection, returnedDocuments, partitionKey);
+ await TestHelpers.bulkQueryItemsWithPartitionKey(container, returnedDocuments, partitionKey);
const querySpec = {
query: "SELECT * FROM Root",
};
try {
- const { result: badUpdate } = await client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
+ const { result: badUpdate } = await container.items.query(
querySpec, { enableScanInQuery: true }).toArray();
assert.fail("Must fail");
} catch (err) {
@@ -186,9 +167,8 @@ describe("NodeJS CRUD Tests", function () {
assert.equal(err.code, badRequestErrorCode,
"response should return error code " + badRequestErrorCode);
}
- const { result: results } = await client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySpec,
- { enableScanInQuery: true, enableCrossPartitionQuery: true }).toArray();
+ const { result: results } = await container.items.query(
+ querySpec, { enableScanInQuery: true, enableCrossPartitionQuery: true }).toArray();
assert(results !== undefined, "error querying documents");
results.sort(function (doc1, doc2) {
return doc1.id.localeCompare(doc2.id);
@@ -197,8 +177,8 @@ describe("NodeJS CRUD Tests", function () {
"Expected " + returnedDocuments.length + " documents to be succesfully queried");
assert.equal(JSON.stringify(results), JSON.stringify(returnedDocuments), "Unexpected query results");
- await TestHelpers.bulkDeleteDocuments(
- client, isNameBased, db, collection, returnedDocuments, partitionKey);
+ await TestHelpers.bulkDeleteItems(
+ container, returnedDocuments, partitionKey);
} catch (err) {
throw err;
}
@@ -206,15 +186,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should do document CRUD operations successfully name based", async function () {
try {
- await documentCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do document CRUD operations successfully rid based", async function () {
- try {
- await documentCRUDTest(false, false);
+ await documentCRUDTest(false);
} catch (err) {
throw err;
}
@@ -222,36 +194,14 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should do document CRUD operations successfully name based with upsert", async function () {
try {
- await documentCRUDTest(true, true);
+ await documentCRUDTest(true);
} catch (err) {
throw err;
}
});
- it("nativeApi Should do document CRUD operations successfully rid based with upsert", async function () {
- try {
- await documentCRUDTest(false, true);
- } catch (err) {
- throw err;
- }
+ it("nativeApi Should do document CRUD operations over multiple partitions", async function () {
+ await documentCRUDMultiplePartitionsTest();
});
-
- it("nativeApi Should do document CRUD operations over multiple partitions successfully name based",
- async function () {
- try {
- await documentCRUDMultiplePartitionsTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do document CRUD operations over multiple partitions successfully rid based",
- async function () {
- try {
- await documentCRUDMultiplePartitionsTest(false);
- } catch (err) {
- throw err;
- }
- });
});
});
diff --git a/src/test/functional/offer.spec.ts b/src/test/functional/offer.spec.ts.ignore
similarity index 86%
rename from src/test/functional/offer.spec.ts
rename to src/test/functional/offer.spec.ts.ignore
index 9d0c9f3..8ea2a39 100644
--- a/src/test/functional/offer.spec.ts
+++ b/src/test/functional/offer.spec.ts.ignore
@@ -1,37 +1,28 @@
+/* Offer is going to be moved to the resources themselves, not a first class top level object */
+
+
+
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { Base, Constants, CosmosClient } from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
+import { OfferDefinition } from "../../client";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
// remove all databases from the endpoint before each test
beforeEach(async function () {
this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(client);
});
describe("Validate Offer CRUD", function () {
- const validateOfferResponseBody = function (offer: any, expectedCollLink: string, expectedOfferType: string) {
+ const validateOfferResponseBody = function (
+ offer: any, expectedCollLink: string, expectedOfferType: string) {
assert(offer.id, "Id cannot be null");
assert(offer._rid, "Resource Id (Rid) cannot be null");
assert(offer._self, "Self Link cannot be null");
@@ -43,10 +34,9 @@ describe("NodeJS CRUD Tests", function () {
}
};
- const offerReadAndQueryTest = async function (isNameBased: boolean, isPartitionedCollection: boolean, offerThroughput: number, expectedCollectionSize: number) {
- const client = new CosmosClient(host, { masterKey });
- // create database
- const { result: db } = await client.createDatabase({ id: "new database" });
+ const offerReadAndQueryTest = async function (
+ isPartitionedCollection: boolean, offerThroughput: number, expectedCollectionSize: number) {
+
const collectionRequestOptions = { offerThroughput };
let collectionDefinition: any = "";
if (isPartitionedCollection) {
@@ -79,11 +69,10 @@ describe("NodeJS CRUD Tests", function () {
} else {
collectionDefinition = { id: "sample collection" };
}
- const { result: createdCollection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition, collectionRequestOptions);
+ const container = await TestHelpers.getTestContainer(
+ client, "Validate Offer CRUD", collectionDefinition, collectionRequestOptions);
- const { result: collection, headers } = await client.readCollection(
- TestHelpers.getCollectionLink(isNameBased, db, createdCollection), { populateQuotaInfo: true });
+ const { result: createdContainerDef, headers } = await container.read({ populateQuotaInfo: true });
// Validate the collection size quota
assert.notEqual(headers[Constants.HttpHeaders.MaxResourceQuota], null);
@@ -96,14 +85,16 @@ describe("NodeJS CRUD Tests", function () {
}, {})[Constants.Quota.CollectionSize]);
assert.equal(collectionSize, expectedCollectionSize, "Collection size is unexpected");
- const { result: offers } = await client.readOffers({}).toArray();
+ const { result: offers } = await client.offers.read().toArray();
assert.equal(offers.length, 1);
const expectedOffer = offers[0];
- assert.equal(expectedOffer.content.offerThroughput, collectionRequestOptions.offerThroughput, "Expected offerThroughput to be " + collectionRequestOptions.offerThroughput);
- validateOfferResponseBody(expectedOffer, collection._self, undefined);
+ assert.equal(expectedOffer.content.offerThroughput, collectionRequestOptions.offerThroughput,
+ "Expected offerThroughput to be " + collectionRequestOptions.offerThroughput);
+ validateOfferResponseBody(expectedOffer, createdContainerDef._self, undefined);
+
// Read the offer
const { result: readOffer } = await client.readOffer(expectedOffer._self);
- validateOfferResponseBody(readOffer, collection._self, undefined);
+ validateOfferResponseBody(readOffer, createdContainerDef._self, undefined);
// Check if the read offer is what we expected.
assert.equal(expectedOffer.id, readOffer.id);
assert.equal(expectedOffer._rid, readOffer._rid);
@@ -131,10 +122,10 @@ describe("NodeJS CRUD Tests", function () {
const { result: offers2 } = await client.queryOffers(querySpec).toArray();
assert.equal(offers2.length, 1);
const oneOffer = offers2[0];
- validateOfferResponseBody(oneOffer, collection._self, undefined);
+ validateOfferResponseBody(oneOffer, createdContainerDef._self, undefined);
// Now delete the collection.
await client.deleteCollection(
- TestHelpers.getCollectionLink(isNameBased, db, collection));
+ TestHelpers.getCollectionLink(isNameBased, db, createdContainerDef));
// read offer after deleting collection.
try {
await client.readOffer(expectedOffer._self);
@@ -200,7 +191,7 @@ describe("NodeJS CRUD Tests", function () {
const offerReplaceTest = async function (isNameBased: boolean) {
try {
- const client = new CosmosClient(host, { masterKey });
+ const client = new CosmosClient(endpoint, { masterKey });
// create database
const { result: db } = await client.createDatabase({ id: "sample database" });
// create collection
@@ -276,7 +267,7 @@ describe("NodeJS CRUD Tests", function () {
const createCollectionWithOfferTypeTest = async function (isNameBased: boolean) {
try {
- const client = new CosmosClient(host, { masterKey });
+ const client = new CosmosClient(endpoint, { masterKey });
// create database
const { result: db } = await client.createDatabase({ id: "sample database" });
// create collection
diff --git a/src/test/functional/permission.spec.ts b/src/test/functional/permission.spec.ts
index 6efa2e8..b6dce2c 100644
--- a/src/test/functional/permission.spec.ts
+++ b/src/test/functional/permission.spec.ts
@@ -1,22 +1,12 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { CosmosClient, DocumentBase } from "../../";
+import { PermissionDefinition } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
@@ -24,40 +14,38 @@ describe("NodeJS CRUD Tests", function () {
beforeEach(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
} catch (err) {
throw err;
}
});
describe("Validate Permission CRUD", function () {
- const permissionCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+ const permissionCRUDTest = async function (isUpsertTest: boolean) {
try {
- const client = new CosmosClient(host, { masterKey });
-
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- const { result: coll } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample coll" });
+ // create container & database
+ const container = await TestHelpers.getTestContainer(client, "Validate Permission Crud");
// create user
- const { result: user } = await client.createUser(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "new user" });
-
+ const { result: userDef } = await container.database.users.create({ id: "new user" });
+ const user = container.database.users.get(userDef.id);
// list permissions
- const { result: permissions } = await client.readPermissions(
- TestHelpers.getUserLink(isNameBased, db, user)).toArray();
+ const { result: permissions } = await user.permissions.readAll().toArray();
assert.equal(permissions.constructor, Array, "Value should be an array");
const beforeCreateCount = permissions.length;
- const permission = { id: "new permission", permissionMode: DocumentBase.PermissionMode.Read, resource: coll._self };
+ const permissionDef: PermissionDefinition = {
+ id: "new permission",
+ permissionMode: DocumentBase.PermissionMode.Read,
+ resource: container.url,
+ };
// create permission
const { result: createdPermission } = await TestHelpers.createOrUpsertPermission(
- TestHelpers.getUserLink(isNameBased, db, user), permission, undefined, client, isUpsertTest);
+ user, permissionDef, undefined, isUpsertTest);
+ let permission = user.permissions.get(createdPermission.id);
assert.equal(createdPermission.id, "new permission", "permission name error");
// list permissions after creation
- const { result: permissionsAfterCreation } = await client.readPermissions(
- TestHelpers.getUserLink(isNameBased, db, user)).toArray();
+ const { result: permissionsAfterCreation } = await user.permissions.readAll().toArray();
assert.equal(permissionsAfterCreation.length, beforeCreateCount + 1);
// query permissions
@@ -66,38 +54,38 @@ describe("NodeJS CRUD Tests", function () {
parameters: [
{
name: "@id",
- value: permission.id,
+ value: permissionDef.id,
},
],
};
- const { result: results } = await client.queryPermissions(
- TestHelpers.getUserLink(isNameBased, db, user), querySpec).toArray();
+ const { result: results } = await user.permissions.query(querySpec).toArray();
assert(results.length > 0, "number of results for the query should be > 0");
- permission.permissionMode = DocumentBase.PermissionMode.All;
- const { result: replacedPermission } = await TestHelpers.replaceOrUpsertPermission(
- TestHelpers.getUserLink(isNameBased, db, user), createdPermission._self, permission, undefined, client, isUpsertTest);
- assert.equal(replacedPermission.permissionMode, DocumentBase.PermissionMode.All, "permission mode should change");
- assert.equal(permission.id, replacedPermission.id, "permission id should stay the same");
+
+ permissionDef.permissionMode = DocumentBase.PermissionMode.All;
+ const { result: replacedPermission } =
+ await TestHelpers.replaceOrUpsertPermission(user, permissionDef, undefined, isUpsertTest);
+ assert.equal(replacedPermission.permissionMode, DocumentBase.PermissionMode.All,
+ "permission mode should change");
+ assert.equal(permissionDef.id, replacedPermission.id,
+ "permission id should stay the same");
// to change the id of an existing resourcewe have to use replace
- permission.id = "replaced permission";
- const { result: replacedPermission2 } = await client.replacePermission(createdPermission._self, permission);
+ permissionDef.id = "replaced permission";
+ const { result: replacedPermission2 } = await permission.replace(permissionDef);
assert.equal(replacedPermission2.id, "replaced permission", "permission name should change");
- assert.equal(permission.id, replacedPermission2.id, "permission id should stay the same");
+ assert.equal(permissionDef.id, replacedPermission2.id, "permission id should stay the same");
+ permission = user.permissions.get(replacedPermission2.id);
// read permission
- const { result: permissionAfterReplace } = await client.readPermission(
- TestHelpers.getPermissionLink(isNameBased, db, user, replacedPermission2));
- assert.equal(permissionAfterReplace.id, permission.id);
+ const { result: permissionAfterReplace } = await permission.read();
+ assert.equal(permissionAfterReplace.id, permissionDef.id);
// delete permission
- const { result: res } = await client.deletePermission(
- TestHelpers.getPermissionLink(isNameBased, db, user, replacedPermission2));
+ const { result: res } = await permission.delete();
// read permission after deletion
try {
- const { result: badPermission } = await client.readPermission(
- TestHelpers.getPermissionLink(isNameBased, db, user, replacedPermission2));
+ await permission.read();
assert.fail("Must fail to read permission after deletion");
} catch (err) {
const notFoundErrorCode = 404;
@@ -108,41 +96,44 @@ describe("NodeJS CRUD Tests", function () {
}
};
- const permissionCRUDOverMultiplePartitionsTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+ const permissionCRUDOverMultiplePartitionsTest = async function (isUpsertTest: boolean) {
try {
- const client = new CosmosClient(host, { masterKey });
-
// create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
+ // create container
const partitionKey = "id";
- const collectionDefinition = {
+ const containerDefinition = {
id: "coll1",
partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash },
};
- const { result: coll } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 });
+ const container = await TestHelpers.getTestContainer(
+ client, "permission CRUD over multiple partitions", containerDefinition);
// create user
- const { result: user } = await client.createUser(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "new user" });
+ const { result: userDef } = await container.database.users.create({ id: "new user" });
+ const user = container.database.users.get(userDef.id);
// list permissions
- const { result: permissions } = await client.readPermissions(
- TestHelpers.getUserLink(isNameBased, db, user)).toArray();
+ const { result: permissions } = await user.permissions.readAll().toArray();
assert(Array.isArray(permissions), "Value should be an array");
const beforeCreateCount = permissions.length;
- const permissionDefinition = { id: "new permission", permissionMode: DocumentBase.PermissionMode.Read, resource: coll._self, resourcePartitionKey: [1] };
+ const permissionDefinition = {
+ id: "new permission",
+ permissionMode: DocumentBase.PermissionMode.Read,
+ resource: container.url,
+ resourcePartitionKey: [1],
+ };
// create permission
- const { result: permission } = await TestHelpers.createOrUpsertPermission(
- TestHelpers.getUserLink(isNameBased, db, user), permissionDefinition, undefined, client, isUpsertTest);
- assert.equal(permission.id, permissionDefinition.id, "permission name error");
- assert.equal(JSON.stringify(permission.resourcePartitionKey), JSON.stringify(permissionDefinition.resourcePartitionKey), "permission resource partition key error");
+ const { result: permissionDef } = await TestHelpers.createOrUpsertPermission(
+ user, permissionDefinition, undefined, isUpsertTest);
+ let permission = user.permissions.get(permissionDef.id);
+ assert.equal(permissionDef.id, permissionDefinition.id, "permission name error");
+ assert.equal(JSON.stringify(permissionDef.resourcePartitionKey),
+ JSON.stringify(permissionDefinition.resourcePartitionKey),
+ "permission resource partition key error");
// list permissions after creation
- const { result: permissionsAfterCreation } = await client.readPermissions(
- TestHelpers.getUserLink(isNameBased, db, user)).toArray();
+ const { result: permissionsAfterCreation } = await user.permissions.readAll().toArray();
assert.equal(permissionsAfterCreation.length, beforeCreateCount + 1);
// query permissions
@@ -151,38 +142,41 @@ describe("NodeJS CRUD Tests", function () {
parameters: [
{
name: "@id",
- value: permission.id,
+ value: permissionDef.id,
},
],
};
- const { result: results } = await client.queryPermissions(
- TestHelpers.getUserLink(isNameBased, db, user), querySpec).toArray();
+ const { result: results } = await user.permissions.query(querySpec).toArray();
assert(results.length > 0, "number of results for the query should be > 0");
- permission.permissionMode = DocumentBase.PermissionMode.All;
+
+ // Replace permission
+ permissionDef.permissionMode = DocumentBase.PermissionMode.All;
const { result: replacedPermission } = await TestHelpers.replaceOrUpsertPermission(
- TestHelpers.getUserLink(isNameBased, db, user), permission._self, permission, undefined, client, isUpsertTest);
- assert.equal(replacedPermission.permissionMode, DocumentBase.PermissionMode.All, "permission mode should change");
- assert.equal(replacedPermission.id, permission.id, "permission id should stay the same");
- assert.equal(JSON.stringify(replacedPermission.resourcePartitionKey), JSON.stringify(permission.resourcePartitionKey), "permission resource partition key error");
+ user, permissionDef, undefined, isUpsertTest);
+ assert.equal(replacedPermission.permissionMode,
+ DocumentBase.PermissionMode.All,
+ "permission mode should change");
+ assert.equal(replacedPermission.id, permissionDef.id, "permission id should stay the same");
+ assert.equal(JSON.stringify(replacedPermission.resourcePartitionKey),
+ JSON.stringify(permissionDef.resourcePartitionKey),
+ "permission resource partition key error");
// to change the id of an existing resourcewe have to use replace
- permission.id = "replaced permission";
- const { result: replacedPermission2 } = await client.replacePermission(permission._self, permission);
- assert.equal(replacedPermission2.id, permission.id);
+ permissionDef.id = "replaced permission";
+ const { result: replacedPermission2 } = await permission.replace(permissionDef);
+ assert.equal(replacedPermission2.id, permissionDef.id);
+ permission = user.permissions.get(replacedPermission2.id);
// read permission
- const { result: permissionAfterReplace } = await client.readPermission(
- TestHelpers.getPermissionLink(isNameBased, db, user, replacedPermission2));
+ const { result: permissionAfterReplace } = await permission.read();
assert.equal(permissionAfterReplace.id, replacedPermission2.id);
// delete permission
- const { result: res } = await client.deletePermission(
- TestHelpers.getPermissionLink(isNameBased, db, user, permissionAfterReplace));
+ const { result: res } = await permission.delete();
// read permission after deletion
try {
- const { result: badPermission } = await client.readPermission(
- TestHelpers.getPermissionLink(isNameBased, db, user, permissionAfterReplace));
+ await permission.read();
assert.fail("Must throw on read after delete");
} catch (err) {
const notFoundErrorCode = 404;
@@ -196,15 +190,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should do Permission CRUD operations successfully name based", async function () {
try {
- await permissionCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do Permission CRUD operations successfully rid based", async function () {
- try {
- await permissionCRUDTest(false, false);
+ await permissionCRUDTest(false);
} catch (err) {
throw err;
}
@@ -212,50 +198,28 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should do Permission CRUD operations successfully name based with upsert", async function () {
try {
- await permissionCRUDTest(true, true);
+ await permissionCRUDTest(true);
} catch (err) {
throw err;
}
});
- it("nativeApi Should do Permission CRUD operations successfully rid based with upsert", async function () {
- try {
- await permissionCRUDTest(false, true);
- } catch (err) {
- throw err;
- }
- });
+ it("nativeApi Should do Permission CRUD operations over multiple partitions successfully name based",
+ async function () {
+ try {
+ await permissionCRUDOverMultiplePartitionsTest(false);
+ } catch (err) {
+ throw err;
+ }
+ });
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully name based", async function () {
- try {
- await permissionCRUDOverMultiplePartitionsTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully rid based", async function () {
- try {
- await permissionCRUDOverMultiplePartitionsTest(false, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully name based with upsert", async function () {
- try {
- await permissionCRUDOverMultiplePartitionsTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully rid based with upsert", async function () {
- try {
- await permissionCRUDOverMultiplePartitionsTest(false, true);
- } catch (err) {
- throw err;
- }
- });
+ it("nativeApi Should do Permission CRUD operations over multiple partitions successfully with upsert",
+ async function () {
+ try {
+ await permissionCRUDOverMultiplePartitionsTest(true);
+ } catch (err) {
+ throw err;
+ }
+ });
});
});
diff --git a/src/test/functional/query.spec.ts b/src/test/functional/query.spec.ts
index 9e011be..9e16667 100644
--- a/src/test/functional/query.spec.ts
+++ b/src/test/functional/query.spec.ts
@@ -1,42 +1,35 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { Constants, CosmosClient, DocumentBase } from "../../";
+import { Container } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
+
+// TODO: This is required for Node 6 and above, so just putting it in here.
+// Might want to decide on only supporting async iterators once Node supports them officially.
+if (!Symbol || !Symbol.asyncIterator) { (Symbol as any).asyncIterator = Symbol.for("Symbol.asyncIterator"); }
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
// remove all databases from the endpoint before each test
- beforeEach(async function () {
+ before(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
} catch (err) {
throw err;
}
});
describe("Validate Queries CRUD", function () {
- const queriesCRUDTest = async function (isNameBased: boolean) {
+ const queriesCRUDTest = async function () {
try {
- const client = new CosmosClient(host, { masterKey });
// create a database
- const databaseDefinition = { id: "sample database" };
- const { result: db } = await client.createDatabase(databaseDefinition);
+ const databaseDefinition = { id: "query test database" };
+ const { result: db } = await client.databases.create(databaseDefinition);
assert.equal(db.id, databaseDefinition.id);
// query databases
const querySpec0 = {
@@ -48,15 +41,15 @@ describe("NodeJS CRUD Tests", function () {
},
],
};
- const { result: results } = await client.queryDatabases(querySpec0).toArray();
+ const { result: results } = await client.databases.query(querySpec0).toArray();
assert(results.length > 0, "number of results for the query should be > 0");
const querySpec1 = {
query: "SELECT * FROM root r WHERE r.id='" + databaseDefinition.id + "'",
};
- const { result: results2 } = await client.queryDatabases(querySpec1).toArray();
+ const { result: results2 } = await client.databases.query(querySpec1).toArray();
assert(results2.length > 0, "number of results for the query should be > 0");
const querySpec2 = "SELECT * FROM root r WHERE r.id='" + databaseDefinition.id + "'";
- const { result: results3 } = await client.queryDatabases(querySpec2).toArray();
+ const { result: results3 } = await client.databases.query(querySpec2).toArray();
assert(results3.length > 0, "number of results for the query should be > 0");
} catch (err) {
throw err;
@@ -65,24 +58,14 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should do queries CRUD operations successfully name based", async function () {
try {
- await queriesCRUDTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do queries CRUD operations successfully rid based", async function () {
- try {
- await queriesCRUDTest(false);
+ await queriesCRUDTest();
} catch (err) {
throw err;
}
});
});
- describe("Validate QueryIterator Functionality For Multiple Partition Collection", function () {
-
- const client = new CosmosClient(host, { masterKey });
+ describe("Validate QueryIterator Functionality For Multiple Partition container", function () {
const documentDefinitions = [
{ id: "document1" },
@@ -93,247 +76,140 @@ describe("NodeJS CRUD Tests", function () {
{ id: "document6", key: "A", prop: 1 },
];
- let db: any;
- let collection: any;
- const isNameBased = false;
+ let container: Container;
- // creates a new database, creates a new collecton, bulk inserts documents to the collection
+ // creates a new database, creates a new collecton, bulk inserts documents to the container
beforeEach(async function () {
- try {
- const { result: createdDB } = await client.createDatabase({ id: "sample 中文 database" });
- db = createdDB;
+ const partitionKey = "key";
+ const containerDefinition = {
+ id: "coll1",
+ partitionKey: {
+ paths: ["/" + partitionKey],
+ kind: DocumentBase.PartitionKind.Hash,
+ },
+ };
- const partitionKey = "key";
- const collectionDefinition = {
- id: "coll1",
- partitionKey: {
- paths: ["/" + partitionKey],
- kind: DocumentBase.PartitionKind.Hash,
- },
- };
-
- const collectionOptions = { offerThroughput: 12000 };
- const { result: createdCollection } =
- await client.createCollection("dbs/sample 中文 database", collectionDefinition, collectionOptions);
- collection = createdCollection;
-
- const insertedDocs =
- await TestHelpers.bulkInsertDocuments(client, isNameBased, db, collection, documentDefinitions);
- } catch (err) {
- throw err;
- }
+ const containerOptions = { offerThroughput: 12000 };
+ container = await TestHelpers.getTestContainer(
+ client, "query CRUD database 中文", containerDefinition, containerOptions);
+ await TestHelpers.bulkInsertItems(container, documentDefinitions);
});
it("nativeApi validate QueryIterator nextItem on Multiple Partition Colleciton", async function () {
- try {
- // obtain an instance of queryIterator
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection));
- let cnt = 0;
- while (queryIterator.hasMoreResults()) {
- const { result: resource } = await queryIterator.nextItem();
- cnt++;
- }
- assert.equal(cnt, documentDefinitions.length);
- } catch (err) {
- throw err;
+ // obtain an instance of queryIterator
+ const queryIterator = container.items.readAll();
+ let cnt = 0;
+ while (queryIterator.hasMoreResults()) {
+ await queryIterator.nextItem();
+ cnt++;
}
+ assert.equal(cnt, documentDefinitions.length);
});
});
describe("Validate QueryIterator Functionality", function () {
this.timeout(30000);
- const createResources = async function (isNameBased: boolean, client: CosmosClient) {
- try {
- const { result: db } = await client.createDatabase({ id: "sample database" + Math.random() });
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
- const { result: doc1 } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "doc1", prop1: "value1" });
- const { result: doc2 } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "doc2", prop1: "value2" });
- const { result: doc3 } = await client.createDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "doc3", prop1: "value3" });
- const resources = {
- db,
- coll: collection,
- doc1,
- doc2,
- doc3,
- };
- return resources;
- } catch (err) {
- throw err;
- }
+ let resources: { container: Container, doc1: any, doc2: any, doc3: any };
+ beforeEach(async function () {
+ const container = await TestHelpers.getTestContainer(client, "Validate QueryIterator Functionality");
+ const { result: doc1 } = await container.items.create({ id: "doc1", prop1: "value1" });
+ const { result: doc2 } = await container.items.create({ id: "doc2", prop1: "value2" });
+ const { result: doc3 } = await container.items.create({ id: "doc3", prop1: "value3" });
+ resources = { container, doc1, doc2, doc3 };
+ });
+
+ const queryIteratorToArrayTest = async function () {
+ const queryIterator = resources.container.items.readAll({ maxItemCount: 2 });
+ const { result: docs } = await queryIterator.toArray();
+ assert.equal(docs.length, 3, "queryIterator should return all documents using continuation");
+ assert.equal(docs[0].id, resources.doc1.id);
+ assert.equal(docs[1].id, resources.doc2.id);
+ assert.equal(docs[2].id, resources.doc3.id);
};
- const queryIteratorToArrayTest = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- const resources = await createResources(isNameBased, client);
- const queryIterator = client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- const { result: docs } = await queryIterator.toArray();
- assert.equal(docs.length, 3, "queryIterator should return all documents using continuation");
- assert.equal(docs[0].id, resources.doc1.id);
- assert.equal(docs[1].id, resources.doc2.id);
- assert.equal(docs[2].id, resources.doc3.id);
- } catch (err) {
- throw err;
+ const queryIteratorForEachTest = async function () {
+ const queryIterator = resources.container.items.readAll({ maxItemCount: 2 });
+ let counter = 0;
+ for await (const { result: doc } of queryIterator.forEach()) {
+ counter++;
+ if (counter === 1) {
+ assert.equal(doc.id, resources.doc1.id, "first document should be doc1");
+ } else if (counter === 2) {
+ assert.equal(doc.id, resources.doc2.id, "second document should be doc2");
+ } else if (counter === 3) {
+ assert.equal(doc.id, resources.doc3.id, "third document should be doc3");
+ }
}
+ assert(counter === 3, "iterator should have run 3 times");
+ };
+
+ const queryIteratorNextAndMoreTest = async function () {
+ const queryIterator = resources.container.items.readAll({ maxItemCount: 2 });
+ assert.equal(queryIterator.hasMoreResults(), true);
+ const { result: doc1 } = await queryIterator.current();
+ assert.equal(doc1.id, resources.doc1.id,
+ "call queryIterator.current after reset should return first document");
+ const { result: doc2 } = await queryIterator.nextItem();
+ assert.equal(doc2.id, resources.doc1.id,
+ "call queryIterator.nextItem after reset should return first document");
+ assert.equal(queryIterator.hasMoreResults(), true);
+ const { result: doc3 } = await queryIterator.current();
+ assert.equal(doc3.id, resources.doc2.id, "call queryIterator.current should return second document");
+ const { result: doc4 } = await queryIterator.nextItem();
+ assert.equal(doc4.id, resources.doc2.id,
+ "call queryIterator.nextItem again should return second document");
+ assert.equal(queryIterator.hasMoreResults(), true);
+ const { result: doc5 } = await queryIterator.current();
+ assert.equal(doc5.id, resources.doc3.id, "call queryIterator.current should return third document");
+ const { result: doc6 } = await queryIterator.nextItem();
+ assert.equal(doc6.id, resources.doc3.id,
+ "call queryIterator.nextItem again should return third document");
+ const { result: doc7 } = await queryIterator.nextItem();
+ assert.equal(doc7, undefined, "queryIterator should return undefined if there is no elements");
+ };
+
+ const queryIteratorExecuteNextTest = async function () {
+ let queryIterator = resources.container.items.readAll({ maxItemCount: 2 });
+ const { result: docs, headers } = await queryIterator.executeNext();
+
+ assert(headers !== undefined, "executeNext should pass headers as the third parameter to the callback");
+ assert(headers[Constants.HttpHeaders.RequestCharge] > 0, "RequestCharge has to be non-zero");
+ assert.equal(docs.length, 2, "first batch size should be 2");
+ assert.equal(docs[0].id, resources.doc1.id, "first batch first document should be doc1");
+ assert.equal(docs[1].id, resources.doc2.id, "batch first second document should be doc2");
+ const { result: docs2 } = await queryIterator.executeNext();
+ assert.equal(docs2.length, 1, "second batch size is unexpected");
+ assert.equal(docs2[0].id, resources.doc3.id, "second batch element should be doc3");
+
+ // validate Iterator.executeNext with continuation token
+ queryIterator = resources.container.items.readAll(
+ { maxItemCount: 2, continuation: headers[Constants.HttpHeaders.Continuation] as string });
+ const {
+ result: docsWithContinuation,
+ headers: headersWithContinuation,
+ } = await queryIterator.executeNext();
+ assert(headersWithContinuation !== undefined,
+ "executeNext should pass headers as the third parameter to the callback");
+ assert(headersWithContinuation[Constants.HttpHeaders.RequestCharge] > 0,
+ "RequestCharge has to be non-zero");
+ assert.equal(docsWithContinuation.length, 1, "second batch size with continuation token is unexpected");
+ assert.equal(docsWithContinuation[0].id, resources.doc3.id, "second batch element should be doc3");
};
it("nativeApi validate QueryIterator iterator toArray name based", async function () {
- try {
- await queryIteratorToArrayTest(true);
- } catch (err) {
- throw err;
- }
+ await queryIteratorToArrayTest();
});
- it("nativeApi validate QueryIterator iterator toArray rid based", async function () {
- try {
- await queryIteratorToArrayTest(false);
- } catch (err) {
- throw err;
- }
- });
-
- const queryIteratorForEachTest = async function (isNameBased: boolean) {
- const client = new CosmosClient(host, { masterKey });
- const resources = await createResources(isNameBased, client);
- const queryIterator = client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- let counter = 0;
- // test queryIterator.forEach
- return new Promise((resolve, reject) => {
- queryIterator.forEach((err, doc) => {
- try {
- counter++;
- if (counter === 1) {
- assert.equal(doc.id, resources.doc1.id, "first document should be doc1");
- } else if (counter === 2) {
- assert.equal(doc.id, resources.doc2.id, "second document should be doc2");
- } else if (counter === 3) {
- assert.equal(doc.id, resources.doc3.id, "third document should be doc3");
- }
-
- if (doc === undefined) {
- assert(counter < 5, "iterator should have stopped");
- resolve();
- }
- } catch (err) {
- reject(err);
- }
- });
- });
- };
-
it("nativeApi validate queryIterator iterator forEach name based", async function () {
- try {
- await queryIteratorForEachTest(true);
- } catch (err) {
- throw err;
- }
+ await queryIteratorForEachTest();
});
- it("nativeApi validate queryIterator iterator forEach rid based", async function () {
- try {
- await queryIteratorForEachTest(false);
- } catch (err) {
- throw err;
- }
- });
-
- const queryIteratorNextAndMoreTest = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- const resources = await createResources(isNameBased, client);
- const queryIterator = client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- assert.equal(queryIterator.hasMoreResults(), true);
- const { result: doc1 } = await queryIterator.current();
- assert.equal(doc1.id, resources.doc1.id, "call queryIterator.current after reset should return first document");
- const { result: doc2 } = await queryIterator.nextItem();
- assert.equal(doc2.id, resources.doc1.id, "call queryIterator.nextItem after reset should return first document");
- assert.equal(queryIterator.hasMoreResults(), true);
- const { result: doc3 } = await queryIterator.current();
- assert.equal(doc3.id, resources.doc2.id, "call queryIterator.current should return second document");
- const { result: doc4 } = await queryIterator.nextItem();
- assert.equal(doc4.id, resources.doc2.id, "call queryIterator.nextItem again should return second document");
- assert.equal(queryIterator.hasMoreResults(), true);
- const { result: doc5 } = await queryIterator.current();
- assert.equal(doc5.id, resources.doc3.id, "call queryIterator.current should return third document");
- const { result: doc6 } = await queryIterator.nextItem();
- assert.equal(doc6.id, resources.doc3.id, "call queryIterator.nextItem again should return third document");
- const { result: doc7 } = await queryIterator.nextItem();
- assert.equal(doc7, undefined, "queryIterator should return undefined if there is no elements");
- } catch (err) {
- throw err;
- }
- };
-
it("nativeApi validate queryIterator nextItem and hasMoreResults name based", async function () {
- try {
- await queryIteratorNextAndMoreTest(true);
- } catch (err) {
- throw err;
- }
+ await queryIteratorNextAndMoreTest();
});
- it("nativeApi validate queryIterator nextItem and hasMoreResults rid based", async function () {
- try {
- await queryIteratorNextAndMoreTest(false);
- } catch (err) {
- throw err;
- }
- });
-
- const queryIteratorExecuteNextTest = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- const resources = await createResources(isNameBased, client);
- let queryIterator = client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- const { result: docs, headers } = await queryIterator.executeNext();
-
- assert(headers !== undefined, "executeNext should pass headers as the third parameter to the callback");
- assert(headers[Constants.HttpHeaders.RequestCharge] > 0, "RequestCharge has to be non-zero");
- assert.equal(docs.length, 2, "first batch size should be 2");
- assert.equal(docs[0].id, resources.doc1.id, "first batch first document should be doc1");
- assert.equal(docs[1].id, resources.doc2.id, "batch first second document should be doc2");
- const { result: docs2 } = await queryIterator.executeNext();
- assert.equal(docs2.length, 1, "second batch size is unexpected");
- assert.equal(docs2[0].id, resources.doc3.id, "second batch element should be doc3");
-
- // validate Iterator.executeNext with continuation token
- queryIterator = client.readDocuments(
- TestHelpers.getCollectionLink(isNameBased, resources.db, resources.coll),
- { maxItemCount: 2, continuation: headers[Constants.HttpHeaders.Continuation] as string });
- const { result: docsWithContinuation, headers: headersWithContinuation } = await queryIterator.executeNext();
- assert(headersWithContinuation !== undefined, "executeNext should pass headers as the third parameter to the callback");
- assert(headersWithContinuation[Constants.HttpHeaders.RequestCharge] > 0, "RequestCharge has to be non-zero");
- assert.equal(docsWithContinuation.length, 1, "second batch size with continuation token is unexpected");
- assert.equal(docsWithContinuation[0].id, resources.doc3.id, "second batch element should be doc3");
- } catch (err) {
- throw err;
- }
- };
-
it("nativeApi validate queryIterator iterator executeNext name based", async function () {
- try {
- await queryIteratorExecuteNextTest(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi validate queryIterator iterator executeNext rid based", async function () {
- try {
- await queryIteratorExecuteNextTest(false);
- } catch (err) {
- throw err;
- }
+ await queryIteratorExecuteNextTest();
});
});
});
diff --git a/src/test/functional/spatial.spec.ts b/src/test/functional/spatial.spec.ts
index be0909e..35705ee 100644
--- a/src/test/functional/spatial.spec.ts
+++ b/src/test/functional/spatial.spec.ts
@@ -1,22 +1,11 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { CosmosClient, Database, DocumentBase } from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
@@ -24,21 +13,19 @@ describe("NodeJS CRUD Tests", function () {
beforeEach(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
} catch (err) {
throw err;
}
});
describe("Validate spatial index", function () {
- const spatialIndexTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+ const spatialIndexTest = async function (isUpsertTest: boolean) {
try {
- const client = new CosmosClient(host, { masterKey });
-
// create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ const database: Database = await TestHelpers.getTestDatabase(client, "validate spatial index");
- // create collection using an indexing policy with spatial index.
+ // create container using an indexing policy with spatial index.
const indexingPolicy = {
includedPaths: [
{
@@ -55,8 +42,11 @@ describe("NodeJS CRUD Tests", function () {
},
],
};
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection", indexingPolicy });
+ const entropy = Math.floor(Math.random() * 10000);
+ const { result: containerDef } = await database.containers.create(
+ { id: `sample container${entropy}`, indexingPolicy });
+ const container = database.containers.get(containerDef.id);
+
const location1 = {
id: "location1",
Location: {
@@ -64,9 +54,7 @@ describe("NodeJS CRUD Tests", function () {
coordinates: [20.0, 20.0],
},
};
- await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- location1, undefined, client, isUpsertTest);
+ await TestHelpers.createOrUpsertItem(container, location1, undefined, isUpsertTest);
const location2 = {
id: "location2",
Location: {
@@ -74,12 +62,10 @@ describe("NodeJS CRUD Tests", function () {
coordinates: [100.0, 100.0],
},
};
- await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- location2, undefined, client, isUpsertTest);
+ await TestHelpers.createOrUpsertItem(container, location2, undefined, isUpsertTest);
+ // tslint:disable-next-line:max-line-length
const query = "SELECT * FROM root WHERE (ST_DISTANCE(root.Location, {type: 'Point', coordinates: [20.1, 20]}) < 20000) ";
- const { result: results } = await client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query).toArray();
+ const { result: results } = await container.items.query(query).toArray();
assert.equal(1, results.length);
assert.equal("location1", results[0].id);
} catch (err) {
@@ -89,15 +75,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should support spatial index name based", async function () {
try {
- await spatialIndexTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should support spatial index rid based", async function () {
- try {
- await spatialIndexTest(false, false);
+ await spatialIndexTest(false);
} catch (err) {
throw err;
}
@@ -105,15 +83,7 @@ describe("NodeJS CRUD Tests", function () {
it("nativeApi Should support spatial index name based with upsert", async function () {
try {
- await spatialIndexTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should support spatial index rid based with upsert", async function () {
- try {
- await spatialIndexTest(false, true);
+ await spatialIndexTest(true);
} catch (err) {
throw err;
}
diff --git a/src/test/functional/sproc.spec.ts b/src/test/functional/sproc.spec.ts
index 2e17b83..20ef3d1 100644
--- a/src/test/functional/sproc.spec.ts
+++ b/src/test/functional/sproc.spec.ts
@@ -5,181 +5,173 @@ import {
DocumentBase, HashPartitionResolver, Range,
RangePartitionResolver, Response, RetryOptions,
} from "../../";
+import { Container, StoredProcedureDefinition } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
// Used for sproc
declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
// TODO: should fix long lines
// tslint:disable:max-line-length
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({
+ endpoint,
+ auth: { masterKey },
+});
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
// remove all databases from the endpoint before each test
beforeEach(async function () {
this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(client);
});
describe("Validate sproc CRUD", function () {
- const sprocCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
-
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
-
- // read sprocs
- const { result: sprocs } = await client.readStoredProcedures(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- assert.equal(sprocs.constructor, Array, "Value should be an array");
-
- // create a sproc
- const beforeCreateSprocsCount = sprocs.length;
- const sprocDefinition: any = {
- id: "sample sproc",
- body() { const x = 10; },
- };
- const { result: sproc } = await TestHelpers.createOrUpsertStoredProcedure(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- sprocDefinition, undefined, client, isUpsertTest);
- for (const property in sprocDefinition) {
- if (property !== "serverScript") {
- assert.equal(sproc[property], sprocDefinition[property], "property " + property + " should match");
- } else {
- assert.equal(sproc.body, "function () { const x = 10; }");
- }
- }
-
- // read sprocs after creation
- const { result: sprocsAfterCreation } = await client.readStoredProcedures(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- assert.equal(sprocsAfterCreation.length, beforeCreateSprocsCount + 1, "create should increase the number of sprocs");
-
- // query sprocs
- const querySpec = {
- query: "SELECT * FROM root r",
- };
- const { result: queriedSprocs } = await client.queryStoredProcedures(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySpec).toArray();
- assert(queriedSprocs.length > 0, "number of sprocs for the query should be > 0");
-
- // replace sproc
- sproc.body = function () { const x = 20; };
- const { result: replacedSproc } = await TestHelpers.replaceOrUpsertStoredProcedure(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, sproc),
- sproc, undefined, client, isUpsertTest);
- for (const property in sprocDefinition) {
- if (property !== "serverScript") {
- assert.equal(replacedSproc[property], sproc[property], "property " + property + " should match");
- } else {
- assert.equal(replacedSproc.body, "function () { const x = 20; }");
- }
- }
-
- // read sproc
- const { result: sprocAfterReplace } = await client.readStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, replacedSproc));
- assert.equal(replacedSproc.id, sprocAfterReplace.id);
-
- // delete sproc
- const { result: res } = await client.deleteStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, replacedSproc));
-
- // read sprocs after deletion
- try {
- const { result: badsproc } = await client.readStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, replacedSproc));
- assert.fail("Must fail to read sproc after deletion");
- } catch (err) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- }
- } catch (err) {
- throw err;
- }
- };
-
- it("nativeApi Should do sproc CRUD operations successfully name based", async function () {
- try {
- await sprocCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
+ let container: Container;
+ beforeEach(async function() {
+ container = await TestHelpers.getTestContainer(client, this.test.fullTitle());
});
- it("nativeApi Should do sproc CRUD operations successfully rid based", async function () {
+ it("nativeApi Should do sproc CRUD operations successfully with create/replace", async function () {
+ // read sprocs
+ const { result: sprocs } = await container.storedProcedures.readAll().toArray();
+ assert.equal(sprocs.constructor, Array, "Value should be an array");
+
+ // create a sproc
+ const beforeCreateSprocsCount = sprocs.length;
+ const sprocDefinition: StoredProcedureDefinition = {
+ id: "sample sproc",
+ body: "function () { const x = 10; }",
+ };
+
+ const { result: sproc } = await container.storedProcedures.create(sprocDefinition);
+
+ assert.equal(sproc.id, sprocDefinition.id);
+ assert.equal(sproc.body, "function () { const x = 10; }");
+
+ // read sprocs after creation
+ const { result: sprocsAfterCreation } = await container.storedProcedures.readAll().toArray();
+ assert.equal(sprocsAfterCreation.length, beforeCreateSprocsCount + 1, "create should increase the number of sprocs");
+
+ // query sprocs
+ const querySpec = {
+ query: "SELECT * FROM root r",
+ };
+ const { result: queriedSprocs } = await container.storedProcedures.query(querySpec).toArray();
+ assert(queriedSprocs.length > 0, "number of sprocs for the query should be > 0");
+
+ // replace sproc
+ sproc.body = function () { const x = 20; };
+ const { result: replacedSproc } = await container.storedProcedures.get(sproc.id).replace(sproc);
+
+ assert.equal(replacedSproc.id, sproc.id);
+ assert.equal(replacedSproc.body, "function () { const x = 20; }");
+
+ // read sproc
+ const { result: sprocAfterReplace } = await container.storedProcedures.get(replacedSproc.id).read();
+ assert.equal(replacedSproc.id, sprocAfterReplace.id);
+
+ // delete sproc
+ await container.storedProcedures.get(replacedSproc.id).delete();
+
+ // read sprocs after deletion
try {
- await sprocCRUDTest(false, false);
+ await container.storedProcedures.get(replacedSproc.id).read();
+ assert.fail("Must fail to read sproc after deletion");
} catch (err) {
- throw err;
+ const notFoundErrorCode = 404;
+ assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
}
});
it("nativeApi Should do sproc CRUD operations successfully name based with upsert", async function () {
- try {
- await sprocCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
+ // read sprocs
+ const { result: sprocs } = await container.storedProcedures.readAll().toArray();
+ assert.equal(sprocs.constructor, Array, "Value should be an array");
- it("nativeApi Should do sproc CRUD operations successfully rid based with upsert", async function () {
+ // create a sproc
+ const beforeCreateSprocsCount = sprocs.length;
+ const sprocDefinition: StoredProcedureDefinition = {
+ id: "sample sproc",
+ // tslint:disable-next-line:object-literal-shorthand
+ body: function() { const x = 10; },
+ };
+
+ const { result: sproc } = await container.storedProcedures.upsert(sprocDefinition);
+
+ assert.equal(sproc.id, sprocDefinition.id);
+ assert.equal(sproc.body, "function () { const x = 10; }");
+
+ // read sprocs after creation
+ const { result: sprocsAfterCreation } = await container.storedProcedures.readAll().toArray();
+ assert.equal(sprocsAfterCreation.length, beforeCreateSprocsCount + 1, "create should increase the number of sprocs");
+
+ // query sprocs
+ const querySpec = {
+ query: "SELECT * FROM root r",
+ };
+ const { result: queriedSprocs } = await container.storedProcedures.query(querySpec).toArray();
+ assert(queriedSprocs.length > 0, "number of sprocs for the query should be > 0");
+
+ // replace sproc
+ sproc.body = function () { const x = 20; };
+ const { result: replacedSproc } = await container.storedProcedures.upsert(sproc);
+
+ assert.equal(replacedSproc.id, sproc.id);
+ assert.equal(replacedSproc.body, "function () { const x = 20; }");
+
+ // read sproc
+ const { result: sprocAfterReplace } = await container.storedProcedures.get(replacedSproc.id).read();
+ assert.equal(replacedSproc.id, sprocAfterReplace.id);
+
+ // delete sproc
+ await container.storedProcedures.get(replacedSproc.id).delete();
+
+ // read sprocs after deletion
try {
- await sprocCRUDTest(false, true);
+ await container.storedProcedures.get(replacedSproc.id).read();
+ assert.fail("Must fail to read sproc after deletion");
} catch (err) {
- throw err;
+ const notFoundErrorCode = 404;
+ assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
}
});
});
- describe("validate stored procedure functionality", function () {
- const storedProcedureCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
+ describe("Validate stored procedure functionality", function () {
+ let container: Container;
+ beforeEach(async function() {
+ container = await TestHelpers.getTestContainer(client, this.test.fullTitle());
+ });
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
- // tslint:disable:no-var-keyword
- // tslint:disable:prefer-const
- // tslint:disable:curly
- // tslint:disable:no-string-throw
- // tslint:disable:object-literal-shorthand
- const sproc1 = {
+ it("nativeApi should do stored procedure operations successfully with create/replace", async function () {
+ // tslint:disable:no-var-keyword
+ // tslint:disable:prefer-const
+ // tslint:disable:curly
+ // tslint:disable:no-string-throw
+ // tslint:disable:object-literal-shorthand
+ const sproc1: StoredProcedureDefinition = {
+ id: "storedProcedure1",
+ body: function () {
+ for (var i = 0; i < 1000; i++) {
+ const item = getContext().getResponse().getBody();
+ if (i > 0 && item !== i - 1) throw "body mismatch";
+ getContext().getResponse().setBody(i);
+ }
+ },
+ };
- id: "storedProcedure1",
- body: function () {
- for (var i = 0; i < 1000; i++) {
- const item = getContext().getResponse().getBody();
- if (i > 0 && item !== i - 1) throw "body mismatch";
- getContext().getResponse().setBody(i);
- }
- },
- };
-
- const sproc2 = {
+ const sproc2: StoredProcedureDefinition = {
id: "storedProcedure2",
body: function () {
for (var i = 0; i < 10; i++) getContext().getResponse().appendValue("Body", i);
},
};
- const sproc3 = {
+ const sproc3: StoredProcedureDefinition = {
id: "storedProcedure3",
// TODO: I put any in here, but not sure how this will work...
body: function (input: any) {
@@ -193,208 +185,182 @@ describe("NodeJS CRUD Tests", function () {
// tslint:enable:no-string-throw
// tslint:enable:object-literal-shorthand
- const { result: retrievedSproc } = await TestHelpers.createOrUpsertStoredProcedure(
- TestHelpers.getCollectionLink(isNameBased, db, collection), sproc1, undefined, client, isUpsertTest);
- const { result: result } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, retrievedSproc));
- assert.equal(result, 999);
+ const { result: retrievedSproc } = await container.storedProcedures.create(sproc1);
+ const { result: result } = await container.storedProcedures.get(retrievedSproc.id).execute();
+ assert.equal(result, 999);
- const { result: retrievedSproc2 } = await TestHelpers.createOrUpsertStoredProcedure(
- TestHelpers.getCollectionLink(isNameBased, db, collection), sproc2, undefined, client, isUpsertTest);
- const { result: result2 } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, retrievedSproc2));
- assert.equal(result2, 123456789);
+ const { result: retrievedSproc2 } = await container.storedProcedures.create(sproc2);
+ const { result: result2 } = await container.storedProcedures.get(retrievedSproc2.id).execute();
+ assert.equal(result2, 123456789);
+ const { result: retrievedSproc3 } = await container.storedProcedures.create(sproc3);
+ const { result: result3 } = await container.storedProcedures.get(retrievedSproc3.id).execute([{ temp: "so" }]);
+ assert.equal(result3, "aso");
+ });
- const { result: retrievedSproc3 } = await TestHelpers.createOrUpsertStoredProcedure(
- TestHelpers.getCollectionLink(isNameBased, db, collection), sproc3, undefined, client, isUpsertTest);
- const { result: result3 } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, retrievedSproc3), [{ temp: "so" }]);
- assert.equal(result3, "aso");
- } catch (err) {
- throw err;
- }
- };
+ it("nativeApi Should do stored procedure operations successfully with upsert", async function () {
+ // tslint:disable:no-var-keyword
+ // tslint:disable:prefer-const
+ // tslint:disable:curly
+ // tslint:disable:no-string-throw
+ // tslint:disable:object-literal-shorthand
+ const sproc1: StoredProcedureDefinition = {
+ id: "storedProcedure1",
+ body: function () {
+ for (var i = 0; i < 1000; i++) {
+ const item = getContext().getResponse().getBody();
+ if (i > 0 && item !== i - 1) throw "body mismatch";
+ getContext().getResponse().setBody(i);
+ }
+ },
+ };
- const executeStoredProcedureWithPartitionKey = async function (isNameBased: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const partitionKey = "key";
-
- const collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash },
- };
-
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 });
- // tslint:disable:no-var-keyword
- // tslint:disable:prefer-const
- // tslint:disable:curly
- // tslint:disable:no-string-throw
- // tslint:disable:no-shadowed-variable
- // tslint:disable:object-literal-shorthand
- const querySproc = {
- id: "querySproc",
+ const sproc2: StoredProcedureDefinition = {
+ id: "storedProcedure2",
body: function () {
- var context = getContext();
- var collection = context.getCollection();
- var response = context.getResponse();
-
- // query for players
- var query = "SELECT r.id, r.key, r.prop FROM r";
- var accept = collection.queryDocuments(collection.getSelfLink(), query, {}, function (err: any, documents: any, responseOptions: any) {
- if (err) throw new Error("Error" + err.message);
- response.setBody(documents);
- });
-
- if (!accept) throw "Unable to read player details, abort ";
- },
- };
- // tslint:enable:no-var-keyword
- // tslint:enable:prefer-const
- // tslint:enable:curly
- // tslint:enable:no-string-throw
- // tslint:enable:no-shadowed-variable
- // tslint:enable:object-literal-shorthand
-
- const documents = [
- { id: "document1" },
- { id: "document2", key: null, prop: 1 },
- { id: "document3", key: false, prop: 1 },
- { id: "document4", key: true, prop: 1 },
- { id: "document5", key: 1, prop: 1 },
- { id: "document6", key: "A", prop: 1 },
- ];
-
- const returnedDocuments = await TestHelpers.bulkInsertDocuments(client, isNameBased, db, collection, documents);
- const { result: sproc } = await client.createStoredProcedure(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySproc);
- const { result: result } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, sproc), [], { partitionKey: null });
- assert(result !== undefined);
- assert.equal(result.length, 1);
- assert.equal(JSON.stringify(result[0]), JSON.stringify(documents[1]));
- const { result: result2 } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(isNameBased, db, collection, sproc), null, { partitionKey: 1 });
- assert(result2 !== undefined);
- assert.equal(result2.length, 1);
- assert.equal(JSON.stringify(result2[0]), JSON.stringify(documents[4]));
- } catch (err) {
- throw err;
- }
- };
-
- it("nativeApi Should do stored procedure operations successfully name based", async function () {
- try {
- await storedProcedureCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do stored procedure operations successfully rid based", async function () {
- try {
- await storedProcedureCRUDTest(false, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do stored procedure operations successfully name based with upsert", async function () {
- try {
- await storedProcedureCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do stored procedure operations successfully rid based with upsert", async function () {
- try {
- await storedProcedureCRUDTest(false, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should execute stored procedure with partition key successfully name based", async function () {
- try {
- await executeStoredProcedureWithPartitionKey(true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should execute stored procedure with partition key successfully rid based", async function () {
- try {
- await executeStoredProcedureWithPartitionKey(false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should enable/disable script logging while executing stored procedure", async function () {
- try {
- const client = new CosmosClient(host, { masterKey });
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const collectionDefinition = { id: "sample collection" };
-
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(true, db), collectionDefinition);
- // tslint:disable:no-var-keyword
- // tslint:disable:prefer-const
- // tslint:disable:curly
- // tslint:disable:no-string-throw
- // tslint:disable:no-shadowed-variable
- // tslint:disable:one-line
- // tslint:disable:object-literal-shorthand
- const sproc1 = {
- id: "storedProcedure",
- body: function () {
- const mytext = "x";
- const myval = 1;
- try {
- console.log("The value of %s is %s.", mytext, myval);
- getContext().getResponse().setBody("Success!");
- }
- catch (err) {
- getContext().getResponse().setBody("inline err: [" + err.number + "] " + err);
- }
+ for (var i = 0; i < 10; i++) getContext().getResponse().appendValue("Body", i);
},
};
- // tslint:enable:no-var-keyword
- // tslint:enable:prefer-const
- // tslint:enable:curly
- // tslint:enable:no-string-throw
- // tslint:enable:no-shadowed-variable
- // tslint:enable:one-line
- // tslint:enable:object-literal-shorthand
+ const sproc3: StoredProcedureDefinition = {
+ id: "storedProcedure3",
+ // TODO: I put any in here, but not sure how this will work...
+ body: function (input: any) {
+ getContext().getResponse().setBody("a" + input.temp);
+ },
+ };
- const { result: retrievedSproc } = await client.createStoredProcedure(
- TestHelpers.getCollectionLink(true, db, collection), sproc1);
- const { result: result1, headers: headers1 } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(true, db, collection, retrievedSproc));
- assert.equal(result1, "Success!");
- assert.equal(headers1[Constants.HttpHeaders.ScriptLogResults], undefined);
+ // tslint:enable:no-var-keyword
+ // tslint:enable:prefer-const
+ // tslint:enable:curly
+ // tslint:enable:no-string-throw
+ // tslint:enable:object-literal-shorthand
- let requestOptions = { enableScriptLogging: true };
- const { result: result2, headers: headers2 } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(true, db, collection, retrievedSproc), undefined, requestOptions);
- assert.equal(result2, "Success!");
- assert.equal(headers2[Constants.HttpHeaders.ScriptLogResults], encodeURIComponent("The value of x is 1."));
+ const { result: retrievedSproc } = await container.storedProcedures.upsert(sproc1);
+ const { result: result } = await container.storedProcedures.get(retrievedSproc.id).execute();
+ assert.equal(result, 999);
- requestOptions = { enableScriptLogging: false };
- const { result: result3, headers: headers3 } = await client.executeStoredProcedure(
- TestHelpers.getStoredProcedureLink(true, db, collection, retrievedSproc), undefined, requestOptions);
- assert.equal(result3, "Success!");
- assert.equal(headers3[Constants.HttpHeaders.ScriptLogResults], undefined);
-
- } catch (err) {
- throw err;
- }
+ const { result: retrievedSproc2 } = await container.storedProcedures.upsert(sproc2);
+ const { result: result2 } = await container.storedProcedures.get(retrievedSproc2.id).execute();
+ assert.equal(result2, 123456789);
+ const { result: retrievedSproc3 } = await container.storedProcedures.upsert(sproc3);
+ const { result: result3 } = await container.storedProcedures.get(retrievedSproc3.id).execute([{ temp: "so" }]);
+ assert.equal(result3, "aso");
});
});
+
+ it("nativeApi Should execute stored procedure with partition key successfully name based", async function () {
+ const { result: db } = await client.databases.create({ id: "sproc test database" });
+ // create container
+ const partitionKey = "key";
+
+ const containerDefinition = {
+ id: "coll1",
+ partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash },
+ };
+
+ const { result: containerResult } = await client.databases.get(db.id).containers.create(containerDefinition, { offerThroughput: 12000 });
+ const container = await client.databases.get(db.id).containers.get(containerResult.id);
+
+ // tslint:disable:no-var-keyword
+ // tslint:disable:prefer-const
+ // tslint:disable:curly
+ // tslint:disable:no-string-throw
+ // tslint:disable:no-shadowed-variable
+ // tslint:disable:object-literal-shorthand
+ const querySproc = {
+ id: "querySproc",
+ body: function () {
+ var context = getContext();
+ var container = context.getCollection();
+ var response = context.getResponse();
+
+ // query for players
+ var query = "SELECT r.id, r.key, r.prop FROM r";
+ var accept = container.queryDocuments(container.getSelfLink(), query, {}, function (err: any, documents: any, responseOptions: any) {
+ if (err) throw new Error("Error" + err.message);
+ response.setBody(documents);
+ });
+
+ if (!accept) throw "Unable to read player details, abort ";
+ },
+ };
+ // tslint:enable:no-var-keyword
+ // tslint:enable:prefer-const
+ // tslint:enable:curly
+ // tslint:enable:no-string-throw
+ // tslint:enable:no-shadowed-variable
+ // tslint:enable:object-literal-shorthand
+
+ const documents = [
+ { id: "document1" },
+ { id: "document2", key: null, prop: 1 },
+ { id: "document3", key: false, prop: 1 },
+ { id: "document4", key: true, prop: 1 },
+ { id: "document5", key: 1, prop: 1 },
+ { id: "document6", key: "A", prop: 1 },
+ ];
+
+ const returnedDocuments = await TestHelpers.bulkInsertItems(container, documents);
+ const { result: sproc } = await container.storedProcedures.create(querySproc);
+ const { result: result } = await container.storedProcedures.get(sproc.id).execute([], { partitionKey: null });
+ assert(result !== undefined);
+ assert.equal(result.length, 1);
+ assert.equal(JSON.stringify(result[0]), JSON.stringify(documents[1]));
+
+ const { result: result2 } = await container.storedProcedures.get(sproc.id).execute(null, { partitionKey: 1 });
+ assert(result2 !== undefined);
+ assert.equal(result2.length, 1);
+ assert.equal(JSON.stringify(result2[0]), JSON.stringify(documents[4]));
+ });
+
+ it("nativeApi Should enable/disable script logging while executing stored procedure", async function () {
+ // create database
+ const { result: db } = await client.databases.create({ id: "sproc test database" });
+ // create container
+ const { result: containerResult } = await client.databases.get(db.id).containers.create({ id: "sample container" });
+
+ const container = await client.databases.get(db.id).containers.get(containerResult.id);
+
+ // tslint:disable:curly
+ // tslint:disable:no-string-throw
+ // tslint:disable:no-shadowed-variable
+ // tslint:disable:one-line
+ // tslint:disable:object-literal-shorthand
+ const sproc1 = {
+ id: "storedProcedure",
+ body: function () {
+ const mytext = "x";
+ const myval = 1;
+ try {
+ console.log("The value of %s is %s.", mytext, myval);
+ getContext().getResponse().setBody("Success!");
+ }
+ catch (err) {
+ getContext().getResponse().setBody("inline err: [" + err.number + "] " + err);
+ }
+ },
+ };
+
+ // tslint:enable:curly
+ // tslint:enable:no-string-throw
+ // tslint:enable:no-shadowed-variable
+ // tslint:enable:one-line
+ // tslint:enable:object-literal-shorthand
+
+ const { result: retrievedSproc } = await container.storedProcedures.create(sproc1);
+ const { result: result1, headers: headers1 } = await container.storedProcedures.get(retrievedSproc.id).execute();
+ assert.equal(result1, "Success!");
+ assert.equal(headers1[Constants.HttpHeaders.ScriptLogResults], undefined);
+
+ let requestOptions = { enableScriptLogging: true };
+ const { result: result2, headers: headers2 } = await container.storedProcedures.get(retrievedSproc.id).execute([], requestOptions);
+ assert.equal(result2, "Success!");
+ assert.equal(headers2[Constants.HttpHeaders.ScriptLogResults], encodeURIComponent("The value of x is 1."));
+
+ requestOptions = { enableScriptLogging: false };
+ const { result: result3, headers: headers3 } = await container.storedProcedures.get(retrievedSproc.id).execute([], requestOptions);
+ assert.equal(result3, "Success!");
+ assert.equal(headers3[Constants.HttpHeaders.ScriptLogResults], undefined);
+
+ });
});
diff --git a/src/test/functional/trigger.spec.ts b/src/test/functional/trigger.spec.ts
index 0e76dce..87e43c1 100644
--- a/src/test/functional/trigger.spec.ts
+++ b/src/test/functional/trigger.spec.ts
@@ -1,82 +1,82 @@
import * as assert from "assert";
-import * as Stream from "stream";
import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
+ CosmosClient,
+ DocumentBase,
} from "../../";
+import { Container, TriggerDefinition } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
+const endpoint = testConfig.host;
+const masterKey = testConfig.masterKey;
+const dbId = "trigger databse";
+const containerId = "trigger container";
+const client = new CosmosClient({
+ endpoint,
+ auth: { masterKey },
+});
+const notFoundErrorCode = 404;
// TODO: should fix long lines
// tslint:disable:max-line-length
-const host = testConfig.host;
-const masterKey = testConfig.masterKey;
+// Mock for trigger function bodies
+declare var getContext: any;
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
- // remove all databases from the endpoint before each test
+ let container: Container;
+
beforeEach(async function () {
- this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ // remove all databases from the endpoint before each test
+ await TestHelpers.removeAllDatabases(client);
+
+ // create database
+ await client.databases.create({
+ id: dbId,
+ });
+
+ // create container
+ await client.databases
+ .get(dbId)
+ .containers.create({ id: containerId });
+
+ container = await client.databases
+ .get(dbId)
+ .containers.get(containerId);
});
describe("Validate Trigger CRUD", function () {
- const triggerCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
- try {
- const client = new CosmosClient(host, { masterKey });
+ it("nativeApi Should do trigger CRUD operations successfully name based", async function () {
+ // read triggers
+ const { result: triggers } = await container.triggers.readAll().toArray();
+ assert.equal(Array.isArray(triggers), true);
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
-
- // read triggers
- const { result: triggers } = await client.readTriggers(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- assert.equal(triggers.constructor, Array, "Value should be an array");
-
- // create a trigger
- const beforeCreateTriggersCount = triggers.length;
- // tslint:disable:no-var-keyword
- // tslint:disable:prefer-const
- const triggerDefinition: any = {
+ // create a trigger
+ const beforeCreateTriggersCount = triggers.length;
+ // tslint:disable:no-var-keyword
+ // tslint:disable:prefer-const
+ const triggerDefinition: TriggerDefinition = {
id: "sample trigger",
- serverScript() { var x = 10; },
+ body: "serverScript() { var x = 10; }",
triggerType: DocumentBase.TriggerType.Pre,
triggerOperation: DocumentBase.TriggerOperation.All,
};
- // tslint:enable:no-var-keyword
- // tslint:enable:prefer-const
+ // tslint:enable:no-var-keyword
+ // tslint:enable:prefer-const
- const { result: trigger } = await TestHelpers.createOrUpsertTrigger(
- TestHelpers.getCollectionLink(isNameBased, db, collection), triggerDefinition, undefined, client, isUpsertTest);
+ const { result: trigger } = await container.triggers.create(triggerDefinition);
- for (const property in triggerDefinition) {
- if (property !== "serverScript") {
- assert.equal(trigger[property], triggerDefinition[property], "property " + property + " should match");
- } else {
- assert.equal(trigger.body, "serverScript() { var x = 10; }");
- }
- }
+ assert.equal(trigger.id, triggerDefinition.id);
+ assert.equal(trigger.body, "serverScript() { var x = 10; }");
- // read triggers after creation
- const { result: triggersAfterCreation } = await client.readTriggers(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- assert.equal(triggersAfterCreation.length, beforeCreateTriggersCount + 1, "create should increase the number of triggers");
+ // read triggers after creation
+ const { result: triggersAfterCreation } = await container.triggers.readAll().toArray();
+ assert.equal(triggersAfterCreation.length, beforeCreateTriggersCount + 1,
+ "create should increase the number of triggers");
- // query triggers
- const querySpec = {
+ // query triggers
+ const querySpec = {
query: "SELECT * FROM root r WHERE r.id=@id",
parameters: [
{
@@ -85,82 +85,99 @@ describe("NodeJS CRUD Tests", function () {
},
],
};
- const { result: results } = await client.queryTriggers(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySpec).toArray();
- assert(results.length > 0, "number of results for the query should be > 0");
+ const { result: results } = await container.triggers.query(querySpec).toArray();
+ assert(results.length > 0, "number of results for the query should be > 0");
- // replace trigger
- trigger.body = function () { const x = 20; };
- const { result: replacedTrigger } = await TestHelpers.replaceOrUpsertTrigger(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- TestHelpers.getTriggerLink(isNameBased, db, collection, trigger),
- trigger, undefined, client, isUpsertTest);
- for (const property in triggerDefinition) {
- if (property !== "serverScript") {
- assert.equal(replacedTrigger[property], trigger[property], "property " + property + " should match");
- } else {
- assert.equal(replacedTrigger.body, "function () { const x = 20; }");
- }
- }
+ // replace trigger
+ trigger.body = function () { const x = 20; };
+ const { result: replacedTrigger } = await container.triggers.get(trigger.id).replace(trigger);
- // read trigger
- const { result: triggerAfterReplace } = await client.readTrigger(
- TestHelpers.getTriggerLink(isNameBased, db, collection, replacedTrigger));
- assert.equal(replacedTrigger.id, triggerAfterReplace.id);
+ assert.equal(replacedTrigger.id, trigger.id);
+ assert.equal(replacedTrigger.body, "function () { const x = 20; }");
- // delete trigger
- const { result: res } = await client.deleteTrigger(
- TestHelpers.getTriggerLink(isNameBased, db, collection, replacedTrigger));
+ // read trigger
+ const { result: triggerAfterReplace } = await container.triggers.get(replacedTrigger.id).read();
+ assert.equal(replacedTrigger.id, triggerAfterReplace.id);
- // read triggers after deletion
- try {
- const { result: badtrigger } = await client.readTrigger(
- TestHelpers.getTriggerLink(isNameBased, db, collection, replacedTrigger));
- assert.fail("Must fail to read after deletion");
- } catch (err) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- }
- } catch (err) {
- throw err;
- }
- };
+ // delete trigger
+ await await container.triggers.get(replacedTrigger.id).delete();
- it("nativeApi Should do trigger CRUD operations successfully name based", async function () {
+ // read triggers after deletion
try {
- await triggerCRUDTest(true, false);
+ await container.triggers.get(replacedTrigger.id).read();
+ assert.fail("Must fail to read after deletion");
} catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do trigger CRUD operations successfully rid based", async function () {
- try {
- await triggerCRUDTest(false, false);
- } catch (err) {
- throw err;
+ assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
}
});
it("nativeApi Should do trigger CRUD operations successfully name based with upsert", async function () {
- try {
- await triggerCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
+ // read triggers
+ const { result: triggers } = await container.triggers.readAll().toArray();
+ assert.equal(Array.isArray(triggers), true);
- it("nativeApi Should do trigger CRUD operations successfully rid based with upsert", async function () {
+ // create a trigger
+ const beforeCreateTriggersCount = triggers.length;
+ // tslint:disable:no-var-keyword
+ // tslint:disable:prefer-const
+ const triggerDefinition: TriggerDefinition = {
+ id: "sample trigger",
+ body: "serverScript() { var x = 10; }",
+ triggerType: DocumentBase.TriggerType.Pre,
+ triggerOperation: DocumentBase.TriggerOperation.All,
+ };
+ // tslint:enable:no-var-keyword
+ // tslint:enable:prefer-const
+
+ const { result: trigger } = await container.triggers.upsert(triggerDefinition);
+
+ assert.equal(trigger.id, triggerDefinition.id);
+ assert.equal(trigger.body, "serverScript() { var x = 10; }");
+
+ // read triggers after creation
+ const { result: triggersAfterCreation } = await container.triggers.readAll().toArray();
+ assert.equal(triggersAfterCreation.length, beforeCreateTriggersCount + 1,
+ "create should increase the number of triggers");
+
+ // query triggers
+ const querySpec = {
+ query: "SELECT * FROM root r WHERE r.id=@id",
+ parameters: [
+ {
+ name: "@id",
+ value: triggerDefinition.id,
+ },
+ ],
+ };
+ const { result: results } = await container.triggers.query(querySpec).toArray();
+ assert(results.length > 0, "number of results for the query should be > 0");
+
+ // replace trigger
+ trigger.body = function () { const x = 20; };
+ const { result: replacedTrigger } = await container.triggers.upsert(trigger);
+
+ assert.equal(replacedTrigger.id, trigger.id);
+ assert.equal(replacedTrigger.body, "function () { const x = 20; }");
+
+ // read trigger
+ const { result: triggerAfterReplace } = await container.triggers.get(replacedTrigger.id).read();
+ assert.equal(replacedTrigger.id, triggerAfterReplace.id);
+
+ // delete trigger
+ await await container.triggers.get(replacedTrigger.id).delete();
+
+ // read triggers after deletion
try {
- await triggerCRUDTest(false, true);
+ await container.triggers.get(replacedTrigger.id).read();
+ assert.fail("Must fail to read after deletion");
} catch (err) {
- throw err;
+ assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
}
});
});
describe("validate trigger functionality", function () {
- const triggers: any = [
+ const triggers: TriggerDefinition[] = [
{
id: "t1",
// tslint:disable:no-var-keyword
@@ -216,91 +233,49 @@ describe("NodeJS CRUD Tests", function () {
// tslint:enable:no-string-throw
// tslint:enable:object-literal-shorthand
- const createTriggers = async function (client: CosmosClient, collection: any, isUpsertTest: boolean) {
- try {
- for (const trigger of triggers) {
- const { result: createdTrigger } = await TestHelpers.createOrUpsertTrigger(collection._self, trigger, undefined, client, isUpsertTest);
- for (const property in trigger) {
- if (trigger.hasOwnProperty(property)) {
- assert.equal(createdTrigger[property], trigger[property], "property " + property + " should match");
- }
- }
- }
- } catch (err) {
- throw err;
+ it("should do trigger operations successfully with create", async function () {
+ for (const trigger of triggers) {
+ await container.triggers.create(trigger);
}
- };
-
- const triggerCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+ // create document
+ const { result: document } = await container.items.create({ id: "doc1", key: "value" }, { preTriggerInclude: "t1" });
+ assert.equal(document.id, "DOC1t1", "name should be capitalized");
+ const { result: document2 } = await container.items.create({ id: "doc2", key2: "value2" }, { preTriggerInclude: "t2" });
+ assert.equal(document2.id, "doc2", "name shouldn't change");
+ const { result: document3 } = await container.items.create({ id: "Doc3", prop: "empty" }, { preTriggerInclude: "t3" });
+ assert.equal(document3.id, "doc3t3");
+ const { result: document4 } = await container.items.create({ id: "testing post trigger" }, { postTriggerInclude: "response1", preTriggerInclude: "t1" });
+ assert.equal(document4.id, "TESTING POST TRIGGERt1");
+ const { result: document5, headers } = await container.items.create({ id: "responseheaders" }, { preTriggerInclude: "t1" });
+ assert.equal(document5.id, "RESPONSEHEADERSt1");
try {
- const client = new CosmosClient(host, { masterKey });
-
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
- // create triggers
- await createTriggers(client, collection, isUpsertTest);
- // create document
- const { result: createdTriggers } = await client.readTriggers(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- const { result: document } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "doc1", key: "value" }, { preTriggerInclude: "t1" }, client, isUpsertTest);
- assert.equal(document.id, "DOC1t1", "name should be capitalized");
- const { result: document2 } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "doc2", key2: "value2" }, { preTriggerInclude: "t2" }, client, isUpsertTest);
- assert.equal(document2.id, "doc2", "name shouldn't change");
- const { result: document3 } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "Doc3", prop: "empty" }, { preTriggerInclude: "t3" }, client, isUpsertTest);
- assert.equal(document3.id, "doc3t3");
- const { result: document4 } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "testing post trigger" }, { postTriggerInclude: "response1", preTriggerInclude: "t1" }, client, isUpsertTest);
- assert.equal(document4.id, "TESTING POST TRIGGERt1");
- const { result: document5, headers } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "responseheaders" }, { preTriggerInclude: "t1" }, client, isUpsertTest);
- assert.equal(document5.id, "RESPONSEHEADERSt1");
- try {
- const { result: document6 } = await TestHelpers.createOrUpsertDocument(
- TestHelpers.getCollectionLink(isNameBased, db, collection), { id: "Docoptype" }, { postTriggerInclude: "triggerOpType" }, client, isUpsertTest);
- assert.fail("Must fail");
- } catch (err) {
- assert.equal(err.code, 400, "Must throw when using a DELETE trigger on a CREATE operation");
- }
+ await container.items.create({ id: "Docoptype" }, { postTriggerInclude: "triggerOpType" });
+ assert.fail("Must fail");
} catch (err) {
- throw err;
- }
- };
-
- it("nativeApi Should do trigger operations successfully name based", async function () {
- try {
- await triggerCRUDTest(true, false);
- } catch (err) {
- throw err;
+ assert.equal(err.code, 400, "Must throw when using a DELETE trigger on a CREATE operation");
}
});
- it("nativeApi Should do trigger operations successfully rid based", async function () {
- try {
- await triggerCRUDTest(false, false);
- } catch (err) {
- throw err;
+ it("should do trigger operations successfully with upsert", async function () {
+ for (const trigger of triggers) {
+ await container.triggers.upsert(trigger);
}
- });
-
- it("nativeApi Should do trigger operations successfully name based", async function () {
+ // create document
+ const { result: document } = await container.items.upsert({ id: "doc1", key: "value" }, { preTriggerInclude: "t1" });
+ assert.equal(document.id, "DOC1t1", "name should be capitalized");
+ const { result: document2 } = await container.items.upsert({ id: "doc2", key2: "value2" }, { preTriggerInclude: "t2" });
+ assert.equal(document2.id, "doc2", "name shouldn't change");
+ const { result: document3 } = await container.items.upsert({ id: "Doc3", prop: "empty" }, { preTriggerInclude: "t3" });
+ assert.equal(document3.id, "doc3t3");
+ const { result: document4 } = await container.items.upsert({ id: "testing post trigger" }, { postTriggerInclude: "response1", preTriggerInclude: "t1" });
+ assert.equal(document4.id, "TESTING POST TRIGGERt1");
+ const { result: document5, headers } = await container.items.upsert({ id: "responseheaders" }, { preTriggerInclude: "t1" });
+ assert.equal(document5.id, "RESPONSEHEADERSt1");
try {
- await triggerCRUDTest(true, true);
+ await container.items.upsert({ id: "Docoptype" }, { postTriggerInclude: "triggerOpType" });
+ assert.fail("Must fail");
} catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do trigger operations successfully rid based", async function () {
- try {
- await triggerCRUDTest(false, true);
- } catch (err) {
- throw err;
+ assert.equal(err.code, 400, "Must throw when using a DELETE trigger on a CREATE operation");
}
});
});
diff --git a/src/test/functional/ttl.spec.ts b/src/test/functional/ttl.spec.ts
index e346083..028db74 100644
--- a/src/test/functional/ttl.spec.ts
+++ b/src/test/functional/ttl.spec.ts
@@ -1,61 +1,54 @@
import * as assert from "assert";
import * as Stream from "stream";
import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
+ CosmosClient,
} from "../../";
+import { Container, ContainerDefinition, Database } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
// TODO: should fix long lines
// tslint:disable:max-line-length
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({
+ endpoint,
+ auth: { masterKey },
+});
+
+async function sleep(time: number) {
+ return new Promise((resolve) => {
+ setTimeout(resolve, time);
+ });
+}
describe("NodeJS CRUD Tests", function () {
- this.timeout(process.env.MOCHA_TIMEOUT || 10000);
+ this.timeout(process.env.MOCHA_TIMEOUT || 600000);
// remove all databases from the endpoint before each test
beforeEach(async function () {
- this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(client);
});
describe("TTL tests", function () {
- this.timeout(60000);
- async function sleep(time: number) {
- return new Promise((resolve, reject) => {
- setTimeout(resolve, time);
- });
- }
-
- async function createCollectionWithInvalidDefaultTtl(client: CosmosClient, db: any, collectionDefinition: any, collId: any, defaultTtl: number) {
- collectionDefinition.id = collId;
- collectionDefinition.defaultTtl = defaultTtl;
+ async function createcontainerWithInvalidDefaultTtl(db: Database, containerDefinition: ContainerDefinition, collId: any, defaultTtl: number) {
+ containerDefinition.id = collId;
+ containerDefinition.defaultTtl = defaultTtl;
try {
- await client.createCollection(db._self, collectionDefinition);
+ await db.containers.create(containerDefinition);
} catch (err) {
const badRequestErrorCode = 400;
assert.equal(err.code, badRequestErrorCode, "response should return error code " + badRequestErrorCode);
}
}
- async function createDocumentWithInvalidTtl(client: CosmosClient, collection: any, documentDefinition: any, docId: any, ttl: number) {
- documentDefinition.id = docId;
- documentDefinition.ttl = ttl;
+ async function createItemWithInvalidTtl(container: Container, itemDefinition: any, itemId: any, ttl: number) {
+ itemDefinition.id = itemId;
+ itemDefinition.ttl = ttl;
try {
- await client.createDocument(collection._self, documentDefinition);
+ await container.items.create(itemDefinition);
assert.fail("Must throw if using invalid TTL");
} catch (err) {
const badRequestErrorCode = 400;
@@ -63,312 +56,258 @@ describe("NodeJS CRUD Tests", function () {
}
}
- it("nativeApi Validate Collection and Document TTL values.", async function () {
+ it("nativeApi Validate container and Item TTL values.", async function () {
try {
- const client = new CosmosClient(host, { masterKey });
+ const { result: db } = await client.databases.create({ id: "ttl test1 database" });
- const { result: db } = await client.createDatabase({ id: "sample database" });
-
- const collectionDefinition = {
- id: "sample collection1",
+ const containerDefinition = {
+ id: "sample container1",
defaultTtl: 5,
};
-
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
- assert.equal(collectionDefinition.defaultTtl, collection.defaultTtl);
+ const database = await client.databases.get(db.id);
+ const { result: containerResult } = await database.containers.create(containerDefinition);
+ assert.equal(containerDefinition.defaultTtl, containerResult.defaultTtl);
+ const container = database.containers.get(containerResult.id);
// null, 0, -10 are unsupported value for defaultTtl.Valid values are -1 or a non-zero positive 32-bit integer value
- await createCollectionWithInvalidDefaultTtl(client, db, collectionDefinition, "sample collection2", null);
- await createCollectionWithInvalidDefaultTtl(client, db, collectionDefinition, "sample collection3", 0);
- await createCollectionWithInvalidDefaultTtl(client, db, collectionDefinition, "sample collection4", -10);
+ await createcontainerWithInvalidDefaultTtl(database, containerDefinition, "sample container2", null);
+ await createcontainerWithInvalidDefaultTtl(database, containerDefinition, "sample container3", 0);
+ await createcontainerWithInvalidDefaultTtl(database, containerDefinition, "sample container4", -10);
- const documentDefinition = {
+ const itemDefinition = {
id: "doc",
- name: "sample document",
+ name: "sample Item",
key: "value",
ttl: 2,
};
// 0, null, -10 are unsupported value for ttl.Valid values are -1 or a non-zero positive 32-bit integer value
- await createDocumentWithInvalidTtl(client, collection, documentDefinition, "doc1", 0);
- await createDocumentWithInvalidTtl(client, collection, documentDefinition, "doc2", null);
- await createDocumentWithInvalidTtl(client, collection, documentDefinition, "doc3", -10);
+ await createItemWithInvalidTtl(container, itemDefinition, "doc1", 0);
+ await createItemWithInvalidTtl(container, itemDefinition, "doc2", null);
+ await createItemWithInvalidTtl(container, itemDefinition, "doc3", -10);
} catch (err) {
throw err;
}
});
- async function checkDocumentGone(client: CosmosClient, collection: any, createdDocument: any) {
+ async function checkItemGone(container: Container, createdItem: any) {
try {
- await client.readDocument(createdDocument._self);
- assert.fail("Must throw if the document isn't there");
+ await container.items.get(createdItem.id).read();
+ assert.fail("Must throw if the Item isn't there");
} catch (err) {
const badRequestErrorCode = 404;
assert.equal(err.code, badRequestErrorCode, "response should return error code " + badRequestErrorCode);
}
}
- async function checkDocumentExists(client: CosmosClient, collection: any, createdDocument: any) {
- try {
- const { result: readDocument } = await client.readDocument(createdDocument._self);
- assert.equal(readDocument.ttl, createdDocument.ttl);
- } catch (err) {
- throw err;
- }
+ async function checkItemExists(container: Container, createdItem: any) {
+ const { result: readItem } = await container.items.get(createdItem.id).read();
+ assert.equal(readItem.ttl, createdItem.ttl);
}
- async function positiveDefaultTtlStep4(client: CosmosClient, collection: any, createdDocument: any) {
- // the created document should NOT be gone as it 's ttl value is set to 8 which overrides the collections' s defaultTtl value(5)
- try {
- await checkDocumentExists(client, collection, createdDocument);
- await sleep(4000);
- await checkDocumentGone(client, collection, createdDocument);
- } catch (err) {
- throw err;
- }
+ async function positiveDefaultTtlStep4(container: Container, createdItem: any) {
+ // the created Item should NOT be gone as it 's ttl value is set to 8 which overrides the containers' s defaultTtl value(5)
+ await checkItemExists(container, createdItem);
+ await sleep(4000);
+ await checkItemGone(container, createdItem);
}
- async function positiveDefaultTtlStep3(client: CosmosClient, collection: any, createdDocument: any, documentDefinition: any) {
- // the created document should be gone now as it 's ttl value is set to 2 which overrides the collections' s defaultTtl value(5)
- try {
- await checkDocumentGone(client, collection, createdDocument);
- documentDefinition.id = "doc4";
- documentDefinition.ttl = 8;
+ async function positiveDefaultTtlStep3(container: Container, createdItem: any, itemDefinition: any) {
+ // the created Item should be gone now as it 's ttl value is set to 2 which overrides the containers' s defaultTtl value(5)
+ await checkItemGone(container, createdItem);
+ itemDefinition.id = "doc4";
+ itemDefinition.ttl = 8;
+
+ const { result: doc } = await container.items.create(itemDefinition);
+ await sleep(6000);
+ await positiveDefaultTtlStep4(container, doc);
- const { result: doc } = await client.createDocument(collection._self, documentDefinition);
- await sleep(6000);
- await positiveDefaultTtlStep4(client, collection, doc);
- } catch (err) {
- throw err;
- }
}
- async function positiveDefaultTtlStep2(client: CosmosClient, collection: any, createdDocument: any, documentDefinition: any) {
- // the created document should NOT be gone as it 's ttl value is set to -1(never expire) which overrides the collections' s defaultTtl value
- try {
- await checkDocumentExists(client, collection, createdDocument);
- documentDefinition.id = "doc3";
- documentDefinition.ttl = 2;
+ async function positiveDefaultTtlStep2(container: Container, createdItem: any, itemDefinition: any) {
+ // the created Item should NOT be gone as it 's ttl value is set to -1(never expire) which overrides the containers' s defaultTtl value
+ await checkItemExists(container, createdItem);
+ itemDefinition.id = "doc3";
+ itemDefinition.ttl = 2;
- const { result: doc } = await client.createDocument(collection._self, documentDefinition);
- await sleep(4000);
- await positiveDefaultTtlStep3(client, collection, doc, documentDefinition);
- } catch (err) {
- throw err;
- }
+ const { result: doc } = await container.items.create(itemDefinition);
+ await sleep(4000);
+ await positiveDefaultTtlStep3(container, doc, itemDefinition);
}
- async function positiveDefaultTtlStep1(client: CosmosClient, collection: any, createdDocument: any, documentDefinition: any) {
- try {
- // the created document should be gone now as it 's ttl value would be same as defaultTtl value of the collection
- await checkDocumentGone(client, collection, createdDocument);
- documentDefinition.id = "doc2";
- documentDefinition.ttl = -1;
+ async function positiveDefaultTtlStep1(container: Container, createdItem: any, itemDefinition: any) {
+ // the created Item should be gone now as it 's ttl value would be same as defaultTtl value of the container
+ await checkItemGone(container, createdItem);
+ itemDefinition.id = "doc2";
+ itemDefinition.ttl = -1;
+
+ const { result: doc } = await container.items.create(itemDefinition);
+ await sleep(5000);
+ await positiveDefaultTtlStep2(container, doc, itemDefinition);
- const { result: doc } = await client.createDocument(collection._self, documentDefinition);
- await sleep(5000);
- await positiveDefaultTtlStep2(client, collection, doc, documentDefinition);
- } catch (err) {
- throw err;
- }
}
- it("nativeApi Validate Document TTL with positive defaultTtl.", async function () {
- try {
- const client = new CosmosClient(host, { masterKey });
+ it("nativeApi Validate Item TTL with positive defaultTtl.", async function () {
+ const { result: db } = await client.databases.create({ id: "ttl test2 database" });
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ const containerDefinition = {
+ id: "sample container",
+ defaultTtl: 5,
+ };
- const collectionDefinition = {
- id: "sample collection",
- defaultTtl: 5,
- };
+ const { result: containerResult } = await client.databases.get(db.id).containers.create(containerDefinition);
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ const container = await client.databases.get(db.id).containers.get(containerResult.id);
- const documentDefinition = {
- id: "doc1",
- name: "sample document",
- key: "value",
- };
+ const itemDefinition = {
+ id: "doc1",
+ name: "sample Item",
+ key: "value",
+ };
- const { result: createdDocument } = await client.createDocument(collection._self, documentDefinition);
- await sleep(7000);
- await positiveDefaultTtlStep1(client, collection, createdDocument, documentDefinition);
- } catch (err) {
- throw err;
- }
+ const { result: createdItem } = await container.items.create(itemDefinition);
+ await sleep(7000);
+ await positiveDefaultTtlStep1(container, createdItem, itemDefinition);
});
- async function minusOneDefaultTtlStep1(client: CosmosClient, collection: any, createdDocument1: any, createdDocument2: any, createdDocument3: any) {
- try {
- // the created document should be gone now as it 's ttl value is set to 2 which overrides the collections' s defaultTtl value(-1)
- await checkDocumentGone(client, collection, createdDocument3);
+ async function minusOneDefaultTtlStep1(container: Container, createdItem1: any, createdItem2: any, createdItem3: any) {
+ // the created Item should be gone now as it 's ttl value is set to 2 which overrides the containers' s defaultTtl value(-1)
+ await checkItemGone(container, createdItem3);
- // The documents with id doc1 and doc2 will never expire
- const { result: readDocument1 } = await client.readDocument(createdDocument1._self);
- assert.equal(readDocument1.id, createdDocument1.id);
+ // The Items with id doc1 and doc2 will never expire
+ const { result: readItem1 } = await container.items.get(createdItem1.id).read();
+ assert.equal(readItem1.id, createdItem1.id);
- const { result: readDocument2 } = await client.readDocument(createdDocument2._self);
- assert.equal(readDocument2.id, createdDocument2.id);
- } catch (err) {
- throw err;
- }
+ const { result: readItem2 } = await container.items.get(createdItem2.id).read();
+ assert.equal(readItem2.id, createdItem2.id);
}
- it("nativeApi Validate Document TTL with -1 defaultTtl.", async function () {
- try {
- const client = new CosmosClient(host, { masterKey });
+ it("nativeApi Validate Item TTL with -1 defaultTtl.", async function () {
+ const { result: db } = await client.databases.create({ id: "ttl test2 database" });
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ const containerDefinition = {
+ id: "sample container",
+ defaultTtl: -1,
+ };
- const collectionDefinition = {
- id: "sample collection",
- defaultTtl: -1,
- };
+ const { result: createdContainer } = await client.databases.get(db.id).containers.create(containerDefinition);
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ const container = await client.databases.get(db.id).containers.get(createdContainer.id);
- const documentDefinition: any = {
- id: "doc1",
- name: "sample document",
- key: "value",
- };
+ const itemDefinition: any = {
+ id: "doc1",
+ name: "sample Item",
+ key: "value",
+ };
- // the created document 's ttl value would be -1 inherited from the collection' s defaultTtl and this document will never expire
- const { result: createdDocument1 } = await client.createDocument(collection._self, documentDefinition);
+ // the created Item 's ttl value would be -1 inherited from the container' s defaultTtl and this Item will never expire
+ const { result: createdItem1 } = await container.items.create(itemDefinition);
- // This document is also set to never expire explicitly
- documentDefinition.id = "doc2";
- documentDefinition.ttl = -1;
+ // This Item is also set to never expire explicitly
+ itemDefinition.id = "doc2";
+ itemDefinition.ttl = -1;
- const { result: createdDocument2 } = await client.createDocument(collection._self, documentDefinition);
+ const { result: createdItem2 } = await container.items.create(itemDefinition);
- documentDefinition.id = "doc3";
- documentDefinition.ttl = 2;
+ itemDefinition.id = "doc3";
+ itemDefinition.ttl = 2;
- const { result: createdDocument3 } = await client.createDocument(collection._self, documentDefinition);
- await sleep(4000);
- await minusOneDefaultTtlStep1(client, collection, createdDocument1, createdDocument2, createdDocument3);
- } catch (err) {
- throw err;
- }
+ const { result: createdItem3 } = await container.items.create(itemDefinition);
+ await sleep(4000);
+ await minusOneDefaultTtlStep1(container, createdItem1, createdItem2, createdItem3);
});
- it("nativeApi Validate Document TTL with no defaultTtl.", async function () {
- try {
- const client = new CosmosClient(host, { masterKey });
+ it("nativeApi Validate Item TTL with no defaultTtl.", async function () {
+ const { result: db } = await client.databases.create({ id: "ttl test3 database" });
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ const containerDefinition = { id: "sample container" };
- const collectionDefinition = { id: "sample collection" };
+ const { result: createdContainer } = await client.databases.get(db.id).containers.create(containerDefinition);
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ const container = await client.databases.get(db.id).containers.get(createdContainer.id);
- const documentDefinition = {
- id: "doc1",
- name: "sample document",
- key: "value",
- ttl: 5,
- };
+ const itemDefinition = {
+ id: "doc1",
+ name: "sample Item",
+ key: "value",
+ ttl: 5,
+ };
- const { result: createdDocument } = await client.createDocument(collection._self, documentDefinition);
+ const { result: createdItem } = await container.items.create(itemDefinition);
- // Created document still exists even after ttl time has passed since the TTL is disabled at collection level(no defaultTtl property defined)
- await sleep(7000);
- await checkDocumentExists(client, collection, createdDocument);
- } catch (err) {
- throw err;
- }
+ // Created Item still exists even after ttl time has passed since the TTL is disabled at container level(no defaultTtl property defined)
+ await sleep(7000);
+ await checkItemExists(container, createdItem);
});
- async function miscCasesStep4(client: CosmosClient, collection: any, createdDocument: any, documentDefinition: any) {
- // Created document still exists even after ttl time has passed since the TTL is disabled at collection level
- try {
- await checkDocumentExists(client, collection, createdDocument);
- } catch (err) {
- throw err;
- }
+ async function miscCasesStep4(container: Container, createdItem: any, itemDefinition: any) {
+ // Created Item still exists even after ttl time has passed since the TTL is disabled at container level
+ await checkItemExists(container, createdItem);
+
}
- async function miscCasesStep3(client: CosmosClient, collection: any, upsertedDocument: any, documentDefinition: any) {
- // the upserted document should be gone now after 10 secs from the last write(upsert) of the document
- try {
- await checkDocumentGone(client, collection, upsertedDocument);
- const query = "SELECT * FROM root r";
- const { result: results } = await client.queryDocuments(collection._self, query).toArray();
- assert.equal(results.length, 0);
+ async function miscCasesStep3(container: Container, upsertedItem: any, itemDefinition: any) {
+ // the upserted Item should be gone now after 10 secs from the last write(upsert) of the Item
+ await checkItemGone(container, upsertedItem);
+ const query = "SELECT * FROM root r";
+ const { result: results } = await container.items.query(query).toArray();
+ assert.equal(results.length, 0);
- // Use a collection definition without defaultTtl to disable ttl at collection level
- const collectionDefinition = { id: collection.id };
+ // Use a container definition without defaultTtl to disable ttl at container level
+ const containerDefinition = { id: container.id };
- const { result: replacedCollection } = await client.replaceCollection(collection._self, collectionDefinition);
+ await container.replace(containerDefinition);
- documentDefinition.id = "doc2";
+ itemDefinition.id = "doc2";
- const { result: createdDocument } = await client.createDocument(replacedCollection._self, documentDefinition);
- await sleep(5000);
- await miscCasesStep4(client, replacedCollection, createdDocument, documentDefinition);
- } catch (err) {
- throw err;
- }
+ const { result: createdItem } = await container.items.create(itemDefinition);
+ await sleep(5000);
+ await miscCasesStep4(container, createdItem, itemDefinition);
}
- async function miscCasesStep2(client: CosmosClient, collection: any, documentDefinition: any) {
- // Upsert the document after 3 secs to reset the document 's ttl
- try {
- documentDefinition.key = "value2";
- const { result: upsertedDocument } = await client.upsertDocument(collection._self, documentDefinition);
- await sleep(7000);
- // Upserted document still exists after (3+7)10 secs from document creation time( with collection 's defaultTtl set to 8) since it' s ttl was reset after 3 secs by upserting it
- await checkDocumentExists(client, collection, upsertedDocument);
- await sleep(3000);
- await miscCasesStep3(client, collection, upsertedDocument, documentDefinition);
- } catch (err) {
- throw err;
- }
+ async function miscCasesStep2(container: Container, itemDefinition: any) {
+ // Upsert the Item after 3 secs to reset the Item 's ttl
+ itemDefinition.key = "value2";
+ const { result: upsertedItem } = await container.items.upsert(itemDefinition);
+ await sleep(7000);
+ // Upserted Item still exists after (3+7)10 secs from Item creation time( with container 's defaultTtl set to 8) since it' s ttl was reset after 3 secs by upserting it
+ await checkItemExists(container, upsertedItem);
+ await sleep(3000);
+ await miscCasesStep3(container, upsertedItem, itemDefinition);
}
- async function miscCasesStep1(client: CosmosClient, collection: any, createdDocument: any, documentDefinition: any) {
- try {
- // the created document should be gone now as the ttl time expired
- await checkDocumentGone(client, collection, createdDocument);
- // We can create a document with the same id after the ttl time has expired
- const { result: doc } = await client.createDocument(collection._self, documentDefinition);
- assert.equal(documentDefinition.id, doc.id);
- await sleep(3000);
- miscCasesStep2(client, collection, documentDefinition);
- } catch (err) {
- throw err;
- }
+ async function miscCasesStep1(container: Container, createdItem: any, itemDefinition: any) {
+ // the created Item should be gone now as the ttl time expired
+ await checkItemGone(container, createdItem);
+ // We can create a Item with the same id after the ttl time has expired
+ const { result: doc } = await container.items.create(itemDefinition);
+ assert.equal(itemDefinition.id, doc.id);
+ await sleep(3000);
+ await miscCasesStep2(container, itemDefinition);
}
- it("nativeApi Validate Document TTL Misc cases.", async function () {
- try {
- const client = new CosmosClient(host, { masterKey });
+ it("nativeApi Validate Item TTL Misc cases.", async function () {
+ const { result: db } = await client.databases.create({ id: "ttl test4 database" });
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ const containerDefinition = {
+ id: "sample container",
+ defaultTtl: 8,
+ };
- const collectionDefinition = {
- id: "sample collection",
- defaultTtl: 8,
- };
+ const { result: containerResult } = await client.databases.get(db.id).containers.create(containerDefinition);
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ const container = await client.databases.get(db.id).containers.get(containerResult.id);
- const documentDefinition = {
- id: "doc1",
- name: "sample document",
- key: "value",
- };
+ const itemDefinition = {
+ id: "doc1",
+ name: "sample Item",
+ key: "value",
+ };
- const { result: createdDocument } = await client.createDocument(collection._self, documentDefinition);
+ const { result: createdItem } = await container.items.create(itemDefinition);
- await sleep(10000);
- await miscCasesStep1(client, collection, createdDocument, documentDefinition);
- } catch (err) {
- throw err;
- }
+ await sleep(10000);
+ await miscCasesStep1(container, createdItem, itemDefinition);
});
});
});
diff --git a/src/test/functional/udf.spec.ts b/src/test/functional/udf.spec.ts
index a815c91..80d4318 100644
--- a/src/test/functional/udf.spec.ts
+++ b/src/test/functional/udf.spec.ts
@@ -1,153 +1,230 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { Container, CosmosClient } from "../../";
+import { UserDefinedFunctionDefinition } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const dbId = "udf test database";
+const containerId = "sample container";
-describe("NodeJS CRUD Tests", function () {
+describe("NodeJS CRUD Tests", function() {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
- // remove all databases from the endpoint before each test
- beforeEach(async function () {
+
+ beforeEach(async function() {
this.timeout(10000);
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ // remove all databases from the endpoint before each test
+ const client = new CosmosClient({
+ endpoint,
+ auth: { masterKey },
+ });
+ await TestHelpers.removeAllDatabases(client);
});
- describe("Validate UDF CRUD", function () {
- const udfCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+
+ describe("User Defined Function", function() {
+ let container: Container;
+
+ beforeEach(async function() {
+ const client = new CosmosClient({
+ endpoint,
+ auth: { masterKey },
+ });
+
+ // create database
+ await client.databases.create({
+ id: dbId,
+ });
+
+ // create container
+ await client.databases
+ .get(dbId)
+ .containers.create({ id: containerId });
+
+ container = await client.databases
+ .get(dbId)
+ .containers.get(containerId);
+ });
+ it("nativeApi Should do UDF CRUD operations successfully", async function() {
+ const {
+ result: udfs,
+ } = await container.userDefinedFunctions.readAll().toArray();
+
+ // create a udf
+ const beforeCreateUdfsCount = udfs.length;
+ const udfDefinition: UserDefinedFunctionDefinition = {
+ id: "sample udf",
+ body: "function () { const x = 10; }",
+ };
+
+ // TODO also handle upsert case
+ const { result: udf } = await container.userDefinedFunctions.create(
+ udfDefinition,
+ );
+
+ assert.equal(udf.id, udfDefinition.id);
+ assert.equal(udf.body, "function () { const x = 10; }");
+
+ // read udfs after creation
+ const {
+ result: udfsAfterCreate,
+ } = await container.userDefinedFunctions.readAll().toArray();
+ assert.equal(
+ udfsAfterCreate.length,
+ beforeCreateUdfsCount + 1,
+ "create should increase the number of udfs",
+ );
+
+ // query udfs
+ const querySpec = {
+ query: "SELECT * FROM root r WHERE r.id=@id",
+ parameters: [
+ {
+ name: "@id",
+ value: udfDefinition.id,
+ },
+ ],
+ };
+ const {
+ result: results,
+ } = await container.userDefinedFunctions.query(querySpec).toArray();
+ assert(
+ results.length > 0,
+ "number of results for the query should be > 0",
+ );
+
+ // replace udf
+ udfDefinition.body = "function () { const x = 10; }";
+ const {
+ result: replacedUdf,
+ } = await container.userDefinedFunctions
+ .get(udfDefinition.id)
+ .replace(udfDefinition);
+
+ assert.equal(replacedUdf.id, udfDefinition.id);
+ assert.equal(replacedUdf.body, "function () { const x = 10; }");
+
+ // read udf
+ const {
+ result: udfAfterReplace,
+ } = await container.userDefinedFunctions
+ .get(replacedUdf.id)
+ .read();
+
+ assert.equal(replacedUdf.id, udfAfterReplace.id);
+
+ // delete udf
+ const {
+ result: res,
+ } = await container.userDefinedFunctions
+ .get(replacedUdf.id)
+ .delete();
+
+ // read udfs after deletion
try {
- const client = new CosmosClient(host, { masterKey });
-
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
- // create collection
- const { result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "sample collection" });
-
- // read udfs
- const { result: udfs } = await client.readUserDefinedFunctions(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- assert.equal(udfs.constructor, Array, "Value should be an array");
-
- // create a udf
- const beforeCreateUdfsCount = udfs.length;
- const udfDefinition: any = {
- id: "sample udf",
- body() { const x = 10; },
- };
- const { result: udf } = await TestHelpers.createOrUpsertUserDefinedFunction(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- udfDefinition, undefined, client, isUpsertTest);
- for (const property in udfDefinition) {
- if (property !== "serverScript") {
- assert.equal(udf[property], udfDefinition[property], "property " + property + " should match");
- } else {
- assert.equal(udf.body, "function () { const x = 10; }");
- }
- }
-
- // read udfs after creation
- const { result: udfsAfterCreate } = await client.readUserDefinedFunctions(
- TestHelpers.getCollectionLink(isNameBased, db, collection)).toArray();
- assert.equal(udfsAfterCreate.length, beforeCreateUdfsCount + 1, "create should increase the number of udfs");
-
- // query udfs
- const querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: udfDefinition.id,
- },
- ],
- };
- const { result: results } = await client.queryUserDefinedFunctions(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySpec).toArray();
- assert(results.length > 0, "number of results for the query should be > 0");
-
- // replace udf
- udf.body = function () { const x = 20; };
- const { result: replacedUdf } = await TestHelpers.replaceOrUpsertUserDefinedFunction(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- TestHelpers.getUserDefinedFunctionLink(isNameBased, db, collection, udf),
- udf, undefined, client, isUpsertTest);
-
- for (const property in udfDefinition) {
- if (property !== "serverScript") {
- assert.equal(replacedUdf[property], udf[property], "property " + property + " should match");
- } else {
- assert.equal(replacedUdf.body, "function () { const x = 20; }");
- }
- }
-
- // read udf
- const { result: udfAfterReplace } = await client.readUserDefinedFunction(
- TestHelpers.getUserDefinedFunctionLink(isNameBased, db, collection, replacedUdf));
- assert.equal(replacedUdf.id, udfAfterReplace.id);
-
- // delete udf
- const { result: res } = await client.deleteUserDefinedFunction(
- TestHelpers.getUserDefinedFunctionLink(isNameBased, db, collection, replacedUdf));
-
- // read udfs after deletion
- try {
- const { result: badudf } = await client.readUserDefinedFunction(
- TestHelpers.getUserDefinedFunctionLink(isNameBased, db, collection, replacedUdf));
- assert.fail("Must fail to read after delete");
- } catch (err) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- }
+ const {
+ result: badudf,
+ } = await container.userDefinedFunctions
+ .get(replacedUdf.id)
+ .read();
+ assert.fail("Must fail to read after delete");
} catch (err) {
- throw err;
- }
- };
-
- it("nativeApi Should do UDF CRUD operations successfully name based", async function () {
- try {
- await udfCRUDTest(true, false);
- } catch (err) {
- throw err;
+ const notFoundErrorCode = 404;
+ assert.equal(
+ err.code,
+ notFoundErrorCode,
+ "response should return error code 404",
+ );
}
});
- it("nativeApi Should do UDF CRUD operations successfully rid based", async function () {
- try {
- await udfCRUDTest(false, false);
- } catch (err) {
- throw err;
- }
- });
+ it("nativeApi Should do UDF CRUD operations successfully", async function() {
+ const {
+ result: udfs,
+ } = await container.userDefinedFunctions.readAll().toArray();
- it("nativeApi Should do UDF CRUD operations successfully name based with upsert", async function () {
- try {
- await udfCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
+ // create a udf
+ const beforeCreateUdfsCount = udfs.length;
+ const udfDefinition = {
+ id: "sample udf",
+ body: "function () { const x = 10; }",
+ };
- it("nativeApi Should do UDF CRUD operations successfully rid based with upsert", async function () {
+ const { result: udf } = await container.userDefinedFunctions.upsert(
+ udfDefinition,
+ );
+
+ assert.equal(udf.id, udfDefinition.id);
+ assert.equal(udf.body, "function () { const x = 10; }");
+
+ // read udfs after creation
+ const {
+ result: udfsAfterCreate,
+ } = await container.userDefinedFunctions.readAll().toArray();
+ assert.equal(
+ udfsAfterCreate.length,
+ beforeCreateUdfsCount + 1,
+ "create should increase the number of udfs",
+ );
+
+ // query udfs
+ const querySpec = {
+ query: "SELECT * FROM root r WHERE r.id=@id",
+ parameters: [
+ {
+ name: "@id",
+ value: udfDefinition.id,
+ },
+ ],
+ };
+ const {
+ result: results,
+ } = await container.userDefinedFunctions.query(querySpec).toArray();
+ assert(
+ results.length > 0,
+ "number of results for the query should be > 0",
+ );
+
+ // replace udf
+ udfDefinition.body = "function () { const x = 10; }";
+ const {
+ result: replacedUdf,
+ } = await container.userDefinedFunctions.upsert(udfDefinition);
+
+ assert.equal(replacedUdf.id, udfDefinition.id);
+ assert.equal(replacedUdf.body, "function () { const x = 10; }");
+
+ // read udf
+ const {
+ result: udfAfterReplace,
+ } = await container.userDefinedFunctions
+ .get(replacedUdf.id)
+ .read();
+
+ assert.equal(replacedUdf.id, udfAfterReplace.id);
+
+ // delete udf
+ const {
+ result: res,
+ } = await container.userDefinedFunctions
+ .get(replacedUdf.id)
+ .delete();
+
+ // read udfs after deletion
try {
- await udfCRUDTest(false, true);
+ const {
+ result: badudf,
+ } = await container.userDefinedFunctions
+ .get(replacedUdf.id)
+ .read();
+ assert.fail("Must fail to read after delete");
} catch (err) {
- throw err;
+ const notFoundErrorCode = 404;
+ assert.equal(
+ err.code,
+ notFoundErrorCode,
+ "response should return error code 404",
+ );
}
});
});
diff --git a/src/test/functional/user.spec.ts b/src/test/functional/user.spec.ts
index 1cce026..22b68b8 100644
--- a/src/test/functional/user.spec.ts
+++ b/src/test/functional/user.spec.ts
@@ -1,22 +1,12 @@
import * as assert from "assert";
-import * as Stream from "stream";
-import {
- AzureDocuments, Base, Constants, CosmosClient,
- DocumentBase, HashPartitionResolver, Range,
- RangePartitionResolver, Response, RetryOptions,
-} from "../../";
+import { CosmosClient } from "../../";
+import { UserDefinition } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-// Used for sproc
-declare var getContext: any;
-// declare var body: (input?: any) => void; // TODO: remove this if it's not necessary
-
-// TODO: should fix long lines
-// tslint:disable:max-line-length
-
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("NodeJS CRUD Tests", function () {
this.timeout(process.env.MOCHA_TIMEOUT || 10000);
@@ -24,110 +14,81 @@ describe("NodeJS CRUD Tests", function () {
beforeEach(async function () {
this.timeout(10000);
try {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
} catch (err) {
throw err;
}
});
describe("Validate User CRUD", function () {
- const userCRUDTest = async function (isNameBased: boolean, isUpsertTest: boolean) {
+ const userCRUDTest = async function (isUpsertTest: boolean) {
+ // create database
+ const database = await TestHelpers.getTestDatabase(client, "Validate user CRUD");
+
+ // list users
+ const { result: users } = await database.users.readAll().toArray();
+ assert.equal(users.constructor, Array, "Value should be an array");
+ const beforeCreateCount = users.length;
+
+ // create user
+ const { result: userDef } = await TestHelpers.createOrUpsertUser(
+ database, { id: "new user" }, undefined, isUpsertTest);
+ assert.equal(userDef.id, "new user", "user name error");
+ let user = database.users.get(userDef.id);
+
+ // list users after creation
+ const { result: usersAfterCreation } = await database.users.readAll().toArray();
+ assert.equal(usersAfterCreation.length, beforeCreateCount + 1);
+
+ // query users
+ const querySpec = {
+ query: "SELECT * FROM root r WHERE r.id=@id",
+ parameters: [
+ {
+ name: "@id",
+ value: "new user",
+ },
+ ],
+ };
+ const { result: results } = await database.users.query(querySpec).toArray();
+ assert(results.length > 0, "number of results for the query should be > 0");
+
+ // replace user
+ userDef.id = "replaced user";
+ let replacedUser: UserDefinition;
+ if (isUpsertTest) {
+ const r = await database.users.upsert(userDef);
+ replacedUser = r.result;
+ } else {
+ const r = await user.replace(userDef);
+ replacedUser = r.result;
+ }
+ assert.equal(replacedUser.id, "replaced user", "user name should change");
+ assert.equal(userDef.id, replacedUser.id, "user id should stay the same");
+ user = database.users.get(replacedUser.id);
+
+ // read user
+ const { result: userAfterReplace } = await user.read();
+ assert.equal(replacedUser.id, userAfterReplace.id);
+
+ // delete user
+ const { result: res } = await user.delete();
+
+ // read user after deletion
try {
- const client = new CosmosClient(host, { masterKey });
-
- // create database
- const { result: db } = await client.createDatabase({ id: "sample database" });
-
- // list users
- const { result: users } = await client.readUsers(
- TestHelpers.getDatabaseLink(isNameBased, db)).toArray();
- assert.equal(users.constructor, Array, "Value should be an array");
- const beforeCreateCount = users.length;
-
- // create user
- const { result: user } = await TestHelpers.createOrUpsertUser(
- TestHelpers.getDatabaseLink(isNameBased, db), { id: "new user" },
- undefined, client, isUpsertTest);
- assert.equal(user.id, "new user", "user name error");
-
- // list users after creation
- const { result: usersAfterCreation } = await client.readUsers(
- TestHelpers.getDatabaseLink(isNameBased, db)).toArray();
- assert.equal(usersAfterCreation.length, beforeCreateCount + 1);
-
- // query users
- const querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: "new user",
- },
- ],
- };
- const { result: results } = await client.queryUsers(
- TestHelpers.getDatabaseLink(isNameBased, db), querySpec).toArray();
- assert(results.length > 0, "number of results for the query should be > 0");
-
- // replace user
- user.id = "replaced user";
- const { result: replacedUser } = await TestHelpers.replaceOrUpsertUser(
- TestHelpers.getDatabaseLink(isNameBased, db), user._self, user, undefined, client, isUpsertTest);
- assert.equal(replacedUser.id, "replaced user", "user name should change");
- assert.equal(user.id, replacedUser.id, "user id should stay the same");
-
- // read user
- const { result: userAfterReplace } = await client.readUser(
- TestHelpers.getUserLink(isNameBased, db, replacedUser));
- assert.equal(replacedUser.id, userAfterReplace.id);
-
- // delete user
- const { result: res } = await client.deleteUser(
- TestHelpers.getUserLink(isNameBased, db, user));
-
- // read user after deletion
- try {
- const { result: badUser } = await client.readUser(
- TestHelpers.getUserLink(isNameBased, db, user));
- assert.fail("Must fail to read user after deletion");
- } catch (err) {
- const notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- }
+ await user.read();
+ assert.fail("Must fail to read user after deletion");
} catch (err) {
- throw err;
+ const notFoundErrorCode = 404;
+ assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
}
};
it("nativeApi Should do User CRUD operations successfully name based", async function () {
- try {
- await userCRUDTest(true, false);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do User CRUD operations successfully rid based", async function () {
- try {
- await userCRUDTest(false, false);
- } catch (err) {
- throw err;
- }
+ await userCRUDTest(false);
});
it("nativeApi Should do User CRUD operations successfully name based with upsert", async function () {
- try {
- await userCRUDTest(true, true);
- } catch (err) {
- throw err;
- }
- });
-
- it("nativeApi Should do User CRUD operations successfully rid based with upsert", async function () {
- try {
- await userCRUDTest(false, true);
- } catch (err) {
- throw err;
- }
+ await userCRUDTest(true);
});
});
});
diff --git a/src/test/integration/aggregateQuery.spec.ts b/src/test/integration/aggregateQuery.spec.ts
index a4330c3..794d36e 100644
--- a/src/test/integration/aggregateQuery.spec.ts
+++ b/src/test/integration/aggregateQuery.spec.ts
@@ -1,42 +1,42 @@
import * as assert from "assert";
-import * as stream from "stream";
-import * as _ from "underscore";
import * as util from "util";
-import { Base, DocumentClient, QueryIterator, Range } from "../../";
+import { QueryIterator } from "../../";
+import { Container, ContainerDefinition, Database } from "../../client";
+import { CosmosClient } from "../../CosmosClient";
+import { DataType, IndexKind, PartitionKind } from "../../documents";
import { SqlQuerySpec } from "../../queryExecutionContext";
-import { ErrorResponse } from "../../request";
import testConfig from "./../common/_testConfig";
import { TestData } from "./../common/TestData";
import { TestHelpers } from "./../common/TestHelpers";
// process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe.skip("NodeJS Aggregate Query Tests", async function () {
const partitionKey = "key";
const uniquePartitionKey = "uniquePartitionKey";
const testdata = new TestData(partitionKey, uniquePartitionKey);
- const client = new DocumentClient(host, { masterKey });
const documentDefinitions = testdata.docs;
- let db: any;
- let collection: any;
+ let db: Database;
+ let container: Container;
- const collectionDefinition = {
- id: "sample collection",
+ const containerDefinition: ContainerDefinition = {
+ id: "sample container",
indexingPolicy: {
includedPaths: [
{
path: "/",
indexes: [
{
- kind: "Range",
- dataType: "Number",
+ kind: IndexKind.Hash,
+ dataType: DataType.Number,
},
{
- kind: "Range",
- dataType: "String",
+ kind: IndexKind.Range,
+ dataType: DataType.Number,
},
],
},
@@ -46,31 +46,31 @@ describe.skip("NodeJS Aggregate Query Tests", async function () {
paths: [
"/" + partitionKey,
],
- kind: "Hash",
+ kind: PartitionKind.Hash,
},
};
- const collectionOptions = { offerThroughput: 10100 };
+ const containerOptions = { offerThroughput: 10100 };
describe("Validate Aggregate Document Query", function () {
// - removes all the databases,
// - creates a new database,
// - creates a new collecton,
- // - bulk inserts documents to the collection
+ // - bulk inserts documents to the container
before(async function () {
- await TestHelpers.removeAllDatabases(host, masterKey);
- ({ result: db } = await client.createDatabase({ id: Base.generateGuidId() }));
- ({ result: collection } = await client.createCollection(
- TestHelpers.getDatabaseLink(true, db), collectionDefinition, collectionOptions));
- await TestHelpers.bulkInsertDocuments(client, false, db, collection, documentDefinitions);
+ await TestHelpers.removeAllDatabases(client);
+ container = await TestHelpers.getTestContainer(
+ client, "Validate Aggregate Document Query", containerDefinition);
+ db = container.database;
+ await TestHelpers.bulkInsertItems(container, documentDefinitions);
});
const validateResult = function (actualValue: any, expectedValue: any) {
assert.deepEqual(actualValue, expectedValue, "actual value doesn't match with expected value.");
};
- const validateToArray = async function (queryIterator: QueryIterator, options: any, expectedResults: any) {
+ const validateToArray = async function (queryIterator: QueryIterator, expectedResults: any) {
try {
const { result: results } = await queryIterator.toArray();
assert.equal(results.length, expectedResults.length, "invalid number of results");
@@ -80,7 +80,7 @@ describe.skip("NodeJS Aggregate Query Tests", async function () {
}
};
- const validateNextItem = async function (queryIterator: QueryIterator, options: any, expectedResults: any) {
+ const validateNextItem = async function (queryIterator: QueryIterator, expectedResults: any) {
let results: any = [];
try {
@@ -103,7 +103,7 @@ describe.skip("NodeJS Aggregate Query Tests", async function () {
};
const validateNextItemAndCurrentAndHasMoreResults =
- async function (queryIterator: QueryIterator, options: any, expectedResults: any[]) {
+ async function (queryIterator: QueryIterator, expectedResults: any[]) {
// curent and nextItem recursively invoke each other till queryIterator is exhausted
////////////////////////////////
// validate nextItem()
@@ -132,7 +132,7 @@ describe.skip("NodeJS Aggregate Query Tests", async function () {
};
const validateExecuteNextAndHasMoreResults =
- async function (queryIterator: QueryIterator, options: any, expectedResults: any[]) {
+ async function (queryIterator: QueryIterator, options: any, expectedResults: any[]) {
////////////////////////////////
// validate executeNext()
////////////////////////////////
@@ -177,50 +177,39 @@ describe.skip("NodeJS Aggregate Query Tests", async function () {
}
};
- const validateForEach = async function (queryIterator: QueryIterator, options: any, expectedResults: any[]) {
+ const validateForEach = async function (queryIterator: QueryIterator, expectedResults: any[]) {
////////////////////////////////
// validate forEach()
////////////////////////////////
- return new Promise((resolve, reject) => {
- const results: any[] = [];
- let callbackSingnalledEnd = false;
- // forEach uses callbacks still, so just wrap in a promise
- queryIterator.forEach((err: ErrorResponse, item: any) => {
- try {
- assert.equal(err, undefined,
- "unexpected failure in fetching the results: " + err + JSON.stringify(err));
- // if the previous invocation returned false, forEach must avoid invoking the callback again!
- assert.equal(callbackSingnalledEnd, false,
- "forEach called callback after the first false returned");
- results.push(item);
- if (results.length === expectedResults.length) {
- callbackSingnalledEnd = true;
- validateResult(results, expectedResults);
- process.nextTick(resolve);
- return false;
- }
- return true;
- } catch (err) {
- reject(err);
- }
- });
- });
+ const results: any[] = [];
+ let callbackSingnalledEnd = false;
+ // forEach uses callbacks still, so just wrap in a promise
+ for await (const { result: item } of queryIterator.forEach()) {
+ // if the previous invocation returned false, forEach must avoid invoking the callback again!
+ assert.equal(callbackSingnalledEnd, false,
+ "forEach called callback after the first false returned");
+ results.push(item);
+ if (results.length === expectedResults.length) {
+ callbackSingnalledEnd = true;
+ }
+ }
+ validateResult(results, expectedResults);
};
const executeQueryAndValidateResults =
- async function (collectionLink: string, query: string | SqlQuerySpec, expectedResults: any[]) {
+ async function (query: string | SqlQuerySpec, expectedResults: any[]) {
const options = { enableCrossPartitionQuery: true };
- const queryIterator = client.queryDocuments(collectionLink, query, options);
- await validateToArray(queryIterator, options, expectedResults);
+ const queryIterator = container.items.query(query);
+ await validateToArray(queryIterator, expectedResults);
queryIterator.reset();
await validateExecuteNextAndHasMoreResults(queryIterator, options, expectedResults);
queryIterator.reset();
- await validateNextItemAndCurrentAndHasMoreResults(queryIterator, options, expectedResults);
- await validateForEach(queryIterator, options, expectedResults);
+ await validateNextItemAndCurrentAndHasMoreResults(queryIterator, expectedResults);
+ await validateForEach(queryIterator, expectedResults);
};
const generateTestConfigs = function () {
@@ -285,8 +274,7 @@ describe.skip("NodeJS Aggregate Query Tests", async function () {
it(test.testName, async function () {
try {
const expected = test.expected === undefined ? [] : [test.expected];
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(false, db, collection), test.query, expected);
+ await executeQueryAndValidateResults(test.query, expected);
} catch (err) {
throw err;
}
diff --git a/src/test/integration/authorization.spec.ts b/src/test/integration/authorization.spec.ts
index a335576..fa5eba0 100644
--- a/src/test/integration/authorization.spec.ts
+++ b/src/test/integration/authorization.spec.ts
@@ -1,126 +1,133 @@
import * as assert from "assert";
-import { Base, CosmosClient, DocumentBase, UriFactory } from "../../";
+import { Base, Container, CosmosClient, DocumentBase, UriFactory } from "../../";
+import { Database } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
describe("Authorization", function () {
- this.timeout(5000);
- const client = new CosmosClient(host, { masterKey });
+ this.timeout(process.env.MOCHA_TIMEOUT || 10000);
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
// TODO: should have types for all these things
- let database: any = { id: "dbs" };
- let collection: any = { id: "colls" };
+ let database: Database;
+ let container: Container;
- let userReadPermission: any = { id: "User With Read Permission" };
- let userAllPermission: any = { id: "User With All Permission" };
+ let userReadDefinition: any = { id: "User With Read Permission" };
+ let userAllDefinition: any = { id: "User With All Permission" };
let collReadPermission: any = {
- id: "collection Read Permission",
+ id: "container Read Permission",
permissionMode: DocumentBase.PermissionMode.Read,
};
let collAllPermission: any = {
- id: "collection All Permission",
+ id: "container All Permission",
permissionMode: DocumentBase.PermissionMode.All,
};
/************** TEST **************/
beforeEach(async function () {
- await TestHelpers.removeAllDatabases(host, masterKey);
- // create a database
- const { result: db } = await client.createDatabase(database);
- assert.equal(db.id, database.id, "database is not created properly");
- database = db;
+ await TestHelpers.removeAllDatabases(client);
+
+ // create a database & container
+ container = await TestHelpers.getTestContainer(client, "Authorization tests");
+ database = container.database;
// create userReadPermission
- const { result: user } = await client.createUser(database._self, userReadPermission);
- assert.equal(userReadPermission.id, user.id, "userReadPermission is not created properly");
- userReadPermission = user;
+ const { result: userDef } = await container.database.users.create(userReadDefinition);
+ assert.equal(userReadDefinition.id, userDef.id, "userReadPermission is not created properly");
+ userReadDefinition = userDef;
+ const userRead = container.database.users.get(userDef.id);
- // create collection
- const { result: coll } = await client.createCollection(database._self, collection);
- assert.equal(collection.id, coll.id, "coll1 is not created properly");
- collection = coll;
-
- // give permission to read collection, to userReadPermission
- collReadPermission.resource = collection._self;
- const { result: readPermission } = await client.createPermission(userReadPermission._self, collReadPermission);
+ // give permission to read container, to userReadPermission
+ collReadPermission.resource = container.url;
+ const { result: readPermission } = await userRead.permissions.create(collReadPermission);
assert.equal(readPermission.id, collReadPermission.id, "permission to read coll1 is not created properly");
collReadPermission = readPermission;
// create userAllPermission
- const { result: userAllPerm } = await client.createUser(database._self, userAllPermission);
- assert.equal(userAllPermission.id, userAllPerm.id, "userAllPermission is not created properly");
- userAllPermission = userAllPerm;
+ const { result: userAllDef } = await container.database.users.create(userAllDefinition);
+ assert.equal(userAllDefinition.id, userAllDef.id, "userAllPermission is not created properly");
+ userAllDefinition = userAllDef;
+ const userAll = container.database.users.get(userAllDef.id);
// create collAllPermission
- collAllPermission.resource = collection._self;
- const { result: allPermission } = await client.createPermission(userAllPermission._self, collAllPermission);
+ collAllPermission.resource = container.url;
+ const { result: allPermission } = await userAll.permissions.create(collAllPermission);
assert.equal(collAllPermission.id, allPermission.id, "permission to read coll2 is not created properly");
collAllPermission = allPermission;
});
afterEach(async function () {
- await TestHelpers.removeAllDatabases(host, masterKey);
+ await TestHelpers.removeAllDatabases(client);
});
- it("Accessing collection by resourceTokens", async function () {
+ it("Accessing container by resourceTokens", async function () {
const rTokens: any = {};
- rTokens[collection.id] = collReadPermission._token;
+ rTokens[container.id] = collReadPermission._token;
- const collectionUri = UriFactory.createDocumentCollectionUri(database.id, collection.id);
- const clientReadPermission = new CosmosClient(host, { resourceTokens: rTokens });
+ const clientReadPermission = new CosmosClient({ endpoint, auth: { resourceTokens: rTokens } });
- const { result: coll } = await clientReadPermission.readCollection(collectionUri);
- assert.equal(coll.id, collection.id, "invalid collection");
+ const { result: coll } = await clientReadPermission.databases.get(database.id)
+ .containers.get(container.id)
+ .read();
+ assert.equal(coll.id, container.id, "invalid container");
});
- it("Accessing collection by permissionFeed", async function () {
- const clientReadPermission = new CosmosClient(host, { permissionFeed: [collReadPermission] });
+ it("Accessing container by permissionFeed", async function () {
+ const clientReadPermission = new CosmosClient({ endpoint, auth: { permissionFeed: [collReadPermission] } });
// self link must be used to access a resource using permissionFeed
- const { result: coll } = await clientReadPermission.readCollection(collection._self);
- assert.equal(coll.id, collection.id, "invalid collection");
+ const { result: coll } = await clientReadPermission.databases.get(database.id)
+ .containers.get(container.id)
+ .read();
+ assert.equal(coll.id, container.id, "invalid container");
});
- it("Accessing collection without permission fails", async function () {
- const clientNoPermission = new CosmosClient(host, null);
+ it("Accessing container without permission fails", async function () {
+ const clientNoPermission = new CosmosClient({ endpoint, auth: null });
- const collectionUri = UriFactory.createDocumentCollectionUri(database.id, collection.id);
try {
- await clientNoPermission.readCollection(collectionUri);
- assert.fail("accessing collectioni did not throw");
+ await clientNoPermission.databases.get(database.id)
+ .containers.get(container.id)
+ .read();
+ assert.fail("accessing container did not throw");
} catch (err) {
assert(err !== undefined); // TODO: should check that we get the right error message
}
});
- it("Accessing document by permissionFeed of parent collection", async function () {
- const { result: createdDoc } = await client.createDocument(collection._self, { id: "document1" });
- const clientReadPermission = new CosmosClient(host, { permissionFeed: [collReadPermission] });
+ it("Accessing document by permissionFeed of parent container", async function () {
+ const { result: createdDoc } = await container.items.create({ id: "document1" });
+ const clientReadPermission = new CosmosClient({ endpoint, auth: { permissionFeed: [collReadPermission] } });
assert.equal("document1", createdDoc.id, "invalid documnet create");
- const { result: readDoc } = await clientReadPermission.readDocument(createdDoc._self);
+ const { result: readDoc } = await clientReadPermission.databases.get(database.id)
+ .containers.get(container.id)
+ .items.get(createdDoc.id)
+ .read();
assert.equal(readDoc.id, createdDoc.id, "invalid document read");
});
- it("Modifying collection by resourceTokens", async function () {
+ it("Modifying container by resourceTokens", async function () {
const rTokens: any = {};
- rTokens[collection.id] = collAllPermission._token;
+ rTokens[container.id] = collAllPermission._token;
+ const clientAllPermission = new CosmosClient({ endpoint, auth: { resourceTokens: rTokens } });
- const collectionUri = UriFactory.createDocumentCollectionUri(database.id, collection.id);
- const clientAllPermission = new CosmosClient(host, { resourceTokens: rTokens });
-
- // delete collection
- return clientAllPermission.deleteCollection(collectionUri);
+ // delete container
+ return clientAllPermission.databases.get(database.id)
+ .containers.get(container.id)
+ .delete();
});
- it("Modifying collection by permissionFeed", async function () {
- const clientAllPermission = new CosmosClient(host, { permissionFeed: [collAllPermission] });
+ it("Modifying container by permissionFeed", async function () {
+ const clientAllPermission = new CosmosClient({ endpoint, auth: { permissionFeed: [collAllPermission] } });
// self link must be used to access a resource using permissionFeed
- // delete collection
- return clientAllPermission.deleteCollection(collection._self);
+ // delete container
+ return clientAllPermission.databases.get(database.id)
+ .containers.get(container.id)
+ .delete();
});
});
diff --git a/src/test/integration/collectionNaming.spec.ts b/src/test/integration/collectionNaming.spec.ts
deleted file mode 100644
index d593c9f..0000000
--- a/src/test/integration/collectionNaming.spec.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import * as assert from "assert";
-import * as stream from "stream";
-import {DocumentClient, UriFactory} from "../../";
-import testConfig from "./../common/_testConfig";
-import { TestHelpers } from "./../common/TestHelpers";
-
-const host = testConfig.host;
-const masterKey = testConfig.masterKey;
-
-describe("Collection Naming", function () {
- const client = new DocumentClient(host, { masterKey });
- const databaseId = "collNamingTestDB";
- const collectionId = "media";
- const documentId = "doc1";
- const attachmentId = "atch1";
-
- const createReadableStream = function (firstChunk: string, secondChunk: string) {
- const readableStream = new stream.Readable();
- let chunkCount = 0;
- readableStream._read = function (n) {
- if (chunkCount === 0) {
- this.push(firstChunk || "first chunk ");
- } else if (chunkCount === 1) {
- this.push(secondChunk || "second chunk");
- } else {
- this.push(null);
- }
- chunkCount++;
- };
-
- return readableStream;
- };
-
- beforeEach(async function () {
- await TestHelpers.removeAllDatabases(host, masterKey);
- // create database
- const {result: db} = await client.createDatabase({ id: databaseId });
- assert.equal(db.id, databaseId, "database is not created properly");
-
- // create collection
- const dbUri = UriFactory.createDatabaseUri(databaseId);
- const {result: collection} = await client.createCollection(dbUri, { id: collectionId });
- assert.equal(collection.id, collectionId, "collection is not created properly");
-
- // createDocument
- const collectionUri = UriFactory.createDocumentCollectionUri(databaseId, collectionId);
- const {result: document} = await client.createDocument(collectionUri, { id: documentId });
- assert.equal(document.id, documentId, "document is not created properly");
-
- // create attachment and upload media
- const mediaOption = { slug: attachmentId, contentType: "application/text" };
- const readableStream = createReadableStream("UPLOADING ", "MEDIA");
- const documentUri = UriFactory.createDocumentUri(databaseId, collectionId, documentId);
- const {result: attachment} =
- await client.createAttachmentAndUploadMedia(documentUri, readableStream, mediaOption);
- assert.equal(attachment.id, attachmentId, "attachment is not created properly");
- });
-
- afterEach(async function () {
- await TestHelpers.removeAllDatabases(host, masterKey);
- });
-
- it("Accessing a collection with 'media' in its name", async function () {
- const collectionUri = UriFactory.createDocumentCollectionUri(databaseId, collectionId);
- const {result: collection} = await client.readCollection(collectionUri);
- assert.equal(collection.id, collectionId, "collectionIds do not match");
- });
-
- it("Accessing media in a collection", async function () {
- const collectionUri = UriFactory.createDocumentCollectionUri(databaseId, collectionId);
- const {result: collection} = await client.readCollection(collectionUri);
- assert.equal(collection.id, collectionId, "collectionIds do not match");
- });
-});
diff --git a/src/test/integration/crossPartition.spec.ts b/src/test/integration/crossPartition.spec.ts
index 099d755..9be1d5a 100644
--- a/src/test/integration/crossPartition.spec.ts
+++ b/src/test/integration/crossPartition.spec.ts
@@ -1,29 +1,20 @@
import * as assert from "assert";
-import * as stream from "stream";
import * as _ from "underscore";
import * as util from "util";
-import {
- AzureDocuments,
- Base,
- Constants,
- CosmosClient,
- DocumentBase,
- HashPartitionResolver,
- Range,
- RangePartitionResolver,
- RetryOptions,
-} from "../../";
+import { Constants, CosmosClient } from "../../";
+import { Container, ContainerDefinition } from "../../client";
+import { DataType, IndexKind, PartitionKind } from "../../documents";
import { SqlQuerySpec } from "../../queryExecutionContext";
import { QueryIterator } from "../../queryIterator";
-import { ErrorResponse } from "../../request";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("Cross Partition", function () {
- this.timeout("30000");
+ this.timeout(process.env.MOCHA_TIMEOUT || "30000");
const generateDocuments = function (docSize: number) {
const docs = [];
for (let i = 0; i < docSize; i++) {
@@ -44,24 +35,22 @@ describe("Cross Partition", function () {
};
describe("Validate Query", function () {
- const client = new CosmosClient(host, { masterKey });
const documentDefinitions = generateDocuments(20);
- const databaseConfig = { id: "sample 中文 database" };
- const collectionDefinition = {
- id: "sample collection",
+ const containerDefinition: ContainerDefinition = {
+ id: "sample container",
indexingPolicy: {
includedPaths: [
{
path: "/",
indexes: [
{
- kind: "Range",
- dataType: "Number",
+ kind: IndexKind.Range,
+ dataType: DataType.Number,
},
{
- kind: "Range",
- dataType: "String",
+ kind: IndexKind.Range,
+ dataType: DataType.String,
},
],
},
@@ -71,24 +60,22 @@ describe("Cross Partition", function () {
paths: [
"/id",
],
- kind: "Hash",
+ kind: PartitionKind.Hash,
},
};
- const collectionOptions = { offerThroughput: 10100 };
+ const containerOptions = { offerThroughput: 10100 };
- let db: any; // TODO: any types
- let collection: any; // TODO: any types
- const isNameBased: boolean = false;
+ let container: Container;
// - removes all the databases,
// - creates a new database,
// - creates a new collecton,
- // - bulk inserts documents to the collection
+ // - bulk inserts documents to the container
before(async function () {
- await TestHelpers.removeAllDatabases(host, masterKey);
- ({ result: db } = await client.createDatabase(databaseConfig));
- ({ result: collection } = await client.createCollection(db._self, collectionDefinition, collectionOptions));
- await TestHelpers.bulkInsertDocuments(client, isNameBased, db, collection, documentDefinitions);
+ await TestHelpers.removeAllDatabases(client);
+ container = await TestHelpers.getTestContainer(
+ client, "Validate 中文 Query", containerDefinition, containerOptions);
+ await TestHelpers.bulkInsertItems(container, documentDefinitions);
});
const validateResults = function (actualResults: any[], expectedOrderIds: string[]) {
@@ -104,7 +91,7 @@ describe("Cross Partition", function () {
};
const validateToArray = async function (
- queryIterator: QueryIterator, options: any, expectedOrderIds: string[]) {
+ queryIterator: QueryIterator, options: any, expectedOrderIds: string[]) {
////////////////////////////////
// validate toArray()
@@ -122,7 +109,7 @@ describe("Cross Partition", function () {
};
const validateNextItem = async function (
- queryIterator: QueryIterator, options: any, expectedOrderIds: string[]) {
+ queryIterator: QueryIterator, expectedOrderIds: string[]) {
////////////////////////////////
// validate nextItem()
@@ -146,7 +133,7 @@ describe("Cross Partition", function () {
};
const validateNextItemAndCurrentAndHasMoreResults =
- async function (queryIterator: QueryIterator, options: any, expectedOrderIds: string[]) {
+ async function (queryIterator: QueryIterator, expectedOrderIds: string[]) {
// curent and nextItem recursively invoke each other till queryIterator is exhausted
////////////////////////////////
// validate nextItem()
@@ -174,8 +161,7 @@ describe("Cross Partition", function () {
};
const validateExecuteNextAndHasMoreResults = async function (
- collectionLink: string, query: string | SqlQuerySpec, options: any,
- queryIterator: QueryIterator, expectedOrderIds: string[],
+ options: any, queryIterator: QueryIterator, expectedOrderIds: string[],
validateExecuteNextWithContinuationToken?: boolean) {
const pageSize = options["maxItemCount"];
@@ -227,44 +213,33 @@ describe("Cross Partition", function () {
// I don't think this code is ever called, which means we're missing tests or should delete it.
throw new Error("Not yet implemented");
// return validateExecuteNextWithGivenContinuationToken(
- // collectionLink, query, options, listOfResultPages, listOfHeaders);
+ // containerLink, query, options, listOfResultPages, listOfHeaders);
}
} catch (err) {
throw err;
}
};
- const validateForEach = function (queryIterator: QueryIterator, options: any, expectedOrderIds: any[]) {
+ const validateForEach = async function (queryIterator: QueryIterator, expectedOrderIds: any[]) {
////////////////////////////////
// validate forEach()
////////////////////////////////
- return new Promise((resolve, reject) => {
- const results: any[] = [];
- let callbackSingnalledEnd = false;
- // forEach uses callbacks still, so just wrap in a promise
- queryIterator.forEach((err: ErrorResponse, item: any) => {
- try {
- assert.equal(err, undefined,
- "unexpected failure in fetching the results: " + err + JSON.stringify(err));
- // if the previous invocation returned false, forEach must avoid invoking the callback again!
- assert.equal(callbackSingnalledEnd, false,
- "forEach called callback after the first false returned");
- results.push(item);
- if (results.length === expectedOrderIds.length) {
- callbackSingnalledEnd = true;
- validateResults(results, expectedOrderIds);
- process.nextTick(resolve);
- return false;
- }
- return true;
- } catch (err) {
- reject(err);
- }
- });
- });
+ const results: any[] = [];
+ let callbackSingnalledEnd = false;
+ // forEach uses callbacks still, so just wrap in a promise
+ for await (const { result: item } of queryIterator.forEach()) {
+ // if the previous invocation returned false, forEach must avoid invoking the callback again!
+ assert.equal(callbackSingnalledEnd, false,
+ "forEach called callback after the first false returned");
+ results.push(item);
+ if (results.length === expectedOrderIds.length) {
+ callbackSingnalledEnd = true;
+ }
+ }
+ validateResults(results, expectedOrderIds);
};
- const validateQueryMetrics = async function (queryIterator: QueryIterator) {
+ const validateQueryMetrics = async function (queryIterator: QueryIterator) {
try {
while (queryIterator.hasMoreResults()) {
const { result: results, headers } = await queryIterator.executeNext();
@@ -281,29 +256,24 @@ describe("Cross Partition", function () {
const executeQueryAndValidateResults =
async function (
- collectionLink: string, query: string | SqlQuerySpec, options: any,
+ query: string | SqlQuerySpec, options: any,
expectedOrderIds: any[], validateExecuteNextWithContinuationToken?: boolean) {
- try {
- options.populateQueryMetrics = true;
- validateExecuteNextWithContinuationToken = validateExecuteNextWithContinuationToken || false;
- const queryIterator = client.queryDocuments(collectionLink, query, options);
- await validateToArray(queryIterator, options, expectedOrderIds);
- queryIterator.reset();
- await validateExecuteNextAndHasMoreResults(
- collectionLink, query, options,
- queryIterator, expectedOrderIds, validateExecuteNextWithContinuationToken);
- queryIterator.reset();
- await validateNextItemAndCurrentAndHasMoreResults(queryIterator, options, expectedOrderIds);
- await validateForEach(queryIterator, options, expectedOrderIds);
- queryIterator.reset();
- await validateQueryMetrics(queryIterator);
- } catch (err) {
- throw err;
- }
+ options.populateQueryMetrics = true;
+ validateExecuteNextWithContinuationToken = validateExecuteNextWithContinuationToken || false;
+ const queryIterator = container.items.query(query, options);
+
+ await validateToArray(queryIterator, options, expectedOrderIds);
+ queryIterator.reset();
+ await validateExecuteNextAndHasMoreResults(
+ options, queryIterator, expectedOrderIds, validateExecuteNextWithContinuationToken);
+ queryIterator.reset();
+ await validateNextItemAndCurrentAndHasMoreResults(queryIterator, expectedOrderIds);
+ await validateForEach(queryIterator, expectedOrderIds);
+ await validateQueryMetrics(queryIterator);
};
- const requestChargeValidator = async function (queryIterator: QueryIterator) {
+ const requestChargeValidator = async function (queryIterator: QueryIterator) {
let counter = 0;
let totalRequestCharge = 0;
@@ -338,9 +308,7 @@ describe("Cross Partition", function () {
const expectedOrderedIds = [1, 10, 18, 2, 3, 13, 14, 16, 17, 0, 11, 12, 5, 9, 19, 4, 6, 7, 8, 15];
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds, false);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds, false);
});
it("Validate Parallel Query As String With maxDegreeOfParallelism: -1", async function () {
@@ -358,9 +326,7 @@ describe("Cross Partition", function () {
const expectedOrderedIds = [1, 10, 18, 2, 3, 13, 14, 16, 17, 0, 11, 12, 5, 9, 19, 4, 6, 7, 8, 15];
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds, false);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds, false);
});
it("Validate Parallel Query As String With maxDegreeOfParallelism: 1", async function () {
@@ -375,9 +341,7 @@ describe("Cross Partition", function () {
const expectedOrderedIds = [1, 10, 18, 2, 3, 13, 14, 16, 17, 0, 11, 12, 5, 9, 19, 4, 6, 7, 8, 15];
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds, false);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds, false);
});
it("Validate Parallel Query As String With maxDegreeOfParallelism: 3", async function () {
@@ -392,9 +356,7 @@ describe("Cross Partition", function () {
const expectedOrderedIds = [1, 10, 18, 2, 3, 13, 14, 16, 17, 0, 11, 12, 5, 9, 19, 4, 6, 7, 8, 15];
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds, false);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds, false);
});
it("Validate Parallel Query Request Charge With maxDegreeOfParallelism: 3", async function () {
@@ -402,8 +364,7 @@ describe("Cross Partition", function () {
const query = "SELECT * FROM root r";
const options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 3 };
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
await requestChargeValidator(queryIterator);
});
@@ -412,8 +373,7 @@ describe("Cross Partition", function () {
const query = "SELECT * FROM root r";
const options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 1 };
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
await requestChargeValidator(queryIterator);
});
@@ -422,8 +382,7 @@ describe("Cross Partition", function () {
const query = "SELECT * FROM root r order by r.spam";
const options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 1 };
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
await requestChargeValidator(queryIterator);
});
@@ -432,8 +391,7 @@ describe("Cross Partition", function () {
const query = "SELECT * FROM root r order by r.spam";
const options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 0 };
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
await requestChargeValidator(queryIterator);
});
@@ -446,8 +404,7 @@ describe("Cross Partition", function () {
const query = util.format("SELECT top %d * FROM root r", topCount);
const options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 3 };
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
await requestChargeValidator(queryIterator);
});
@@ -460,8 +417,7 @@ describe("Cross Partition", function () {
const query = util.format("SELECT top %d * FROM root r", topCount);
const options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 0 };
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
await requestChargeValidator(queryIterator);
});
@@ -479,9 +435,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds);
});
it("Validate Simple OrderBy Query As String With maxDegreeOfParallelism = 1", async function () {
@@ -498,9 +452,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds);
});
it("Validate Simple OrderBy Query As String With maxDegreeOfParallelism = 3", async function () {
@@ -517,9 +469,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds);
});
it("Validate Simple OrderBy Query As String With maxDegreeOfParallelism = -1", async function () {
@@ -536,9 +486,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds);
});
it("Validate Simple OrderBy Query As String", async function () {
@@ -555,9 +503,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds);
});
it("Validate Simple OrderBy Query", async function () {
@@ -576,9 +522,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- querySpec, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(querySpec, options, expectedOrderedIds);
});
it("Validate OrderBy Query With ASC", async function () {
@@ -597,9 +541,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- querySpec, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(querySpec, options, expectedOrderedIds);
});
it("Validate OrderBy Query With DESC", async function () {
@@ -618,9 +560,7 @@ describe("Cross Partition", function () {
})).reverse();
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- querySpec, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(querySpec, options, expectedOrderedIds);
});
it("Validate OrderBy with top", async function () {
@@ -639,9 +579,7 @@ describe("Cross Partition", function () {
return r["id"];
})).slice(0, topCount);
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- querySpec, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(querySpec, options, expectedOrderedIds);
});
@@ -663,9 +601,7 @@ describe("Cross Partition", function () {
return r["id"];
}));
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- querySpec, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(querySpec, options, expectedOrderedIds);
});
it("Validate Top Query with maxDegreeOfParallelism = 3", async function () {
@@ -678,8 +614,7 @@ describe("Cross Partition", function () {
const options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 3 };
// prepare expected behaviour verifier
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
const { result: results } = await queryIterator.toArray();
assert.equal(results.length, topCount);
@@ -703,8 +638,7 @@ describe("Cross Partition", function () {
const options = { enableCrossPartitionQuery: true, maxItemCount: 2 };
// prepare expected behaviour verifier
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
const { result: results } = await queryIterator.toArray();
assert.equal(results.length, topCount);
@@ -728,8 +662,7 @@ describe("Cross Partition", function () {
const options = { enableCrossPartitionQuery: true, maxItemCount: 2 };
// prepare expected behaviour verifier
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
const { result: results } = await queryIterator.toArray();
assert.equal(results.length, topCount);
@@ -759,8 +692,7 @@ describe("Cross Partition", function () {
const options = { enableCrossPartitionQuery: true, maxItemCount: 2 };
// prepare expected behaviour verifier
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), querySpec, options);
+ const queryIterator = container.items.query(querySpec, options);
const { result: results } = await queryIterator.toArray();
assert.equal(results.length, topCount);
@@ -797,9 +729,7 @@ describe("Cross Partition", function () {
return r["id"];
})).slice(0, topCount);
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- querySpec, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(querySpec, options, expectedOrderedIds);
});
it("Validate OrderBy with Parametrized Predicate", async function () {
@@ -826,9 +756,7 @@ describe("Cross Partition", function () {
return r["id"];
}));
- executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- querySpec, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(querySpec, options, expectedOrderedIds);
});
it("Validate Error Handling - Orderby where types are noncomparable", async function () {
@@ -841,8 +769,7 @@ describe("Cross Partition", function () {
// prepare expected behaviour verifier
try {
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
await queryIterator.toArray();
} catch (err) {
assert.notEqual(err, undefined);
@@ -863,9 +790,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds);
});
it("Validate OrderBy Floating Point Number Query", async function () {
@@ -882,9 +807,7 @@ describe("Cross Partition", function () {
}));
// validates the results size and order
- await executeQueryAndValidateResults(
- TestHelpers.getCollectionLink(isNameBased, db, collection),
- query, options, expectedOrderedIds);
+ await executeQueryAndValidateResults(query, options, expectedOrderedIds);
});
it("Validate OrderBy Boolean Query", async function () {
@@ -892,8 +815,7 @@ describe("Cross Partition", function () {
const query = "SELECT * FROM root r order by r.boolVar";
const options = { enableCrossPartitionQuery: true, maxItemCount: 2 };
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
const { result: results } = await queryIterator.toArray();
assert.equal(results.length, documentDefinitions.length);
@@ -913,26 +835,6 @@ describe("Cross Partition", function () {
}
});
- it("Validate forEach quick termination", async function () {
- // simple order by query in string format
- const query = "SELECT * FROM root r order by r.spam";
-
- const options = { enableCrossPartitionQuery: true, maxItemCount: 2 };
-
- // prepare expected results
- const getOrderByKey = function (r: any) {
- return r["spam"];
- };
- const expectedOrderedIds = (_.sortBy(documentDefinitions, getOrderByKey).map(function (r) {
- return r["id"];
- })).slice(0, 1);
-
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
-
- await validateForEach(queryIterator, options, expectedOrderedIds);
- });
-
it("Validate Failure", async function () {
// simple order by query in string format
const query = "SELECT * FROM root r order by r.spam";
@@ -947,8 +849,7 @@ describe("Cross Partition", function () {
return r["id"];
}));
- const queryIterator = client.queryDocuments(
- TestHelpers.getCollectionLink(isNameBased, db, collection), query, options);
+ const queryIterator = container.items.query(query, options);
let firstTime = true;
diff --git a/src/test/integration/documentClient.spec.ts b/src/test/integration/documentClient.spec.ts
index fac2770..12d49ec 100644
--- a/src/test/integration/documentClient.spec.ts
+++ b/src/test/integration/documentClient.spec.ts
@@ -1,19 +1,19 @@
import * as assert from "assert";
-import {Constants, CosmosClient, IHeaders} from "../../";
+import { Constants, CosmosClient, IHeaders } from "../../";
import testConfig from "./../common/_testConfig";
// TODO: Should evaluate whether any of these tests are necessary. Are these really public apis?
describe("DocumentClient Tests", function () {
- const host = testConfig.host;
+ const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
- const client = new CosmosClient(host, { masterKey });
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("setIsUpsertHeader", function () {
it("Should add is-upsert header.", function (done) {
- const headers = client.defaultHeaders;
+ const headers = client.documentClient.defaultHeaders;
assert.equal(undefined, headers[Constants.HttpHeaders.IsUpsert]);
- client.setIsUpsertHeader(headers);
+ client.documentClient.setIsUpsertHeader(headers);
assert.equal(true, headers[Constants.HttpHeaders.IsUpsert]);
done();
});
@@ -22,14 +22,14 @@ describe("DocumentClient Tests", function () {
const headers: IHeaders = {};
headers[Constants.HttpHeaders.IsUpsert] = false;
assert.equal(false, headers[Constants.HttpHeaders.IsUpsert]);
- client.setIsUpsertHeader(headers);
+ client.documentClient.setIsUpsertHeader(headers);
assert.equal(true, headers[Constants.HttpHeaders.IsUpsert]);
done();
});
it("Should throw on undefined headers", function (done) {
assert.throws(
- function () { client.setIsUpsertHeader(undefined); },
+ function () { client.documentClient.setIsUpsertHeader(undefined); },
/The "headers" parameter must not be null or undefined/,
);
done();
@@ -37,7 +37,7 @@ describe("DocumentClient Tests", function () {
it("Should throw on null headers", function (done) {
assert.throws(
- function () { client.setIsUpsertHeader(null); },
+ function () { client.documentClient.setIsUpsertHeader(null); },
/The "headers" parameter must not be null or undefined/,
);
done();
@@ -45,7 +45,9 @@ describe("DocumentClient Tests", function () {
it("Should throw on invalid string headers", function (done) {
assert.throws(
- function () { client.setIsUpsertHeader("" as any); }, // Any type is intentional for test failure
+ function () {
+ client.documentClient.setIsUpsertHeader("" as any);
+ }, // Any type is intentional for test failure
/The "headers" parameter must be an instance of "Object". Actual type is: "string"./,
);
done();
@@ -53,7 +55,9 @@ describe("DocumentClient Tests", function () {
it("Should throw on invalid number headers", function (done) {
assert.throws(
- function () { client.setIsUpsertHeader(0 as any); }, // Any type is intentional for test failure
+ function () {
+ client.documentClient.setIsUpsertHeader(0 as any);
+ }, // Any type is intentional for test failure
/The "headers" parameter must be an instance of "Object". Actual type is: "number"./,
);
done();
@@ -61,7 +65,9 @@ describe("DocumentClient Tests", function () {
it("Should throw on invalid boolean headers", function (done) {
assert.throws(
- function () { client.setIsUpsertHeader(false as any); }, // Any type is intentional for test failure
+ function () {
+ client.documentClient.setIsUpsertHeader(false as any);
+ }, // Any type is intentional for test failure
/The "headers" parameter must be an instance of "Object". Actual type is: "boolean"./,
);
done();
@@ -70,7 +76,7 @@ describe("DocumentClient Tests", function () {
describe("validateOptionsAndCallback Unit Tests", function () {
it("no parameters", function (done) {
- const result = client.validateOptionsAndCallback(undefined, undefined);
+ const result = client.documentClient.validateOptionsAndCallback(undefined, undefined);
assert.notEqual(null, result.options);
assert.equal("object", typeof result.options);
@@ -80,7 +86,7 @@ describe("DocumentClient Tests", function () {
});
it("options", function (done) {
- const result = client.validateOptionsAndCallback({}, undefined);
+ const result = client.documentClient.validateOptionsAndCallback({}, undefined);
assert.notEqual(null, result.options);
assert.equal("object", typeof result.options);
@@ -90,7 +96,7 @@ describe("DocumentClient Tests", function () {
});
it("callback", function (done) {
- const result = client.validateOptionsAndCallback(function () { /* no op */ }, undefined);
+ const result = client.documentClient.validateOptionsAndCallback(function () { /* no op */ }, undefined);
assert.notEqual(null, result.options);
assert.equal("object", typeof result.options);
@@ -99,7 +105,7 @@ describe("DocumentClient Tests", function () {
});
it("options, callback.", function (done) {
- const result = client.validateOptionsAndCallback({}, function () { /* no up */ });
+ const result = client.documentClient.validateOptionsAndCallback({}, function () { /* no up */ });
assert.notEqual(null, result.options);
assert.equal("object", typeof result.options);
@@ -108,7 +114,7 @@ describe("DocumentClient Tests", function () {
});
it("undefined, callback", function (done) {
- const result = client.validateOptionsAndCallback(undefined, function () { /* no op */ });
+ const result = client.documentClient.validateOptionsAndCallback(undefined, function () { /* no op */ });
assert.notEqual(null, result.options);
assert.equal("object", typeof result.options);
@@ -117,7 +123,7 @@ describe("DocumentClient Tests", function () {
});
it("null, callback", function (done) {
- const result = client.validateOptionsAndCallback(null, function () { /* no op */ });
+ const result = client.documentClient.validateOptionsAndCallback(null, function () { /* no op */ });
assert.equal(null, result.options);
assert.equal("object", typeof result.options);
@@ -127,7 +133,7 @@ describe("DocumentClient Tests", function () {
it("invalid string options", function (done) {
assert.throws(
- function () { client.validateOptionsAndCallback("foo", function () { /* no op */ }); },
+ function () { client.documentClient.validateOptionsAndCallback("foo", function () { /* no op */ }); },
/The "options" parameter must be of type "object". Actual type is: "string"/,
);
done();
@@ -135,7 +141,7 @@ describe("DocumentClient Tests", function () {
it("invalid number options", function (done) {
assert.throws(
- function () { client.validateOptionsAndCallback(0, function () { /* no op */ }); },
+ function () { client.documentClient.validateOptionsAndCallback(0, function () { /* no op */ }); },
/The "options" parameter must be of type "object". Actual type is: "number"/,
);
done();
@@ -143,7 +149,7 @@ describe("DocumentClient Tests", function () {
it("invalid bool options", function (done) {
assert.throws(
- function () { client.validateOptionsAndCallback(false, function () { /* no op */ }); },
+ function () { client.documentClient.validateOptionsAndCallback(false, function () { /* no op */ }); },
/The "options" parameter must be of type "object". Actual type is: "boolean"/,
);
done();
@@ -151,7 +157,7 @@ describe("DocumentClient Tests", function () {
it("invalid string callback", function (done) {
assert.throws(
- function () { client.validateOptionsAndCallback({}, "bar"); },
+ function () { client.documentClient.validateOptionsAndCallback({}, "bar"); },
/The "callback" parameter must be of type "function". Actual type is: "string"/,
);
done();
@@ -159,7 +165,7 @@ describe("DocumentClient Tests", function () {
it("invalid number callback", function (done) {
assert.throws(
- function () { client.validateOptionsAndCallback({}, 0); },
+ function () { client.documentClient.validateOptionsAndCallback({}, 0); },
/The "callback" parameter must be of type "function". Actual type is: "number"/,
);
done();
@@ -167,7 +173,7 @@ describe("DocumentClient Tests", function () {
it("invalid boolean callback", function (done) {
assert.throws(
- function () { client.validateOptionsAndCallback({}, false); },
+ function () { client.documentClient.validateOptionsAndCallback({}, false); },
/The "callback" parameter must be of type "function". Actual type is: "boolean"/,
);
done();
@@ -175,7 +181,7 @@ describe("DocumentClient Tests", function () {
it("invalid options, invalid callback", function (done) {
assert.throws(
- function () { client.validateOptionsAndCallback("foo", "bar"); },
+ function () { client.documentClient.validateOptionsAndCallback("foo", "bar"); },
/The "options" parameter must be of type "object". Actual type is: "string"/,
);
done();
@@ -185,55 +191,55 @@ describe("DocumentClient Tests", function () {
describe("isResourceValid Unit Tests", function () {
it("id is not string", function (done) {
const err = {};
- const result = client.isResourceValid({id: 1}, err);
+ const result = client.documentClient.isResourceValid({ id: 1 }, err);
assert.equal(result, false);
- assert.deepEqual(err, { message: "Id must be a string."});
+ assert.deepEqual(err, { message: "Id must be a string." });
done();
});
});
- describe("extractPartitionKey", function() {
+ describe("extractPartitionKey", function () {
let partitionKeyDefinition: any; // TODO: any
- beforeEach(function() {
+ beforeEach(function () {
partitionKeyDefinition = undefined;
});
- describe("With undefined partitionKeyDefinition", function() {
- it("should return undefined", function() {
+ describe("With undefined partitionKeyDefinition", function () {
+ it("should return undefined", function () {
const document: any = {};
- const result = client.extractPartitionKey(document, partitionKeyDefinition);
+ const result = client.documentClient.extractPartitionKey(document, partitionKeyDefinition);
assert.equal(result, undefined);
});
});
- describe("With a defined partitionKeyDefinition", function() {
- beforeEach(function() {
+ describe("With a defined partitionKeyDefinition", function () {
+ beforeEach(function () {
partitionKeyDefinition = { paths: ["/a/b"] };
});
- it("should return [{}] when document has no partition key value", function() {
+ it("should return [{}] when document has no partition key value", function () {
const document = {};
- const result = client.extractPartitionKey(document, partitionKeyDefinition);
+ const result = client.documentClient.extractPartitionKey(document, partitionKeyDefinition);
assert.deepEqual(result, [{}]);
});
- it("should return [null] when document has a null partition key value", function() {
+ it("should return [null] when document has a null partition key value", function () {
const document: any = { a: { b: null } };
- const result = client.extractPartitionKey(document, partitionKeyDefinition);
+ const result = client.documentClient.extractPartitionKey(document, partitionKeyDefinition);
assert.deepEqual(result, [null]);
});
- it("should return [{}] when document has a partially defined partition key value", function() {
+ it("should return [{}] when document has a partially defined partition key value", function () {
const document = { a: "some value" };
- const result = client.extractPartitionKey(document, partitionKeyDefinition);
+ const result = client.documentClient.extractPartitionKey(document, partitionKeyDefinition);
assert.deepEqual(result, [{}]);
});
- it("should return [value] when document has a valid partition key value", function() {
+ it("should return [value] when document has a valid partition key value", function () {
const document = { a: { b: "some value" } };
- const result = client.extractPartitionKey(document, partitionKeyDefinition);
+ const result = client.documentClient.extractPartitionKey(document, partitionKeyDefinition);
assert.deepEqual(result, ["some value"]);
});
});
diff --git a/src/test/integration/encoding.spec.ts b/src/test/integration/encoding.spec.ts
index 35d499d..30eae12 100644
--- a/src/test/integration/encoding.spec.ts
+++ b/src/test/integration/encoding.spec.ts
@@ -1,10 +1,12 @@
import * as assert from "assert";
-import { CosmosClient, UriFactory } from "../../";
+import { CosmosClient } from "../../";
+import { IndexingMode } from "../../documents";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
const testDoc = {
id: "ABC",
@@ -15,38 +17,33 @@ const testDoc = {
describe("Create And Read Validation", function () {
this.timeout(10000);
- const client = new CosmosClient(host, { masterKey });
const dateTime = new Date();
const databaseId = "encodingTestDB";
- afterEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
- beforeEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
+ afterEach(async function () { await TestHelpers.removeAllDatabases(client); });
+ beforeEach(async function () { await TestHelpers.removeAllDatabases(client); });
it("check if the document from db matches the actual document", async function () {
try {
- const databaseBody = { id: databaseId };
-
// Create Database
- const { result: database } = await client.createDatabase(databaseBody);
- assert.equal(database.id, databaseId, "invalid database Id");
-
- const collectionBody = {
+ const database = await TestHelpers.getTestDatabase(client, databaseId);
+ const containerBody = {
id: "डेटाबेस پایگاه داده 数据库" + dateTime.getTime(),
- indexingPolicy: { indexingMode: "Lazy" }, // Modes : Lazy, Consistent
+ indexingPolicy: { indexingMode: IndexingMode.Lazy }, // Modes : Lazy, Consistent
};
- // Create a collection inside the database
- const { result: collection } = await client.createCollection(database._self, collectionBody);
- const path = UriFactory.createDocumentCollectionUri(databaseId, collectionBody.id);
+ // Create a container inside the database
+ const { result: containerDef } = await database.containers.create(containerBody);
+ const container = database.containers.get(containerDef.id);
+ assert.equal(containerDef.id, containerBody.id, "invalid container Id");
- assert.equal(collection.id, collectionBody.id, "invalid collection Id");
-
- // Add the document in the collection
- const { result: doc } = await client.createDocument(collection._self, testDoc);
+ // Add the document in the container
+ const { result: doc } = await container.items.create(testDoc);
assert.equal(doc.id, testDoc.id, "invalid document Id");
- // Read the collection and see if it matches to the initial document
- const { result: resultDoc } = await client.readDocument(doc._self);
+ // Read the container and see if it matches to the initial document
+ const { result: resultDoc } = await container.items.get(doc.id)
+ .read<{ id: string, content: string }>();
assert.equal(testDoc.content, resultDoc.content, "read document result is different from initial document");
} catch (err) {
throw err;
diff --git a/src/test/integration/incrementalFeed.spec.ts b/src/test/integration/incrementalFeed.spec.ts
index 08c3c18..a366f14 100644
--- a/src/test/integration/incrementalFeed.spec.ts
+++ b/src/test/integration/incrementalFeed.spec.ts
@@ -1,108 +1,47 @@
import * as assert from "assert";
-import { Base, CosmosClient, Range } from "../../";
-import { FeedOptions } from "../../documentclient";
+import { CosmosClient, Database, FeedOptions } from "../../";
+import { Container } from "../../client";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
describe("NodeJS Incremental Feed Tests using 'a_im' and 'IfNoneMatch' options", function () {
- const client = new CosmosClient(host, { masterKey });
- let db: any;
-
// delete all databases and create sample database
before(async function () {
- await TestHelpers.removeAllDatabases(host, masterKey);
- const { result: createdDB } = await client.createDatabase({ id: "sample database" });
- db = createdDB;
+ await TestHelpers.removeAllDatabases(client);
});
- const isNameBased = false;
-
- const createCollection = async function (): Promise { // any === collection
- const collectionDefinition = {
- id: "sample collection",
- };
- const dbLink = TestHelpers.getDatabaseLink(false, db);
- return client.createCollection(dbLink, collectionDefinition);
- };
-
describe("Newly updated documents should be fetched incremetally", function () {
- let collection: any;
+ let container: Container;
- // create collection and two documents
+ // create container and two documents
before(async function () {
- const { result: coll } = await createCollection();
- collection = coll;
- const collLink = TestHelpers.getCollectionLink(isNameBased, db, collection);
- const { result: doc1 } = await client.createDocument(collLink, { id: "doc1" });
- const { result: doc2 } = await client.createDocument(collLink, { id: "doc2" });
+ container = await TestHelpers.getTestContainer(
+ client, "Newly updated documents should be fetched incrementally");
+ await container.items.create({ id: "doc1" });
+ await container.items.create({ id: "doc2" });
});
after(async function () {
- await client.deleteCollection(TestHelpers.getCollectionLink(isNameBased, db, collection));
+ await container.delete();
});
it("should fetch updated documents only", async function () {
- try {
- let options: FeedOptions = { a_im: "Incremental feed" };
- const query = client.readDocuments(TestHelpers.getCollectionLink(isNameBased, db, collection), options);
-
- const { result: document, headers } = await query.current();
- assert(headers.etag, "listDocuments response should have etag header");
-
- const { result: results } = await query.toArray();
- assert.equal(results.length, 2, "initial number of documents should be equal 2");
-
- const documentLink = TestHelpers.getDocumentLink(isNameBased, db, collection, document);
-
- document.name = "xyz";
- const { result: replaced } = await client.replaceDocument(documentLink, document);
- assert.deepEqual(replaced.name, "xyz", "replaced document should be valid");
-
- options = {
- a_im: "Incremental feed",
- accessCondition: {
- type: "IfNoneMatch",
- condition: headers.etag,
- },
- };
- const collLink = TestHelpers.getCollectionLink(isNameBased, db, collection);
- const { result: docs } = await client.readDocuments(collLink, options).toArray();
- assert.equal(docs.length, 1, "initial number of documents should be equal 1");
- assert.equal(docs[0].name, "xyz", "fetched document should have 'name: xyz'");
- assert.equal(docs[0].id, document.id, "fetched document should be valid");
- } catch (err) {
- throw err;
- }
- });
- });
-
- describe("Newly created documents should be fetched incrementally", async function () {
- let collection: any;
-
- // create collection and one document
- before(async function () {
- const { result: coll } = await createCollection();
- collection = coll;
- const collLink = TestHelpers.getCollectionLink(isNameBased, db, collection);
- const { result: doc1 } = await client.createDocument(collLink, { id: "doc1" });
- });
-
- after(async function () {
- await client.deleteCollection(TestHelpers.getCollectionLink(isNameBased, db, collection));
- });
-
- it("should fetch new documents only", async function () {
let options: FeedOptions = { a_im: "Incremental feed" };
- const collLink = TestHelpers.getCollectionLink(isNameBased, db, collection);
- let query = client.readDocuments(collLink, options);
+ const query = container.items.readAll(options);
- let {result, headers} = await query.current();
+ const { result: document, headers } = await query.current();
assert(headers.etag, "listDocuments response should have etag header");
- const {result: document} = await client.createDocument(collLink, { id: "doc2", prop: 1 });
+ const { result: results } = await query.toArray();
+ assert.equal(results.length, 2, "initial number of documents should be equal 2");
+
+ document.name = "xyz";
+ const { result: replaced } = await container.items.get(document.id).replace(document);
+ assert.deepEqual(replaced.name, "xyz", "replaced document should be valid");
options = {
a_im: "Incremental feed",
@@ -111,8 +50,45 @@ describe("NodeJS Incremental Feed Tests using 'a_im' and 'IfNoneMatch' options",
condition: headers.etag,
},
};
- query = await client.readDocuments(collLink, options);
- ({result, headers} = await query.current());
+ const { result: docs } = await container.items.readAll(options).toArray();
+ assert.equal(docs.length, 1, "initial number of documents should be equal 1");
+ assert.equal(docs[0].name, "xyz", "fetched document should have 'name: xyz'");
+ assert.equal(docs[0].id, document.id, "fetched document should be valid");
+ });
+ });
+
+ describe("Newly created documents should be fetched incrementally", async function () {
+ let container: Container;
+
+ // create container and one document
+ before(async function () {
+ container = await TestHelpers.getTestContainer(
+ client, "Newly updated documents should be fetched incrementally");
+ await container.items.create({ id: "doc1" });
+ });
+
+ after(async function () {
+ await container.delete();
+ });
+
+ it("should fetch new documents only", async function () {
+ let options: FeedOptions = { a_im: "Incremental feed" };
+ let query = container.items.readAll(options);
+
+ let { result, headers } = await query.current();
+ assert(headers.etag, "listDocuments response should have etag header");
+
+ const { result: document } = await container.items.create({ id: "doc2", prop: 1 });
+
+ options = {
+ a_im: "Incremental feed",
+ accessCondition: {
+ type: "IfNoneMatch",
+ condition: headers.etag,
+ },
+ };
+ query = await container.items.readAll(options);
+ ({ result, headers } = await query.current());
assert.notDeepEqual(result, document, "actual should not match with expected value.");
delete result._lsn;
@@ -120,12 +96,12 @@ describe("NodeJS Incremental Feed Tests using 'a_im' and 'IfNoneMatch' options",
options.accessCondition.condition = headers.etag;
- const {result: results} = await client.readDocuments(collLink, options).toArray();
+ const { result: results } = await container.items.readAll(options).toArray();
assert.equal(results.length, 0, "should be nothing new");
- await client.createDocument(collLink, { id: "doc3" });
- await client.createDocument(collLink, { id: "doc4" });
- const {result: docs} = await client.readDocuments(collLink, options).toArray();
+ await container.items.create({ id: "doc3" });
+ await container.items.create({ id: "doc4" });
+ const { result: docs } = await container.items.readAll(options).toArray();
assert.equal(docs.length, 2, "there should be 2 results");
});
});
diff --git a/src/test/integration/proxy.spec.ts b/src/test/integration/proxy.spec.ts
index a4ecb88..94ae37c 100644
--- a/src/test/integration/proxy.spec.ts
+++ b/src/test/integration/proxy.spec.ts
@@ -34,9 +34,13 @@ if (!isBrowser()) {
proxy.listen(proxyPort, "127.0.0.1", async () => {
try {
const client =
- new CosmosClient(testConfig.host, { masterKey: testConfig.masterKey }, connectionPolicy);
+ new CosmosClient({
+ endpoint: testConfig.host,
+ auth: { masterKey: testConfig.masterKey },
+ connectionPolicy,
+ });
// create database
- await client.createDatabase({ id: Base.generateGuidId() });
+ await client.databases.create({ id: Base.generateGuidId() });
resolve();
} catch (err) {
throw err;
@@ -54,10 +58,13 @@ if (!isBrowser()) {
proxy.listen(proxyPort + 1, "127.0.0.1", async () => {
try {
const client =
- new CosmosClient(testConfig.host,
- { masterKey: testConfig.masterKey }, connectionPolicy);
+ new CosmosClient({
+ endpoint: testConfig.host,
+ auth: { masterKey: testConfig.masterKey },
+ connectionPolicy,
+ });
// create database
- await client.createDatabase({ id: Base.generateGuidId() });
+ await client.databases.create({ id: Base.generateGuidId() });
reject(new Error("Should create database in error while the proxy setting is not correct"));
} catch (err) {
resolve();
diff --git a/src/test/integration/query.spec.ts b/src/test/integration/query.spec.ts
index cc1e9a8..0b1d459 100644
--- a/src/test/integration/query.spec.ts
+++ b/src/test/integration/query.spec.ts
@@ -1,71 +1,69 @@
import * as assert from "assert";
-import { Constants, CosmosClient, UriFactory } from "../../";
-import { FeedOptions } from "../../documentclient";
+import { Constants, CosmosClient, FeedOptions, UriFactory } from "../../";
+import { PartitionKind } from "../../documents";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
const doc = { id: "myId", pk: "pk" };
describe("ResourceLink Trimming of leading and trailing slashes", function () {
this.timeout(10000);
- const client = new CosmosClient(host, { masterKey });
- const databaseId = "testDatabase";
- const collectionId = "testCollection";
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
+ const containerId = "testcontainer";
- afterEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
- beforeEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
+ beforeEach(async function () { await TestHelpers.removeAllDatabases(client); });
- it("validate correct execution of query using named collection link with leading and trailing slashes"
+ it("validate correct execution of query using named container link with leading and trailing slashes"
, async function () {
- try {
- const databaseBody = { id: databaseId };
+ const containerDefinition = {
+ id: containerId,
+ partitionKey: {
+ paths: ["/pk"],
+ kind: PartitionKind.Hash,
+ },
+ };
+ const containerOptions = { offerThroughput: 10100 };
- const { result: database } = await client.createDatabase(databaseBody);
- const collectionDefinition = { id: collectionId, partitionKey: { paths: ["/pk"], kind: "Hash" } };
- const collectionOptions = { offerThroughput: 10100 };
+ const container = await TestHelpers.getTestContainer(
+ client, "validate correct execution of query", containerDefinition, containerOptions);
- const { result: createdCollection } = await client
- .createCollection(database._self, collectionDefinition, collectionOptions);
+ await container.items.create(doc);
+ const query = "SELECT * from " + containerId;
+ const queryOptions = { partitionKey: "pk" };
+ const queryIterator = container.items.query(query, queryOptions);
- const { result: docResult } = await client.createDocument(createdCollection._self, doc);
- const collectionLink = "/dbs/" + databaseId + "/colls/" + collectionId + "/";
- const query = "SELECT * from " + collectionId;
- const queryOptions = { partitionKey: "pk" };
- const queryIterator = client.queryDocuments(collectionLink, query, queryOptions);
-
- const { result } = await queryIterator.toArray();
- assert.equal(result[0]["id"], "myId");
- } catch (err) {
- throw err;
- }
+ const { result } = await queryIterator.toArray();
+ assert.equal(result[0]["id"], "myId");
});
});
describe("Test Query Metrics On Single Partition Collection", function () {
- const client = new CosmosClient(host, { masterKey });
- const databaseId = "testDatabase";
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
+ const databaseId = "query metrics test db";
const collectionId = "testCollection2";
const testQueryMetricsOnSinglePartition = async function (document: any) {
try {
const databaseBody = { id: databaseId };
- const { result: database } = await client.createDatabase(databaseBody);
+ const { result: databaseDef } = await client.databases.create(databaseBody);
+ const database = client.databases.get(databaseDef.id);
const collectionDefinition = { id: collectionId };
const collectionOptions = { offerThroughput: 4000 };
- const { result: createdCollection } =
- await client.createCollection(database._self, collectionDefinition, collectionOptions);
+ const { result: createdCollectionDef } =
+ await database.containers.create(collectionDefinition, collectionOptions);
+ const createdContainer = database.containers.get(createdCollectionDef.id);
- await client.createDocument(createdCollection._self, document);
+ await createdContainer.items.create(document);
const collectionLink = "/dbs/" + databaseId + "/colls/" + collectionId + "/";
const query = "SELECT * from " + collectionId;
const queryOptions: FeedOptions = { populateQueryMetrics: true };
- const queryIterator = client.queryDocuments(collectionLink, query, queryOptions);
+ const queryIterator = createdContainer.items.query(query, queryOptions);
while (queryIterator.hasMoreResults()) {
const { result: results, headers } = await queryIterator.executeNext();
@@ -83,26 +81,14 @@ describe("Test Query Metrics On Single Partition Collection", function () {
};
afterEach(async function () {
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(client);
});
beforeEach(async function () {
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(client);
});
it("validate that query metrics are correct for a single partition query", async function () {
- try {
- await testQueryMetricsOnSinglePartition(doc);
- } catch (err) {
- throw err;
- }
+ await testQueryMetricsOnSinglePartition(doc);
});
});
diff --git a/src/test/integration/retry.spec.ts b/src/test/integration/retry.spec.ts
index 427a28e..9af7a71 100644
--- a/src/test/integration/retry.spec.ts
+++ b/src/test/integration/retry.spec.ts
@@ -1,11 +1,9 @@
import * as assert from "assert";
-import * as sinon from "sinon";
-import * as stream from "stream";
import { AzureDocuments, Constants, CosmosClient, RetryOptions } from "../..";
import * as request from "../../request";
import testConfig from "../common/_testConfig";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
describe("retry policy tests", function () {
@@ -46,13 +44,13 @@ describe("retry policy tests", function () {
// TODO: need to fix this, the stubbing doesn't work with the new way we work
xit("throttle retry policy test default retryAfter", async function () {
- connectionPolicy.RetryOptions = new RetryOptions(5);
+ // connectionPolicy.RetryOptions = new RetryOptions(5);
- const client = new CosmosClient(host, { masterKey }, connectionPolicy);
+ // const client = new CosmosClient({endpoint, auth: { masterKey }, connectionPolicy});
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ // const { result: db } = await client.createDatabase({ id: "sample database" });
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ // const { result: collection } = await client.createCollection(db._self, collectionDefinition);
// const originalGetDatabaseAccount = client.getDatabaseAccount;
// client.getDatabaseAccount = mockGetDatabaseAccount;
@@ -60,30 +58,30 @@ describe("retry policy tests", function () {
// const originalCreateRequestObjectStub = request._createRequestObjectStub;
// request._createRequestObjectStub = mockCreateRequestObjectStub;
- try {
- const { result: createdDocument } =
- await client.createDocument(collection._self, documentDefinition);
- } catch (err) {
- const responseHeaders = (err as request.ErrorResponse).headers;
- assert.equal(err.code, 429, "invalid error code");
- assert.equal(responseHeaders[Constants.ThrottleRetryCount],
- connectionPolicy.RetryOptions.MaxRetryAttemptCount, "Current retry attempts not maxed out");
- assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs]
- >= connectionPolicy.RetryOptions.MaxRetryAttemptCount * retryAfterInMilliseconds);
+ // try {
+ // const { result: createdDocument } =
+ // await client.createDocument(collection._self, documentDefinition);
+ // } catch (err) {
+ // const responseHeaders = (err as request.ErrorResponse).headers;
+ // assert.equal(err.code, 429, "invalid error code");
+ // assert.equal(responseHeaders[Constants.ThrottleRetryCount],
+ // connectionPolicy.RetryOptions.MaxRetryAttemptCount, "Current retry attempts not maxed out");
+ // assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs]
+ // >= connectionPolicy.RetryOptions.MaxRetryAttemptCount * retryAfterInMilliseconds);
- }
+ // }
// request._createRequestObjectStub = originalCreateRequestObjectStub;
// client.getDatabaseAccount = originalGetDatabaseAccount;
});
xit("throttle retry policy test fixed retryAfter", async function () {
- connectionPolicy.RetryOptions = new RetryOptions(5, 2000);
+ // connectionPolicy.RetryOptions = new RetryOptions(5, 2000);
- const client = new CosmosClient(host, { masterKey }, connectionPolicy);
+ // const client = new CosmosClient(endpoint, { masterKey }, connectionPolicy);
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ // const { result: db } = await client.createDatabase({ id: "sample database" });
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ // const { result: collection } = await client.createCollection(db._self, collectionDefinition);
// const originalGetDatabaseAccount = client.getDatabaseAccount;
// client.getDatabaseAccount = mockGetDatabaseAccount;
@@ -91,31 +89,31 @@ describe("retry policy tests", function () {
// const originalCreateRequestObjectStub = request._createRequestObjectStub;
// request._createRequestObjectStub = mockCreateRequestObjectStub;
- try {
- await client.createDocument(collection._self, documentDefinition);
- assert.fail("Must throw");
- } catch (err) {
- const responseHeaders = (err as request.ErrorResponse).headers;
- assert.equal(err.code, 429, "invalid error code");
- assert.equal(responseHeaders[Constants.ThrottleRetryCount],
- connectionPolicy.RetryOptions.MaxRetryAttemptCount, "Current retry attempts not maxed out");
- assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs]
- >= connectionPolicy.RetryOptions.MaxRetryAttemptCount
- * connectionPolicy.RetryOptions.FixedRetryIntervalInMilliseconds);
- }
+ // try {
+ // await client.createDocument(collection._self, documentDefinition);
+ // assert.fail("Must throw");
+ // } catch (err) {
+ // const responseHeaders = (err as request.ErrorResponse).headers;
+ // assert.equal(err.code, 429, "invalid error code");
+ // assert.equal(responseHeaders[Constants.ThrottleRetryCount],
+ // connectionPolicy.RetryOptions.MaxRetryAttemptCount, "Current retry attempts not maxed out");
+ // assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs]
+ // >= connectionPolicy.RetryOptions.MaxRetryAttemptCount
+ // * connectionPolicy.RetryOptions.FixedRetryIntervalInMilliseconds);
+ // }
// request._createRequestObjectStub = originalCreateRequestObjectStub;
// client.getDatabaseAccount = originalGetDatabaseAccount;
});
xit("throttle retry policy test max wait time", async function () {
- connectionPolicy.RetryOptions = new RetryOptions(5, 2000, 3);
+ // connectionPolicy.RetryOptions = new RetryOptions(5, 2000, 3);
- const client = new CosmosClient(host, { masterKey }, connectionPolicy);
+ // const client = new CosmosClient(endpoint, { masterKey }, connectionPolicy);
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ // const { result: db } = await client.createDatabase({ id: "sample database" });
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ // const { result: collection } = await client.createCollection(db._self, collectionDefinition);
// const originalGetDatabaseAccount = client.getDatabaseAccount;
// client.getDatabaseAccount = mockGetDatabaseAccount;
@@ -123,57 +121,57 @@ describe("retry policy tests", function () {
// const originalCreateRequestObjectStub = request._createRequestObjectStub;
// request._createRequestObjectStub = mockCreateRequestObjectStub;
- try {
- await client.createDocument(collection._self, documentDefinition);
- } catch (err) {
- const responseHeaders = (err as request.ErrorResponse).headers;
- assert.equal(err.code, 429, "invalid error code");
- assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs]
- >= connectionPolicy.RetryOptions.MaxWaitTimeInSeconds * 1000);
- }
+ // try {
+ // await client.createDocument(collection._self, documentDefinition);
+ // } catch (err) {
+ // const responseHeaders = (err as request.ErrorResponse).headers;
+ // assert.equal(err.code, 429, "invalid error code");
+ // assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs]
+ // >= connectionPolicy.RetryOptions.MaxWaitTimeInSeconds * 1000);
+ // }
// request._createRequestObjectStub = originalCreateRequestObjectStub;
// client.getDatabaseAccount = originalGetDatabaseAccount;
});
xit("default retry policy validate create failure", async function () {
- const client = new CosmosClient(host, { masterKey }, connectionPolicy);
+ // const client = new CosmosClient(endpoint, { masterKey }, connectionPolicy);
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ // const { result: db } = await client.createDatabase({ id: "sample database" });
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ // const { result: collection } = await client.createCollection(db._self, collectionDefinition);
// global.originalFunc = request._createRequestObjectStub;
// global.counter = 0;
// request._createRequestObjectStub = mockCreateRequestObjectForDefaultRetryStub;
- try {
- await client.createDocument(collection._self, documentDefinition);
- } catch (err) {
- assert.equal(err.code, "ECONNRESET", "invalid error code");
- // assert.equal(global.counter, 6, "invalid number of retries");
- }
+ // try {
+ // await client.createDocument(collection._self, documentDefinition);
+ // } catch (err) {
+ // assert.equal(err.code, "ECONNRESET", "invalid error code");
+ // // assert.equal(global.counter, 6, "invalid number of retries");
+ // }
// request._createRequestObjectStub = global.originalFunc;
});
xit("default retry policy validate read success", async function () {
- const client = new CosmosClient(host, { masterKey }, connectionPolicy);
+ // const client = new CosmosClient(endpoint, { masterKey }, connectionPolicy);
- const { result: db } = await client.createDatabase({ id: "sample database" });
+ // const { result: db } = await client.createDatabase({ id: "sample database" });
- const { result: collection } = await client.createCollection(db._self, collectionDefinition);
+ // const { result: collection } = await client.createCollection(db._self, collectionDefinition);
- const { result: createdDocument } = await client.createDocument(collection._self, documentDefinition);
+ // const { result: createdDocument } = await client.createDocument(collection._self, documentDefinition);
// global.originalFunc = request._createRequestObjectStub;
// global.counter = 0;
// request._createRequestObjectStub = mockCreateRequestObjectForDefaultRetryStub;
- const { result: readDocument } = await client.readDocument(createdDocument._self);
- assert.equal(readDocument.id, documentDefinition.id, "invalid document id");
+ // const { result: readDocument } = await client.readDocument(createdDocument._self);
+ // assert.equal(readDocument.id, documentDefinition.id, "invalid document id");
// assert.equal(global.counter, 5, "invalid number of retries");
// request._createRequestObjectStub = global.originalFunc;
diff --git a/src/test/integration/ruPerMin.spec.ts b/src/test/integration/ruPerMin.spec.ts
index 31ef1a4..fab28d1 100644
--- a/src/test/integration/ruPerMin.spec.ts
+++ b/src/test/integration/ruPerMin.spec.ts
@@ -1,44 +1,31 @@
import * as assert from "assert";
-import { Base, Constants, CosmosClient, DocumentBase, UriFactory } from "../../";
+import { Constants, CosmosClient, Database } from "../../";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
+const client = new CosmosClient({ endpoint, auth: { masterKey } });
// TODO: these tests are all disabled
describe("RU Per Minute", function () {
- const client = new CosmosClient(host, { masterKey });
-
- let databaseLink: string;
- const createDatabase = async () => {
- const { result: createdDB } = await client.createDatabase({ id: "Database" });
- databaseLink = UriFactory.createDatabaseUri(createdDB.id);
- };
+ let database: Database;
// - removes all the databases,
// - creates a new database,
beforeEach(async () => {
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- await createDatabase();
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(client);
+ database = await TestHelpers.getTestDatabase(client, "RU Per minute");
});
// - removes all the databases,
afterEach(async () => {
- try {
- await TestHelpers.removeAllDatabases(host, masterKey);
- } catch (err) {
- throw err;
- }
+ await TestHelpers.removeAllDatabases(client);
});
- xit("Create Collection with RU Per Minute Offer", function (done) {
- const collectionDefinition = {
+ xit("Create container with RU Per Minute Offer", async function () {
+ const containerDefinition = {
id: "sample col",
};
@@ -48,27 +35,18 @@ describe("RU Per Minute", function () {
offerThroughput: 400,
};
- client.createCollection(databaseLink, collectionDefinition, options, function (err, collection) {
- assert.equal(err, undefined, "Error in creating collection");
+ await database.containers.create(containerDefinition, options);
+ const { result: offers } = await client.offers.readAll().toArray();
+ assert.equal(offers.length, 1);
+ const offer = offers[0];
- const validateOffer = function (error: any, offers: any) {
- assert.equal(error, undefined, "unexpected failure in reading offers");
- assert.equal(offers.length, 1);
- const offer = offers[0];
-
- assert.equal(offer.offerType, "Invalid");
- assert.notEqual(offer.content, undefined);
- assert.equal(offer.content.offerIsRUPerMinuteThroughputEnabled, true);
-
- done();
- };
-
- const queryIterator = client.readOffers().toArray(validateOffer);
- });
+ assert.equal(offer.offerType, "Invalid");
+ assert.notEqual(offer.content, undefined);
+ assert.equal(offer.content.offerIsRUPerMinuteThroughputEnabled, true);
});
- xit("Create Collection without RU Per Minute Offer", function (done) {
- const collectionDefinition = {
+ xit("Create container without RU Per Minute Offer", async function () {
+ const containerDefinition = {
id: "sample col",
};
@@ -77,49 +55,36 @@ describe("RU Per Minute", function () {
offerThroughput: 400,
};
- client.createCollection(databaseLink, collectionDefinition, options, function (err, collection) {
- assert.equal(err, undefined, "Error in creating collection");
+ await database.containers.create(containerDefinition, options);
+ const { result: offers } = await client.offers.readAll().toArray();
+ assert.equal(offers.length, 1);
+ const offer = offers[0];
- const validateOffer = function (error: any, offers: any) {
- assert.equal(error, undefined, "unexpected failure in reading offers");
- assert.equal(offers.length, 1);
- const offer = offers[0];
-
- assert.equal(offer.offerType, "Invalid");
- assert.notEqual(offer.content, undefined);
- assert.equal(offer.content.offerIsRUPerMinuteThroughputEnabled, false);
-
- done();
- };
-
- const queryIterator = client.readOffers().toArray(validateOffer);
- });
+ assert.equal(offer.offerType, "Invalid");
+ assert.notEqual(offer.content, undefined);
+ assert.equal(offer.content.offerIsRUPerMinuteThroughputEnabled, false);
});
- xit("Create Collection with RU Per Minute Offer and insert Document with disableRUPerMinuteUsage options",
- function (done) {
- const collectionDefinition = {
- id: "sample col",
- };
+ xit("Create container with RU Per Minute Offer and insert Document with disableRUPerMinuteUsage options",
+ async function () {
+ const containerDefinition = {
+ id: "sample col",
+ };
- const options = {
- offerEnableRUPerMinuteThroughput: true,
- offerVersion: "V2",
- offerThroughput: 400,
- };
+ const options = {
+ offerEnableRUPerMinuteThroughput: true,
+ offerVersion: "V2",
+ offerThroughput: 400,
+ };
- client.createCollection(databaseLink, collectionDefinition, options, function (err, collection) {
- assert.equal(err, undefined, "Error in creating collection");
- const collectionLink = collection._self;
+ await database.containers.create(containerDefinition, options);
+ const container = database.containers.get(containerDefinition.id);
const options2: any = {
disableRUPerMinuteUsage: true,
};
- client.createDocument(collectionLink, { id: "sample document" },
- options2, function (err2, document, headers) {
- assert.equal(err2, undefined, "Error in creating document");
- assert(headers[Constants.HttpHeaders.IsRUPerMinuteUsed] !== true);
- done();
- });
+ const { headers } = await container.items.create({ id: "sample document" },
+ options2);
+ assert(headers[Constants.HttpHeaders.IsRUPerMinuteUsed] !== true);
+
});
- });
});
diff --git a/src/test/integration/session.spec.ts b/src/test/integration/session.spec.ts
index 2a64855..b9789f9 100644
--- a/src/test/integration/session.spec.ts
+++ b/src/test/integration/session.spec.ts
@@ -1,30 +1,31 @@
import * as assert from "assert";
import * as sinon from "sinon";
import { Base, Constants, CosmosClient, IHeaders } from "../../";
-import { ConsistencyLevel } from "../../documents";
+import { ConsistencyLevel, PartitionKind } from "../../documents";
import testConfig from "./../common/_testConfig";
import { TestHelpers } from "./../common/TestHelpers";
-const host = testConfig.host;
+const endpoint = testConfig.host;
const masterKey = testConfig.masterKey;
// TODO: there is alot of "any" types for tokens here
+// TODO: there is alot of leaky document client stuff here that will make removing document client hard
describe("Session Token", function () {
- this.timeout(10000);
- const client = new CosmosClient(host, { masterKey }, null, ConsistencyLevel.Session);
+ this.timeout(process.env.MOCHA_TIMEOUT || 20000);
+ const client = new CosmosClient({ endpoint, auth: { masterKey }, consistencyLevel: ConsistencyLevel.Session });
const databaseId = "sessionTestDB";
- const collectionId = "sessionTestColl";
- const collectionLink = "dbs/" + databaseId + "/colls/" + collectionId;
+ const containerId = "sessionTestColl";
+ const containerLink = "dbs/" + databaseId + "/colls/" + containerId;
const databaseBody = { id: databaseId };
- const collectionDefinition = { id: collectionId, partitionKey: { paths: ["/id"], kind: "Hash" } };
- const collectionOptions = { offerThroughput: 10100 };
+ const containerDefinition = { id: containerId, partitionKey: { paths: ["/id"], kind: PartitionKind.Hash } };
+ const containerOptions = { offerThroughput: 10100 };
- const getSpy = sinon.spy(client, "get");
- const postSpy = sinon.spy(client, "post");
- const putSpy = sinon.spy(client, "put");
- const deleteSpy = sinon.spy(client, "delete");
+ const getSpy = sinon.spy(client.documentClient, "get");
+ const postSpy = sinon.spy(client.documentClient, "post");
+ const putSpy = sinon.spy(client.documentClient, "put");
+ const deleteSpy = sinon.spy(client.documentClient, "delete");
const getToken = function (tokens: any) {
const newToken: any = {};
@@ -49,88 +50,90 @@ describe("Session Token", function () {
}
};
- afterEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
- beforeEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
+ afterEach(async function () { await TestHelpers.removeAllDatabases(client); });
+ beforeEach(async function () { await TestHelpers.removeAllDatabases(client); });
it("validate session tokens for sequence of opearations", async function () {
let index1;
let index2;
- const { result: database } = await client.createDatabase(databaseBody);
+ const { result: databaseDef } = await client.databases.create(databaseBody);
+ const database = client.databases.get(databaseDef.id);
- const { result: createdCollection } =
- await client.createCollection(database._self, collectionDefinition, collectionOptions as any);
+ const { result: createdContainerDef } =
+ await database.containers.create(containerDefinition, containerOptions);
+ const container = database.containers.get(createdContainerDef.id);
assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], undefined);
- // TODO: testing implementation detail by looking at collectionResourceIdToSesssionTokens
- assert.deepEqual(client.sessionContainer.collectionResourceIdToSessionTokens, {});
+ // TODO: testing implementation detail by looking at containerResourceIdToSesssionTokens
+ assert.deepEqual(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens, {});
- const { result: document1 } = await client.createDocument(collectionLink, { id: "1" });
+ const { result: document1 } = await container.items.create({ id: "1" });
assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], undefined);
- let tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
+ let tokens = getToken(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens);
index1 = getIndex(tokens);
assert.notEqual(tokens[index1], undefined);
let firstPartitionLSN = tokens[index1];
- const { result: document2 } = await client.createDocument(collectionLink, { id: "2" });
+ const { result: document2 } = await container.items.create({ id: "2" });
assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken],
- client.sessionContainer.getCombinedSessionToken(tokens));
+ client.documentClient.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
+ tokens = getToken(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens);
index2 = getIndex(tokens, index1);
assert.equal(tokens[index1], firstPartitionLSN);
assert.notEqual(tokens[index2], undefined);
let secondPartitionLSN = tokens[index2];
- const { result: document12 } = await client.readDocument(document1._self, { partitionKey: "1" });
+ const { result: document12 } = await container.items.get(document1.id, "1").read();
assert.equal(getSpy.lastCall.args[2][Constants.HttpHeaders.SessionToken],
- client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
+ client.documentClient.sessionContainer.getCombinedSessionToken(tokens));
+ tokens = getToken(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens);
assert.equal(tokens[index1], firstPartitionLSN);
assert.equal(tokens[index2], secondPartitionLSN);
const { result: document13 } =
- await client.upsertDocument(createdCollection._self,
- { id: "1", operation: "upsert" }, { partitionKey: "1" });
+ await container.items.upsert({ id: "1", operation: "upsert" }, { partitionKey: "1" });
assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken],
- client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
+ client.documentClient.sessionContainer.getCombinedSessionToken(tokens));
+ tokens = getToken(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens);
assert.equal(tokens[index1], (Number(firstPartitionLSN) + 1).toString());
assert.equal(tokens[index2], secondPartitionLSN);
firstPartitionLSN = tokens[index1];
- const { result: document22 } = await client.deleteDocument(document2._self, { partitionKey: "2" });
+ const { result: document22 } = await container.items.get(document2.id, "2").delete();
assert.equal(deleteSpy.lastCall.args[2][Constants.HttpHeaders.SessionToken],
- client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
+ client.documentClient.sessionContainer.getCombinedSessionToken(tokens));
+ tokens = getToken(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens);
assert.equal(tokens[index1], firstPartitionLSN);
assert.equal(tokens[index2], (Number(secondPartitionLSN) + 1).toString());
secondPartitionLSN = tokens[index2];
const { result: document14 } =
- await client.replaceDocument(document13._self, { id: "1", operation: "replace" }, { partitionKey: "1" });
+ await container.items.get(document13.id)
+ .replace({ id: "1", operation: "replace" }, { partitionKey: "1" });
assert.equal(putSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken],
- client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
+ client.documentClient.sessionContainer.getCombinedSessionToken(tokens));
+ tokens = getToken(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens);
assert.equal(tokens[index1], (Number(firstPartitionLSN) + 1).toString());
assert.equal(tokens[index2], secondPartitionLSN);
firstPartitionLSN = tokens[index1];
- const query = "SELECT * from " + collectionId;
+ const query = "SELECT * from " + containerId;
const queryOptions = { partitionKey: "1" };
- const queryIterator = client.queryDocuments(collectionLink, query, queryOptions);
+ const queryIterator = container.items.query(query, queryOptions);
const { result } = await queryIterator.toArray();
assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken],
- client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
+ client.documentClient.sessionContainer.getCombinedSessionToken(tokens));
+ tokens = getToken(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens);
assert.equal(tokens[index1], firstPartitionLSN);
assert.equal(tokens[index2], secondPartitionLSN);
- const { result: result2 } = await client.deleteCollection(createdCollection._self);
+ await container.delete();
assert.equal(deleteSpy.lastCall.args[2][Constants.HttpHeaders.SessionToken],
- client.sessionContainer.getCombinedSessionToken(tokens));
- assert.deepEqual(client.sessionContainer.collectionResourceIdToSessionTokens, {});
+ client.documentClient.sessionContainer.getCombinedSessionToken(tokens));
+ assert.deepEqual(client.documentClient.sessionContainer.collectionResourceIdToSessionTokens, {});
getSpy.restore();
postSpy.restore();
@@ -139,85 +142,94 @@ describe("Session Token", function () {
});
it("validate 'lsn not caught up' error for higher lsn and clearing session token", async function () {
- try {
- const { result: database } = await client.createDatabase(databaseBody);
-
- const increaseLSN = function (oldTokens: any) {
- for (const coll in oldTokens) {
- if (oldTokens.hasOwnProperty(coll)) {
- for (const token in oldTokens[coll]) {
- if (oldTokens[coll].hasOwnProperty(token)) {
- const newVal = (Number(oldTokens[coll][token]) + 2000).toString();
- return token + ":" + newVal;
- }
+ const { result: databaseDef } = await client.databases.create(databaseBody);
+ const database = client.databases.get(databaseDef.id);
+ const increaseLSN = function (oldTokens: any) {
+ for (const coll in oldTokens) {
+ if (oldTokens.hasOwnProperty(coll)) {
+ for (const token in oldTokens[coll]) {
+ if (oldTokens[coll].hasOwnProperty(token)) {
+ const newVal = (Number(oldTokens[coll][token]) + 2000).toString();
+ return token + ":" + newVal;
}
}
}
- };
-
- const { result: createCollection } =
- await client.createCollection(database._self, collectionDefinition, collectionOptions);
- const { result: document1 } = await client.createDocument(collectionLink, { id: "1" });
- const callbackSpy = sinon.spy(function (pat: string, reqHeaders: IHeaders) {
- const oldTokens = client.sessionContainer.collectionResourceIdToSessionTokens;
- reqHeaders[Constants.HttpHeaders.SessionToken] = increaseLSN(oldTokens);
- });
- const applySessionTokenStub = sinon.stub(client, "applySessionToken").callsFake(callbackSpy);
- try {
- const { result: document11 } =
- await client.readDocument(collectionLink + "/docs/1", { partitionKey: "1" });
- assert.fail("readDocument must throw");
- } catch (err) {
- assert.equal(err.substatus, 1002, "Substatus should indicate the LSN didn't catchup.");
- assert.equal(callbackSpy.callCount, 1);
- assert.equal(Base._trimSlashes(callbackSpy.lastCall.args[0]), collectionLink + "/docs/1");
- applySessionTokenStub.restore();
}
- const { result: document12 } = await client.readDocument(collectionLink + "/docs/1", { partitionKey: "1" });
- } catch (err) {
- throw err;
- }
- });
-
- // tslint:disable-next-line:max-line-length
- it("validate session container update on 'Not found' with 'undefined' status code for non master resource", async function () {
- const client2 = new CosmosClient(host, { masterKey }, null, ConsistencyLevel.Session);
- const { result: database } = await client.createDatabase(databaseBody);
-
- const { result: createdCollection } =
- await client.createCollection(database._self, collectionDefinition, collectionOptions);
-
- const { result: createdDocument } = await client.createDocument(createdCollection._self, { id: "1" });
- const requestOptions = { partitionKey: "1" };
-
- const { result: document2 } = await client2.deleteDocument(createdDocument._self, requestOptions);
- const setSessionTokenSpy = sinon.spy(client.sessionContainer, "setSessionToken");
+ };
+ await database.containers.create(containerDefinition, containerOptions);
+ const container = database.containers.get(containerDefinition.id);
+ await container.items.create({ id: "1" });
+ const callbackSpy = sinon.spy(function (pat: string, reqHeaders: IHeaders) {
+ const oldTokens = client.documentClient.sessionContainer.collectionResourceIdToSessionTokens;
+ reqHeaders[Constants.HttpHeaders.SessionToken] = increaseLSN(oldTokens);
+ });
+ const applySessionTokenStub = sinon.stub(client.documentClient, "applySessionToken").callsFake(callbackSpy);
try {
- const { result: readDocument } = await client.readDocument(createdDocument._self, requestOptions);
- assert.fail("Must throw");
+ await container.items.get("1").read({ partitionKey: "1" });
+ assert.fail("readDocument must throw");
} catch (err) {
- assert.equal(err.code, 404, "expecting 404 (Not found)");
- assert.equal(err.substatus, undefined, "expecting substatus code to be undefined");
- assert.equal(setSessionTokenSpy.callCount, 1, "unexpected number of calls to sesSessionToken");
- setSessionTokenSpy.restore();
+ assert.equal(err.substatus, 1002, "Substatus should indicate the LSN didn't catchup.");
+ assert.equal(callbackSpy.callCount, 1);
+ assert.equal(Base._trimSlashes(callbackSpy.lastCall.args[0]), containerLink + "/docs/1");
+ applySessionTokenStub.restore();
}
+ await container.items.get("1").read({ partitionKey: "1" });
});
- it("validate client should not have session token of a collection created by another client", async function () {
- const client2 = new CosmosClient(host, { masterKey }, null, ConsistencyLevel.Session);
+ // TODO: chrande - looks like this might be broken by going name based?
+ // We never had a name based version of this test. Looks like we fail to set the session token
+ // because OwnerId is missing on the header. This only happens for name based.
+ it.skip("client should not have session token of a container created by another client", async function () {
+ const client2 = new CosmosClient({ endpoint, auth: { masterKey }, consistencyLevel: ConsistencyLevel.Session });
- const { result: database } = await client.createDatabase(databaseBody);
- const { result: createdCollection } =
- await client.createCollection(database._self, collectionDefinition, collectionOptions);
- const { result: collection } = await client.readCollection(createdCollection._self);
- const { result: deletedCollection } = await client2.deleteCollection(createdCollection._self);
+ const { result: databaseDef } = await client.databases.create(databaseBody);
+ const database = client.databases.get(databaseDef.id);
+ await database.containers.create(containerDefinition, containerOptions);
+ const container = database.containers.get(containerDefinition.id);
+ await container.read();
+ await client2.databases.get(databaseDef.id)
+ .containers.get(containerDefinition.id)
+ .delete();
const { result: createdCollection2 } =
- await client2.createCollection(database._self, collectionDefinition, collectionOptions);
+ await client2.databases.get(databaseDef.id)
+ .containers.create(containerDefinition, containerOptions);
- const { result: collection2 } = await client2.readCollection(createdCollection2._self);
- assert.equal(client.getSessionToken(collection2._self), "");
- assert.notEqual(client2.getSessionToken(collection2._self), "");
+ const { result: collection2 } = await client2.databases.get(databaseDef.id)
+ .containers.get(containerDefinition.id)
+ .read();
+ assert.equal(client.documentClient.getSessionToken(container.url), ""); // TODO: _self
+ assert.notEqual(client2.documentClient.getSessionToken(container.url), "");
});
+
+ it("validate session container update on 'Not found' with 'undefined' status code for non master resource",
+ async function () {
+ const client2 = new CosmosClient({
+ endpoint, auth: { masterKey }, consistencyLevel: ConsistencyLevel.Session,
+ });
+ const { result: databaseDef } = await client.databases.create(databaseBody);
+ const db = client.databases.get(databaseDef.id);
+
+ const { result: createdContainerDef } =
+ await db.containers.create(containerDefinition, containerOptions);
+ const createdContainer = db.containers.get(createdContainerDef.id);
+
+ const { result: createdDocument } = await createdContainer.items.create({ id: "1" });
+ const requestOptions = { partitionKey: "1" };
+ await client2.databases.get(databaseDef.id)
+ .containers.get(createdContainerDef.id)
+ .items.get(createdDocument.id).delete(requestOptions);
+ const setSessionTokenSpy = sinon.spy(client.documentClient.sessionContainer, "setSessionToken");
+
+ try {
+ await createdContainer.items.get(createdDocument.id).read(requestOptions);
+ assert.fail("Must throw");
+ } catch (err) {
+ assert.equal(err.code, 404, "expecting 404 (Not found)");
+ assert.equal(err.substatus, undefined, "expecting substatus code to be undefined");
+ assert.equal(setSessionTokenSpy.callCount, 1, "unexpected number of calls to sesSessionToken");
+ setSessionTokenSpy.restore();
+ }
+ });
});
diff --git a/src/test/integration/sslVerification.spec.ts b/src/test/integration/sslVerification.spec.ts
index 296fd32..d0ec6ab 100644
--- a/src/test/integration/sslVerification.spec.ts
+++ b/src/test/integration/sslVerification.spec.ts
@@ -1,7 +1,7 @@
import * as assert from "assert";
import { Base, CosmosClient, DocumentBase } from "../../";
-const host = "https://localhost:443";
+const endpoint = "https://localhost:443";
const masterKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
// TODO: Skipping these tests for now until we find a way to run these tests in a seperate nodejs process
@@ -10,9 +10,9 @@ const masterKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGG
describe.skip("Validate SSL verification check for emulator", function () {
it("nativeApi Client Should throw exception", async function () {
try {
- const client = new CosmosClient(host, { masterKey });
+ const client = new CosmosClient({ endpoint, auth: { masterKey } });
// create database
- await client.createDatabase({ id: Base.generateGuidId() });
+ await client.databases.create({ id: Base.generateGuidId() });
} catch (err) {
// connecting to emulator should throw SSL verification error,
// unless you explicitly disable it via connectionPolicy.DisableSSLVerification
@@ -21,17 +21,15 @@ describe.skip("Validate SSL verification check for emulator", function () {
});
it("nativeApi Client Should successfully execute request", async function () {
- try {
- const connectionPolicy = new DocumentBase.ConnectionPolicy();
- // Disable SSL verification explicitly
- connectionPolicy.DisableSSLVerification = true;
- const client = new CosmosClient(host, { masterKey },
- connectionPolicy);
+ const connectionPolicy = new DocumentBase.ConnectionPolicy();
+ // Disable SSL verification explicitly
+ connectionPolicy.DisableSSLVerification = true;
+ const client = new CosmosClient({
+ endpoint, auth: { masterKey },
+ connectionPolicy,
+ });
- // create database
- await client.createDatabase({ id: Base.generateGuidId() });
- } catch (err) {
- throw err;
- }
+ // create database
+ await client.databases.create({ id: Base.generateGuidId() });
});
});
diff --git a/src/test/integration/uriFactory.spec.ts b/src/test/integration/uriFactory.spec.ts
deleted file mode 100644
index adb2df6..0000000
--- a/src/test/integration/uriFactory.spec.ts
+++ /dev/null
@@ -1,289 +0,0 @@
-import * as assert from "assert";
-import { CosmosClient, UriFactory } from "../../";
-import testConfig from "./../common/_testConfig";
-import { TestHelpers } from "./../common/TestHelpers";
-
-const host = testConfig.host;
-const masterKey = testConfig.masterKey;
-
-describe("URI Factory Tests", function () {
-
- const executeExceptionThrowingFunction = function (func: () => void) {
- let isThrown = false;
- try {
- func();
- } catch (err) {
- isThrown = true;
- }
- assert(isThrown, "function did not throw an exception");
- };
-
- describe("Create Database URI", function () {
- const createDatabaseUriTest = function (dbId: string, expectedUri: string) {
- assert.equal(UriFactory.createDatabaseUri(dbId), expectedUri, "error invalid database URI");
- };
-
- it("Normal database Id", function () {
- createDatabaseUriTest("database1", "dbs/database1");
- });
-
- it("Empty database Id", function () {
- executeExceptionThrowingFunction(function () {
- createDatabaseUriTest("", "exception");
- });
- });
-
- it("Database Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createDatabaseUriTest("db?1", "exception");
- });
- });
- });
-
- describe("Create Collection URI", function () {
- const createCollectionUriTest = function (dbId: string, collId: string, expectedUri: string) {
- assert.equal(UriFactory.createDocumentCollectionUri(dbId, collId), expectedUri);
- };
-
- it("Normal database & collection IDs", function () {
- createCollectionUriTest("db1", "col1", "dbs/db1/colls/col1");
- });
-
- it("Empty collection Id", function () {
- executeExceptionThrowingFunction(function () {
- createCollectionUriTest("db1", "", "must throw exception");
- });
- });
-
- it("Collection Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createCollectionUriTest("db1", "coll?", "exception");
- });
- });
- });
-
- describe("Create User URI", function () {
- const createUserUriTest = function (dbId: string, userId: string, expectedUri: string) {
- assert.equal(UriFactory.createUserUri(dbId, userId), expectedUri);
- };
-
- it("Noramal Database Id & User Id", function () {
- createUserUriTest("db1", "user1", "dbs/db1/users/user1");
- });
-
- it("Empty user Id", function () {
- executeExceptionThrowingFunction(function () {
- createUserUriTest("db1", null, "exception");
- });
- });
-
- it("User Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createUserUriTest("db1", "user\\1", "exception");
- });
- });
-
- });
-
- describe("Create Document URI", function () {
- const createDocumentUriTest = function (dbId: string, collId: string, docId: string, expectedUri: string) {
- assert.equal(UriFactory.createDocumentUri(dbId, collId, docId), expectedUri);
- };
-
- it("Normal database Id, collection Id and, document Id", function () {
- createDocumentUriTest("db1", "coll1", "doc1", "dbs/db1/colls/coll1/docs/doc1");
- });
-
- it("Empty document Id", function () {
- executeExceptionThrowingFunction(function () {
- createDocumentUriTest("db1", "coll1", undefined, "exception");
- });
- });
-
- it("Document Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createDocumentUriTest("db1", "coll1", "?doc1", "exception");
- });
- });
- });
-
- describe("Create Permission URI", function () {
- const createPermissionUriTest = function (dbId: string, userId: string, permId: string, expectedUri: string) {
- assert.equal(UriFactory.createPermissionUri(dbId, userId, permId), expectedUri);
- };
-
- it("Normal database Id, user Id and, permission Id", function () {
- createPermissionUriTest("db1", "user1", "perm1", "dbs/db1/users/user1/permissions/perm1");
- });
-
- it("Empty permission Id", function () {
- executeExceptionThrowingFunction(function () {
- createPermissionUriTest("db1", "user1", " ", "exception");
- });
- });
-
- it("Permission Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createPermissionUriTest("db1", "user1", "perm/1", "exception");
- });
- });
- });
-
- describe("Create StoredProcedure URI", function () {
- const createStoredProcedureUriTest =
- function (dbId: string, collId: string, sprocId: string, expectedUri: string) {
- assert.equal(UriFactory.createStoredProcedureUri(dbId, collId, sprocId), expectedUri);
- };
-
- it("Normal database Id, collection Id and, storedProcedure Id", function () {
- createStoredProcedureUriTest("db1", "col1", "sproc1", "dbs/db1/colls/col1/sprocs/sproc1");
- });
-
- it("Empty storedProcedure Id", function () {
- executeExceptionThrowingFunction(function () {
- createStoredProcedureUriTest("db1", "col1", "", "exception");
- });
- });
-
- it("StoredProcedure Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createStoredProcedureUriTest("db1", "col1", "\sproc 1", "exception");
- });
- });
- });
-
- describe("Create Trigger URI", function () {
- const createTriggerUriTest = function (dbId: string, collId: string, trgId: string, expectedUri: string) {
- assert.equal(UriFactory.createTriggerUri(dbId, collId, trgId), expectedUri);
- };
-
- it("Normal database Id, collection Id and, trigger Id", function () {
- createTriggerUriTest("db1", "col1", "trig1", "dbs/db1/colls/col1/triggers/trig1");
- });
-
- it("Empty trigger Id", function () {
- executeExceptionThrowingFunction(function () {
- createTriggerUriTest("db1", "col1", null, "exception");
- });
- });
-
- it("trigger Id with illegals chars", function () {
- executeExceptionThrowingFunction(function () {
- createTriggerUriTest("db1", "col1", "tr?iger", "exception");
- });
- });
- });
-
- describe("Create User-Defined-Function URI", function () {
- const createUserDefinedFunctionUriTest =
- function (dbId: string, collId: string, udfId: string, expectedUri: string) {
- assert.equal(UriFactory.createUserDefinedFunctionUri(dbId, collId, udfId), expectedUri);
- };
-
- it("Normal database Id, collection Id and, UDF Id", function () {
- createUserDefinedFunctionUriTest("db1", "col1", "udf1", "dbs/db1/colls/col1/udfs/udf1");
- });
-
- it("Empty UDF Id", function () {
- executeExceptionThrowingFunction(function () {
- createUserDefinedFunctionUriTest("db1", "col1", undefined, "exception");
- });
- });
-
- it("UDF Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createUserDefinedFunctionUriTest("db1", "col1", "u/df1/", "exception");
- });
- });
- });
-
- describe("Create Conflict URI", function () {
- const createConflictUriTest = function (dbId: string, collId: string, confId: string, expectedUri: string) {
- assert.equal(UriFactory.createConflictUri(dbId, collId, confId), expectedUri);
- };
-
- it("Normal database Id, collection Id and, conflict Id", function () {
- createConflictUriTest("db1", "col1", "conf1", "dbs/db1/colls/col1/conflicts/conf1");
- });
-
- it("Empty conflict Id", function () {
- executeExceptionThrowingFunction(function () {
- createConflictUriTest("db1", "col1", " ", "exception");
- });
- });
-
- it("Conflict Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createConflictUriTest("db1", "col1", "\\conf\\1", "exception");
- });
- });
- });
-
- describe("Create Attachment URI", function () {
- const createAttachmentUriTest =
- function (dbId: string, collId: string, docId: string, atchId: string, expectedUri: string) {
- assert.equal(UriFactory.createAttachmentUri(dbId, collId, docId, atchId), expectedUri);
- };
-
- it("Normal database Id, collection Id and, document Id, attachmentId", function () {
- createAttachmentUriTest("db1", "coll1", "doc1", "atch1", "dbs/db1/colls/coll1/docs/doc1/attachments/atch1");
- });
-
- it("Empty attachment Id", function () {
- executeExceptionThrowingFunction(function () {
- createAttachmentUriTest("db1", "coll1", "doc1", null, "exception");
- });
- });
-
- it("Attachment Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createAttachmentUriTest("db1", "coll1", "d ?oc1", "atch?#1", "exception");
- });
- });
- });
-
- describe("Create PartitionKeyRanges URI", function () {
- const createPartitionKeyRangesUriTest = function (dbId: string, collId: string, expectedUir: string) {
- assert.equal(UriFactory.createPartitionKeyRangesUri(dbId, collId), expectedUir);
- };
-
- it("Normal database & collection IDs", function () {
- createPartitionKeyRangesUriTest("db1", "col1", "dbs/db1/colls/col1/pkranges");
- });
- });
-
- describe("Use uriFactory in integration with other methods", function () {
- const testDatabaseId = "uriFactoryTestDb";
-
- const client = new CosmosClient(host, { masterKey });
-
- const createDocumentUsingUriFactory =
- async function (databaseId: string, collectionId: string, documentId: string) {
- const { result: database } = await client.createDatabase({ id: databaseId });
- assert.equal(database.id, databaseId, "invalid database Id");
-
- const databaseUri = UriFactory.createDatabaseUri(databaseId);
- const collectionBody = {
- id: collectionId,
- indexingPolicy: { indexingMode: "Lazy" }, // Modes : Lazy, Consistent
- };
- const { result: collection } = await client.createCollection(databaseUri, collectionBody);
- assert.equal(collection.id, collectionBody.id, "invalid collection Id");
-
- const collectionUri = UriFactory.createDocumentCollectionUri(databaseId, collectionId);
- const documentBody = {
- id: documentId,
- context: "something to consume space",
- };
- const { result: document } = await client.createDocument(collectionUri, documentBody);
- assert.equal(document.id, documentId, "invalid document Id");
- };
-
- afterEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
- beforeEach(async function () { await TestHelpers.removeAllDatabases(host, masterKey); });
-
- it("check uriFactory generates valid URIs when resource Ids contain unicode", async function () {
- await createDocumentUsingUriFactory(testDatabaseId, "डेटाबेस پایگاه داده 数据库", "doc1");
- });
- });
-});
diff --git a/src/test/legacy/BaselineTest.PathParser.json b/src/test/legacy/BaselineTest.PathParser.json
deleted file mode 100644
index 96393d3..0000000
--- a/src/test/legacy/BaselineTest.PathParser.json
+++ /dev/null
@@ -1,94 +0,0 @@
-[
- {
- "path": "/",
- "parts": [ ]
- },
- {
- "path": "/*",
- "parts": [ "*" ]
- },
- {
- "path": "/\"Key1\"/*",
- "parts": [ "Key1", "*" ]
- },
- {
- "path": "/\"Key1\"/\"StringValue\"/*",
- "parts": [ "Key1", "StringValue", "*" ]
- },
- {
- "path": "/'Key1'/'StringValue'/*",
- "parts": [ "Key1", "StringValue", "*" ]
- },
- {
- "path": "/'Ke\\\"\\\"y1'/'Strin\\\"gValue'/*",
- "parts": [ "Ke\\\"\\\"y1", "Strin\\\"gValue", "*" ]
- },
- {
- "path": "/'Ke\\\"\\\"y1'/\"Strin'gValue\"/*",
- "parts": [ "Ke\\\"\\\"y1", "Strin'gValue", "*" ]
- },
- {
- "path": "/'Key1'/'StringValue'/*",
- "parts": [ "Key1", "StringValue", "*" ]
- },
- {
- "path": "/\"Key1\"/\"Key2\"/*",
- "parts": [ "Key1", "Key2", "*" ]
- },
- {
- "path": "/\"Key1\"/\"Key2\"/\"Key3\"/*",
- "parts": [ "Key1", "Key2", "Key3", "*" ]
- },
- {
- "path": "/\"A\"/\"B\"/\"R\"/[]/\"Address\"/[]/*",
- "parts": [ "A", "B", "R", "[]", "Address", "[]", "*" ]
- },
- {
- "path": "/\"A\"/\"B\"/\"R\"/[]/\"Address\"/[]/*",
- "parts": [ "A", "B", "R", "[]", "Address", "[]", "*" ]
- },
- {
- "path": "/\"A\"/\"B\"/\"R\"/[]/\"Address\"/*",
- "parts": [ "A", "B", "R", "[]", "Address", "*" ]
- },
- {
- "path": "/\"Key1\"/\"Key2\"/?",
- "parts": [ "Key1", "Key2", "?" ]
- },
- {
- "path": "/\"Key1\"/\"Key2\"/*",
- "parts": [ "Key1", "Key2", "*" ]
- },
- {
- "path": "/\"123\"/\"StringValue\"/*",
- "parts": [ "123", "StringValue", "*" ]
- },
- {
- "path": "/'!@#$%^&*()_+='/'StringValue'/*",
- "parts": [ "!@#$%^&*()_+=", "StringValue", "*" ]
- },
- {
- "path": "/\"_ts\"/?",
- "parts": [ "_ts", "?" ]
- },
- {
- "path": "/[]/\"City\"/*",
- "parts": [ "[]", "City", "*" ]
- },
- {
- "path": "/[]/*",
- "parts": [ "[]", "*" ]
- },
- {
- "path": "/[]/\"fine!\"/*",
- "parts": [ "[]", "fine!", "*" ]
- },
- {
- "path": "/\"this is a long key with speicial characters (*)(*)__)((*&*(&*&'*(&)()(*_)()(_(_)*!@#$%^ and numbers 132654890\"/*",
- "parts": [ "this is a long key with speicial characters (*)(*)__)((*&*(&*&'*(&)()(*_)()(_(_)*!@#$%^ and numbers 132654890", "*" ]
- },
- {
- "path": "/ Key 1 / Key 2 ",
- "parts": [ "Key 1", "Key 2" ]
- }
-]
diff --git a/src/test/legacy/_testConfig.js b/src/test/legacy/_testConfig.js
deleted file mode 100644
index 5292499..0000000
--- a/src/test/legacy/_testConfig.js
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-// [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine")]
-var masterKey = process.env.ACCOUNT_KEY || "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
-var host = process.env.ACCOUNT_HOST || "https://localhost:8081";
-
-var adminUtilitiesPath = "../../../../../bin/x64/Debug/Product/AdminUtilities/Microsoft.Azure.Documents.Tools.AdminUtilities.exe"
-
-// This is needed to disable SSL verification for the tests running against emulator.
-// This needs to be commented if you are running tests against production endpoint specified as host above.
-process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-
-exports.host = host;
-exports.masterKey = masterKey;
-exports.adminUtilitiesPath = adminUtilitiesPath;
diff --git a/src/test/legacy/aggregateQueryTests.js b/src/test/legacy/aggregateQueryTests.js
deleted file mode 100644
index 455a718..0000000
--- a/src/test/legacy/aggregateQueryTests.js
+++ /dev/null
@@ -1,480 +0,0 @@
-/*
- The MIT License (MIT)
- Copyright (c) 2017 Microsoft Corporation
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- */
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig"),
- Stream = require("stream"),
- util = require("util"),
- _ = require('underscore');
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient,
- Range = lib.Range
-
-process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-describe("NodeJS Aggregate Query Tests", function () {
- var partitionKey = "key";
- var uniquePartitionKey = "uniquePartitionKey";
- var field = "field";
- var sum;
- var numberOfDocuments;
- var numberOfDocumentsWithNumbericId;
- var numberOfDocsWithSamePartitionKey;
-
- var removeAllDatabases = function (done) {
- var client = new DocumentDBClient(host, {masterKey: masterKey});
- client.readDatabases().toArray(function (err, databases) {
- if (err !== undefined) {
- console.log("An error occured", err);
- assert.fail();
- return done(err);
- }
-
- var length = databases.length;
-
- if (length === 0) {
- return done();
- }
-
- var count = 0;
- databases.forEach(function (database) {
- client.deleteDatabase(database._self, function (err, db) {
- if (err !== undefined) {
- console.log("An error occured", err);
- assert.fail();
- return done(err);
- }
-
- count++;
- if (count === length) {
- done();
- }
- });
- });
- });
- };
-
- var generateTestData = function () {
- numberOfDocuments = 800;
- field = "field";
- var docs = []
-
- var values = [null, false, true, "abc", "cdfg", "opqrs", "ttttttt", "xyz", "oo", "ppp"]
- for (var i = 0; i < values.length; ++i) {
- var d = {};
- d[partitionKey] = values[i];
- docs.push(d);
- }
-
- numberOfDocsWithSamePartitionKey = 400;
- for (var i = 0; i < numberOfDocsWithSamePartitionKey; ++i) {
- var d = {};
- d[partitionKey] = uniquePartitionKey;
- d['resourceId'] = i.toString();
- d[field] = i + 1;
- docs.push(d);
- }
-
- numberOfDocumentsWithNumbericId = numberOfDocuments - values.length - numberOfDocsWithSamePartitionKey;
- for (var i = 0; i < numberOfDocumentsWithNumbericId; ++i) {
- var d = {};
- d[partitionKey] = i + 1;
- docs.push(d);
- }
-
- sum = numberOfDocumentsWithNumbericId * (numberOfDocumentsWithNumbericId + 1) / 2.0;
-
- return docs;
- };
-
- var getDatabaseLink = function (isNameBasedLink, db) {
- if (isNameBasedLink) {
- return "dbs/" + db.id;
- } else {
- return db._self;
- }
- };
-
- var getCollectionLink = function (isNameBasedLink, db, coll) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id;
- } else {
- return coll._self;
- }
- };
-
- var getDocumentLink = function (isNameBasedLink, db, coll, doc) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/docs/" + doc.id;
- } else {
- return doc._self;
- }
- };
-
- var bulkInsertDocuments = function (client, isNameBased, db, collection, documents, callback) {
- var returnedDocuments = [];
- var insertDocument = function (currentIndex) {
- if (currentIndex >= documents.length) {
- callback(returnedDocuments);
- }
- else {
- client.createDocument(getCollectionLink(isNameBased, db, collection), documents[currentIndex], function (err, document) {
- assert.equal(err, undefined, "error creating document " + JSON.stringify(documents[currentIndex]) + ", err: " + err);
- returnedDocuments.push(document);
- insertDocument(++currentIndex);
- });
- }
- };
-
- insertDocument(0);
- };
-
- describe("Validate Aggregate Document Query", function () {
- var client = new DocumentDBClient(host, {masterKey: masterKey});
- var documentDefinitions = generateTestData();
-
- //- removes all the databases,
- // - creates a new database,
- // - creates a new collecton,
- // - bulk inserts documents to the collection
- before(function (done) {
- removeAllDatabases(function () {
- return createDatabase(function () {
- return createCollection(
- function () {
- bulkInsertDocuments(client, isNameBased, db, collection, documentDefinitions,
- function (insertedDocs) {
- return done();
- });
- }
- );
- });
- })
- });
-
- var db = undefined;
- var createDatabase = function (done) {
- client.createDatabase({id: Base.generateGuidId()}, function (err, createdDB) {
- assert.equal(err, undefined, "error creating database: " + JSON.stringify(err));
- db = createdDB;
- done();
- });
- }
- var collection = undefined;
- var isNameBased = false;
-
- var createCollection = function (done) {
- var collectionDefinition = {
- 'id': 'sample collection',
- 'indexingPolicy': {
- 'includedPaths': [
- {
- 'path': '/',
- 'indexes': [
- {
- 'kind': 'Range',
- 'dataType': 'Number'
- },
- {
- 'kind': 'Range',
- 'dataType': 'String'
- }
- ]
- }
- ]
- },
- 'partitionKey': {
- 'paths': [
- '/' + partitionKey
- ],
- 'kind': 'Hash'
- }
- }
- var collectionOptions = {'offerThroughput': 10100}
- client.createCollection(getDatabaseLink(true, db), collectionDefinition, collectionOptions, function (err, createdCollection) {
- assert.equal(err, undefined, "error creating collection: " + JSON.stringify(err));
- collection = createdCollection;
- done();
- });
- };
-
- var validateResult = function (actualValue, expectedValue) {
- assert.deepEqual(actualValue, expectedValue, "actual value doesn't match with expected value.");
- }
-
- var validateToArray = function (queryIterator, options, expectedResults, done) {
-
- ////////////////////////////////
- // validate toArray()
- ////////////////////////////////
- var toArrayVerifier = function (err, results) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + JSON.stringify(err));
- assert.equal(results.length, expectedResults.length, "invalid number of results");
- assert.equal(queryIterator.hasMoreResults(), false, "hasMoreResults: no more results is left");
-
- validateResult(results, expectedResults);
- return done();
- };
-
- queryIterator.toArray(toArrayVerifier);
- };
-
- var validateNextItem = function (queryIterator, options, expectedResults, done) {
-
- ////////////////////////////////
- // validate nextItem()
- ////////////////////////////////
-
- var results = [];
- var nextItemVerifier = function (err, item) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + JSON.stringify(err));
- if (item === undefined) {
- assert(!queryIterator.hasMoreResults(), "hasMoreResults must signal results exhausted");
- validateResult(results, expectedResults);
-
- return done();
- }
- results = results.concat(item);
-
- if (results.length < expectedResults.length) {
- assert(queryIterator.hasMoreResults(), "hasMoreResults must indicate more results");
- }
- return queryIterator.nextItem(nextItemVerifier);
- };
-
- queryIterator.nextItem(nextItemVerifier);
- };
-
- var validateNextItemAndCurrentAndHasMoreResults = function (queryIterator, options, expectedResults, done) {
- // curent and nextItem recursively invoke each other till queryIterator is exhausted
- ////////////////////////////////
- // validate nextItem()
- ////////////////////////////////
-
- var results = [];
- var nextItemVerifier = function (err, item) {
-
- ////////////////////////////////
- // validate current()
- ////////////////////////////////
- var currentVerifier = function (err, currentItem) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + JSON.stringify(err));
- assert.equal(item, currentItem, "current must give the previously item returned by nextItem");
-
- if (currentItem === undefined) {
- assert(!queryIterator.hasMoreResults(), "hasMoreResults must signal results exhausted");
- validateResult(results, expectedResults);
-
- return done();
- }
-
- if (results.length < expectedResults.length) {
- assert(queryIterator.hasMoreResults(), "hasMoreResults must indicate more results");
- }
-
- return queryIterator.nextItem(nextItemVerifier);
- };
-
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + JSON.stringify(err));
-
- if (item === undefined) {
- assert(!queryIterator.hasMoreResults(), "hasMoreResults must signal results exhausted");
- validateResult(results, expectedResults);
-
- return queryIterator.current(currentVerifier);
- }
- results = results.concat(item);
-
- if (results.length < expectedResults.length) {
- assert(queryIterator.hasMoreResults(), "hasMoreResults must indicate more results");
- }
-
- var currentVerifier = function (err, currentItem) {
- queryIterator.nextItem(nextItemVerifier);
- }
-
- return queryIterator.current(currentVerifier);
- };
- queryIterator.nextItem(nextItemVerifier);
- };
-
-
- var validateExecuteNextAndHasMoreResults = function (queryIterator, options, expectedResults, done) {
- ////////////////////////////////
- // validate executeNext()
- ////////////////////////////////
-
- var totalFetchedResults = [];
- var executeNextValidator = function (err, results) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + JSON.stringify(err));
- if (results === undefined || (totalFetchedResults.length === expectedResults.length)) {
- // no more results
- validateResult(totalFetchedResults, expectedResults);
- assert.equal(queryIterator.hasMoreResults(), false, "hasMoreResults: no more results is left");
- assert.equal(results, undefined, "unexpected more results" + JSON.stringify(results));
-
- return done();
- }
-
- totalFetchedResults = totalFetchedResults.concat(results);
-
- if (totalFetchedResults.length < expectedResults.length) {
- // there are more results
- assert.equal(results.length, pageSize, "executeNext: invalid fetch block size");
- assert(queryIterator.hasMoreResults(), "hasMoreResults expects to return true");
- return queryIterator.executeNext(executeNextValidator);
-
- } else {
- // no more results
- assert.equal(expectedResults.length, totalFetchedResults.length, "executeNext: didn't fetch all the results");
-
- //validate that next execute returns undefined resources
- return queryIterator.executeNext(executeNextValidator);
- }
- };
-
- queryIterator.executeNext(executeNextValidator);
- }
-
- var validateForEach = function (queryIterator, options, expectedResults, done) {
-
- ////////////////////////////////
- // validate forEach()
- ////////////////////////////////
-
- var results = [];
- var callbackSingnalledEnd = false;
- var forEachCallback = function (err, item) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + JSON.stringify(err));
- // if the previous invocation returned false, forEach must avoid invoking the callback again!
- assert.equal(callbackSingnalledEnd, false, "forEach called callback after the first false returned");
-
- // item == undefined means no more results
- if (item !== undefined) {
- results = results.concat(item);
- }
-
- if (results.length == expectedResults.length) {
- callbackSingnalledEnd = true;
- validateResult(results, expectedResults);
- process.nextTick(done);
- return false;
- }
- return true;
- };
-
- queryIterator.forEach(forEachCallback);
- }
-
- var executeQueryAndValidateResults = function (collectionLink, query, expectedResults, done) {
-
- var options = {enableCrossPartitionQuery: true};
-
- var queryIterator = client.queryDocuments(collectionLink, query, options);
-
- validateToArray(queryIterator, options, expectedResults,
- function () {
- queryIterator.reset();
- validateExecuteNextAndHasMoreResults(queryIterator, options, expectedResults,
- function () {
- queryIterator.reset();
- validateNextItemAndCurrentAndHasMoreResults(queryIterator, options, expectedResults,
- function () {
- validateForEach(queryIterator, options, expectedResults, done);
- }
- );
- }
- );
- }
- );
- };
-
- var generateTestConfigs = function () {
- var testConfigs = [];
- var aggregateQueryFormat = "SELECT VALUE %s(r.%s) FROM r WHERE %s";
- var aggregateOrderByQueryFormat = "SELECT VALUE %s(r.%s) FROM r WHERE %s ORDER BY r.%s";
- var aggregateConfigs = [
- {
- operator: 'AVG',
- expected: sum / numberOfDocumentsWithNumbericId,
- condition: util.format("IS_NUMBER(r.%s)", partitionKey)
- },
- {operator: 'AVG', expected: undefined, condition: 'true'},
- {operator: 'COUNT', expected: numberOfDocuments, condition: 'true'},
- {operator: 'MAX', expected: 'xyz', condition: 'true'},
- {operator: 'MIN', expected: null, condition: 'true'},
- {operator: 'SUM', expected: sum, condition: util.format("IS_NUMBER(r.%s)", partitionKey)},
- {operator: 'SUM', expected: undefined, condition: 'true'}
- ];
-
-
- aggregateConfigs.forEach(function (config) {
- var query = util.format(aggregateQueryFormat, config.operator, partitionKey, config.condition);
- var testName = util.format("%s %s", config.operator, config.condition);
- testConfigs.push({'testName': testName, 'query': query, 'expected': config.expected});
-
- var query = util.format(aggregateOrderByQueryFormat, config.operator, partitionKey, config.condition, partitionKey);
- var testName = util.format("%s %s OrderBy", config.operator, config.condition);
- testConfigs.push({'testName': testName, 'query': query, 'expected': config.expected});
- });
-
- var aggregateSinglePartitionQueryFormat = "SELECT VALUE %s(r.%s) FROM r WHERE r.%s = '%s'";
- var aggregateSinglePartitionQueryFormatSelect = "SELECT %s(r.%s) FROM r WHERE r.%s = '%s'";
- var samePartitionSum = numberOfDocsWithSamePartitionKey * (numberOfDocsWithSamePartitionKey + 1) / 2.0;
- var aggregateSinglePartitionConfigs = [
- {operator: 'AVG', expected: samePartitionSum / numberOfDocsWithSamePartitionKey},
- {operator: 'COUNT', expected: numberOfDocsWithSamePartitionKey},
- {operator: 'MAX', expected: numberOfDocsWithSamePartitionKey},
- {operator: 'MIN', expected: 1},
- {operator: 'SUM', expected: samePartitionSum}
- ];
-
- aggregateSinglePartitionConfigs.forEach(function (config) {
- var query = util.format(aggregateSinglePartitionQueryFormat, config.operator, field, partitionKey, uniquePartitionKey);
- var testName = util.format("%s SinglePartition %s", config.operator, "SELECT VALUE");
- testConfigs.push({'testName': testName, 'query': query, 'expected': config.expected});
-
- query = util.format(aggregateSinglePartitionQueryFormatSelect, config.operator, field, partitionKey, uniquePartitionKey);
- testName = util.format("%s SinglePartition %s", config.operator, "SELECT");
- testConfigs.push({'testName': testName, 'query': query, 'expected': {'$1': config.expected}});
- });
-
- return testConfigs;
- }
-
- generateTestConfigs().forEach(function (test) {
- it(test.testName, function (done) {
- var expected = test.expected === undefined ? [] : [test.expected];
- executeQueryAndValidateResults(getCollectionLink(isNameBased, db, collection), test.query, expected, done);
- });
- });
-
- });
-});
diff --git a/src/test/legacy/authorizationTests.js b/src/test/legacy/authorizationTests.js
deleted file mode 100644
index f66e221..0000000
--- a/src/test/legacy/authorizationTests.js
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var assert = require("assert"),
- lib = require("../..//"),
- testConfig = require("./_testConfig.js"),
- DocumentBase = lib.DocumentBase,
- UriFactory = lib.UriFactory;
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-describe("Authorization bug fix Test", function () {
- /************** VARIABLES **************/
- this.timeout(5000);
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- var database = { id: "dbs" };
- var collection = { id: "colls" };
-
- var userReadPermission = { id: "User With Read Permission" };
- var userAllPermission = { id: "User With All Permission" };
- var collReadPermission = {
- id: "collection Read Permission",
- permissionMode: DocumentBase.PermissionMode.Read
- };
- var collAllPermission = {
- id: "collection All Permission",
- permissionMode: DocumentBase.PermissionMode.All
- };
-
- /************** METHODS **************/
-
- var assertError = function (message, error) {
- if (error) {
- assert.fail("code: " + error.code + " " + message + error.body);
- }
- }
-
- var cleanup = function (dbId, done) {
- client.deleteDatabase(UriFactory.createDatabaseUri(dbId), function (err, db) {
- //resource not found error
- if (err && err.code == 404) {
- return done();
- }
-
- assertError("error deleting database:", err);
- return done();
- });
- };
-
- var createResources = function (callback) {
- //create a database
- client.createDatabase(database, function (err, db) {
- assertError("error creating database: ", err);
- assert.equal(db.id, database.id, "database is not created properly");
- database = db;
-
- //create userReadPermission
- client.createUser(database._self, userReadPermission, function (err, user) {
- assertError("error creating userReadPermission: ", err);
- assert.equal(userReadPermission.id, user.id, "userReadPermission is not created properly");
- userReadPermission = user;
-
- //create collection
- client.createCollection(database._self, collection, function (err, coll) {
- assertError("error creating document: ", err);
- assert.equal(collection.id, coll.id, "coll1 is not created properly");
- collection = coll;
-
- //give permission to read collection, to userReadPermission
- collReadPermission.resource = collection._self;
- client.createPermission(userReadPermission._self, collReadPermission, function (err, readPermission) {
- assertError("error creating permission: ", err);
- assert.equal(readPermission.id, collReadPermission.id, "permission to read coll1 is not created properly");
- collReadPermission = readPermission;
-
- //create userAllPermission
- client.createUser(database._self, userAllPermission, function (err, userAllPerm) {
- assertError("error creating userAllPermission: ", err);
- assert.equal(userAllPermission.id, userAllPerm.id, "userAllPermission is not created properly");
- userAllPermission = userAllPerm;
-
- collAllPermission.resource = collection._self;
- client.createPermission(userAllPermission._self, collAllPermission, function (err, allPermission) {
- assertError("error creating permission: ", err);
- assert.equal(collAllPermission.id, allPermission.id, "permission to read coll2 is not created properly");
-
- //permissions.push(permission);
- collAllPermission = allPermission;
- callback();
- });
- });
- //create all permission for coll
-
- });
- });
-
- });
- });
- };
-
- var accessCollectionByPermission = function (documentClient, link, callback) {
- //read collection
- documentClient.readCollection(link, function (err, collection) {
- assertError("error reading collection", err);
- assert.equal(collection.id, collection.id, "invalid collection");
-
- if (callback) {
- callback();
- }
-
- });
- };
-
- var modifyCollectionByPermission = function (documentClient, link, callback) {
- //read collection
- documentClient.deleteCollection(link, function (err, collection) {
- assertError("error deleting collection", err);
-
- if (callback) {
- callback();
- }
-
- });
- };
- /************** TEST **************/
-
- beforeEach(function (done) {
- cleanup(database.id, done);
- });
-
- afterEach(function (done) {
- cleanup(database.id, done);
- });
-
- it("Accessing collection by resourceTokens", function (done) {
- createResources(function () {
- var rTokens = {};
- rTokens[collection.id] = collReadPermission._token;
-
- var collectionUri = UriFactory.createDocumentCollectionUri(database.id, collection.id);
- var clientReadPermission = new DocumentDBClient(host, { resourceTokens: rTokens });
-
- accessCollectionByPermission(clientReadPermission, collectionUri, done);
- });
- });
-
- it("Accessing collection by permissionFeed", function (done) {
- createResources(function () {
- var clientReadPermission = new DocumentDBClient(host, { permissionFeed: [collReadPermission] });
-
- //self link must be used to access a resource using permissionFeed
- accessCollectionByPermission(clientReadPermission, collection._self, done);
- });
- });
-
- it("Accessing collection withot permission fails", function (done) {
- createResources(function () {
- var clientNoPermission = new DocumentDBClient(host);
-
- var collectionUri = UriFactory.createDocumentCollectionUri(database.id, collection.id);
- clientNoPermission.readCollection(collectionUri, function (err, coll) {
- assert(err !== undefined, "unauthorized access to database did not fail");
- done();
- });
- });
- });
-
- it("Accessing document by permissionFeed of parent collection", function (done) {
- createResources(function () {
- client.createDocument(collection._self, { id: "document1" }, function (err, createdDoc) {
- var clientReadPermission = new DocumentDBClient(host, { permissionFeed: [collReadPermission] });
- assertError("error creating document", err);
- assert.equal("document1", createdDoc.id, "invalid documnet create");
-
- clientReadPermission.readDocument(createdDoc._self, function (err, readDoc) {
- assertError("error reading document with parent permission", err);
- assert.equal(readDoc.id, createdDoc.id, "invalid document read");
-
- done();
- });
- });
- });
- });
-
- it("Modifying collection by resourceTokens", function (done) {
- createResources(function () {
- var rTokens = {};
- rTokens[collection.id] = collAllPermission._token;
-
- var collectionUri = UriFactory.createDocumentCollectionUri(database.id, collection.id);
- var clientAllPermission = new DocumentDBClient(host, { resourceTokens: rTokens });
-
- modifyCollectionByPermission(clientAllPermission, collectionUri, done);
- });
- });
-
- it("Modifying collection by permissionFeed", function (done) {
- createResources(function () {
- var clientAllPermission = new DocumentDBClient(host, { permissionFeed: [collAllPermission] });
-
- //self link must be used to access a resource using permissionFeed
- modifyCollectionByPermission(clientAllPermission, collection._self, done);
- });
- });
-});
diff --git a/src/test/legacy/collectionNamingTest.js b/src/test/legacy/collectionNamingTest.js
deleted file mode 100644
index 9b36d65..0000000
--- a/src/test/legacy/collectionNamingTest.js
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig.js"),
- Stream = require("stream"),
- DocumentDBClient = lib.DocumentClient,
- UriFactory = lib.UriFactory;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-
-describe("Collection Naming Test", function () {
-
- /**************** VARIABLES ****************/
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- var databaseId = "collNamingTestDB";
- var collectionId = "media";
- var documentId = "doc1";
- var attachmentId = "atch1";
-
- /************** METHODS **************/
- var assertError = function (error, message) {
- if (error) {
- assert.fail("code: " + error.code+ " " + message + error.body);
- }
- }
-
- var cleanup = function (dbId, done) {
- client.deleteDatabase(UriFactory.createDatabaseUri(dbId), function (err, db) {
- if (err && err.code === 404) {
- return done();
- }
-
- assertError(err, "error deleting database");
- return done();
- });
- };
-
- var createReadableStream = function (firstChunk, secondChunk) {
- var readableStream = new Stream.Readable();
- var chunkCount = 0;
- readableStream._read = function (n) {
- if (chunkCount === 0) {
- this.push(firstChunk || "first chunk ");
- } else if (chunkCount === 1) {
- this.push(secondChunk || "second chunk");
- } else {
- this.push(null);
- }
- chunkCount++;
- };
-
- return readableStream;
- };
-
- var createResources = function (specialName, callback) {
- //create database
- client.createDatabase({ id: databaseId }, function (err, db) {
- assertError(err, "error creating database");
- assert.equal(db.id, databaseId, "database is not created properly");
-
- //create collection
- var dbUri = UriFactory.createDatabaseUri(databaseId);
- client.createCollection(dbUri, { id: collectionId }, function (err, collection) {
- assertError(err, "error creating collection");
- assert.equal(collection.id, collectionId, "collection is not created properly");
-
- //createDocument
- var collectionUri = UriFactory.createDocumentCollectionUri(databaseId, collectionId);
- client.createDocument(collectionUri, { id: documentId }, function (err, document) {
- assertError(err, "error creating document");
- assert.equal(document.id, documentId, "document is not created properly");
-
- //create attachment and upload media
- var mediaOption = { slug: attachmentId, contentType: "application/text" };
- var readableStream = createReadableStream("UPLOADING ", "MEDIA");
- var documentUri = UriFactory.createDocumentUri(databaseId, collectionId, documentId);
- client.createAttachmentAndUploadMedia(documentUri, readableStream, mediaOption, function (err, attachment) {
- assertError(err, "error creating attachment");
- assert.equal(attachment.id, attachmentId, "attachment is not created properly");
- callback();
- });
- });
- });
- });
- };
-
- var readCollectionWithSpecialName = function (specialName, done) {
- var collectionUri = UriFactory.createDocumentCollectionUri(databaseId, collectionId);
- client.readCollection(collectionUri, function (err, collection) {
- assertError(err, "error reading collection [" + collectionId + "]");
- assert.equal(collection.id, collectionId, "collectionIds do not match");
- done();
- });
- };
-
- var readMedia = function (done) {
- //read attachment
- var attachmentUri = UriFactory.createAttachmentUri(databaseId, collectionId, documentId, attachmentId);
- client.readAttachment(attachmentUri, function (err, attachment) {
- assertError(err, "error reading attachment");
- assert.equal(attachment.id, attachmentId, "attachmentIds don't match");
-
- //read media
- client.readMedia(attachment.media, function (err, media) {
- assertError(err, "error reading media");
- assert.equal(media, "UPLOADING MEDIA");
- done();
- });
- });
- };
-
- /************** TESTS **************/
- beforeEach(function (done) {
- cleanup(databaseId, done);
- });
-
- afterEach(function (done) {
- cleanup(databaseId, done);
- });
-
- it("Accessing a collection with 'media' in its name", function (done) {
- createResources("media", function () {
- readCollectionWithSpecialName("media", done);
- });
- });
-
- it("Accessing media in a collection", function (done) {
- createResources("media", function () {
- readCollectionWithSpecialName("media", done);
- });
- });
-});
\ No newline at end of file
diff --git a/src/test/legacy/documentClientTests.js b/src/test/legacy/documentClientTests.js
deleted file mode 100644
index 62d43ce..0000000
--- a/src/test/legacy/documentClientTests.js
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- testConfig = require("./_testConfig"),
- assert = require("assert");
-
-var DocumentClient = lib.DocumentClient,
- Constants = lib.Constants;
-
-describe("DocumentClient Tests", function () {
- var host = testConfig.host;
- var masterKey = testConfig.masterKey;
- var client = new DocumentClient(host, { masterKey: masterKey });
-
- describe("setIsUpsertHeader", function () {
- it("Should add is-upsert header.", function (done) {
- var headers = client.defaultHeaders;
- assert.equal(undefined, headers[Constants.HttpHeaders.IsUpsert]);
- client.setIsUpsertHeader(headers);
- assert.equal(true, headers[Constants.HttpHeaders.IsUpsert]);
- done();
- });
-
- it("Should update is-upsert header.", function (done) {
- var headers = {};
- headers[Constants.HttpHeaders.IsUpsert] = false;
- assert.equal(false, headers[Constants.HttpHeaders.IsUpsert]);
- client.setIsUpsertHeader(headers);
- assert.equal(true, headers[Constants.HttpHeaders.IsUpsert]);
- done();
- });
-
- it("Should throw on undefined headers", function (done) {
- assert.throws(
- function () { client.setIsUpsertHeader(); },
- /The "headers" parameter must not be null or undefined/
- );
- done();
- });
-
- it("Should throw on null headers", function (done) {
- assert.throws(
- function () { client.setIsUpsertHeader(null); },
- /The "headers" parameter must not be null or undefined/
- );
- done();
- });
-
- it("Should throw on invalid string headers", function (done) {
- assert.throws(
- function () { client.setIsUpsertHeader(""); },
- /The "headers" parameter must be an instance of "Object". Actual type is: "string"./
- );
- done();
- });
-
- it("Should throw on invalid number headers", function (done) {
- assert.throws(
- function () { client.setIsUpsertHeader(0); },
- /The "headers" parameter must be an instance of "Object". Actual type is: "number"./
- );
- done();
- });
-
- it("Should throw on invalid boolean headers", function (done) {
- assert.throws(
- function () { client.setIsUpsertHeader(false); },
- /The "headers" parameter must be an instance of "Object". Actual type is: "boolean"./
- );
- done();
- });
- });
-
- // //we are using util.format function instead.
- // describe.skip("sprintf", function () {
- // it("0 strings", function (done) {
- // assert.equal("foo", client.sprintf("foo"));
- // done();
- // });
-
- // it("1 string", function (done) {
- // assert.equal("foo", client.sprintf("%s", "foo"));
- // done();
- // });
-
- // it("2 strings", function (done) {
- // assert.equal("foobar", client.sprintf("%s%s", "foo", "bar"));
- // done();
- // });
-
- // it("3 strings", function (done) {
- // assert.equal("foobarbaz", client.sprintf("%s%s%s", "foo", "bar", "baz"));
- // done();
- // });
-
- // it("%% escapes", function (done) {
- // assert.equal('%s', client.sprintf("%%s", 'foo'));
- // done();
- // });
- // });
-
- describe("validateOptionsAndCallback Unit Tests", function () {
- it("no parameters", function (done) {
- var result = client.validateOptionsAndCallback();
-
- assert.notEqual(null, result.options);
- assert.equal("object", typeof result.options);
-
- assert.equal(undefined, result.callback);
- done();
- });
-
- it("options", function (done) {
- var result = client.validateOptionsAndCallback({});
-
- assert.notEqual(null, result.options);
- assert.equal("object", typeof result.options);
-
- assert.equal(undefined, result.callback);
- done();
- });
-
- it("callback", function (done) {
- var result = client.validateOptionsAndCallback(function () { });
- assert.notEqual(null, result.options);
- assert.equal("object", typeof result.options);
-
- assert.equal("function", typeof result.callback);
- done();
- });
-
- it("options, callback.", function (done) {
- var result = client.validateOptionsAndCallback({}, function () { });
- assert.notEqual(null, result.options);
- assert.equal("object", typeof result.options);
-
- assert.equal("function", typeof result.callback);
- done();
- });
-
- it("undefined, callback", function (done) {
- var result = client.validateOptionsAndCallback(undefined, function () { });
- assert.notEqual(null, result.options);
- assert.equal("object", typeof result.options);
-
- assert.equal("function", typeof result.callback);
- done();
- });
-
- it("null, callback", function (done) {
- var result = client.validateOptionsAndCallback(null, function () { });
- assert.equal(null, result.options);
- assert.equal("object", typeof result.options);
-
- assert.equal("function", typeof result.callback);
- done();
- });
-
-
- it("invalid string options", function (done) {
- assert.throws(
- function () { client.validateOptionsAndCallback("foo", function () { }); },
- /The "options" parameter must be of type "object". Actual type is: "string"/
- );
- done();
- });
-
- it("invalid number options", function (done) {
- assert.throws(
- function () { client.validateOptionsAndCallback(0, function () { }); },
- /The "options" parameter must be of type "object". Actual type is: "number"/
- );
- done();
- });
-
- it("invalid bool options", function (done) {
- assert.throws(
- function () { client.validateOptionsAndCallback(false, function () { }); },
- /The "options" parameter must be of type "object". Actual type is: "boolean"/
- );
- done();
- });
-
- it("invalid string callback", function (done) {
- assert.throws(
- function () { client.validateOptionsAndCallback({}, "bar"); },
- /The "callback" parameter must be of type "function". Actual type is: "string"/
- );
- done();
- });
-
- it("invalid number callback", function (done) {
- assert.throws(
- function () { client.validateOptionsAndCallback({}, 0); },
- /The "callback" parameter must be of type "function". Actual type is: "number"/
- );
- done();
- });
-
- it("invalid boolean callback", function (done) {
- assert.throws(
- function () { client.validateOptionsAndCallback({}, false); },
- /The "callback" parameter must be of type "function". Actual type is: "boolean"/
- );
- done();
- });
-
- it("invalid options, invalid callback", function (done) {
- assert.throws(
- function () { client.validateOptionsAndCallback("foo", "bar"); },
- /The "options" parameter must be of type "object". Actual type is: "string"/
- );
- done();
- });
- });
-
- describe("isResourceValid Unit Tests", function () {
- it("id is not string", function (done) {
- var err = {};
- var result = client.isResourceValid({id: 1}, err);
-
- assert.equal(result, false);
- assert.deepEqual(err, {"message": "Id must be a string."});
- done();
- });
- });
-
- describe("extractPartitionKey", function() {
- var document, partitionKeyDefinition;
-
- beforeEach(function() {
- document = undefined;
- partitionKeyDefinition = undefined;
- });
-
- describe("With undefined partitionKeyDefinition", function() {
- it("should return undefined", function() {
- var document = {};
- var result = client.extractPartitionKey(document, partitionKeyDefinition);
- assert.equal(result, undefined);
- });
- });
-
- describe("With a defined partitionKeyDefinition", function() {
- beforeEach(function() {
- partitionKeyDefinition = { paths: ["/a/b"] }
- });
-
- it("should return [{}] when document has no partition key value", function() {
- var document = {};
- var result = client.extractPartitionKey(document, partitionKeyDefinition);
- assert.deepEqual(result, [{}]);
- });
-
- it("should return [null] when document has a null partition key value", function() {
- var document = { a: { b: null } };
- var result = client.extractPartitionKey(document, partitionKeyDefinition);
- assert.deepEqual(result, [null]);
- });
-
- it("should return [{}] when document has a partially defined partition key value", function() {
- var document = { a: "some value" };
- var result = client.extractPartitionKey(document, partitionKeyDefinition);
- assert.deepEqual(result, [{}]);
- });
-
- it("should return [value] when document has a valid partition key value", function() {
- var document = { a: { b: "some value" } };
- var result = client.extractPartitionKey(document, partitionKeyDefinition);
- assert.deepEqual(result, ["some value"]);
- });
- });
- });
-
-});
\ No newline at end of file
diff --git a/src/test/legacy/encodingTests.js b/src/test/legacy/encodingTests.js
deleted file mode 100644
index e878d6c..0000000
--- a/src/test/legacy/encodingTests.js
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig"),
- DocumentDBClient = lib.DocumentClient,
- UriFactory = lib.UriFactory;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-var testDoc = {
- "id": "ABC", "content": "€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€"
-}
-
-describe("Create And Read Validation", function () {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- var dateTime = new Date();
- var databaseId = "encodingTestDB";
-
- var deleteDatabases = function (done) {
- client.readDatabases().toArray(function (err, databases) {
- if (err) {
- console.log("error occured reading databases", err);
- return done();
- }
-
- var index = databases.length;
- if (index === 0) {
- return done();
- }
-
- databases.forEach(function (database) {
- index--;
- if (database.id === databaseId) {
- client.deleteDatabase(database._self, function (err, db) {
- if (err) {
- return done();
- }
- });
- }
- if (index === 0) {
- return done();
- }
- });
- });
- }
-
- var addAndReadDocument = function (document, done) {
- var databaseBody = { id: databaseId };
-
- //Create Database
- client.createDatabase(databaseBody, function (err, database) {
- assert.equal(err, undefined, "error creating database");
- assert.equal(database.id, databaseId, "invalid database Id");
-
- var collectionBody = {
- id: "डेटाबेस پایگاه داده 数据库" + dateTime.getTime(),
- indexingPolicy: { indexingMode: "Lazy" } //Modes : Lazy, Consistent
- };
-
- //Create a collection inside the database
- client.createCollection(database._self, collectionBody, function (err, collection) {
- var path = UriFactory.createDocumentCollectionUri(databaseId, collectionBody.id);
-
- assert.equal(err, undefined, "error creating collection");
- assert.equal(collection.id, collectionBody.id, "invalid collection Id");
-
- //Add the document in the collection
- client.createDocument(collection._self, testDoc, function (err, doc) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(doc.id, testDoc.id, "invalid document Id");
-
- //Read the collection and see if it matches to the initial document
- client.readDocument(doc._self, function (err, resultDoc) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(testDoc.content, resultDoc.content, "read document result is different from initial document");
- done();
- });
- });
- });
- });
- }
-
- afterEach(function(done) { deleteDatabases(done) });
- beforeEach(function(done) { deleteDatabases(done) });
-
- it("check if the document from db matches the actual document", function (done) {
- addAndReadDocument(testDoc, done);
- });
-});
\ No newline at end of file
diff --git a/src/test/legacy/incrementalFeedTests.js b/src/test/legacy/incrementalFeedTests.js
deleted file mode 100644
index 231a332..0000000
--- a/src/test/legacy/incrementalFeedTests.js
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- The MIT License (MIT)
- Copyright (c) 2017 Microsoft Corporation
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- */
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig");
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient,
- Range = lib.Range;
-
-process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-describe("NodeJS Incremental Feed Tests using 'a_im' and 'IfNoneMatch' options", function () {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- // delete all databases and create sample database
- before(function (done) {
- deleteAllDatabases(function() {
- createDatabase(function () {
- done();
- });
- });
- });
-
- var isNameBased = false;
-
- var getDatabaseLink = function (isNameBasedLink, db) {
- if (isNameBasedLink) {
- return "dbs/" + db.id;
- } else {
- return db._self;
- }
- };
-
- var getCollectionLink = function (isNameBasedLink, db, coll) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id;
- } else {
- return coll._self;
- }
- };
-
- var getDocumentLink = function (isNameBasedLink, db, coll, doc) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/docs/" + doc.id;
- } else {
- return doc._self;
- }
- };
-
- var deleteAllDatabases = function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- client.readDatabases().toArray(function (err, databases) {
- if (err !== undefined) {
- console.log("An error occured", err);
- return done();
- }
-
- var length = databases.length;
-
- if (length === 0) {
- return done();
- }
-
- var count = 0;
- databases.forEach(function (database) {
- client.deleteDatabase(database._self, function (err, db) {
- if (err !== undefined) {
- console.log("An error occured", err);
- return done();
- }
-
- count++;
- if (count === length) {
- return done();
- }
- });
- });
- });
- };
-
- var db = undefined;
- var createDatabase = function (done) {
- client.createDatabase({id: "sample database"}, function (err, createdDB) {
- assert.equal(err, undefined, "error creating database: " + JSON.stringify(err));
- db = createdDB;
- done();
- });
- };
-
- var collection = undefined;
- var createCollection = function (done) {
- var collectionDefinition = {
- "id": "sample collection"
- };
- var dbLink = getDatabaseLink(false, db);
- client.createCollection(dbLink, collectionDefinition, function (err, result) {
- assert.equal(err, undefined, "error creating collection: " + JSON.stringify(err));
- collection = result;
- done();
- });
- };
-
- var deleteCollection = function (done) {
- client.deleteCollection(getCollectionLink(isNameBased, db, collection), function(err) {
- assert.equal(err, undefined, "error deleting collection");
- done();
- });
- };
-
- describe("Newly updated documents should be fetched incremetally", function(done) {
-
- // create collection and two documents
- before(function (done) {
- createCollection( function () {
- var collLink = getCollectionLink(isNameBased, db, collection);
- client.createDocument(collLink, {id: "doc1"}, function (err, document) {
- assert.equal(err, undefined, "error creating first initial document");
- client.createDocument(collLink, {id: "doc2"}, function (err, document) {
- assert.equal(err, undefined, "error creating second initial document");
- done();
- });
- });
- });
- });
-
- after(function(done) {
- deleteCollection(done);
- });
-
- it("should fetch updated documents only", function(done) {
- var options = { a_im: "Incremental feed" };
- var query = client.readDocuments(getCollectionLink(isNameBased, db, collection), options);
-
- query.current( function(err, document, headers) {
- assert.equal(err, undefined, "unexpected failure in listDocuments request" + JSON.stringify(err));
- assert(headers.etag, "listDocuments response should have etag header");
-
- query.toArray(function(err, results) {
- assert.equal(err, undefined, "error reading documents");
- assert.equal(results.length, 2, "initial number of documents should be equal 2");
-
-
- var documentLink = getDocumentLink(isNameBased, db, collection, document);
-
- document.name = "xyz";
- client.replaceDocument(documentLink, document, function(err, replaced) {
- assert.equal(err, undefined, "error reading documents");
- assert.deepEqual(replaced.name, "xyz", "replaced document should be valid");
-
-
- options = {
- a_im: "Incremental feed",
- accessCondition: {
- type: "IfNoneMatch",
- condition: headers.etag
- }
- };
- var collLink = getCollectionLink(isNameBased, db, collection);
- client.readDocuments(collLink, options).toArray(function(err, results) {
- assert.equal(err, undefined, "error reading documents");
- assert.equal(results.length, 1, "initial number of documents should be equal 1");
- assert.equal(results[0].name, "xyz", "fetched document should have 'name: xyz'");
- assert.equal(results[0].id, document.id, "fetched document should be valid");
- done();
- });
- });
- });
- });
- });
- });
-
- describe("Newly created documents should be fetched incrementally", function(done) {
- // create collection and one document
- before(function (done) {
- createCollection( function () {
- client.createDocument(getCollectionLink(isNameBased, db, collection), {id: "doc1"}, function (err, document) {
- assert.equal(err, undefined, "error creating first initial document");
- done();
- });
- });
- });
-
- after(function(done) {
- deleteCollection(done);
- });
-
- it("should fetch new documents only", function(done) {
- var options = { a_im: "Incremental feed" };
- var collLink = getCollectionLink(isNameBased, db, collection);
- var query = client.readDocuments(collLink, options);
-
- query.current( function(err, result, headers) {
- assert.equal(err, undefined, "unexpected failure in listDocuments request" + JSON.stringify(err));
- assert(headers.etag, "listDocuments response should have etag header");
-
-
- client.createDocument(collLink, { id: "doc2", prop: 1 }, function (err, document) {
- assert.equal(err, undefined, "error creating document");
-
- options = {
- a_im: "Incremental feed",
- accessCondition: {
- type: "IfNoneMatch",
- condition: headers.etag
- }
- };
- var query = client.readDocuments(collLink, options);
- query.current(function(err, result, headers) {
- assert.equal(err, undefined, "error reading current document");
-
- assert.notDeepEqual(result, document, "actual should not match with expected value.");
- delete result._lsn;
- assert.deepEqual(result, document, "actual value doesn't match with expected value.");
-
-
- options.accessCondition.condition = headers.etag;
-
- client.readDocuments(collLink, options).toArray(function(err, results) {
- assert.equal(err, undefined, "error reading current documents");
- assert.equal(results.length, 0, "should be nothing new");
-
- client.createDocument(collLink, {id: "doc3"}, function (err, document) {
- client.createDocument(collLink, {id: "doc4"}, function (err, document) {
- client.readDocuments(collLink, options).toArray(function(err, results) {
- assert.equal(err, undefined, "error reading current document");
- assert.equal(results.length, 2, "there should be 2 results");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
-
-
-});
diff --git a/src/test/legacy/proxyTests.js b/src/test/legacy/proxyTests.js
deleted file mode 100644
index 8f55890..0000000
--- a/src/test/legacy/proxyTests.js
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- The MIT License (MIT)
- Copyright (c) 2017 Microsoft Corporation
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- */
-
-"use strict";
-
-var http = require("http"),
- net = require("net"),
- url = require("url"),
- lib = require("../..//"),
- testConfig = require("./_testConfig");
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient,
- DocumentBase = lib.DocumentBase;
-
-var proxy = http.createServer((req, resp) => {
- resp.writeHead(200, { "Content-Type": "text/plain" });
- resp.end();
-});
-
-proxy.on("connect", (req, clientSocket, head) => {
- var serverUrl = url.parse(`http://${req.url}`);
- var serverSocket = net.connect(serverUrl.port, serverUrl.hostname, () => {
- clientSocket.write("HTTP/1.1 200 Connection Established\r\n" +
- "Proxy-agent: Node.js-Proxy\r\n" +
- "\r\n");
- serverSocket.write(head);
- serverSocket.pipe(clientSocket);
- clientSocket.pipe(serverSocket);
- });
-});
-
-var proxyPort = 8989;
-var connectionPolicy = new DocumentBase.ConnectionPolicy();
-connectionPolicy.ProxyUrl = "http://127.0.0.1:8989";
-
-describe("Validate http proxy setting in environment variable", function () {
- it("nativeApi Client Should successfully execute request", function (done) {
- proxy.listen(proxyPort, "127.0.0.1", () => {
- var client = new DocumentDBClient(testConfig.host, { masterKey: testConfig.masterKey }, connectionPolicy);
- // create database
- client.createDatabase({ id: Base.generateGuidId() }, function (err, db) {
- if (err) {
- done(err);
- } else {
- done();
- }
- proxy.close();
- });
- });
- });
-
- it("nativeApi Client Should execute request in error while the proxy setting is not correct", function (done) {
- proxy.listen(proxyPort + 1, "127.0.0.1", () => {
- var client = new DocumentDBClient(testConfig.host, { masterKey: testConfig.masterKey }, connectionPolicy);
- // create database
- client.createDatabase({ id: Base.generateGuidId() }, function (err, db) {
- if (!err) {
- done("Should create database in error while the proxy setting is not correct");
- } else {
- done();
- }
- proxy.close();
- });
- });
- });
-});
diff --git a/src/test/legacy/queryTests.js b/src/test/legacy/queryTests.js
deleted file mode 100644
index 0e28a1e..0000000
--- a/src/test/legacy/queryTests.js
+++ /dev/null
@@ -1,83 +0,0 @@
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig"),
- DocumentDBClient = lib.DocumentClient,
- UriFactory = lib.UriFactory;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-var doc = { "id": "myId", "pk": "pk" }
-
-describe("ResourceLink Trimming of leading and trailing slashes", function () {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- var databaseId = "testDatabase";
- var collectionId = "testCollection";
-
- var deleteDatabases = function (done) {
- client.readDatabases().toArray(function (err, databases) {
- if (err) {
- console.log("error occured reading databases", err);
- return done();
- }
-
- var index = databases.length;
- if (index === 0) {
- return done();
- }
-
- databases.forEach(function (database) {
- index--;
- if (database.id === databaseId) {
- client.deleteDatabase(database._self, function (err, db) {
- });
- }
- if (index === 0) {
- return done();
- }
- });
- });
- }
-
- var testFirstAndLastSlashesTrimmedForQueryString = function (document, done) {
- var databaseBody = { id: databaseId };
-
- client.createDatabase(databaseBody, function (dbCreateErr, database) {
-
- assert.equal(dbCreateErr, undefined);
- var collectionDefinition = {"id": collectionId, "partitionKey": {"paths": ["/pk"],"kind": "Hash"}}
- var collectionOptions = { "offerThroughput": 10100 }
-
- client.createCollection(database._self, collectionDefinition, collectionOptions, function (createCollErr, createdCollection) {
-
- assert.equal(createCollErr, undefined);
-
- client.createDocument(createdCollection._self, document, function (err, doc) {
- if (err) {
- return done(err)
- }
- assert.equal(err, undefined);
- var collectionLink = "/dbs/" + databaseId + "/colls/" + collectionId + "/"
- var query = "SELECT * from " + collectionId
- var queryOptions = { "partitionKey": "pk" }
- var queryIterator = client.queryDocuments(collectionLink, query, queryOptions);
-
- queryIterator.toArray(function (error, result) {
- assert.equal(error, undefined);
- assert.equal(result[0]["id"], "myId");
- done();
- });
- });
- });
- });
- }
-
- afterEach(function (done) { deleteDatabases(done) });
- beforeEach(function (done) { deleteDatabases(done) });
-
- it("validate correct execution of query using named collection link with leading and trailing slashes", function (done) {
- testFirstAndLastSlashesTrimmedForQueryString(doc, done);
- });
-});
\ No newline at end of file
diff --git a/src/test/legacy/rangePartitionResolverTests.js b/src/test/legacy/rangePartitionResolverTests.js
deleted file mode 100644
index 810160c..0000000
--- a/src/test/legacy/rangePartitionResolverTests.js
+++ /dev/null
@@ -1,433 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert");
-
-var Range = lib.Range,
- RangePartitionResolver = lib.RangePartitionResolver;
-
-describe("RangePartitionResolver", function () {
- // NOTICE: chrande changed test title to fix tooling bug
- describe("constructor tests", function () {
- it("missing partitionKeyExtractor throws", function (done) {
- var expetcedError = /Error: partitionKeyExtractor cannot be null or undefined/;
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver();
- },
- expetcedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver(undefined);
- },
- expetcedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver(null);
- },
- expetcedError
- );
-
- done();
- });
-
- it("invalid partitionKeyExtractor throws", function (done) {
- var expetcedError = /partitionKeyExtractor must be either a 'string' or a 'function'/;
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver(0);
- },
- expetcedError
- );
-
- assert.throws(
- function () {
- // NOTICE: chrande modified this because it appeared to be an invalid test
- var r = new RangePartitionResolver(true);
- },
- expetcedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver(NaN);
- },
- expetcedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver([]);
- },
- expetcedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver({});
- },
- expetcedError
- );
-
-
- done();
- });
-
- it("missing partitionKeyMap throws", function (done) {
- var expectedError = /Error: partitionKeyMap cannot be null or undefined/;
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver("");
- },
- expectedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver(function () {
- });
- },
- expectedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver("", null);
- },
- expectedError
- );
-
- done();
- });
-
- it("invalid partitionKeyMap throws", function (done) {
- var expectedError = /Error: partitionKeyMap has to be an Array/;
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver("", 0);
- },
- expectedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver("", "");
- },
- expectedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver("", true);
- },
- expectedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver("", NaN);
- },
- expectedError
- );
-
- assert.throws(
- function () {
- var r = new RangePartitionResolver("", {});
- },
- expectedError
- );
-
- var r = new RangePartitionResolver("", new Array());
- done();
- });
-
- it("valid RangePartitionResolver", function (done) {
- var resolver = new RangePartitionResolver("", []);
- assert(resolver);
- assert.strictEqual(resolver.partitionKeyExtractor, "");
- assert.deepEqual(resolver.partitionKeyMap, []);
- done();
- });
- });
-
- describe("_getFirstContainingMapEntryOrNull", function () {
- it("_getFirstContainingMapEntryOrNull - empty map returns null", function (done) {
- var ranges = [undefined, null, 0, "", true, [], {}, NaN, new Range()];
- var resolver = new RangePartitionResolver("", []);
- ranges.forEach(function (r) {
- var result = resolver._getFirstContainingMapEntryOrNull(r);
- assert.equal(result, null);
- });
- done();
- });
-
- it("_tryGetContainingRange - map with no containing entry returns null", function (done) {
- var mapEntry = { range: new Range({ low: "A" }), link: "link1" };
- var resolver = new RangePartitionResolver("key", [mapEntry]);
- var result = resolver._getFirstContainingMapEntryOrNull(new Range({ low: "B" }));
- assert.equal(result, null);
- done();
- });
-
- it("_tryGetContainingRange - map with single containing entry returns entry", function (done) {
- var mapEntry = { range: new Range(), link: "link1" };
- var resolver = new RangePartitionResolver("key", [mapEntry]);
- var result = resolver._getFirstContainingMapEntryOrNull(new Range());
- assert.deepEqual(result, { range: new Range(), link: "link1" });
- done();
- });
-
- it("_tryGetContainingRange - map with more multiple containing entries returns first entry", function (done) {
- var map1 = [
- { range: new Range({ low: "A", high: "B" }), link: "link1" },
- { range: new Range({ low: "A" }), link: "link2" }
- ];
-
- var resolver1 = new RangePartitionResolver("key", map1);
- var result1 = resolver1._getFirstContainingMapEntryOrNull(new Range({ low: "A" }));
- assert.strictEqual(result1.link, "link1");
-
- var map2 = [
- { range: new Range({ low: "A" }), link: "link2" },
- { range: new Range({ low: "A", high: "Z" }), link: "link1" }
- ];
-
- var resolver2 = new RangePartitionResolver("key", map2);
- var result2 = resolver2._getFirstContainingMapEntryOrNull(new Range({ low: "A" }));
- assert.strictEqual(result2.link, "link2");
- done();
- });
- });
-
- describe("resolveForCreate", function () {
- it("_tryGetContainingRange - map containing parition key returns corresponding link", function (done) {
- var resolver = new RangePartitionResolver("key", [
- { range: new Range({ low: "A", high: "M" }), link: "link1" },
- { range: new Range({ low: "N", high: "Z" }), link: "link2" }
- ]);
- var result = resolver.resolveForCreate("X");
- assert.strictEqual(result, "link2");
- done();
- });
-
- it("_tryGetContainingRange - map not containing parition key throws", function (done) {
- var resolver = new RangePartitionResolver("key", [
- { range: new Range({ low: "A", high: "M" }), link: "link1" }
- ]);
-
- assert.throws(
- function () {
- var result = resolver.resolveForCreate("X");
- },
- /Error: Invalid operation: A containing range for 'X,X' doesn't exist in the partition map./
- );
- done();
- });
- });
-
- var resolveForReadTest = function (resolver, partitionKey, expectedLinks) {
- var result = resolver.resolveForRead(partitionKey);
- assert.deepEqual(expectedLinks, result);
- };
-
- describe("resolveForRead", function () {
- var resolver = new RangePartitionResolver(
- function (doc) {
- return doc.key;
- },
- [
- {
- range: new Range({ low: "A", high: "M" }),
- link: "link1"
- },
- {
- range: new Range({ low: "N", high: "Z" }),
- link: "link2"
- }
- ]);
-
- it("undefined", function (done) {
- var partitionKey = undefined;
- var expectedLinks = ["link1", "link2"];
- resolveForReadTest(resolver, partitionKey, expectedLinks);
- done();
- });
-
- it("null", function (done) {
- var partitionKey = null;
- var expectedLinks = ["link1", "link2"];
- resolveForReadTest(resolver, partitionKey, expectedLinks);
- done();
- });
- });
-
- describe("resolveForRead string", function () {
- var resolver = new RangePartitionResolver(
- function (doc) {
- return doc.key;
- },
- [
- {
- range: new Range({ low: "A", high: "M" }),
- link: "link1"
- },
- {
- range: new Range({ low: "N", high: "Z" }),
- link: "link2"
- }
- ]);
-
- it("point", function (done) {
- var partitionKey = new Range({ low: "D" });
- var expectedLinks = ["link1"];
- resolveForReadTest(resolver, partitionKey, expectedLinks);
-
- var partitionKey2 = new Range({ low: "Q" });
- var expectedLinks2 = ["link2"];
- resolveForReadTest(resolver, partitionKey2, expectedLinks2);
- done();
- });
-
- it("range", function (done) {
- var partitionKey = new Range({ low: "D", high: "Q" });
- var expectedLinks = ["link1", "link2"];
- resolveForReadTest(resolver, partitionKey, expectedLinks);
- done();
- });
-
- it("array of ranges", function (done) {
- var partitionKey = [
- new Range({ low: "A", high: "B" }),
- new Range({ low: "Q" })
- ];
- var expectedLinks = ["link1", "link2"];
- resolveForReadTest(resolver, partitionKey, expectedLinks);
- done();
- });
- });
-
- describe("resolveForRead number", function () {
- var partitionKeyExtractor = function (doc) {
- return doc.key;
- };
-
- var partitionKeyMap = [
- {
- range: new Range({ low: 1, high: 15 }),
- link: "link1"
- },
- {
- range: new Range({ low: 16, high: 30 }),
- link: "link2"
- }
- ];
-
- it("point, default compareFunction", function (done) {
- var resolver = new RangePartitionResolver(partitionKeyExtractor, partitionKeyMap);
-
- var partitionKey = new Range({ low: 2 });
- var expectedLinks = ["link2"];
-
- resolveForReadTest(resolver, partitionKey, expectedLinks);
- done();
- });
-
- it("point, custom compareFunction", function (done) {
- var resolver = new RangePartitionResolver(partitionKeyExtractor, partitionKeyMap, function (a, b) {
- return a - b;
- });
-
- var partitionKey = new Range({ low: 2 });
- var expectedLinks = ["link1"];
-
- resolveForReadTest(resolver, partitionKey, expectedLinks);
- done();
- });
- });
-
- describe("compareFunction", function () {
- var invalidCompareFunctionTest = function (compareFunction, done) {
- assert.throws(
- function () {
- var resolver = new RangePartitionResolver(
- "key",
- [{ range: new Range({ low: "A" }), link: "link1" }],
- compareFunction
- );
- },
- /Invalid argument: 'compareFunction' is not a function/);
- done();
- }
-
- it("invalid compareFunction - null", function (done) {
- var compareFunction = null;
- invalidCompareFunctionTest(compareFunction, done);
- });
-
- it("invalid compareFunction - string", function (done) {
- var compareFunction = "";
- invalidCompareFunctionTest(compareFunction, done);
- });
-
- it("invalid compareFunction - number", function (done) {
- var compareFunction = 0;
- invalidCompareFunctionTest(compareFunction, done);
- });
-
- it("invalid compareFunction - boolean", function (done) {
- var compareFunction = false;
- invalidCompareFunctionTest(compareFunction, done);
- });
-
- it("invalid compareFunction - object", function (done) {
- var compareFunction = {};
- invalidCompareFunctionTest(compareFunction, done);
- });
-
- it("compareFunction throws", function (done) {
- var resolver = new RangePartitionResolver(
- "key",
- [{ range: new Range({ low: "A" }), link: "link1" }],
- function (a, b) { throw new Error("Compare error"); }
- );
-
- assert.throws(
- function () {
- var result = resolver.resolveForRead("A", ["link1"]);
- },
- /Error: Compare error/);
- done();
- });
- });
-});
diff --git a/src/test/legacy/rangeTests.js b/src/test/legacy/rangeTests.js
deleted file mode 100644
index 360707a..0000000
--- a/src/test/legacy/rangeTests.js
+++ /dev/null
@@ -1,506 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert");
-
-var Range = lib.Range;
-
-describe("Range Tests", function () {
-
- // NOTICE: test name changed due to tooling glitch
- describe("constructor tests", function () {
- var invalidOptionsTest = function (options, expectedError, done) {
- assert.throws(
- function () {
- var r = new Range(options);
- },
- expectedError);
- done();
- }
-
- var optionsIsNullTest = function (options, done) {
- invalidOptionsTest(options, /Invalid argument: 'options' is null/, done);
- }
-
- var optionsIsNotAnObjectTest = function (options, done) {
- invalidOptionsTest(options, /Invalid argument: 'options' is not an object/, done);
- }
-
- var invalidRangeTest = function (options, done) {
- invalidOptionsTest(options, /Invalid argument: 'options.low' must be less than or equal than 'options.high'/, done);
- }
-
- it("options - undefined (ommited argument)", function (done) {
- assert(new Range());
- done();
- });
-
- it("options - undefined (literal argument)", function (done) {
- assert(new Range(undefined));
- done();
- });
-
- it("options - null ", function (done) {
- var options = null;
- optionsIsNullTest(options, done);
- });
-
- it("options - number", function (done) {
- var options = 0;
- optionsIsNotAnObjectTest(options, done);
- });
-
- it("invalid options - string", function (done) {
- var options = "";
- optionsIsNotAnObjectTest(options, done);
- });
-
- it("invalid options - boolean", function (done) {
- var options = false;
- optionsIsNotAnObjectTest(options, done);
- });
-
- it("Range instances are frozen", function (done) {
- var r = new Range();
-
- assert.throws(
- function () {
- r.compareFunction = 1;
- },
- // NOTICE: chrande changed the error message to "cannot" from "can't"
- /Cannot add property compareFunction, object is not extensible/
- );
-
- done();
- });
- });
-
- describe("_contains", function () {
- it("undefined,undefined contains undefined is true", function (done) {
- var r = new Range();
- assert(r._contains(undefined));
- done();
- });
-
- it("undefined,undefined contains null is false", function (done) {
- var r = new Range();
- assert(!r._contains(null));
- done();
- });
-
- it("null,null contains undefined is true", function (done) {
- var r = new Range({ low: null });
- assert(r._contains(null));
- done();
- });
-
- it("null,null contains null is true", function (done) {
- var r = new Range({ low: null });
- assert(r._contains(null));
- done();
- });
-
- it("range contains self is true - default range", function (done) {
- var r = new Range();
- assert(r._contains(r));
- done();
- });
-
- it("range contains self is true - non-default range", function (done) {
- var r = new Range({ low: "A" });
- assert(r._contains(r));
- done();
- });
-
- it("A,D contains B,C is true", function (done) {
- var r1 = new Range({ low: "A", high: "D" });
- var r2 = new Range({ low: "B", high: "C" });
- assert(r1._contains(r2));
- done();
- });
-
- it("B,C contains A,D is false", function (done) {
- var r1 = new Range({ low: "B", high: "C" });
- var r2 = new Range({ low: "A", high: "D" });
- assert(!r1._contains(r2));
- done();
- });
-
- it("A,C contains B,D is false", function (done) {
- var r1 = new Range({ low: "A", high: "C" });
- var r2 = new Range({ low: "B", high: "D" });
- assert(!r1._contains(r2));
- done();
- });
-
- it("B,D contains A,C is false", function (done) {
- var r1 = new Range({ low: "B", high: "D" });
- var r2 = new Range({ low: "A", high: "C" });
- assert(!r1._contains(r2));
- done();
- });
-
- it("A,B contains B,C is false", function (done) {
- var r1 = new Range({ low: "A", high: "B" });
- var r2 = new Range({ low: "B", high: "C" });
- assert(!r1._contains(r2));
- done();
- });
-
- it("B,C contains A,B is false", function (done) {
- var r1 = new Range({ low: "B", high: "C" });
- var r2 = new Range({ low: "A", high: "B" });
- assert(!r1._contains(r2));
- done();
- });
-
- it("A,B contains C,D is false", function (done) {
- var r1 = new Range({ low: "A", high: "B" });
- var r2 = new Range({ low: "C", high: "D" });
- assert(!r1._contains(r2));
- done();
- });
-
- it("C,D contains A,B is false", function (done) {
- var r1 = new Range({ low: "C", high: "D" });
- var r2 = new Range({ low: "A", high: "B" });
- assert(!r1._contains(r2));
- done();
- });
-
- it("A,C contains B is true", function (done) {
- var r1 = new Range({ low: "A", high: "C" });
- assert(r1._contains("B"));
- done();
- });
-
- it("B,C contains A is false", function (done) {
- var r1 = new Range({ low: "B", high: "C" });
- assert(!r1._contains("A"));
- done();
- });
-
- it("A,B contains C is false", function (done) {
- var r1 = new Range({ low: "A", high: "B" });
- assert(!r1._contains("C"));
- done();
- });
- });
-
- describe("_containsPoint", function () {
- var range = new Range({ low: 1, high: 3 });
-
- it("numbers, default comparison", function (done) {
- assert(range._containsPoint(20));
- done();
- });
-
- it("numbers, custom comparison", function (done) {
-
- assert(!range._containsPoint(20, function (a, b) {
- return a - b;
- }));
-
- done();
- });
- });
-
- describe("_containsRange", function () {
- var range = new Range({ low: 1, high: 3 });
-
- it("numbers, default comparison", function (done) {
- assert(range._containsRange({ low: 20, high: 29}));
- done();
- });
-
- it("numbers, custom comparison", function (done) {
- assert(!range._containsRange({ low: 20, high: 29 }, function (a, b) {
- return a - b;
- }));
-
- done();
- });
- });
-
- describe("_intersect", function () {
- var otherIsUndefinedOrNullTest = function (other, done) {
- var r = new Range();
- assert.throws(
- function () {
- r._intersect(other);
- },
- /Invalid Argument: 'other' is undefined or null/
- );
- done();
- };
-
- it("error - other is undefined", function (done) {
- otherIsUndefinedOrNullTest(undefined, done);
- });
-
- it("error - other is null", function (done) {
- otherIsUndefinedOrNullTest(null, done);
- });
-
- it("range intersect self is true - default range", function (done) {
- var r = new Range();
- assert(r._intersect(r));
- done();
- });
-
- it("R intersect R is true - non default range", function (done) {
- var r = new Range({ low: 1, high: "2" });
- assert(r._intersect(r));
- done();
- });
-
- it("A,D insersects B,C is true", function (done) {
- var r1 = new Range({ low: "A", high: "D" });
- var r2 = new Range({ low: "B", high: "C" });
- assert(r1._intersect(r2));
- done();
- });
-
- it("B,C insersects A,D is true", function (done) {
- var r1 = new Range({ low: "B", high: "C" });
- var r2 = new Range({ low: "A", high: "D" });
- assert(r1._intersect(r2));
- done();
- });
-
- it("A,C insersects B,D is true", function (done) {
- var r1 = new Range({ low: "A", high: "C" });
- var r2 = new Range({ low: "B", high: "D" });
- assert(r1._intersect(r2));
- assert(r2._intersect(r1));
- done();
- });
-
- it("B,D insersects A,C is true", function (done) {
- var r1 = new Range({ low: "B", high: "D" });
- var r2 = new Range({ low: "A", high: "C" });
- assert(r1._intersect(r2));
- done();
- });
-
- it("A,B insersects B,C is true", function (done) {
- var r1 = new Range({ low: "A", high: "B" });
- var r2 = new Range({ low: "B", high: "C" });
- assert(r1._intersect(r2));
- assert(r2._intersect(r1));
- done();
- });
-
- it("B,C insersects A,B is true", function (done) {
- var r1 = new Range({ low: "B", high: "C" });
- var r2 = new Range({ low: "A", high: "B" });
- assert(r1._intersect(r2));
- done();
- });
-
- it("A,B insersects C,D is false", function (done) {
- var r1 = new Range({ low: "A", high: "B" });
- var r2 = new Range({ low: "C", high: "D" });
- assert(!r1._intersect(r2));
- done();
- });
-
- it("C,D insersects A,B is false", function (done) {
- var r1 = new Range({ low: "C", high: "D" });
- var r2 = new Range({ low: "A", high: "B" });
- assert(!r1._intersect(r2));
- done();
- });
- });
-
- describe("_toString", function () {
- var toStringTest = function (options, expectedString, done) {
- var r = new Range(options);
- assert.strictEqual(r._toString(), expectedString);
- done();
- };
-
- it("undefined values", function (done) {
- toStringTest(undefined, "undefined,undefined", done);
- });
- it("null values", function (done) {
- toStringTest({ low: null }, "null,null", done);
- });
- it("NaN values", function (done) {
- toStringTest({ low: NaN }, "NaN,NaN", done);
- });
- it("number values", function (done) {
- toStringTest({ low: 1 }, "1,1", done);
- });
- it("string values", function (done) {
- toStringTest({ low: "a" }, "a,a", done);
- });
- it("boolean values", function (done) {
- toStringTest({ low: false, high: true }, "false,true", done);
- });
- it("object values", function (done) {
- toStringTest({ low: {} }, "[object Object],[object Object]", done);
- });
- });
-
- describe("_compare", function () {
- var r = new Range();
-
- var compareAsNumbers = function (a, b) {
- return a - b;
- }
-
- var constantCompareFunction = function (a, b) {
- return 0;
- };
-
- it("(undefined, undefined) === 0", function (done) {
- assert(r._compare() === 0);
- assert(r._compare(undefined) === 0);
- assert(r._compare(undefined, undefined) === 0);
- done();
- });
-
- it("(undefined, y) > 0", function (done) {
- assert(r._compare(undefined, null) > 0);
- assert(r._compare(undefined, -NaN) > 0);
- assert(r._compare(undefined, 0) > 0);
- assert(r._compare(undefined, NaN) > 0);
- assert(r._compare(undefined, true) > 0);
- assert(r._compare(undefined, false) > 0);
- assert(r._compare(undefined, "a") > 0);
- assert(r._compare(undefined, "undefined") > 0);
- assert(r._compare(undefined, "z") > 0);
- assert(r._compare(undefined, []) > 0);
- assert(r._compare(undefined, {}) > 0);
- assert(r._compare(undefined, 2, constantCompareFunction) > 0);
- assert(r._compare(undefined, 2, compareAsNumbers) > 0);
-
- done();
- });
-
- it("(x, undefined) < 0", function (done) {
- assert(r._compare(null) < 0);
- assert(r._compare(-NaN) < 0);
- assert(r._compare(0) < 0);
- assert(r._compare(NaN) < 0);
- assert(r._compare(true) < 0);
- assert(r._compare(false) < 0);
- assert(r._compare("a") < 0);
- assert(r._compare("undefined") < 0);
- assert(r._compare("z") < 0);
- assert(r._compare([]) < 0);
- assert(r._compare({}) < 0);
- assert(r._compare(1, undefined, constantCompareFunction) < 0);
- assert(r._compare(1, undefined, compareAsNumbers) < 0);
- done();
- });
-
- it("values as strings (default)", function (done) {
- assert(r._compare("A", "B") < 0);
- assert(r._compare("", "") === 0);
- assert(r._compare("B", "A") > 0);
- assert(r._compare("10", "2") < 0);
- assert(r._compare(10, "02") > 0);
- assert(r._compare(10, 2) < 0);
- assert(r._compare(null, "nulm") < 0);
- assert(r._compare(null, "null") === 0);
- assert(r._compare(null, "nulk") > 0);
- assert(r._compare(true, "truf") < 0);
- assert(r._compare(true, "true") === 0);
- assert(r._compare(true, "trud") > 0);
- assert(r._compare({}, "[object Object]") === 0);
- done();
- });
-
- it("values as numbers", function (done) {
-
- assert(r._compare(undefined, 2, compareAsNumbers) > 0);
- assert(r._compare(1, 2, compareAsNumbers) < 0);
- assert(r._compare(0, 0, compareAsNumbers) === 0);
- assert(r._compare(10, 2, compareAsNumbers) > 0);
- done();
- });
-
- it("always return 0", function (done) {
- assert(r._compare(1, 2, constantCompareFunction) === 0);
- assert(r._compare(2, 1, constantCompareFunction) === 0);
- done();
- });
- });
-
- describe("_isRange", function () {
- it("_isRange(undefined) is false", function (done) {
- assert(!Range._isRange());
- done();
- });
-
- it("_isRange(null) is false", function (done) {
- assert(!Range._isRange(null));
- done();
- });
-
- it("_isRange(non-object) is false", function (done) {
- var points = [
- undefined,
- null,
- 1,
- "",
- true,
- NaN,
- function () {
- },
- {},
- {
- low: ""
- }
- ];
-
- for (var i = 0; i < points.length; i++) {
- assert(!Range._isRange(points[i]));
- }
-
- done();
- });
-
- it("_isRange(point) is false", function (done) {
- var ranges = [
- {
- low: "",
- high: 1
- },
- new Range()
- ];
-
- // NOTICE: chrande modified this test because it wasn't passing and the logic didn't make sense.
- assert(!Range._isRange(ranges[0]));
- assert(Range._isRange(ranges[1]));
-
-
- done();
- });
- });
-});
diff --git a/src/test/legacy/readme.md b/src/test/legacy/readme.md
deleted file mode 100644
index 3caa766..0000000
--- a/src/test/legacy/readme.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Notice
-
-Only update these tests if you really know what you're doing.
-
-These tests are here in their near original form to serve as our backwards compatibility tests. They are tests which only test user facing functionality. Non-customer facing API tests are not tested for backwards compatibility.
-
-These tests should only be updated to address bugs that would have affected the legacy behavior or to add additional coverage that we've avoided breaking changes on the legacy APIs.
-
-They are kept in vanilla JS to reduce risk of breaking change.
\ No newline at end of file
diff --git a/src/test/legacy/ruPerMinTests.js b/src/test/legacy/ruPerMinTests.js
deleted file mode 100644
index 211038b..0000000
--- a/src/test/legacy/ruPerMinTests.js
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig");
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient,
- DocumentBase = lib.DocumentBase,
- Constants = lib.Constants,
- UriFactory = lib.UriFactory;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-describe("RU Per Minute", function () {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- var removeAllDatabases = function(done) {
- client.readDatabases().toArray(function(err, databases) {
- if (err !== undefined) {
- console.log("An error occured", err);
- assert.fail();
- return done(err);
- }
-
- var length = databases.length;
-
- if (length === 0) {
- return done();
- }
-
- var count = 0;
- databases.forEach(function(database) {
- client.deleteDatabase(database._self, function(err, db) {
- if (err !== undefined) {
- console.log("An error occured", err);
- assert.fail();
- return done(err);
- }
-
- count++;
- if (count === length) {
- done();
- }
- });
- });
- });
- };
-
- var databaseLink = undefined;
- var createDatabase = function (done) {
- client.createDatabase({ id: "Database" }, function (err, createdDB) {
- assert.equal(err, undefined, "error creating database ");
- databaseLink = UriFactory.createDatabaseUri(createdDB.id);
- done();
- });
- }
-
- //- removes all the databases,
- // - creates a new database,
- beforeEach(function(done) {
- removeAllDatabases(function() {
- return createDatabase(function() {
- done();
- });
- });
- });
-
- //- removes all the databases,
- afterEach(function (done) {
- removeAllDatabases(function () {
- done();
- });
- });
-
- xit("Create Collection with RU Per Minute Offer", function(done) {
- var collectionDefinition = {
- id: "sample col"
- };
-
- var options = {
- offerEnableRUPerMinuteThroughput: true,
- offerVersion: "V2",
- offerThroughput: 400
- };
-
- client.createCollection(databaseLink, collectionDefinition, options, function(err, collection) {
- assert.equal(err, undefined, "Error in creating collection");
-
- var validateOffer = function(error, offers) {
- assert.equal(error, undefined, "unexpected failure in reading offers");
- assert.equal(offers.length, 1);
- var offer = offers[0];
-
- assert.equal(offer.offerType, "Invalid");
- assert.notEqual(offer.content, undefined);
- assert.equal(offer.content.offerIsRUPerMinuteThroughputEnabled, true);
-
- done();
- };
-
- var queryIterator = client.readOffers().toArray(validateOffer);
- });
- });
-
- xit("Create Collection without RU Per Minute Offer", function (done) {
- var collectionDefinition = {
- id: "sample col"
- };
-
- var options = {
- offerVersion: "V2",
- offerThroughput: 400
- };
-
- client.createCollection(databaseLink, collectionDefinition, options, function (err, collection) {
- assert.equal(err, undefined, "Error in creating collection");
-
- var validateOffer = function (error, offers) {
- assert.equal(error, undefined, "unexpected failure in reading offers");
- assert.equal(offers.length, 1);
- var offer = offers[0];
-
- assert.equal(offer.offerType, "Invalid");
- assert.notEqual(offer.content, undefined);
- assert.equal(offer.content.offerIsRUPerMinuteThroughputEnabled, false);
-
- done();
- };
-
- var queryIterator = client.readOffers().toArray(validateOffer);
- });
- });
-
- xit("Create Collection with RU Per Minute Offer and insert Document with disableRUPerMinuteUsage options", function (done) {
- var collectionDefinition = {
- id: "sample col"
- };
-
- var options = {
- offerEnableRUPerMinuteThroughput: true,
- offerVersion: "V2",
- offerThroughput: 400
- };
-
- client.createCollection(databaseLink, collectionDefinition, options, function (err, collection) {
- assert.equal(err, undefined, "Error in creating collection");
- var collectionLink = collection._self;
- var options = {
- disableRUPerMinuteUsage: true
- };
- client.createDocument(collectionLink, { id : "sample document"}, options, function(err, document, headers) {
- assert.equal(err, undefined, "Error in creating document");
- assert(headers[Constants.HttpHeaders.IsRUPerMinuteUsed] != true);
- done();
- });
- });
- });
-});
\ No newline at end of file
diff --git a/src/test/legacy/sessionTests.js b/src/test/legacy/sessionTests.js
deleted file mode 100644
index 617ccc2..0000000
--- a/src/test/legacy/sessionTests.js
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig"),
- sinon = require("sinon"),
- Base = lib.Base,
- Constants = lib.Constants,
- DocumentDBClient = lib.DocumentClient;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-describe("Session Token", function () {
- var client = new DocumentDBClient(host, { masterKey: masterKey }, null, 'Session');
- var databaseId = "sessionTestDB";
- var collectionId = "sessionTestColl";
- var collectionLink = "dbs/" + databaseId + "/colls/" + collectionId;
-
- var databaseBody = { id: databaseId };
- var collectionDefinition = { 'id': collectionId, 'partitionKey': { 'paths': ['/id'], 'kind': 'Hash' } };
- var collectionOptions = { 'offerThroughput': 10100 };
-
- var getSpy = sinon.spy(client, 'get');
- var postSpy = sinon.spy(client, 'post');
- var putSpy = sinon.spy(client, 'put');
- var deleteSpy = sinon.spy(client, 'delete');
-
- var deleteDatabases = function (done) {
-
- client.queryDatabases("SELECT * FROM root r WHERE r.id='" + databaseId + "'").toArray(function (err, databases) {
- if (err || databases.length == 0) {
- return done();
- }
-
- client.deleteDatabase("dbs/" + databaseId, function (err, db) {
- return done();
- });
- });
- };
-
- var getToken = function (tokens) {
- var newToken = {};
- for (var coll in tokens) {
- for (var k in tokens[coll]) {
- newToken[k] = tokens[coll][k];
- }
- return newToken;
- }
- };
-
- var getIndex = function (tokens, index1) {
- var keys = Object.keys(tokens);
- if (typeof index1 == 'undefined')
- return keys[0]
- else
- return keys[1];
- }
-
- it("validate session tokens for sequence of opearations", function (done) {
- var index1;
- var index2;
-
- client.createDatabase(databaseBody, function (err, database) {
- assert.equal(err, undefined, "error creating database");
-
- client.createCollection(database._self, collectionDefinition, collectionOptions, function (err, createdCollection) {
- assert.equal(err, undefined, "error creating collection");
- assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], undefined);
- assert.deepEqual(client.sessionContainer.collectionResourceIdToSessionTokens, {});
-
- client.createDocument(collectionLink, { "id": "1" }, function (err, document1) {
- assert.equal(err, undefined, "error creating document 1");
- assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], undefined);
-
- var tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
- index1 = getIndex(tokens);
- assert.notEqual(tokens[index1], undefined);
- var firstPartitionLSN = tokens[index1];
-
- client.createDocument(collectionLink, { "id": "2" }, function (err, document2) {
- assert.equal(err, undefined, "error creating document 2");
- assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], client.sessionContainer.getCombinedSessionToken(tokens));
-
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
- index2 = getIndex(tokens, index1);
- assert.equal(tokens[index1], firstPartitionLSN);
- assert.notEqual(tokens[index2], undefined);
- var secondPartitionLSN = tokens[index2];
-
- client.readDocument(document1._self, { 'partitionKey': '1' }, function (err, document1) {
- assert.equal(err, undefined, "error reading document 1");
- assert.equal(getSpy.lastCall.args[2][Constants.HttpHeaders.SessionToken], client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
- assert.equal(tokens[index1], firstPartitionLSN);
- assert.equal(tokens[index2], secondPartitionLSN);
-
- client.upsertDocument(createdCollection._self, { "id": "1", "operation": "upsert" }, { 'partitionKey': '1' }, function (err, document1) {
- assert.equal(err, undefined, "error upserting document 1");
- assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
- assert.equal(tokens[index1], (Number(firstPartitionLSN) + 1).toString());
- assert.equal(tokens[index2], secondPartitionLSN);
- firstPartitionLSN = tokens[index1];
-
- client.deleteDocument(document2._self, { 'partitionKey': '2' }, function (err, document2) {
- assert.equal(err, undefined, "error deleting document 2");
- assert.equal(deleteSpy.lastCall.args[2][Constants.HttpHeaders.SessionToken], client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
- assert.equal(tokens[index1], firstPartitionLSN);
- assert.equal(tokens[index2], (Number(secondPartitionLSN) + 1).toString());
- secondPartitionLSN = tokens[index2];
-
- client.replaceDocument(document1._self, { "id": "1", "operation": "replace" }, { 'partitionKey': '1' }, function (err, document1) {
- assert.equal(err, undefined, "error replacing document 1");
- assert.equal(putSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
- assert.equal(tokens[index1], (Number(firstPartitionLSN) + 1).toString());
- assert.equal(tokens[index2], secondPartitionLSN);
- firstPartitionLSN = tokens[index1];
-
- var query = "SELECT * from " + collectionId
- var queryOptions = { 'partitionKey': '1' }
- var queryIterator = client.queryDocuments(collectionLink, query, queryOptions);
-
- queryIterator.toArray(function (error, result) {
- assert.equal(error, undefined);
- assert.equal(postSpy.lastCall.args[3][Constants.HttpHeaders.SessionToken], client.sessionContainer.getCombinedSessionToken(tokens));
- tokens = getToken(client.sessionContainer.collectionResourceIdToSessionTokens);
- assert.equal(tokens[index1], firstPartitionLSN);
- assert.equal(tokens[index2], secondPartitionLSN);
-
-
- client.deleteCollection(createdCollection._self, function (err, result) {
- assert.equal(err, undefined, "error deleting collection");
- assert.equal(deleteSpy.lastCall.args[2][Constants.HttpHeaders.SessionToken], client.sessionContainer.getCombinedSessionToken(tokens));
- assert.deepEqual(client.sessionContainer.collectionResourceIdToSessionTokens, {});
-
- getSpy.restore();
- postSpy.restore();
- deleteSpy.restore();
- putSpy.restore();
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
-
- it("validate 'lsn not caught up' error for higher lsn and clearing session token", function (done) {
-
- client.createDatabase(databaseBody, function (err, database) {
- assert.equal(err, undefined, "error creating database");
-
- var increaseLSN = function (oldTokens) {
- for (var coll in oldTokens) {
- for (var token in oldTokens[coll]) {
- var newVal = (Number(oldTokens[coll][token]) + 2000).toString();
- return token + ":" + newVal;
- }
- }
- }
-
- client.createCollection(database._self, collectionDefinition, collectionOptions, function (err, createdCollection) {
- assert.equal(err, undefined, "error creating collection");
- client.createDocument(collectionLink, { "id": "1" }, function (err, document1) {
- var callbackSpy = sinon.spy(function (path, reqHeaders) {
- var oldTokens = client.sessionContainer.collectionResourceIdToSessionTokens;
- reqHeaders[Constants.HttpHeaders.SessionToken] = increaseLSN(oldTokens);
- });
-
- var applySessionTokenStub = sinon.stub(client, 'applySessionToken').callsFake(callbackSpy);
- client.readDocument(collectionLink + "/docs/1", { 'partitionKey': '1' }, function (err, document1) {
- assert.equal(err.substatus, 1002, "Substatus should indicate the LSN didn't catchup.");
- assert.equal(callbackSpy.callCount, 1);
- assert.equal(Base._trimSlashes(callbackSpy.lastCall.args[0]), collectionLink + "/docs/1");
- applySessionTokenStub.restore();
-
- client.readDocument(collectionLink + "/docs/1", { 'partitionKey': '1' }, function (err, document1) {
- //console.log(document1);
- assert.equal(err, undefined, "error creating collection");
- done();
- });
- });
- });
- });
- });
- });
-
- it("validate that a client does not have session token of a collection created by another client", function (done) {
-
- var client2 = new DocumentDBClient(host, { masterKey: masterKey }, null, 'Session');
- client.createDatabase(databaseBody, function (err, database) {
- assert.equal(err, undefined, "error creating database");
-
- client.createCollection(database._self, collectionDefinition, collectionOptions, function (err, createdCollection) {
- assert.equal(err, undefined, "error creating collection");
-
- client.readCollection(createdCollection._self, function (err, collection) {
- assert.equal(err, undefined, "error reading collection");
-
- client2.deleteCollection(createdCollection._self, function (err, collection) {
- assert.equal(err, undefined, "error deleting collection");
-
- client2.createCollection(database._self, collectionDefinition, collectionOptions, function (err, createdCollection) {
- assert.equal(err, undefined, "error creating collection");
-
- client2.readCollection(createdCollection._self, function (err, collection) {
- assert.equal(err, undefined, "error reading collection");
- assert.equal(client.getSessionToken(collection._self), "");
- assert.notEqual(client2.getSessionToken(collection._self), "");
- done();
- });
- });
- });
- });
- });
- });
- });
-
- afterEach(function (done) { deleteDatabases(done) });
- beforeEach(function (done) { deleteDatabases(done) });
-
-});
-
diff --git a/src/test/legacy/splitTests.js b/src/test/legacy/splitTests.js
deleted file mode 100644
index b8b54ac..0000000
--- a/src/test/legacy/splitTests.js
+++ /dev/null
@@ -1,563 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig"),
- Stream = require("stream"),
- util = require("util"),
- HeaderUtils = require("../..//queryExecutionContext/headerUtils"), // TODO: shouldn't be using the direct path, use lib.HeaderUtils
- spawn = require("child_process").spawnSync,
- exec = require("child_process").execFileSync,
- _ = require('underscore');
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient,
- DocumentBase = lib.DocumentBase,
- Constants = lib.Constants,
- Range = lib.Range,
- RangePartitionResolver = lib.RangePartitionResolver,
- HashPartitionResolver = lib.HashPartitionResolver,
- AzureDocuments = lib.AzureDocuments,
- RetryOptions = lib.RetryOptions;
-
-process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-var adminUtilitiesPath = testConfig.adminUtilitiesPath;
-var splitRangeCommand = "SplitRange";
-var partitionKey = "key";
-var stopWorkload = false;
-
-var SplitMethod = {
- "EqualRange": 0,
- "EqualCount": 1,
- "Explicit": 2
-};
-
-describe.skip("NodeJS Split Tests", function () {
- var removeAllDatabases = function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- client.readDatabases().toArray(function (err, databases) {
- if (err !== undefined) {
- console.log("An error occured", err);
- assert.fail();
- return done(err);
- }
-
- var length = databases.length;
-
- if (length === 0) {
- return done();
- }
-
- var count = 0;
- databases.forEach(function (database) {
- client.deleteDatabase(database._self, function (err, db) {
- if (err !== undefined) {
- console.log("An error occured", err);
- assert.fail();
- return done(err);
- }
-
- count++;
- if (count === length) {
- done();
- }
- });
- });
- });
- };
-
- var generateDocuments = function (docSize) {
- var docs = []
- for (var i = 0; i < docSize; i++) {
- var d = {
- 'id': i.toString(),
- 'name': 'sample document',
- 'spam': 'eggs' + i.toString(),
- 'cnt': i,
- 'key': 'value',
- 'spam2': (i == 3) ? 'eggs' + i.toString() : i,
- 'boolVar': (i % 2 === 0),
- 'number': 1.1 * i
-
- };
- docs.push(d);
- }
- return docs;
- };
-
- var getDatabaseLink = function (isNameBasedLink, db) {
- if (isNameBasedLink) {
- return "dbs/" + db.id;
- } else {
- return db._self;
- }
- };
-
- var getCollectionLink = function (isNameBasedLink, db, coll) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id;
- } else {
- return coll._self;
- }
- };
-
- var getDocumentLink = function (isNameBasedLink, db, coll, doc) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/docs/" + doc.id;
- } else {
- return doc._self;
- }
- };
-
- var bulkInsertDocuments = function (client, isNameBased, db, collection, documents, callback) {
- var returnedDocuments = [];
- var insertDocument = function (currentIndex) {
- if (currentIndex >= documents.length) {
- callback(returnedDocuments);
- }
- else {
- client.createDocument(getCollectionLink(isNameBased, db, collection), documents[currentIndex], function (err, document) {
- assert.equal(err, undefined, "error creating document " + JSON.stringify(documents[currentIndex]));
- returnedDocuments.push(document);
- insertDocument(++currentIndex);
- });
- }
- };
-
- insertDocument(0);
- };
-
- describe("Validate Split", function () {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- var documentDefinitions = generateDocuments(20);
- // Global variable to determine if we should split after a round trip.
- var shouldSplit = true;
- //- removes all the databases,
- // - creates a new database,
- // - creates a new collecton,
- // - bulk inserts documents to the collection
- beforeEach(function (done) {
- shouldSplit = true;
- removeAllDatabases(function () {
- return createDatabase(function () {
- return createCollection(
- function () {
- bulkInsertDocuments(client, isNameBased, db, collection, documentDefinitions,
- function (insertedDocs) {
- return done();
- });
- }
- );
- });
- });
- });
-
- var db = undefined;
- var createDatabase = function (done) {
- client.createDatabase({ id: "sample 中文 database" }, function (err, createdDB) {
- assert.equal(err, undefined, "error creating database ");
- db = createdDB;
- done();
- });
- }
- var collection = undefined;
- var isNameBased = false;
-
- var createCollection = function (done) {
- var collectionDefinition = {
- 'id': 'sample collection',
- 'indexingPolicy': {
- 'includedPaths': [
- {
- 'path': '/',
- 'indexes': [
- {
- 'kind': 'Range',
- 'dataType': 'Number'
- },
- {
- 'kind': 'Range',
- 'dataType': 'String'
- }
- ]
- }
- ]
- },
- 'partitionKey': {
- 'paths': [
- '/id'
- ],
- 'kind': 'Hash'
- }
- }
- var collectionOptions = { 'offerThroughput': 10100 }
- client.createCollection("dbs/sample 中文 database", collectionDefinition, collectionOptions, function (err, createdCollection) {
- assert.equal(err, undefined, "error creating collection");
- collection = createdCollection;
- done();
- });
- };
-
- var executeSplitRange = function (collectionRid, partitionKeyRangeId, minimumAllowedFraction, splitMethod) {
- console.log("Launching Command: ");
- var args = [splitRangeCommand, collectionRid, partitionKeyRangeId, minimumAllowedFraction, splitMethod];
- var childProcess = spawn(adminUtilitiesPath, args, { stdio: 'inherit' });
- assert.equal(childProcess.status, 0);
- };
-
- var validateResults = function (actualResults, expectedOrderIds) {
- assert.equal(actualResults.length, expectedOrderIds.length,
- "actual results length doesn't match with expected results length.");
-
- for (var i = 0; i < actualResults.length; i++) {
- assert.equal(actualResults[i].id, expectedOrderIds[i],
- "actual result content doesn't match with expected result content.");
- }
- }
-
- var validateToArray = function (queryIterator, options, expectedOrderIds, done) {
-
- ////////////////////////////////
- // validate toArray()
- ////////////////////////////////
- options.continuation = undefined;
- var toArrayVerifier = function (err, results) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + JSON.stringify(err));
- assert.equal(results.length, expectedOrderIds.length, "invalid number of results");
- assert.equal(queryIterator.hasMoreResults(), false, "hasMoreResults: no more results is left");
-
- validateResults(results, expectedOrderIds);
- return done();
- };
-
- queryIterator.toArray(toArrayVerifier);
- };
-
- var validateNextItem = function (queryIterator, options, expectedOrderIds, done) {
-
- ////////////////////////////////
- // validate nextItem()
- ////////////////////////////////
- var results = [];
- var nextItemVerifier = function (err, item) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + err);
- if (item === undefined) {
- assert(!queryIterator.hasMoreResults(), "hasMoreResults must signal results exhausted");
- validateResults(results, expectedOrderIds);
-
- return done();
- }
- results = results.concat(item);
-
- if (results.length < expectedOrderIds.length) {
- assert(queryIterator.hasMoreResults(), "hasMoreResults must indicate more results");
- }
- return queryIterator.nextItem(nextItemVerifier);
- };
-
- queryIterator.nextItem(nextItemVerifier);
- };
-
- var validateNextItemAndCurrentAndHasMoreResults = function (queryIterator, options, expectedOrderIds, done) {
- // curent and nextItem recursively invoke each other till queryIterator is exhausted
- ////////////////////////////////
- // validate nextItem()
- ////////////////////////////////
- var results = [];
- var nextItemVerifier = function (err, item) {
-
- ////////////////////////////////
- // validate current()
- ////////////////////////////////
- var currentVerifier = function (err, currentItem) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + err);
- assert.equal(item, currentItem, "current must give the previously item returned by nextItem");
-
- if (currentItem === undefined) {
- assert(!queryIterator.hasMoreResults(), "hasMoreResults must signal results exhausted");
- validateResults(results, expectedOrderIds);
-
- return done();
- }
-
- if (results.length < expectedOrderIds.length) {
- assert(queryIterator.hasMoreResults(), "hasMoreResults must indicate more results");
- }
-
- return queryIterator.nextItem(nextItemVerifier);
- };
-
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + err);
-
- if (item === undefined) {
- assert(!queryIterator.hasMoreResults(), "hasMoreResults must signal results exhausted");
- validateResults(results, expectedOrderIds);
-
- return queryIterator.current(currentVerifier);
- }
- results = results.concat(item);
-
- if (results.length < expectedOrderIds.length) {
- assert(queryIterator.hasMoreResults(), "hasMoreResults must indicate more results");
- }
-
- var currentVerifier = function (err, currentItem) {
- queryIterator.nextItem(nextItemVerifier);
- }
-
- return queryIterator.current(currentVerifier);
- };
- queryIterator.nextItem(nextItemVerifier);
- };
-
- var validateExecuteNextWithGivenContinuationToken = function (collectionLink, query, origOptions, listOfResultPages, listOfHeaders, done) {
- var options = JSON.parse(JSON.stringify(origOptions));
- var expectedResults = listOfResultPages.shift();
- var headers = listOfHeaders.shift();
- if (headers === undefined) {
- assert(listOfHeaders.length == 0, "only last header is empty");
- assert(listOfResultPages.length == 0);
- return done();
- }
-
- assert.notEqual(expectedResults, undefined);
-
- var continuationToken = headers[Constants.HttpHeaders.Continuation];
-
- var fromTokenValidator = function (token, expectedResultsFromToken, expectedHeadersFromToken) {
- options.continuation = token;
- var queryIterator = client.queryDocuments(collectionLink, query, options);
-
- var fromTokenToLastPageValidator = function (queryIterator, token, expectedResultsFromToken, expectedHeadersFromToken) {
-
- // validates single page result and
- var resultPageValidator = function (err, resources, headers) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + err + JSON.stringify(err));
-
- var exptectedResultPage = expectedResultsFromToken.shift();
- var expectedHeaders = expectedHeadersFromToken.shift();
- if (exptectedResultPage === undefined) {
- assert.equal(resources, undefined);
- assert.equal(headers, undefined);
- } else {
-
- validateResults(resources, exptectedResultPage.map(
- function (r) {
- return r['id'];
- }));
-
- if (expectedHeaders) {
- assert.equal(
- headers[Constants.HttpHeaders.Continuation],
- expectedHeaders[Constants.HttpHeaders.Continuation]);
- } else {
- assert.equal(headers, undefined);
- }
- }
-
- if (expectedHeadersFromToken.length > 0) {
- return fromTokenToLastPageValidator(queryIterator, token, expectedResultsFromToken, expectedHeadersFromToken);
- } else {
- // start testing from next continuation token ...
- return validateExecuteNextWithGivenContinuationToken(collectionLink, query, options, listOfResultPages, listOfHeaders, done);
- }
- }
- queryIterator.executeNext(resultPageValidator);
- }
- return fromTokenToLastPageValidator(queryIterator, continuationToken, listOfResultPages, listOfHeaders);
- }
- return fromTokenValidator(continuationToken, listOfResultPages, listOfHeaders);
- }
-
- var validateExecuteNextAndHasMoreResults = function (collectionLink, query, options, queryIterator, expectedOrderIds, done,
- validateExecuteNextWithContinuationToken) {
- var pageSize = options['maxItemCount'];
-
- ////////////////////////////////
- // validate executeNext()
- ////////////////////////////////
-
- var listOfResultPages = [];
- var listOfHeaders = [];
-
- var totalFetchedResults = [];
- var executeNextValidator = function (err, results, headers) {
- // CollectionRid is case sensitive.
- var collectionRid = collectionLink.split("/")[3];
-
- // Spliting to test split proof after retrieving the page
- if (shouldSplit) {
- executeSplitRange(collectionRid, "0", "0.1", "EqualRange");
- shouldSplit = false;
- }
-
- listOfResultPages.push(results);
- listOfHeaders.push(headers);
-
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + err + JSON.stringify(err));
- if (results === undefined || (totalFetchedResults.length === expectedOrderIds.length)) {
- // no more results
- validateResults(totalFetchedResults, expectedOrderIds);
- assert.equal(queryIterator.hasMoreResults(), false, "hasMoreResults: no more results is left");
- assert.equal(results, undefined, "unexpected more results" + JSON.stringify(results));
- if (validateExecuteNextWithContinuationToken) {
- return validateExecuteNextWithGivenContinuationToken(
- collectionLink, query, options, listOfResultPages, listOfHeaders, done
- );
- } else {
- return done();
- }
- }
-
- totalFetchedResults = totalFetchedResults.concat(results);
-
- if (totalFetchedResults.length < expectedOrderIds.length) {
- // there are more results
- assert(results.length <= pageSize, "executeNext: invalid fetch block size");
- //if (validateExecuteNextWithContinuationToken) {
- // assert(results.length <= pageSize, "executeNext: invalid fetch block size");
- //} else {
- // assert.equal(results.length, pageSize, "executeNext: invalid fetch block size");
-
- //}
- assert(queryIterator.hasMoreResults(), "hasMoreResults expects to return true");
- return queryIterator.executeNext(executeNextValidator);
-
- } else {
- // no more results
- assert.equal(expectedOrderIds.length, totalFetchedResults.length, "executeNext: didn't fetch all the results");
- assert(results.length <= pageSize, "executeNext: actual fetch size is more than the requested page size");
-
- //validate that next execute returns undefined resources
- return queryIterator.executeNext(executeNextValidator);
- }
- };
-
- queryIterator.executeNext(executeNextValidator);
- }
-
- var validateForEach = function (queryIterator, options, expectedOrderIds, done) {
-
- ////////////////////////////////
- // validate forEach()
- ////////////////////////////////
- var results = [];
- var callbackSingnalledEnd = false;
- var forEachCallback = function (err, item) {
- assert.equal(err, undefined, "unexpected failure in fetching the results: " + err + JSON.stringify(err));
- // if the previous invocation returned false, forEach must avoid invoking the callback again!
- assert.equal(callbackSingnalledEnd, false, "forEach called callback after the first false returned");
- results = results.concat(item);
- if (results.length === expectedOrderIds.length) {
- callbackSingnalledEnd = true;
- validateResults(results, expectedOrderIds);
- process.nextTick(done);
- return false
- }
- return true;
- };
-
- queryIterator.forEach(forEachCallback);
- }
-
- var executeQueryAndValidateResults = function (collectionLink, query, options, expectedOrderIds, done, validateExecuteNextWithContinuationToken) {
-
- validateExecuteNextWithContinuationToken = validateExecuteNextWithContinuationToken || false;
- var queryIterator = client.queryDocuments(collectionLink, query, options);
-
- validateToArray(queryIterator, options, expectedOrderIds,
- function () {
- queryIterator.reset();
- validateExecuteNextAndHasMoreResults(collectionLink, query, options, queryIterator, expectedOrderIds,
- function () {
- queryIterator.reset();
- validateNextItemAndCurrentAndHasMoreResults(queryIterator, options, expectedOrderIds,
- function () {
- validateForEach(queryIterator, options, expectedOrderIds, done);
- }
- );
- },
- validateExecuteNextWithContinuationToken
- );
- }
- );
- };
- // We can only have 5 split test cases, since the VM will only let us split 10 times
-
- // Parallel Query Tests
- it("Validate Parallel Query As String With maxDegreeOfParallelism: 3", function (done) {
- // simple order by query in string format
- var query = 'SELECT * FROM root r';
- var options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 3 };
-
- var expectedOrderedIds = [1, 10, 18, 2, 3, 13, 14, 16, 17, 0, 11, 12, 5, 9, 19, 4, 6, 7, 8, 15];
-
- // validates the results size and order
- executeQueryAndValidateResults(getCollectionLink(isNameBased, db, collection), query, options, expectedOrderedIds, done);
- });
-
- // OrderBy Tests
- it("Validate Simple OrderBy Query As String With maxDegreeOfParallelism = 3", function (done) {
- // simple order by query in string format
- var query = 'SELECT * FROM root r order by r.spam';
- var options = { enableCrossPartitionQuery: true, maxItemCount: 2, maxDegreeOfParallelism: 3 };
-
- // prepare expected results
- var getOrderByKey = function (r) {
- return r['spam'];
- }
- var expectedOrderedIds = (_.sortBy(documentDefinitions, getOrderByKey).map(function (r) {
- return r['id'];
- }));
-
- // validates the results size and order
- executeQueryAndValidateResults(getCollectionLink(isNameBased, db, collection), query, options, expectedOrderedIds, done);
- });
-
- it("Validate OrderBy with top", function (done) {
- // an order by query with top, total existing docs more than requested top count
- var topCount = 9;
- var querySpec = {
- 'query': util.format('SELECT top %d * FROM root r order by r.spam', topCount)
- }
- var options = { enableCrossPartitionQuery: true, maxItemCount: 2 };
-
- // prepare expected results
- var getOrderByKey = function (r) {
- return r['spam'];
- }
- var expectedOrderedIds = (_.sortBy(documentDefinitions, getOrderByKey).map(function (r) {
- return r['id'];
- })).slice(0, topCount);
-
- executeQueryAndValidateResults(getCollectionLink(isNameBased, db, collection), querySpec, options, expectedOrderedIds, done);
-
- });
- });
-});
\ No newline at end of file
diff --git a/src/test/legacy/sslVerificationTests.js b/src/test/legacy/sslVerificationTests.js
deleted file mode 100644
index 9bdda47..0000000
--- a/src/test/legacy/sslVerificationTests.js
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- The MIT License (MIT)
- Copyright (c) 2017 Microsoft Corporation
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- */
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert");
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient,
- DocumentBase = lib.DocumentBase;
-
-var host = "https://localhost:443";
-var masterKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
-
-// Skipping these tests for now until we find a way to run these tests in a seperate nodejs process
-// Currently all tests are run in same process so we cannot update the environment variables for different tests
-// This test runs fine when run independently but fails when run along with rest of the tests.
-describe.skip("Validate SSL verification check for emulator", function () {
- it("nativeApi Client Should throw exception", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey});
-
- // create database
- client.createDatabase({ id: Base.generateGuidId() }, function (err, db) {
- // connecting to emulator should throw SSL verification error,
- // unless you explicitly disable it via connectionPolicy.DisableSSLVerification
- assert.equal(err.code, "DEPTH_ZERO_SELF_SIGNED_CERT", "client should throw exception");
- done();
- });
- });
-
- it("nativeApi Client Should successfully execute request", function (done) {
- var connectionPolicy = new DocumentBase.ConnectionPolicy();
- // Disable SSL verification explicitly
- connectionPolicy.DisableSSLVerification = true;
- var client = new DocumentDBClient(host, { masterKey: masterKey },
- connectionPolicy);
-
- // create database
- client.createDatabase({ id: Base.generateGuidId() }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- done();
- });
- });
- });
diff --git a/src/test/legacy/test.js b/src/test/legacy/test.js
deleted file mode 100644
index eb527d0..0000000
--- a/src/test/legacy/test.js
+++ /dev/null
@@ -1,4111 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig"),
- Stream = require("stream");
-
-var Base = lib.Base,
- DocumentDBClient = lib.DocumentClient,
- DocumentBase = lib.DocumentBase,
- Constants = lib.Constants,
- Range = lib.Range,
- RangePartitionResolver = lib.RangePartitionResolver,
- HashPartitionResolver = lib.HashPartitionResolver,
- AzureDocuments = lib.AzureDocuments,
- RetryOptions = lib.RetryOptions;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-describe("NodeJS CRUD Tests", function () {
-
- // remove all databases from the endpoint before each test
- beforeEach(function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- var qf = client.readDatabases();
- qf.toArray(function (err, databases) {
- if (err !== undefined) {
- console.log("An error occured", err);
- return done();
- }
-
- var length = databases.length;
-
- if (length === 0) {
- return done();
- }
-
- var count = 0;
- databases.forEach(function (database) {
- client.deleteDatabase(database._self, function (err, db) {
- if (err !== undefined) {
- console.log("An error occured", err);
- return done();
- }
-
- count++;
- if (count === length) {
- done();
- }
- });
- });
- });
- });
-
- var addUpsertWrapperMethods = function (client, isUpsertTest) {
- // Document
- client["createOrUpsertDocument"] = function (collectionLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertDocument(collectionLink, body, options, callback);
- }
- else {
- this.createDocument(collectionLink, body, options, callback);
- }
- };
- client["replaceOrUpsertDocument"] = function (collectionLink, documentLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertDocument(collectionLink, body, options, callback);
- }
- else {
- this.replaceDocument(documentLink, body, options, callback);
- }
- };
-
- // Attachment
- client["createOrUpsertAttachment"] = function (documentLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertAttachment(documentLink, body, options, callback);
- }
- else {
- this.createAttachment(documentLink, body, options, callback);
- }
- };
- client["replaceOrUpsertAttachment"] = function (documentLink, attachmentLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertAttachment(documentLink, body, options, callback);
- }
- else {
- this.replaceAttachment(attachmentLink, body, options, callback);
- }
- };
-
- // User
- client["createOrUpsertUser"] = function (databaseLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertUser(databaseLink, body, options, callback);
- }
- else {
- this.createUser(databaseLink, body, options, callback);
- }
- };
- client["replaceOrUpsertUser"] = function (databaseLink, userLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertUser(databaseLink, body, options, callback);
- }
- else {
- this.replaceUser(userLink, body, options, callback);
- }
- };
-
- // Permission
- client["createOrUpsertPermission"] = function (userLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertPermission(userLink, body, options, callback);
- }
- else {
- this.createPermission(userLink, body, options, callback);
- }
- };
- client["replaceOrUpsertPermission"] = function (userLink, permissionLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertPermission(userLink, body, options, callback);
- }
- else {
- this.replacePermission(permissionLink, body, options, callback);
- }
- };
-
- // Trigger
- client["createOrUpsertTrigger"] = function (collectionLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertTrigger(collectionLink, body, options, callback);
- }
- else {
- this.createTrigger(collectionLink, body, options, callback);
- }
- };
- client["replaceOrUpsertTrigger"] = function (collectionLink, triggerLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertTrigger(collectionLink, body, options, callback);
- }
- else {
- this.replaceTrigger(triggerLink, body, options, callback);
- }
- };
-
- // User Defined Function
- client["createOrUpsertUserDefinedFunction"] = function (collectionLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertUserDefinedFunction(collectionLink, body, options, callback);
- }
- else {
- this.createUserDefinedFunction(collectionLink, body, options, callback);
- }
- };
- client["replaceOrUpsertUserDefinedFunction"] = function (collectionLink, udfLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertUserDefinedFunction(collectionLink, body, options, callback);
- }
- else {
- this.replaceUserDefinedFunction(udfLink, body, options, callback);
- }
- };
-
- // Stored Procedure
- client["createOrUpsertStoredProcedure"] = function (collectionLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertStoredProcedure(collectionLink, body, options, callback);
- }
- else {
- this.createStoredProcedure(collectionLink, body, options, callback);
- }
- };
- client["replaceOrUpsertStoredProcedure"] = function (collectionLink, sprocLink, body, options, callback) {
- if (isUpsertTest) {
- this.upsertStoredProcedure(collectionLink, body, options, callback);
- }
- else {
- this.replaceStoredProcedure(sprocLink, body, options, callback);
- }
- };
-
- // Attachment and Upload Media
- client["createOrUpsertAttachmentAndUploadMedia"] = function (documentLink, readableStream, options, callback) {
- if (isUpsertTest) {
- this.upsertAttachmentAndUploadMedia(documentLink, readableStream, options, callback);
- }
- else {
- this.createAttachmentAndUploadMedia(documentLink, readableStream, options, callback);
- }
- };
-
- client["updateOrUpsertMedia"] = function (documentLink, mediaLink, readableStream, options, callback) {
- if (isUpsertTest) {
- this.upsertAttachmentAndUploadMedia(documentLink, readableStream, options, callback);
- }
- else {
- this.updateMedia(mediaLink, readableStream, options, callback);
- }
- };
- };
-
- var getDatabaseLink = function (isNameBasedLink, db) {
- if (isNameBasedLink) {
- return "dbs/" + db.id;
- } else {
- return db._self;
- }
- };
-
- var getCollectionLink = function (isNameBasedLink, db, coll) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id;
- } else {
- return coll._self;
- }
- };
-
- var getDocumentLink = function (isNameBasedLink, db, coll, doc) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/docs/" + doc.id;
- } else {
- return doc._self;
- }
- };
-
- var getAttachmentLink = function (isNameBasedLink, db, coll, doc, attachment) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/docs/" + doc.id + "/attachments/" + attachment.id;
- } else {
- return attachment._self;
- }
- };
-
- var getUserLink = function (isNameBasedLink, db, user) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/users/" + user.id;
- } else {
- return user._self;
- }
- };
-
- var getPermissionLink = function (isNameBasedLink, db, user, permission) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/users/" + user.id + "/permissions/" + permission.id;
- } else {
- return permission._self;
- }
- };
-
- var getTriggerLink = function (isNameBasedLink, db, coll, trigger) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/triggers/" + trigger.id;
- } else {
- return trigger._self;
- }
- };
-
- var getUserDefinedFunctionLink = function (isNameBasedLink, db, coll, udf) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/udfs/" + udf.id;
- } else {
- return udf._self;
- }
- };
-
- var getStoredProcedureLink = function (isNameBasedLink, db, coll, sproc) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/sprocs/" + sproc.id;
- } else {
- return sproc._self;
- }
- };
-
- var getConflictLink = function (isNameBasedLink, db, coll, conflict) {
- if (isNameBasedLink) {
- return "dbs/" + db.id + "/colls/" + coll.id + "/conflicts/" + conflict.id;
- } else {
- return conflict._self;
- }
- };
-
- var bulkInsertDocuments = function (client, isNameBased, db, collection, documents, callback) {
- var returnedDocuments = [];
- var insertDocument = function (currentIndex) {
- if (currentIndex >= documents.length) {
- callback(undefined, returnedDocuments);
- }
- else {
- client.createDocument(getCollectionLink(isNameBased, db, collection), documents[currentIndex], function (err, document) {
- try {
- assert.equal(err, undefined, "error creating document " + JSON.stringify(documents[currentIndex]));
- returnedDocuments.push(document);
- insertDocument(++currentIndex);
- } catch (err) {
- callback(err);
- }
- });
- }
- };
-
- insertDocument(0);
- };
-
- var bulkReadDocuments = function (client, isNameBased, db, collection, documents, partitionKey, callback) {
- var readDocument = function (currentIndex) {
- if (currentIndex >= documents.length) {
- callback();
- }
- else {
- var options = undefined;
- if (partitionKey) {
- if (documents[currentIndex].hasOwnProperty(partitionKey)) {
- options = { partitionKey: documents[currentIndex][partitionKey] };
- }
- else {
- options = { partitionKey: {} };
- }
- }
-
- client.readDocument(getDocumentLink(isNameBased, db, collection, documents[currentIndex]), options, function (err, document) {
- assert.equal(err, undefined, "error reading document " + JSON.stringify(documents[currentIndex]));
- assert.equal(JSON.stringify(document), JSON.stringify(documents[currentIndex]));
- readDocument(++currentIndex);
- });
- }
- };
-
- readDocument(0);
- };
-
- var bulkReplaceDocuments = function (client, isNameBased, db, collection, documents, partitionKey, callback) {
- var returnedDocuments = [];
- var replaceDocument = function (currentIndex) {
- if (currentIndex >= documents.length) {
- callback(returnedDocuments);
- }
- else {
- client.replaceDocument(getDocumentLink(isNameBased, db, collection, documents[currentIndex]), documents[currentIndex], function (err, document) {
- assert.equal(err, undefined, "error replacing document " + JSON.stringify(documents[currentIndex]));
- var expectedModifiedDocument = JSON.parse(JSON.stringify(documents[currentIndex]));
- delete expectedModifiedDocument._etag;
- delete expectedModifiedDocument._ts;
- var actualModifiedDocument = JSON.parse(JSON.stringify(document));
- delete actualModifiedDocument._etag;
- delete actualModifiedDocument._ts;
- assert.equal(JSON.stringify(actualModifiedDocument), JSON.stringify(expectedModifiedDocument));
- returnedDocuments.push(document);
- replaceDocument(++currentIndex);
- });
- }
- };
-
- replaceDocument(0);
- };
-
- var bulkDeleteDocuments = function (client, isNameBased, db, collection, documents, partitionKey, callback) {
- var deleteDocument = function (currentIndex) {
- if (currentIndex >= documents.length) {
- callback();
- }
- else {
- var options = undefined;
- if (partitionKey) {
- if (documents[currentIndex].hasOwnProperty(partitionKey)) {
- options = { partitionKey: documents[currentIndex][partitionKey] };
- }
- else {
- options = { partitionKey: {} };
- }
- }
-
- client.deleteDocument(getDocumentLink(isNameBased, db, collection, documents[currentIndex]), options, function (err, result) {
- assert.equal(err, undefined, "error deleting document " + JSON.stringify(documents[currentIndex]));
- deleteDocument(++currentIndex);
- });
- }
- };
-
- deleteDocument(0);
- };
-
- var bulkQueryDocumentsWithPartitionKey = function (client, isNameBased, db, collection, documents, partitionKey, callback) {
- var queryDocument = function (currentIndex) {
- if (currentIndex >= documents.length) {
- callback();
- }
- else {
- if (!documents[currentIndex].hasOwnProperty(partitionKey)) {
- return queryDocument(++currentIndex);
- }
-
- var querySpec = {
- query: "SELECT * FROM root r WHERE r." + partitionKey + "=@key",
- parameters: [
- {
- name: "@key",
- value: documents[currentIndex][partitionKey]
- }
- ]
- };
-
- client.queryDocuments(getCollectionLink(isNameBased, db, collection), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying document " + JSON.stringify(documents[currentIndex]));
- assert.equal(results.length, 1, "Expected exactly 1 document");
- assert.equal(JSON.stringify(results[0]), JSON.stringify(documents[currentIndex]));
- queryDocument(++currentIndex);
- });
- }
- };
-
- queryDocument(0);
- };
-
- describe("Validate Database CRUD", function () {
- var databaseCRUDTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // read databases
- client.readDatabases().toArray(function (err, databases) {
- assert.equal(err, undefined, "error reading databases");
- assert.equal(databases.constructor, Array, "Value should be an array");
- // create a database
- var beforeCreateDatabasesCount = databases.length;
- var databaseDefinition = { id: "sample database" };
- client.createDatabase(databaseDefinition, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- assert.equal(db.id, databaseDefinition.id);
- // read databases after creation
- client.readDatabases().toArray(function (err, databases) {
- assert.equal(err, undefined, "error reading databases");
- assert.equal(databases.length, beforeCreateDatabasesCount + 1, "create should increase the number of databases");
- // query databases
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: databaseDefinition.id
- }
- ]
- };
- client.queryDatabases(querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying databases");
- assert(results.length > 0, "number of results for the query should be > 0");
-
- // delete database
- client.deleteDatabase(getDatabaseLink(isNameBased, db), function (err, res) {
- assert.equal(err, undefined, "error deleting database");
- // read database after deletion
- client.readDatabase(getDatabaseLink(isNameBased, db), function (err, database) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do database CRUD operations successfully name based", function (done) {
- databaseCRUDTest(true, done);
- });
-
- it("nativeApi Should do database CRUD operations successfully rid based", function (done) {
- databaseCRUDTest(false, done);
- });
- });
-
- describe("Validate Queries CRUD", function () {
- var queriesCRUDTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create a database
- var databaseDefinition = { id: "sample database" };
- client.createDatabase(databaseDefinition, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- assert.equal(db.id, databaseDefinition.id);
- // query databases
- var querySpec0 = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: databaseDefinition.id
- }
- ]
- };
- client.queryDatabases(querySpec0).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying databases");
- assert(results.length > 0, "number of results for the query should be > 0");
- var querySpec1 = {
- query: "SELECT * FROM root r WHERE r.id='" + databaseDefinition.id + "'"
- };
- client.queryDatabases(querySpec1).toArray(function (err, results) {
- assert.equal(err, undefined, "error creating databases");
- assert(results.length > 0, "number of results for the query should be > 0");
- var querySpec2 = "SELECT * FROM root r WHERE r.id='" + databaseDefinition.id + "'";
- client.queryDatabases(querySpec2).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying databases");
- assert(results.length > 0, "number of results for the query should be > 0");
- done();
- });
- });
- });
- });
- };
-
- it("nativeApi Should do queries CRUD operations successfully name based", function (done) {
- queriesCRUDTest(true, done);
- });
-
- it("nativeApi Should do queries CRUD operations successfully rid based", function (done) {
- queriesCRUDTest(false, done);
- });
- });
-
- describe("Validate Collection CRUD", function () {
- var collectionCRUDTest = function (isNameBased, hasPartitionKey, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- client.readCollections(getDatabaseLink(isNameBased, db)).toArray(function (err, collections) {
- assert.equal(err, undefined, "error reading collections");
- assert.equal(collections.constructor, Array, "Value should be an array");
- // create a collection
- var beforeCreateCollectionsCount = collections.length;
- var collectionDefinition = {
- id: "sample collection",
- indexingPolicy: { indexingMode: "Consistent" }
- };
-
- if (hasPartitionKey) {
- collectionDefinition.partitionKey = { paths: ["/id"], kind: DocumentBase.PartitionKind.Hash };
- }
-
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- assert.equal(collectionDefinition.id, collection.id);
- assert.equal("consistent", collection.indexingPolicy.indexingMode);
- assert.equal(JSON.stringify(collection.partitionKey), JSON.stringify(collectionDefinition.partitionKey));
- // read collections after creation
- client.readCollections(getDatabaseLink(isNameBased, db)).toArray(function (err, collections) {
- assert.equal(err, undefined, "error reading collections");
- assert.equal(collections.length, beforeCreateCollectionsCount + 1, "create should increase the number of collections");
- // query collections
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: collectionDefinition.id
- }
- ]
- };
- client.queryCollections(getDatabaseLink(isNameBased, db), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying collections");
- assert(results.length > 0, "number of results for the query should be > 0");
-
- // Replacing indexing policy is allowed.
- collection.indexingPolicy.indexingMode = "Lazy";
- client.replaceCollection(getCollectionLink(isNameBased, db, collection), collection, function (err, replacedCollection) {
- assert.equal(err, undefined, "replaceCollection should work successfully");
- assert.equal("lazy", replacedCollection.indexingPolicy.indexingMode);
-
- // Replacing partition key is not allowed.
- collection.partitionKey = { paths: ["/key"], kind: DocumentBase.PartitionKind.Hash };
- client.replaceCollection(getCollectionLink(isNameBased, db, collection), collection, function (err, replacedCollection) {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode, "response should return error code " + badRequestErrorCode);
-
- collection.partitionKey = collectionDefinition.partitionKey; // Resume partition key
-
- // Replacing id is not allowed.
- collection.id = "try_to_replace_id";
- client.replaceCollection(getCollectionLink(isNameBased, db, collection), collection, function (err, replacedCollection) {
- if (isNameBased) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- } else {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode, "response should return error code 400");
- }
-
- // read collection
- collection.id = collectionDefinition.id; // Resume Id.
- client.readCollection(getCollectionLink(isNameBased, db, collection), function (err, collection) {
- assert.equal(err, undefined, "readCollection should work successfully");
- assert.equal(collectionDefinition.id, collection.id);
- // delete collection
- client.deleteCollection(getCollectionLink(isNameBased, db, collection), function (err, res) {
- assert.equal(err, undefined, "error deleting collection");
- // read collection after deletion
- client.readCollection(getCollectionLink(isNameBased, db, collection), function (err, collection) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- var badPartitionKeyDefinitionTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create a collection
- var collectionDefinition = {
- id: "sample collection",
- indexingPolicy: { indexingMode: "Consistent" },
- partitionKey: { paths: "/id", kind: DocumentBase.PartitionKind.Hash }
- };
-
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, function (err, collection) {
- assert.equal(err.code, 400);
- done();
- });
- });
- };
-
- it("nativeApi Should do collection CRUD operations successfully name based", function (done) {
- collectionCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do collection CRUD operations successfully rid based", function (done) {
- collectionCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do elastic collection CRUD operations successfully name based", function (done) {
- collectionCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do elastic collection CRUD operations successfully rid based", function (done) {
- collectionCRUDTest(false, true, done);
- });
-
- it("nativeApi Collection with bad partition key definition name based", function (done) {
- badPartitionKeyDefinitionTest(true, done);
- });
-
- it("nativeApi Collection with bad partition key definition name based", function (done) {
- badPartitionKeyDefinitionTest(false, done);
- });
- });
-
- describe("Validate Document CRUD", function () {
- var documentCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample 中文 database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection("dbs/sample 中文 database", { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- // read documents
- client.readDocuments(getCollectionLink(isNameBased, db, collection)).toArray(function (err, documents) {
- assert.equal(err, undefined, "error reading documents");
- assert.equal(documents.constructor, Array, "Value should be an array");
- // create a document
- var beforeCreateDocumentsCount = documents.length;
- var documentDefinition = { name: "sample document", foo: "bar", key: "value", replace: "new property" };
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), documentDefinition, { disableAutomaticIdGeneration: true }, function (err, document) {
- assert(err !== undefined, "should throw an error because automatic id generation is disabled");
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), documentDefinition, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(document.name, documentDefinition.name);
- assert(document.id !== undefined);
- // read documents after creation
- client.readDocuments(getCollectionLink(isNameBased, db, collection)).toArray(function (err, documents) {
- assert.equal(err, undefined, "error reading documents");
- assert.equal(documents.length, beforeCreateDocumentsCount + 1, "create should increase the number of documents");
- // query documents
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: document.id
- }
- ]
- };
- client.queryDocuments(getCollectionLink(isNameBased, db, collection), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying documents");
- assert(results.length > 0, "number of results for the query should be > 0");
- client.queryDocuments(getCollectionLink(isNameBased, db, collection), querySpec, { enableScanInQuery: true }).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying documents");
- assert(results.length > 0, "number of results for the query should be > 0");
- //replace document
- document.name = "replaced document";
- document.foo = "not bar";
- client.replaceOrUpsertDocument(getCollectionLink(isNameBased, db, collection), getDocumentLink(isNameBased, db, collection, document), document, function (error, replacedDocument) {
- assert.equal(replacedDocument.name, "replaced document", "document name property should change");
- assert.equal(replacedDocument.foo, "not bar", "property should have changed");
- assert.equal(document.id, replacedDocument.id, "document id should stay the same");
- // read document
- client.readDocument(getDocumentLink(isNameBased, db, collection, replacedDocument), function (err, document) {
- assert.equal(err, undefined, "readDocument should work successfully");
- assert.equal(replacedDocument.id, document.id);
- // delete document
- client.deleteDocument(getDocumentLink(isNameBased, db, collection, replacedDocument), function (err, res) {
- assert.equal(err, undefined, "error deleting document");
- // read documents after deletion
- client.readDocument(getDocumentLink(isNameBased, db, collection, document), function (err, document) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- var documentCRUDMultiplePartitionsTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "db1" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
-
- var partitionKey = "key";
-
- // create collection
- var collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash }
- };
-
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
-
- var documents = [
- { id: "document1" },
- { id: "document2", key: null, prop: 1 },
- { id: "document3", key: false, prop: 1 },
- { id: "document4", key: true, prop: 1 },
- { id: "document5", key: 1, prop: 1 },
- { id: "document6", key: "A", prop: 1 }
- ];
-
- bulkInsertDocuments(client, isNameBased, db, collection, documents, function (err, returnedDocuments) {
- if(err) {
- return done(err);
- }
- assert.equal(returnedDocuments.length, documents.length);
- returnedDocuments.sort(function (doc1, doc2) {
- return doc1.id.localeCompare(doc2.id);
- });
- bulkReadDocuments(client, isNameBased, db, collection, returnedDocuments, partitionKey, function () {
- client.readDocuments(getCollectionLink(isNameBased, db, collection)).toArray(function (err, successDocuments) {
- assert.equal(err, undefined, "error reading documents");
- assert(successDocuments !== undefined, "error reading documents");
- assert.equal(successDocuments.length, returnedDocuments.length, "Expected " + returnedDocuments.length + " documents to be succesfully read");
- successDocuments.sort(function (doc1, doc2) {
- return doc1.id.localeCompare(doc2.id);
- });
- assert.equal(JSON.stringify(successDocuments), JSON.stringify(returnedDocuments), "Unexpected documents are returned");
-
- returnedDocuments.forEach(function (document) { ++document.prop; });
- bulkReplaceDocuments(client, isNameBased, db, collection, returnedDocuments, partitionKey, function (newReturnedDocuments) {
- returnedDocuments = newReturnedDocuments;
- bulkQueryDocumentsWithPartitionKey(client, isNameBased, db, collection, returnedDocuments, partitionKey, function () {
- var querySpec = {
- query: "SELECT * FROM Root"
- };
-
- client.queryDocuments(getCollectionLink(isNameBased, db, collection), querySpec, { enableScanInQuery: true }).toArray(function (err, results) {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode, "response should return error code " + badRequestErrorCode);
- client.queryDocuments(getCollectionLink(isNameBased, db, collection), querySpec, { enableScanInQuery: true, enableCrossPartitionQuery: true }).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying documents");
- assert(results !== undefined, "error querying documents");
- results.sort(function (doc1, doc2) {
- return doc1.id.localeCompare(doc2.id);
- });
- assert.equal(results.length, returnedDocuments.length, "Expected " + returnedDocuments.length + " documents to be succesfully queried");
- assert.equal(JSON.stringify(results), JSON.stringify(returnedDocuments), "Unexpected query results");
-
- bulkDeleteDocuments(client, isNameBased, db, collection, returnedDocuments, partitionKey, function () {
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do document CRUD operations successfully name based", function (done) {
- documentCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do document CRUD operations successfully rid based", function (done) {
- documentCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do document CRUD operations successfully name based with upsert", function (done) {
- documentCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do document CRUD operations successfully rid based with upsert", function (done) {
- documentCRUDTest(false, true, done);
- });
-
- it("nativeApi Should do document CRUD operations over multiple partitions successfully name based", function (done) {
- documentCRUDMultiplePartitionsTest(true, done);
- });
-
- it("nativeApi Should do document CRUD operations over multiple partitions successfully rid based", function (done) {
- documentCRUDMultiplePartitionsTest(false, done);
- });
- });
-
- describe("Validate Attachment CRUD", function () {
- var createReadableStream = function (firstChunk, secondChunk) {
- var readableStream = new Stream.Readable();
- var chunkCount = 0;
- readableStream._read = function (n) {
- if (chunkCount === 0) {
- this.push(firstChunk || "first chunk ");
- } else if (chunkCount === 1) {
- this.push(secondChunk || "second chunk");
- } else {
- this.push(null);
- }
- chunkCount++;
- };
-
- return readableStream;
- };
-
- var readMediaResponse = function (response, callback) {
- var data = "";
- response.on("data", function (chunk) {
- data += chunk;
- });
- response.on("end", function () {
- if (response.statusCode >= 300) {
- return callback({ code: response.statusCode, body: data });
- }
-
- return callback(undefined, data);
- });
- };
-
- var attachmentCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- // create document
- client.createDocument(getCollectionLink(isNameBased, db, collection), { id: "sample document", foo: "bar", key: "value" }, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- // list all attachments
- client.readAttachments(getDocumentLink(isNameBased, db, collection, document)).toArray(function (err, attachments) {
- assert.equal(err, undefined, "error reading attachments");
- assert.equal(attachments.constructor, Array, "Value should be an array");
- var initialCount = attachments.length;
- var validMediaOptions = { slug: "attachment name", contentType: "application/text" };
- var invalidMediaOptions = { slug: "attachment name", contentType: "junt/test" };
- // create attachment with invalid content-type
- var contentStream = createReadableStream();
- client.createOrUpsertAttachmentAndUploadMedia(getDocumentLink(isNameBased, db, collection, document), contentStream, invalidMediaOptions, function (err, attachment) {
- assert(err !== undefined, "create attachment should return error on invalid mediatypes");
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode);
- contentStream = createReadableStream();
- // create streamed attachment with valid content-type
- client.createOrUpsertAttachmentAndUploadMedia(getDocumentLink(isNameBased, db, collection, document), contentStream, validMediaOptions, function (err, validAttachment) {
- assert.equal(err, undefined, "error creating valid attachment");
- assert.equal(validAttachment.id, "attachment name", "name of created attachment should be the same as the one in the request");
- contentStream = createReadableStream();
- // create colliding attachment
- var content2 = "bug";
- client.createAttachmentAndUploadMedia(getDocumentLink(isNameBased, db, collection, document), contentStream, validMediaOptions, function (err, attachment) {
- assert(err !== undefined, "create conflicting attachment should return error on conflicting names");
- var conflictErrorCode = 409;
- assert.equal(err.code, conflictErrorCode);
- contentStream = createReadableStream();
- // create attachment with media link
- var dynamicAttachment = {
- id: "dynamic attachment",
- media: "http://xstore.",
- MediaType: "Book",
- Author: "My Book Author",
- Title: "My Book Title",
- contentType: "application/text"
- };
- client.createOrUpsertAttachment(getDocumentLink(isNameBased, db, collection, document), dynamicAttachment, function (err, attachment) {
- assert.equal(err, undefined, "error creating valid attachment");
- assert.equal(attachment.MediaType, "Book", "invalid media type");
- assert.equal(attachment.Author, "My Book Author", "invalid property value");
- // list all attachments
- client.readAttachments(getDocumentLink(isNameBased, db, collection, document)).toArray(function (err, attachments) {
- assert.equal(err, undefined, "error reading attachments");
- assert.equal(attachments.length, initialCount + 2, "number of attachments should've increased by 2");
- attachment.Author = "new author";
- //replace the attachment
- client.replaceOrUpsertAttachment(getDocumentLink(isNameBased, db, collection, document), getAttachmentLink(isNameBased, db, collection, document, attachment), attachment, function (err, attachment) {
- assert.equal(err, undefined, "error replacing attachment");
- assert.equal(attachment.MediaType, "Book", "invalid media type");
- assert.equal(attachment.Author, "new author", "invalid property value");
- // read attachment media
- client.readMedia(validAttachment.media, function (err, mediaResponse) {
- assert.equal(err, undefined, "error reading attachment media");
- assert.equal(mediaResponse, "first chunk second chunk");
- contentStream = createReadableStream("modified first chunk ", "modified second chunk");
- // update attachment media
- client.updateOrUpsertMedia(getDocumentLink(isNameBased, db, collection, document), validAttachment.media, contentStream, validMediaOptions, function (err, mediaResult) {
- assert.equal(err, undefined, "error update media");
- // read attachment media after update
- // read media buffered
- client.readMedia(validAttachment.media, function (err, mediaResponse) {
- assert.equal(err, undefined, "error reading media");
- assert.equal(mediaResponse, "modified first chunk modified second chunk");
- // read media streamed
- client.connectionPolicy.MediaReadMode = DocumentBase.MediaReadMode.Streamed;
- client.readMedia(validAttachment.media, function (err, mediaResponse) {
- assert.equal(err, undefined, "error reading media");
- readMediaResponse(mediaResponse, function (err, mediaResult) {
- assert.equal(err, undefined, "error reading media");
- assert.equal(mediaResult, "modified first chunk modified second chunk");
- // share attachment with a second document
- client.createDocument(getCollectionLink(isNameBased, db, collection), { id: "document 2" }, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- var secondAttachment = { id: validAttachment.id, contentType: validAttachment.contentType, media: validAttachment.media };
- client.createOrUpsertAttachment(getDocumentLink(isNameBased, db, collection, document), secondAttachment, function (err, attachment) {
- assert.equal(err, undefined, "error creating attachment");
- assert.equal(validAttachment.id, attachment.id, "name mismatch");
- assert.equal(validAttachment.media, attachment.media, "media mismatch");
- assert.equal(validAttachment.contentType, attachment.contentType, "contentType mismatch");
- // deleting attachment
- client.deleteAttachment(getAttachmentLink(isNameBased, db, collection, document, validAttachment), function (err, attachment) {
- assert.equal(err, undefined, "error deleting attachments");
- // read attachments after deletion
- client.readAttachment(getAttachmentLink(isNameBased, db, collection, document, validAttachment), function (err, attachment) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- var attachmentCRUDOverMultiplePartitionsTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- var partitionKey = "id";
-
- // create collection
- var collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash }
- };
-
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- // create document
- client.createDocument(getCollectionLink(isNameBased, db, collection), { id: "sample document", foo: "bar", key: "value" }, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- var sampleDocumentPartitionKeyValue = document[partitionKey];
- // list all attachments
- client.readAttachments(getDocumentLink(isNameBased, db, collection, document), { partitionKey: sampleDocumentPartitionKeyValue }).toArray(function (err, attachments) {
- assert.equal(err, undefined, "error reading attachments");
- assert.equal(attachments.constructor, Array, "Value should be an array");
- var initialCount = attachments.length;
- var validMediaOptions = { slug: "attachment name", contentType: "application/text", partitionKey: document[partitionKey] };
- var invalidMediaOptions = { slug: "attachment name", contentType: "junt/test", partitionKey: document[partitionKey] };
- // create attachment with invalid content-type
- var contentStream = createReadableStream();
- client.createOrUpsertAttachmentAndUploadMedia(getDocumentLink(isNameBased, db, collection, document), contentStream, invalidMediaOptions, function (err, attachment) {
- assert(err !== undefined, "create attachment should return error on invalid mediatypes");
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode);
- contentStream = createReadableStream();
- // create streamed attachment with valid content-type
- client.createOrUpsertAttachmentAndUploadMedia(getDocumentLink(isNameBased, db, collection, document), contentStream, validMediaOptions, function (err, validAttachment) {
- assert.equal(err, undefined, "error creating valid attachment");
- assert.equal(validAttachment.id, "attachment name", "name of created attachment should be the same as the one in the request");
- contentStream = createReadableStream();
- // create colliding attachment
- var content2 = "bug";
- client.createAttachmentAndUploadMedia(getDocumentLink(isNameBased, db, collection, document), contentStream, validMediaOptions, function (err, attachment) {
- assert(err !== undefined, "create conflicting attachment should return error on conflicting names");
- var conflictErrorCode = 409;
- assert.equal(err.code, conflictErrorCode);
- contentStream = createReadableStream();
- // create attachment with media link
- var dynamicAttachment = {
- id: "dynamic attachment",
- media: "http://xstore.",
- MediaType: "Book",
- Author: "My Book Author",
- Title: "My Book Title",
- contentType: "application/text"
- };
- client.createOrUpsertAttachment(getDocumentLink(isNameBased, db, collection, document), dynamicAttachment, { partitionKey: sampleDocumentPartitionKeyValue }, function (err, attachment) {
- assert.equal(err, undefined, "error creating valid attachment");
- assert.equal(attachment.MediaType, "Book", "invalid media type");
- assert.equal(attachment.Author, "My Book Author", "invalid property value");
- // list all attachments
- client.readAttachments(getDocumentLink(isNameBased, db, collection, document), { partitionKey: document[partitionKey] }).toArray(function (err, attachments) {
- assert.equal(err, undefined, "error reading attachments");
- assert.equal(attachments.length, initialCount + 2, "number of attachments should've increased by 2");
- attachment.Author = "new author";
- //replace the attachment
- client.replaceOrUpsertAttachment(getDocumentLink(isNameBased, db, collection, document), getAttachmentLink(isNameBased, db, collection, document, attachment), attachment, { partitionKey: sampleDocumentPartitionKeyValue }, function (err, attachment) {
- assert.equal(err, undefined, "error replacing attachment");
- assert.equal(attachment.MediaType, "Book", "invalid media type");
- assert.equal(attachment.Author, "new author", "invalid property value");
- // read attachment media
- client.readMedia(validAttachment.media, function (err, mediaResponse) {
- assert.equal(err, undefined, "error reading attachment media");
- assert.equal(mediaResponse, "first chunk second chunk");
- contentStream = createReadableStream("modified first chunk ", "modified second chunk");
- // update attachment media
- client.updateOrUpsertMedia(getDocumentLink(isNameBased, db, collection, document), validAttachment.media, contentStream, validMediaOptions, function (err, mediaResult) {
- assert.equal(err, undefined, "error update media");
- // read attachment media after update
- // read media buffered
- client.readMedia(validAttachment.media, function (err, mediaResponse) {
- assert.equal(err, undefined, "error reading media");
- assert.equal(mediaResponse, "modified first chunk modified second chunk");
- // read media streamed
- client.connectionPolicy.MediaReadMode = DocumentBase.MediaReadMode.Streamed;
- client.readMedia(validAttachment.media, function (err, mediaResponse) {
- assert.equal(err, undefined, "error reading media");
- readMediaResponse(mediaResponse, function (err, mediaResult) {
- assert.equal(err, undefined, "error reading media");
- assert.equal(mediaResult, "modified first chunk modified second chunk");
- // share attachment with a second document
- client.createDocument(getCollectionLink(isNameBased, db, collection), { id: "document 2" }, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- var secondDocumentPartitionKeyValue = document[partitionKey];
- var secondAttachment = { id: validAttachment.id, contentType: validAttachment.contentType, media: validAttachment.media };
- client.createOrUpsertAttachment(getDocumentLink(isNameBased, db, collection, document), secondAttachment, { partitionKey: secondDocumentPartitionKeyValue }, function (err, attachment) {
- assert.equal(err, undefined, "error creating attachment");
- assert.equal(validAttachment.id, attachment.id, "name mismatch");
- assert.equal(validAttachment.media, attachment.media, "media mismatch");
- assert.equal(validAttachment.contentType, attachment.contentType, "contentType mismatch");
- var createdAttachment = attachment;
- // deleting attachment
- client.deleteAttachment(getAttachmentLink(isNameBased, db, collection, document, createdAttachment), { partitionKey: secondDocumentPartitionKeyValue }, function (err, attachment) {
- assert.equal(err, undefined, "error deleting attachment");
- // read attachments after deletion
- client.readAttachment(getAttachmentLink(isNameBased, db, collection, document, createdAttachment), { partitionKey: secondDocumentPartitionKeyValue }, function (err, attachment) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do attachment CRUD operations successfully name based", function (done) {
- attachmentCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do attachment CRUD operations successfully rid based", function (done) {
- attachmentCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do attachment CRUD operations successfully name based with upsert", function (done) {
- attachmentCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do attachment CRUD operations successfully rid based with upsert", function (done) {
- attachmentCRUDTest(false, true, done);
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully name based", function (done) {
- attachmentCRUDOverMultiplePartitionsTest(true, false, done);
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully rid based", function (done) {
- attachmentCRUDOverMultiplePartitionsTest(false, false, done);
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully name based with upsert", function (done) {
- attachmentCRUDOverMultiplePartitionsTest(true, true, done);
- });
-
- it("nativeApi Should do attachment CRUD operations over multiple partitions successfully rid based with upsert", function (done) {
- attachmentCRUDOverMultiplePartitionsTest(false, true, done);
- });
- });
-
- describe("Validate User CRUD", function () {
- var userCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // list users
- client.readUsers(getDatabaseLink(isNameBased, db)).toArray(function (err, users) {
- assert.equal(err, undefined, "error reading users");
- assert.equal(users.constructor, Array, "Value should be an array");
- var beforeCreateCount = users.length;
- // create user
- client.createOrUpsertUser(getDatabaseLink(isNameBased, db), { id: "new user" }, function (err, user) {
- assert.equal(err, undefined, "error creating User");
- assert.equal(user.id, "new user", "user name error");
- // list users after creation
- client.readUsers(getDatabaseLink(isNameBased, db)).toArray(function (err, users) {
- assert.equal(err, undefined, "error reading users");
- assert.equal(users.length, beforeCreateCount + 1);
- // query users
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: "new user"
- }
- ]
- };
- client.queryUsers(getDatabaseLink(isNameBased, db), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error reading users");
- assert(results.length > 0, "number of results for the query should be > 0");
- //replace user
- user.id = "replaced user";
- client.replaceOrUpsertUser(getDatabaseLink(isNameBased, db), user._self, user, function (error, replacedUser) {
- assert.equal(replacedUser.id, "replaced user", "user name should change");
- assert.equal(user.id, replacedUser.id, "user id should stay the same");
- // read user
- client.readUser(getUserLink(isNameBased, db, replacedUser), function (err, user) {
- assert.equal(err, undefined, "readUser should work successfully");
- assert.equal(replacedUser.id, user.id);
- // delete user
- client.deleteUser(getUserLink(isNameBased, db, user), function (err, res) {
- assert.equal(err, undefined, "delete user should should work successfully");
- // read user after deletion
- client.readUser(getUserLink(isNameBased, db, user), function (err, user) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do User CRUD operations successfully name based", function (done) {
- userCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do User CRUD operations successfully rid based", function (done) {
- userCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do User CRUD operations successfully name based with upsert", function (done) {
- userCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do User CRUD operations successfully rid based with upsert", function (done) {
- userCRUDTest(false, true, done);
- });
- });
-
- describe("Validate Permission CRUD", function () {
- var permissionCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample coll" }, function (err, coll) {
- assert.equal(err, undefined, "error creating collection");
- // create user
- client.createUser(getDatabaseLink(isNameBased, db), { id: "new user" }, function (err, user) {
- assert.equal(err, undefined, "error creating user");
- assert.equal(err, undefined, "error creating user");
- // list permissions
- client.readPermissions(getUserLink(isNameBased, db, user)).toArray(function (err, permissions) {
- assert.equal(err, undefined, "error reading permissions");
- assert.equal(permissions.constructor, Array, "Value should be an array");
- var beforeCreateCount = permissions.length;
- var permission = { id: "new permission", permissionMode: DocumentBase.PermissionMode.Read, resource: coll._self };
- // create permission
- client.createOrUpsertPermission(getUserLink(isNameBased, db, user), permission, function (err, permission) {
- assert.equal(err, undefined, "error creating permission");
- assert.equal(permission.id, "new permission", "permission name error");
- // list permissions after creation
- client.readPermissions(getUserLink(isNameBased, db, user)).toArray(function (err, permissions) {
- assert.equal(err, undefined, "error reading permissions");
- assert.equal(permissions.length, beforeCreateCount + 1);
- // query permissions
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: permission.id
- }
- ]
- };
- client.queryPermissions(getUserLink(isNameBased, db, user), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying permissions");
- assert(results.length > 0, "number of results for the query should be > 0");
- permission.permissionMode = DocumentBase.PermissionMode.All;
- client.replaceOrUpsertPermission(getUserLink(isNameBased, db, user), permission._self, permission, function (error, replacedPermission) {
- assert.equal(error, undefined, "error replacing permission");
- assert.equal(replacedPermission.permissionMode, DocumentBase.PermissionMode.All, "permission mode should change");
- assert.equal(permission.id, replacedPermission.id, "permission id should stay the same");
- // to change the id of an existing resourcewe have to use replace
- permission.id = "replaced permission";
- client.replacePermission(permission._self, permission, function (error, replacedPermission) {
- assert.equal(error, undefined, "error replacing permission");
- assert.equal(replacedPermission.id, "replaced permission", "permission name should change");
- assert.equal(permission.id, replacedPermission.id, "permission id should stay the same");
- // read permission
- client.readPermission(getPermissionLink(isNameBased, db, user, replacedPermission), function (err, permission) {
- assert.equal(err, undefined, "readUser should work successfully");
- assert.equal(replacedPermission.id, permission.id);
- // delete permission
- client.deletePermission(getPermissionLink(isNameBased, db, user, replacedPermission), function (err, res) {
- assert.equal(err, undefined, "delete permission should should work successfully");
- // read permission after deletion
- client.readPermission(getPermissionLink(isNameBased, db, user, permission), function (err, permission) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- var permissionCRUDOverMultiplePartitionsTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- var partitionKey = "id";
-
- var collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash }
- };
-
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 }, function (err, coll) {
- assert.equal(err, undefined, "error creating collection");
- // create user
- client.createUser(getDatabaseLink(isNameBased, db), { id: "new user" }, function (err, user) {
- assert.equal(err, undefined, "error creating user");
- assert.equal(err, undefined, "error creating user");
- // list permissions
- client.readPermissions(getUserLink(isNameBased, db, user)).toArray(function (err, permissions) {
- assert.equal(err, undefined, "error reading permissions");
- assert.equal(permissions.constructor, Array, "Value should be an array");
- var beforeCreateCount = permissions.length;
- var permissionDefinition = { id: "new permission", permissionMode: DocumentBase.PermissionMode.Read, resource: coll._self, resourcePartitionKey: [1] };
- // create permission
- client.createOrUpsertPermission(getUserLink(isNameBased, db, user), permissionDefinition, function (err, permission) {
- assert.equal(err, undefined, "error creating permission");
- assert.equal(permission.id, permissionDefinition.id, "permission name error");
- assert.equal(JSON.stringify(permission.resourcePartitionKey), JSON.stringify(permissionDefinition.resourcePartitionKey), "permission resource partition key error");
- // list permissions after creation
- client.readPermissions(getUserLink(isNameBased, db, user)).toArray(function (err, permissions) {
- assert.equal(err, undefined, "error reading permissions");
- assert.equal(permissions.length, beforeCreateCount + 1);
- // query permissions
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: permission.id
- }
- ]
- };
- client.queryPermissions(getUserLink(isNameBased, db, user), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying permissions");
- assert(results.length > 0, "number of results for the query should be > 0");
- permission.permissionMode = DocumentBase.PermissionMode.All;
- client.replaceOrUpsertPermission(getUserLink(isNameBased, db, user), permission._self, permission, function (error, replacedPermission) {
- assert.equal(error, undefined, "error replacing permission");
- assert.equal(replacedPermission.permissionMode, DocumentBase.PermissionMode.All, "permission mode should change");
- assert.equal(replacedPermission.id, permission.id, "permission id should stay the same");
- assert.equal(JSON.stringify(replacedPermission.resourcePartitionKey), JSON.stringify(permission.resourcePartitionKey), "permission resource partition key error");
- // to change the id of an existing resourcewe have to use replace
- permission.id = "replaced permission";
- client.replacePermission(permission._self, permission, function (error, replacedPermission) {
- assert.equal(error, undefined, "error replacing permission");
- assert.equal(replacedPermission.id, permission.id);
- // read permission
- client.readPermission(getPermissionLink(isNameBased, db, user, replacedPermission), function (err, permission) {
- assert.equal(err, undefined, "readUser should work successfully");
- assert.equal(permission.id, replacedPermission.id);
- // delete permission
- client.deletePermission(getPermissionLink(isNameBased, db, user, replacedPermission), function (err, res) {
- assert.equal(err, undefined, "delete permission should should work successfully");
- // read permission after deletion
- client.readPermission(getPermissionLink(isNameBased, db, user, permission), function (err, permission) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do Permission CRUD operations successfully name based", function (done) {
- permissionCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do Permission CRUD operations successfully rid based", function (done) {
- permissionCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do Permission CRUD operations successfully name based with upsert", function (done) {
- permissionCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do Permission CRUD operations successfully rid based with upsert", function (done) {
- permissionCRUDTest(false, true, done);
- });
-
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully name based", function (done) {
- permissionCRUDOverMultiplePartitionsTest(true, false, done);
- });
-
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully rid based", function (done) {
- permissionCRUDOverMultiplePartitionsTest(false, false, done);
- });
-
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully name based with upsert", function (done) {
- permissionCRUDOverMultiplePartitionsTest(true, true, done);
- });
-
- it("nativeApi Should do Permission CRUD operations over multiple partitions successfully rid based with upsert", function (done) {
- permissionCRUDOverMultiplePartitionsTest(false, true, done);
- });
- });
-
- describe("Validate Authorization", function () {
- var setupEntities = function (isNameBased, client, callback) {
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection1
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection1) {
- assert.equal(err, undefined, "error creating collection");
- // create document1
- client.createDocument(getCollectionLink(isNameBased, db, collection1), { id: "coll1doc1", foo: "bar", key: "value" }, function (err, document1) {
- assert.equal(err, undefined, "error creating document");
- // create document 2
- client.createDocument(getCollectionLink(isNameBased, db, collection1), { id: "coll1doc2", foo: "bar2", key: "value2" }, function (err, document2) {
- assert.equal(err, undefined, "error creating document");
- // create attachment
- var dynamicAttachment = {
- id: "dynamic attachment",
- media: "http://xstore.",
- MediaType: "Book",
- Author: "My Book Author",
- Title: "My Book Title",
- contentType: "application/text"
- };
- client.createAttachment(getDocumentLink(isNameBased, db, collection1, document1), dynamicAttachment, function (err, attachment) {
- assert.equal(err, undefined, "error creating attachment");
- // create collection 2
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection2" }, function (err, collection2) {
- assert.equal(err, undefined, "error creating collection");
- // create user1
- client.createUser(getDatabaseLink(isNameBased, db), { id: "user1" }, function (err, user1) {
- assert.equal(err, undefined, "error creating user");
- var permission = { id: "permission On Coll1", permissionMode: DocumentBase.PermissionMode.Read, resource: collection1._self };
- // create permission for collection1
- client.createOrUpsertPermission(getUserLink(isNameBased, db, user1), permission, function (err, permissionOnColl1) {
- assert.equal(err, undefined, "error creating permission");
- assert(permissionOnColl1._token !== undefined, "permission token is invalid");
- permission = { id: "permission On Doc1", permissionMode: DocumentBase.PermissionMode.All, resource: document2._self };
- // create permission for document 2
- client.createOrUpsertPermission(getUserLink(isNameBased, db, user1), permission, function (err, permissionOnDoc2) {
- assert.equal(err, undefined, "error creating permission");
- assert(permissionOnDoc2._token !== undefined, "permission token is invalid");
- // create user 2
- client.createUser(getDatabaseLink(isNameBased, db), { id: "user2" }, function (err, user2) {
- assert.equal(err, undefined, "error creating user");
- permission = { id: "permission On coll2", permissionMode: DocumentBase.PermissionMode.All, resource: collection2._self };
- // create permission on collection 2
- client.createOrUpsertPermission(getUserLink(isNameBased, db, user2), permission, function (err, permissionOnColl2) {
- assert.equal(err, undefined, "error creating permission");
- var entities = {
- db: db,
- coll1: collection1,
- coll2: collection2,
- doc1: document1,
- doc2: document2,
- user1: user1,
- user2: user2,
- attachment: attachment,
- permissionOnColl1: permissionOnColl1,
- permissionOnDoc2: permissionOnDoc2,
- permissionOnColl2: permissionOnColl2
- };
-
- callback(entities);
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- var authorizationCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host);
- client.readDatabases().toArray(function (err, databases) {
- assert(err !== undefined, "error should not be undefined");
- var unauthorizedErrorCode = 401;
- assert.equal(err.code, unauthorizedErrorCode, "error code should be equal to 401");
- client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // setup entities
- setupEntities(isNameBased, client, function (entities) {
- var resourceTokens = {};
- if (isNameBased) {
- resourceTokens[entities.coll1.id] = entities.permissionOnColl1._token;
- resourceTokens[entities.doc1.id] = entities.permissionOnColl1._token;
- }
- else {
- resourceTokens[entities.coll1._rid] = entities.permissionOnColl1._token;
- resourceTokens[entities.doc1._rid] = entities.permissionOnColl1._token;
- }
-
- var col1Client = new DocumentDBClient(host, { resourceTokens: resourceTokens });
- var coll1Link = getCollectionLink(isNameBased, entities.db, entities.coll1);
- // 1. Success-- Use Col1 Permission to Read
- col1Client.readCollection(coll1Link, function (err, successColl1) {
- assert.equal(err, undefined, "error reading collections");
- assert(successColl1 !== undefined, "error reading collection");
- // 2. Failure-- Use Col1 Permission to delete
- col1Client.deleteCollection(coll1Link, function (err, result) {
- assert(err !== undefined, "expected to fail, no permission to delete");
- // 3. Success-- Use Col1 Permission to Read All Docs
- col1Client.readDocuments(coll1Link).toArray(function (err, successDocuments) {
- assert.equal(err, undefined, "error reading documents");
- assert(successDocuments !== undefined, "error reading documents");
- assert.equal(successDocuments.length, 2, "Expected 2 Documents to be succesfully read");
- // 4. Success-- Use Col1 Permission to Read Col1Doc1
- var doc1Link = getDocumentLink(isNameBased, entities.db, entities.coll1, entities.doc1);
- col1Client.readDocument(doc1Link, function (err, successDoc) {
- assert.equal(err, undefined, "error reading document");
- assert(successDoc !== undefined, "error reading document");
- assert.equal(successDoc.id, entities.doc1.id, "Expected to read children using parent permissions");
- var col2Client = new DocumentDBClient(host, { permissionFeed: [entities.permissionOnColl2] });
- addUpsertWrapperMethods(col2Client, isUpsertTest);
- var doc = { id: "new doc", CustomProperty1: "BBBBBB", customProperty2: 1000 };
- col2Client.createOrUpsertDocument(entities.coll2._self, doc, function (err, successDoc) {
- assert.equal(err, undefined, "error creating document");
- assert(successDoc !== undefined, "error creating document");
- assert.equal(successDoc.CustomProperty1, doc.CustomProperty1, "document should have been created successfully");
- done();
- });
- });
- });
- });
- });
- });
- });
- };
-
- var authorizationCRUDOverMultiplePartitionsTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- var partitionKey = "key";
-
- var collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash }
- };
-
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 }, function (err, coll) {
- assert.equal(err, undefined, "error creating collection");
-
- // create user
- client.createUser(getDatabaseLink(isNameBased, db), { id: "user1" }, function (err, user) {
- assert.equal(err, undefined, "error creating user");
-
- var key = 1;
- var permissionDefinition = { id: "permission1", permissionMode: DocumentBase.PermissionMode.All, resource: getCollectionLink(isNameBased, db, coll), resourcePartitionKey: [key] };
- // create permission
- client.createPermission(getUserLink(isNameBased, db, user), permissionDefinition, function (err, permission) {
- assert.equal(err, undefined, "error creating permission");
- assert(permission._token !== undefined, "permission token is invalid");
- var resourceTokens = {};
- if (isNameBased) {
- resourceTokens[coll.id] = permission._token;
- }
- else {
- resourceTokens[coll._rid] = permission._token;
- }
-
- var restrictedClient = new DocumentDBClient(host, { resourceTokens: resourceTokens });
-
- restrictedClient.createDocument(getCollectionLink(isNameBased, db, coll), { id: "document1", key: 1 }, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- restrictedClient.createDocument(getCollectionLink(isNameBased, db, coll), { id: "document2", key: 2 }, function (err, document) {
- var unauthorizedErrorCode = 403;
- assert.equal(err.code, unauthorizedErrorCode);
- done();
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do authorization successfully name based", function (done) {
- authorizationCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do authorization successfully rid based", function (done) {
- authorizationCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do authorization successfully name based with upsert", function (done) {
- authorizationCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do authorization successfully rid based with upsert", function (done) {
- authorizationCRUDTest(false, true, done);
- });
-
- it("nativeApi Should do authorization over multiple partitions successfully name based", function (done) {
- authorizationCRUDOverMultiplePartitionsTest(true, done);
- });
-
- it("nativeApi Should do authorization over multiple partitions successfully rid based", function (done) {
- authorizationCRUDOverMultiplePartitionsTest(false, done);
- });
- });
-
- describe("Validate Trigger CRUD", function () {
- var triggerCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- // read triggers
- client.readTriggers(getCollectionLink(isNameBased, db, collection)).toArray(function (err, triggers) {
- assert.equal(err, undefined, "error reading triggers");
- assert.equal(triggers.constructor, Array, "Value should be an array");
- // create a trigger
- var beforeCreateTriggersCount = triggers.length;
- var triggerDefinition = {
- id: "sample trigger",
- serverScript: function () { var x = 10; },
- triggerType: DocumentBase.TriggerType.Pre,
- triggerOperation: DocumentBase.TriggerOperation.All
- };
- client.createOrUpsertTrigger(getCollectionLink(isNameBased, db, collection), triggerDefinition, function (err, trigger) {
- assert.equal(err, undefined, "error creating trigger");
- for (var property in triggerDefinition) {
- if (property !== "serverScript") {
- assert.equal(trigger[property], triggerDefinition[property], "property " + property + " should match");
- } else {
- assert.equal(trigger.body, "function () { var x = 10; }");
- }
- }
- // read triggers after creation
- client.readTriggers(getCollectionLink(isNameBased, db, collection)).toArray(function (err, triggers) {
- assert.equal(err, undefined, "error reading triggers");
- assert.equal(triggers.length, beforeCreateTriggersCount + 1, "create should increase the number of triggers");
- // query triggers
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: triggerDefinition.id
- }
- ]
- };
- client.queryTriggers(getCollectionLink(isNameBased, db, collection), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying triggers");
- assert(results.length > 0, "number of results for the query should be > 0");
- //replace trigger
- trigger.body = function () { var x = 20; };
- client.replaceOrUpsertTrigger(getCollectionLink(isNameBased, db, collection), getTriggerLink(isNameBased, db, collection, trigger), trigger, function (error, replacedTrigger) {
- assert.equal(err, undefined, "error replacing trigger");
- for (var property in triggerDefinition) {
- if (property !== "serverScript") {
- assert.equal(replacedTrigger[property], trigger[property], "property " + property + " should match");
- } else {
- assert.equal(replacedTrigger.body, "function () { var x = 20; }");
- }
- }
- // read trigger
- client.readTrigger(getTriggerLink(isNameBased, db, collection, replacedTrigger), function (err, trigger) {
- assert.equal(err, undefined, "readTrigger should work successfully");
- assert.equal(replacedTrigger.id, trigger.id);
- // delete trigger
- client.deleteTrigger(getTriggerLink(isNameBased, db, collection, replacedTrigger), function (err, res) {
- assert.equal(err, undefined, "error deleting trigger");
- // read triggers after deletion
- client.readTrigger(getTriggerLink(isNameBased, db, collection, replacedTrigger), function (err, trigger) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do trigger CRUD operations successfully name based", function (done) {
- triggerCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do trigger CRUD operations successfully rid based", function (done) {
- triggerCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do trigger CRUD operations successfully name based with upsert", function (done) {
- triggerCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do trigger CRUD operations successfully rid based with upsert", function (done) {
- triggerCRUDTest(false, true, done);
- });
- });
-
- describe("Validate UDF CRUD", function () {
- var udfCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- // read udfs
- client.readUserDefinedFunctions(getCollectionLink(isNameBased, db, collection)).toArray(function (err, udfs) {
- assert.equal(err, undefined, "error reading udfs");
- assert.equal(udfs.constructor, Array, "Value should be an array");
- // create a udf
- var beforeCreateUdfsCount = udfs.length;
- var udfDefinition = {
- id: "sample udf",
- serverScript: function () { var x = 10; }
- };
- client.createOrUpsertUserDefinedFunction(getCollectionLink(isNameBased, db, collection), udfDefinition, function (err, udf) {
- assert.equal(err, undefined, "error creating udf");
- for (var property in udfDefinition) {
- if (property !== "serverScript") {
- assert.equal(udf[property], udfDefinition[property], "property " + property + " should match");
- } else {
- assert.equal(udf.body, "function () { var x = 10; }");
- }
- }
-
- // read udfs after creation
- client.readUserDefinedFunctions(getCollectionLink(isNameBased, db, collection)).toArray(function (err, udfs) {
- assert.equal(err, undefined, "error reading user defined functions");
- assert.equal(udfs.length, beforeCreateUdfsCount + 1, "create should increase the number of udfs");
- // query udfs
- var querySpec = {
- query: "SELECT * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: udfDefinition.id
- }
- ]
- };
- client.queryUserDefinedFunctions(getCollectionLink(isNameBased, db, collection), querySpec).toArray(function (err, results) {
- assert.equal(err, undefined, "error creating user defined functions");
- assert(results.length > 0, "number of results for the query should be > 0");
- // replace udf
- udf.body = function () { var x = 20; };
- client.replaceOrUpsertUserDefinedFunction(getCollectionLink(isNameBased, db, collection), getUserDefinedFunctionLink(isNameBased, db, collection, udf), udf, function (error, replacedUdf) {
- assert.equal(err, undefined, "error replacing user defined function");
- for (var property in udfDefinition) {
- if (property !== "serverScript") {
- assert.equal(replacedUdf[property], udf[property], "property " + property + " should match");
- } else {
- assert.equal(replacedUdf.body, "function () { var x = 20; }");
- }
- }
- // read udf
- client.readUserDefinedFunction(getUserDefinedFunctionLink(isNameBased, db, collection, replacedUdf), function (err, udf) {
- assert.equal(err, undefined, "readUserDefinedFunctions should work successfully");
- assert.equal(replacedUdf.id, udf.id);
- // delete udf
- client.deleteUserDefinedFunction(getUserDefinedFunctionLink(isNameBased, db, collection, replacedUdf), function (err, res) {
- assert.equal(err, undefined, "error deleting user defined function");
- // read udfs after deletion
- client.readUserDefinedFunction(getUserDefinedFunctionLink(isNameBased, db, collection, replacedUdf), function (err, udf) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do UDF CRUD operations successfully name based", function (done) {
- udfCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do UDF CRUD operations successfully rid based", function (done) {
- udfCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do UDF CRUD operations successfully name based with upsert", function (done) {
- udfCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do UDF CRUD operations successfully rid based with upsert", function (done) {
- udfCRUDTest(false, true, done);
- });
- });
-
- describe("Validate sproc CRUD", function () {
- var sprocCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- // read sprocs
- client.readStoredProcedures(getCollectionLink(isNameBased, db, collection)).toArray(function (err, sprocs) {
- assert.equal(err, undefined, "error reading sprocs");
- assert.equal(sprocs.constructor, Array, "Value should be an array");
- // create a sproc
- var beforeCreateSprocsCount = sprocs.length;
- var sprocDefinition = {
- id: "sample sproc",
- serverScript: function () { var x = 10; }
- };
- client.createOrUpsertStoredProcedure(getCollectionLink(isNameBased, db, collection), sprocDefinition, function (err, sproc) {
- assert.equal(err, undefined, "error creating sproc");
- for (var property in sprocDefinition) {
- if (property !== "serverScript") {
- assert.equal(sproc[property], sprocDefinition[property], "property " + property + " should match");
- } else {
- assert.equal(sproc.body, "function () { var x = 10; }");
- }
- }
-
- // read sprocs after creation
- client.readStoredProcedures(getCollectionLink(isNameBased, db, collection)).toArray(function (err, sprocs) {
- assert.equal(err, undefined, "error reading stored procedures");
- assert.equal(sprocs.length, beforeCreateSprocsCount + 1, "create should increase the number of sprocs");
- // query sprocs
- var querySpec = {
- query: "SELECT * FROM root r"
- };
- client.queryStoredProcedures(getCollectionLink(isNameBased, db, collection), querySpec).toArray(function (err, sprocs) {
- assert.equal(err, undefined, "error querying stored procedures");
- assert(sprocs.length > 0, "number of sprocs for the query should be > 0");
- // replace sproc
- sproc.body = function () { var x = 20; };
- client.replaceOrUpsertStoredProcedure(getCollectionLink(isNameBased, db, collection), getStoredProcedureLink(isNameBased, db, collection, sproc), sproc, function (error, replacedSproc) {
- assert.equal(error, undefined, "error replacing store procedure");
- for (var property in sprocDefinition) {
- if (property !== "serverScript") {
- assert.equal(replacedSproc[property], sproc[property], "property " + property + " should match");
- } else {
- assert.equal(replacedSproc.body, "function () { var x = 20; }");
- }
- }
- // read sproc
- client.readStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, replacedSproc), function (err, sproc) {
- assert.equal(err, undefined, "readStoredProcedures should work successfully");
- assert.equal(replacedSproc.id, sproc.id);
- // delete sproc
- client.deleteStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, replacedSproc), function (err, res) {
- assert.equal(err, undefined, "error deleting stored procedure");
- // read sprocs after deletion
- client.readStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, replacedSproc), function (err, sproc) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do sproc CRUD operations successfully name based", function (done) {
- sprocCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do sproc CRUD operations successfully rid based", function (done) {
- sprocCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do sproc CRUD operations successfully name based with upsert", function (done) {
- sprocCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do sproc CRUD operations successfully rid based with upsert", function (done) {
- sprocCRUDTest(false, true, done);
- });
- });
-
- describe("Validate spatial index", function () {
- var spatialIndexTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection using an indexing policy with spatial index.
- var indexingPolicy = {
- includedPaths: [
- {
- path: "/\"Location\"/?",
- indexes: [
- {
- kind: DocumentBase.IndexKind.Spatial,
- dataType: DocumentBase.DataType.Point
- }
- ]
- },
- {
- path: "/"
- }
- ]
- };
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection", indexingPolicy: indexingPolicy }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- var location1 = {
- id: "location1",
- Location: {
- type: "Point",
- coordinates: [20.0, 20.0]
- }
- };
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), location1, function (err, _) {
- assert.equal(err, undefined, "error creating location1");
- var location2 = {
- id: "location2",
- Location: {
- type: "Point",
- coordinates: [100.0, 100.0]
- }
- };
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), location2, function (err, _) {
- assert.equal(err, undefined, "error creating location2");
- var query = "SELECT * FROM root WHERE (ST_DISTANCE(root.Location, {type: 'Point', coordinates: [20.1, 20]}) < 20000) ";
- client.queryDocuments(getCollectionLink(isNameBased, db, collection), query).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying locations");
- assert.equal(1, results.length);
- assert.equal("location1", results[0].id);
- done();
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should support spatial index name based", function (done) {
- spatialIndexTest(true, false, done);
- });
-
- it("nativeApi Should support spatial index rid based", function (done) {
- spatialIndexTest(false, false, done);
- });
-
- it("nativeApi Should support spatial index name based with upsert", function (done) {
- spatialIndexTest(true, true, done);
- });
-
- it("nativeApi Should support spatial index rid based with upsert", function (done) {
- spatialIndexTest(false, true, done);
- });
- });
-
- describe("Validate collection indexing policy", function () {
- var indexPolicyTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- assert.equal(collection.indexingPolicy.indexingMode, DocumentBase.IndexingMode.Consistent, "default indexing mode should be consistent");
- var lazyCollectionDefinition = { id: "lazy collection", indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Lazy } };
- client.deleteCollection(getCollectionLink(isNameBased, db, collection), function (err, coll) {
- assert.equal(err, undefined, "error deleting collection");
- client.createCollection(getDatabaseLink(isNameBased, db), lazyCollectionDefinition, function (err, lazyCollection) {
- assert.equal(err, undefined, "error creating collection");
- assert.equal(lazyCollection.indexingPolicy.indexingMode, DocumentBase.IndexingMode.Lazy, "indexing mode should be lazy");
- var consistentCollectionDefinition = { id: "lazy collection", indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Consistent } };
- client.deleteCollection(getCollectionLink(isNameBased, db, lazyCollection), function (err, coll) {
- assert.equal(err, undefined, "error deleting collection");
- client.createCollection(getDatabaseLink(isNameBased, db), consistentCollectionDefinition, function (err, consistentCollection) {
- assert.equal(err, undefined, "error creating collection");
- assert.equal(collection.indexingPolicy.indexingMode, DocumentBase.IndexingMode.Consistent, "indexing mode should be consistent");
- var collectionDefinition = {
- "id": "CollectionWithIndexingPolicy",
- "indexingPolicy": {
- automatic: true,
- indexingMode: DocumentBase.IndexingMode.Consistent,
- "includedPaths": [
- {
- "path": "/",
- "indexes": [
- {
- "kind": DocumentBase.IndexKind.Hash,
- "dataType": DocumentBase.DataType.Number,
- "precision": 2
- }
- ]
- }
- ],
- "excludedPaths": [
- {
- "path": "/\"systemMetadata\"/*"
- }
- ]
- }
-
- };
-
- client.deleteCollection(getCollectionLink(isNameBased, db, consistentCollection), function (err, coll) {
- assert.equal(err, undefined, "error deleting collection");
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, function (err, collectionWithIndexingPolicy) {
- assert.equal(err, undefined, "error creating collection");
-
- // Two included paths.
- assert.equal(1, collectionWithIndexingPolicy.indexingPolicy.includedPaths.length, "Unexpected includedPaths length");
- // The first included path is what we created.
- assert.equal("/", collectionWithIndexingPolicy.indexingPolicy.includedPaths[0].path);
- assert(collectionWithIndexingPolicy.indexingPolicy.includedPaths[0].indexes.length > 1); // Backend adds a default index
- assert.equal(DocumentBase.IndexKind.Hash, collectionWithIndexingPolicy.indexingPolicy.includedPaths[0].indexes[0].kind);
- // The second included path is a timestamp index created by the server.
-
- // And one excluded path.
- assert.equal(1, collectionWithIndexingPolicy.indexingPolicy.excludedPaths.length, "Unexpected excludedPaths length");
- assert.equal("/\"systemMetadata\"/*", collectionWithIndexingPolicy.indexingPolicy.excludedPaths[0].path);
-
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should create collection with correct indexing policy name based", function (done) {
- indexPolicyTest(true, done);
- });
-
- it("nativeApi Should create collection with correct indexing policy rid based", function (done) {
- indexPolicyTest(false, done);
- });
-
- var checkDefaultIndexingPolicyPaths = function (indexingPolicy) {
- // no excluded paths.
- assert.equal(0, indexingPolicy["excludedPaths"].length);
- // included paths should be 1 "/".
- assert.equal(1, indexingPolicy["includedPaths"].length);
-
- var rootIncludedPath = null;
- if (indexingPolicy["includedPaths"][0]["path"] == "/*") {
- rootIncludedPath = indexingPolicy["includedPaths"][0];
- }
-
- assert(rootIncludedPath); // root path should exist.
-
- // In the root path, there should be one HashIndex for Strings, and one RangeIndex for Numbers.
- assert.equal(2, rootIncludedPath["indexes"].length);
-
- var hashIndex = null;
- var rangeIndex = null;
-
- for (var i = 0; i < 2; ++i) {
- if (rootIncludedPath["indexes"][i]["kind"] == "Hash") {
- hashIndex = rootIncludedPath["indexes"][i];
- } else if (rootIncludedPath["indexes"][i]["kind"] == "Range") {
- rangeIndex = rootIncludedPath["indexes"][i];
- }
- }
-
- assert(hashIndex);
- assert.equal("String", hashIndex["dataType"]);
- assert(rangeIndex);
- assert.equal("Number", rangeIndex["dataType"]);
- };
-
- var defaultIndexingPolicyTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection with no indexing policy specified.
- var collectionDefinition01 = { id: "TestCreateDefaultPolicy01" };
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition01, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- checkDefaultIndexingPolicyPaths(collection["indexingPolicy"]);
- // create collection with partial policy specified.
- var collectionDefinition02 = {
- id: "TestCreateDefaultPolicy02",
- indexingPolicy: {
- indexingMode: "Lazy",
- automatic: true
- }
- };
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition02, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- checkDefaultIndexingPolicyPaths(collection["indexingPolicy"]);
- // create collection with default policy.
- var collectionDefinition03 = {
- id: "TestCreateDefaultPolicy03",
- indexingPolicy: {}
- };
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition03, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- checkDefaultIndexingPolicyPaths(collection["indexingPolicy"]);
- // create collection with indexing policy missing indexes.
- var collectionDefinition04 = {
- id: "TestCreateDefaultPolicy04",
- indexingPolicy: {
- includedPaths: [
- {
- path: "/*"
- }
- ]
- }
- };
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition04, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- checkDefaultIndexingPolicyPaths(collection["indexingPolicy"]);
- // create collection with indexing policy missing precision.
- var collectionDefinition05 = {
- id: "TestCreateDefaultPolicy05",
- indexingPolicy: {
- includedPaths: [
- {
- path: "/*",
- indexes: [
- {
- kind: "Hash",
- dataType: "String"
- },
- {
- kind: "Range",
- dataType: "Number"
- }
- ]
- }
- ]
- }
- };
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition05, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- checkDefaultIndexingPolicyPaths(collection["indexingPolicy"]);
- done();
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should create collection with default indexing policy name based", function (done) {
- defaultIndexingPolicyTest(true, done);
- });
-
- it("nativeApi Should create collection with default indexing policy rid based", function (done) {
- defaultIndexingPolicyTest(false, done);
- });
- });
-
- describe.skip("Validate client request timeout", function () {
- it("nativeApi Client Should throw exception", function (done) {
- var connectionPolicy = new DocumentBase.ConnectionPolicy();
- // making timeout 5 ms to make sure it will throw(create database request takes 10ms-15ms to finish on emulator)
- connectionPolicy.RequestTimeout = 5;
- var client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err.code, "ECONNRESET", "client should throw exception");
- done();
- });
- });
- });
-
- describe("Validate QueryIterator Functionality For Multiple Partition Collection", function () {
-
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- var documentDefinitions = [
- { id: "document1" },
- { id: "document2", key: null, prop: 1 },
- { id: "document3", key: false, prop: 1 },
- { id: "document4", key: true, prop: 1 },
- { id: "document5", key: 1, prop: 1 },
- { id: "document6", key: "A", prop: 1 }
- ];
-
- // creates a new database, creates a new collecton, bulk inserts documents to the collection
- beforeEach(function (done) {
-
- return createDatabase(function () {
- return createCollection(
- function () {
- bulkInsertDocuments(client, isNameBased, db, collection, documentDefinitions, function (insertedDocs) {
- return done();
- });
- }
- );
- });
- });
-
- var db = undefined;
- var createDatabase = function (done) {
- client.createDatabase({ id: "sample 中文 database" }, function (err, createdDB) {
- assert.equal(err, undefined, "error creating database ");
- db = createdDB;
- done();
- });
- }
- var collection = undefined;
- var isNameBased = false;
-
- var createCollection = function (done) {
- var partitionKey = "key";
- var collectionDefinition = {
- id: "coll1",
- partitionKey: {
- paths: ["/" + partitionKey],
- kind: DocumentBase.PartitionKind.Hash
- }
- };
-
- var collectionOptions = { offerThroughput: 12000 }
- client.createCollection("dbs/sample 中文 database", collectionDefinition, collectionOptions, function (err, createdCollection) {
- assert.equal(err, undefined, "error creating collection");
- collection = createdCollection;
- done();
- });
- };
-
- var queryIteratorNextItemVerifier = function (done) {
-
- // obtain an instance of queryIterator
- var queryIterator = client.queryDocuments(getCollectionLink(isNameBased, db, collection));
- // a recursive function for visiting all the documents
- var cnt = 0;
- var visitResultsFunc = function () {
- queryIterator.nextItem(function (err, resource) {
- if (err) {
- // error
- console.log("an err occured " + err);
- return done(err);
- }
- if (resource === undefined) {
- // there is no more results
- // verify the total number of visited documents
- assert.equal(cnt, documentDefinitions.length);
- return done(undefined, resource);
- }
-
- // increment the visited documents counter
- cnt++;
- // visit the remaining results recursively
- visitResultsFunc();
- })
- }
- // invoke the function
- visitResultsFunc(queryIterator);
- }
-
- it("nativeApi validate QueryIterator nextItem on Multiple Partition Colleciton", function (done) {
- queryIteratorNextItemVerifier(done);
- });
- });
-
- describe("Validate QueryIterator Functionality", function () {
- var createResources = function (isNameBased, client, callback) {
- client.createDatabase({ id: "sample database" + Math.random() }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- client.createDocument(getCollectionLink(isNameBased, db, collection), { id: "doc1", prop1: "value1" }, function (err, doc1) {
- assert.equal(err, undefined, "error creating document");
- client.createDocument(getCollectionLink(isNameBased, db, collection), { id: "doc2", prop1: "value2" }, function (err, doc2) {
- assert.equal(err, undefined, "error creating document");
- client.createDocument(getCollectionLink(isNameBased, db, collection), { id: "doc3", prop1: "value3" }, function (err, doc3) {
- assert.equal(err, undefined, "error creating document");
- var resources = {
- db: db,
- coll: collection,
- doc1: doc1,
- doc2: doc2,
- doc3: doc3
- };
-
- callback(resources);
- });
- });
- });
- });
- });
- };
-
- var queryIteratorToArrayTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- createResources(isNameBased, client, function (resources) {
- var queryIterator = client.readDocuments(getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- queryIterator.toArray(function (err, docs) {
- assert.equal(err, undefined, "error reading documents");
- assert.equal(docs.length, 3, "queryIterator should return all documents using continuation");
- assert.equal(docs[0].id, resources.doc1.id);
- assert.equal(docs[1].id, resources.doc2.id);
- assert.equal(docs[2].id, resources.doc3.id);
- done();
- });
- });
- };
-
- it("nativeApi validate QueryIterator iterator toArray name based", function (done) {
- queryIteratorToArrayTest(true, done);
- });
-
- it("nativeApi validate QueryIterator iterator toArray rid based", function (done) {
- queryIteratorToArrayTest(false, done);
- });
-
- var queryIteratorForEachTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- createResources(isNameBased, client, function (resources) {
- var queryIterator = client.readDocuments(getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- var counter = 0;
- // test queryIterator.forEach
- queryIterator.forEach(function (err, doc) {
- assert.equal(err, undefined, "error reading documents");
- counter++;
- if (counter === 1) {
- assert.equal(doc.id, resources.doc1.id, "first document should be doc1");
- } else if (counter === 2) {
- assert.equal(doc.id, resources.doc2.id, "second document should be doc2");
- } else if (counter === 3) {
- assert.equal(doc.id, resources.doc3.id, "third document should be doc3");
- }
-
- if (doc === undefined) {
- assert(counter < 5, "iterator should have stopped");
- done();
- }
- });
- });
- };
-
- it("nativeApi validate queryIterator iterator forEach name based", function (done) {
- queryIteratorForEachTest(true, done);
- });
-
- it("nativeApi validate queryIterator iterator forEach rid based", function (done) {
- queryIteratorForEachTest(false, done);
- });
-
- var queryIteratorNextAndMoreTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- createResources(isNameBased, client, function (resources) {
- var queryIterator = client.readDocuments(getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- assert.equal(queryIterator.hasMoreResults(), true);
- queryIterator.current(function (err, doc) {
- assert.equal(err, undefined, "error querying documents");
- assert.equal(doc.id, resources.doc1.id, "call queryIterator.current after reset should return first document");
- queryIterator.nextItem(function (err, doc) {
- assert.equal(err, undefined, "error querying documents");
- assert.equal(doc.id, resources.doc1.id, "call queryIterator.nextItem after reset should return first document");
- assert.equal(queryIterator.hasMoreResults(), true);
- queryIterator.current(function (err, doc) {
- assert.equal(err, undefined, "error querying documents");
- assert.equal(doc.id, resources.doc2.id, "call queryIterator.current should return second document");
- queryIterator.nextItem(function (err, doc) {
- assert.equal(err, undefined, "error querying documents");
- assert.equal(doc.id, resources.doc2.id, "call queryIterator.nextItem again should return second document");
- assert.equal(queryIterator.hasMoreResults(), true);
- queryIterator.current(function (err, doc) {
- assert.equal(err, undefined, "error querying documents");
- assert.equal(doc.id, resources.doc3.id, "call queryIterator.current should return third document");
- queryIterator.nextItem(function (err, doc) {
- assert.equal(err, undefined, "error querying documents");
- assert.equal(doc.id, resources.doc3.id, "call queryIterator.nextItem again should return third document");
- queryIterator.nextItem(function (err, doc) {
- assert.equal(err, undefined, "error querying documents");
- assert.equal(doc, undefined, "queryIterator should return undefined if there is no elements");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi validate queryIterator nextItem and hasMoreResults name based", function (done) {
- queryIteratorNextAndMoreTest(true, done);
- });
-
- it("nativeApi validate queryIterator nextItem and hasMoreResults rid based", function (done) {
- queryIteratorNextAndMoreTest(false, done);
- });
-
- var queryIteratorExecuteNextTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- createResources(isNameBased, client, function (resources) {
- var queryIterator = client.readDocuments(getCollectionLink(isNameBased, resources.db, resources.coll), { maxItemCount: 2 });
- queryIterator.executeNext(function (err, docs, headers) {
- assert.equal(err, undefined, "error reading documents");
- assert(headers !== undefined, "executeNext should pass headers as the third parameter to the callback");
- assert(headers[Constants.HttpHeaders.RequestCharge] > 0, "RequestCharge has to be non-zero");
- assert.equal(docs.length, 2, "first batch size should be 2");
- assert.equal(docs[0].id, resources.doc1.id, "first batch first document should be doc1");
- assert.equal(docs[1].id, resources.doc2.id, "batch first second document should be doc2");
- queryIterator.executeNext(function (err, docs) {
- assert.equal(err, undefined, "error reading documents");
- assert.equal(docs.length, 1, "second batch size is unexpected");
- assert.equal(docs[0].id, resources.doc3.id, "second batch element should be doc3");
- });
-
- // validate Iterator.executeNext with continuation token
- queryIterator = client.readDocuments(
- getCollectionLink(isNameBased, resources.db, resources.coll),
- { maxItemCount: 2, continuation: headers[Constants.HttpHeaders.Continuation] });
- queryIterator.executeNext(function (err, docs) {
- assert.equal(err, undefined, "error reading documents");
- assert(headers !== undefined, "executeNext should pass headers as the third parameter to the callback");
- assert(headers[Constants.HttpHeaders.RequestCharge] > 0, "RequestCharge has to be non-zero");
- assert.equal(docs.length, 1, "second batch size with continuation token is unexpected");
- assert.equal(docs[0].id, resources.doc3.id, "second batch element should be doc3");
- done();
- });
- });
- });
- };
-
- it("nativeApi validate queryIterator iterator executeNext name based", function (done) {
- queryIteratorExecuteNextTest(true, done);
- });
-
- it("nativeApi validate queryIterator iterator executeNext rid based", function (done) {
- queryIteratorExecuteNextTest(false, done);
- });
- });
-
- describe("validate trigger functionality", function () {
- var triggers = [
- {
- id: "t1",
- body: function () {
- var item = getContext().getRequest().getBody();
- item.id = item.id.toUpperCase() + "t1";
- getContext().getRequest().setBody(item);
- },
- triggerType: DocumentBase.TriggerType.Pre,
- triggerOperation: DocumentBase.TriggerOperation.All
- },
- {
- id: "t2",
- body: "function() { }", // trigger already stringified
- triggerType: DocumentBase.TriggerType.Pre,
- triggerOperation: DocumentBase.TriggerOperation.All
- },
- {
- id: "t3",
- body: function () {
- var item = getContext().getRequest().getBody();
- item.id = item.id.toLowerCase() + "t3";
- getContext().getRequest().setBody(item);
- },
- triggerType: DocumentBase.TriggerType.Pre,
- triggerOperation: DocumentBase.TriggerOperation.All
- },
- {
- id: "response1",
- body: function () {
- var prebody = getContext().getRequest().getBody();
- if (prebody.id !== "TESTING POST TRIGGERt1") throw "name mismatch";
- var postbody = getContext().getResponse().getBody();
- if (postbody.id !== "TESTING POST TRIGGERt1") throw "name mismatch";
- },
- triggerType: DocumentBase.TriggerType.Post,
- triggerOperation: DocumentBase.TriggerOperation.All
- },
- {
- id: "triggerOpType",
- body: "function() { }",
- triggerType: DocumentBase.TriggerType.Post,
- triggerOperation: DocumentBase.TriggerOperation.Delete
- }
- ];
-
- var createTriggers = function (client, collection, index, callback) {
- if (index === triggers.length) {
- return callback();
- }
-
- client.createOrUpsertTrigger(collection._self, triggers[index], function (err, trigger) {
- assert.equal(err, undefined, "error creating trigger");
- for (var property in triggers[index]) {
- assert.equal(trigger[property], triggers[index][property], "property " + property + " should match");
- }
-
- createTriggers(client, collection, index + 1, callback);
- });
- };
-
- var triggerCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- // create triggers
- createTriggers(client, collection, 0, function () {
- assert.equal(err, undefined, "error creating trigger");
- // create document
- client.readTriggers(getCollectionLink(isNameBased, db, collection)).toArray(function (err, triggers) {
- assert.equal(err, undefined, "error reading triggers");
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), { id: "doc1", key: "value" }, { preTriggerInclude: "t1" }, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(document.id, "DOC1t1", "name should be capitalized");
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), { id: "doc2", key2: "value2" }, { preTriggerInclude: "t2" }, function (err, document2) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(document2.id, "doc2", "name shouldn't change");
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), { id: "Doc3", prop: "empty" }, { preTriggerInclude: "t3" }, function (err, document3) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(document3.id, "doc3t3");
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), { id: "testing post trigger" }, { postTriggerInclude: "response1", preTriggerInclude: "t1" }, function (err, document4) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(document4.id, "TESTING POST TRIGGERt1");
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), { id: "responseheaders" }, { preTriggerInclude: "t1" }, function (err, document5, headers) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(document5.id, "RESPONSEHEADERSt1");
- client.createOrUpsertDocument(getCollectionLink(isNameBased, db, collection), { id: "Docoptype" }, { postTriggerInclude: "triggerOpType" }, function (err, document6) {
- assert(err !== undefined);
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do trigger operations successfully name based", function (done) {
- triggerCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do trigger operations successfully rid based", function (done) {
- triggerCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do trigger operations successfully name based", function (done) {
- triggerCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do trigger operations successfully rid based", function (done) {
- triggerCRUDTest(false, true, done);
- });
- });
-
- describe("validate stored procedure functionality", function () {
- var storedProcedureCRUDTest = function (isNameBased, isUpsertTest, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- addUpsertWrapperMethods(client, isUpsertTest);
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- var sproc1 = {
- id: "storedProcedure1",
- body: function () {
- for (var i = 0; i < 1000; i++) {
- var item = getContext().getResponse().getBody();
- if (i > 0 && item !== i - 1) throw "body mismatch";
- getContext().getResponse().setBody(i);
- }
- }
- };
-
- client.createOrUpsertStoredProcedure(getCollectionLink(isNameBased, db, collection), sproc1, function (err, retrievedSproc) {
- assert.equal(err, undefined, "error creating stored procedure");
- client.executeStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, retrievedSproc), function (err, result) {
- assert.equal(err, undefined, "error executing stored procedure");
- assert.equal(result, 999);
- var sproc2 = {
- id: "storedProcedure2",
- body: function () {
- for (var i = 0; i < 10; i++) getContext().getResponse().appendValue("Body", i);
- }
- };
-
- client.createOrUpsertStoredProcedure(getCollectionLink(isNameBased, db, collection), sproc2, function (err, retrievedSproc2) {
- assert.equal(err, undefined, "error creating stored procedure");
- client.executeStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, retrievedSproc2), function (err, result) {
- assert.equal(err, undefined, "error executing stored procedure");
- assert.equal(result, 123456789);
- var sproc3 = {
- id: "storedProcedure3",
- body: function (input) {
- getContext().getResponse().setBody("a" + input.temp);
- }
- };
-
- client.createOrUpsertStoredProcedure(getCollectionLink(isNameBased, db, collection), sproc3, function (err, retrievedSproc3) {
- assert.equal(err, undefined, "error creating stored procedure");
- client.executeStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, retrievedSproc3), { temp: "so" }, function (err, result) {
- assert.equal(err, undefined, "error executing stored procedure");
- assert.equal(result, "aso");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- var executeStoredProcedureWithPartitionKey = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- var partitionKey = "key";
-
- var collectionDefinition = {
- id: "coll1",
- partitionKey: { paths: ["/" + partitionKey], kind: DocumentBase.PartitionKind.Hash }
- };
-
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, { offerThroughput: 12000 }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- var querySproc = {
- id: "querySproc",
- body: function () {
- var context = getContext();
- var collection = context.getCollection();
- var response = context.getResponse();
-
- // query for players
- var query = 'SELECT r.id, r.key, r.prop FROM r';
- var accept = collection.queryDocuments(collection.getSelfLink(), query, {}, function (err, documents, responseOptions) {
- if (err) throw new Error("Error" + err.message);
- response.setBody(documents);
- });
-
- if (!accept) throw "Unable to read player details, abort ";
- }
- };
-
- var documents = [
- { id: "document1" },
- { id: "document2", key: null, prop: 1 },
- { id: "document3", key: false, prop: 1 },
- { id: "document4", key: true, prop: 1 },
- { id: "document5", key: 1, prop: 1 },
- { id: "document6", key: "A", prop: 1 }
- ];
-
- bulkInsertDocuments(client, isNameBased, db, collection, documents, function (returnedDocuments) {
- client.createStoredProcedure(getCollectionLink(isNameBased, db, collection), querySproc, function (err, sproc) {
- assert.equal(err, undefined, "error creating sproc");
- client.executeStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, sproc), [], { partitionKey: null }, function (err, result) {
- assert.equal(err, undefined, "error executing sproc");
- assert(result !== undefined);
- assert.equal(result.length, 1);
- assert.equal(JSON.stringify(result[0]), JSON.stringify(documents[1]));
- client.executeStoredProcedure(getStoredProcedureLink(isNameBased, db, collection, sproc), null, { partitionKey: 1 }, function (err, result) {
- assert.equal(err, undefined, "error executing sproc");
- assert(result !== undefined);
- assert.equal(result.length, 1);
- assert.equal(JSON.stringify(result[0]), JSON.stringify(documents[4]));
- done();
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do stored procedure operations successfully name based", function (done) {
- storedProcedureCRUDTest(true, false, done);
- });
-
- it("nativeApi Should do stored procedure operations successfully rid based", function (done) {
- storedProcedureCRUDTest(false, false, done);
- });
-
- it("nativeApi Should do stored procedure operations successfully name based with upsert", function (done) {
- storedProcedureCRUDTest(true, true, done);
- });
-
- it("nativeApi Should do stored procedure operations successfully rid based with upsert", function (done) {
- storedProcedureCRUDTest(false, true, done);
- });
-
- it("nativeApi Should execute stored procedure with partition key successfully name based", function (done) {
- executeStoredProcedureWithPartitionKey(true, done);
- });
-
- it("nativeApi Should execute stored procedure with partition key successfully rid based", function (done) {
- executeStoredProcedureWithPartitionKey(false, done);
- });
-
- it("nativeApi Should enable/disable script logging while executing stored procedure", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- var collectionDefinition = { id: "sample collection" };
-
- client.createCollection(getDatabaseLink(true, db), collectionDefinition, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- var sproc1 = {
- id: "storedProcedure",
- body: function () {
- var mytext = 'x';
- var myval = 1;
- try {
- console.log('The value of %s is %s.', mytext, myval);
- getContext().getResponse().setBody('Success!');
- }
- catch (err) {
- getContext().getResponse().setBody('inline err: [' + err.number + '] ' + err);
- }
- }
- };
-
- client.createStoredProcedure(getCollectionLink(true, db, collection), sproc1, function (err, retrievedSproc) {
- assert.equal(err, undefined, "error creating stored procedure");
- client.executeStoredProcedure(getStoredProcedureLink(true, db, collection, retrievedSproc), function (err, result, headers) {
- assert.equal(err, undefined, "error executing stored procedure");
- assert.equal(result, 'Success!');
- assert.equal(headers[Constants.HttpHeaders.ScriptLogResults], undefined);
-
- var requestOptions = { enableScriptLogging: true };
- client.executeStoredProcedure(getStoredProcedureLink(true, db, collection, retrievedSproc), undefined, requestOptions, function (err, result, headers) {
- assert.equal(err, undefined, "error executing stored procedure");
- assert.equal(result, 'Success!');
- assert.equal(headers[Constants.HttpHeaders.ScriptLogResults], "The value of x is 1.");
-
- var requestOptions = { enableScriptLogging: false };
- client.executeStoredProcedure(getStoredProcedureLink(true, db, collection, retrievedSproc), undefined, requestOptions, function (err, result, headers) {
- assert.equal(err, undefined, "error executing stored procedure");
- assert.equal(result, 'Success!');
- assert.equal(headers[Constants.HttpHeaders.ScriptLogResults], undefined);
- done();
- });
- });
- });
- });
- });
- });
- });
- });
-
- describe("Validate Offer CRUD", function () {
- var validateOfferResponseBody = function (offer, expectedCollLink, expectedOfferType) {
- assert(offer.id, "Id cannot be null");
- assert(offer._rid, "Resource Id (Rid) cannot be null");
- assert(offer._self, "Self Link cannot be null");
- assert(offer.resource, "Resource Link cannot be null");
- assert(offer._self.indexOf(offer.id) !== -1, "Offer id not contained in offer self link.");
- assert.equal(expectedCollLink.replace(/^\/|\/$/g, ""), offer.resource.replace(/^\/|\/$/g, ""));
- if (expectedOfferType) {
- assert.equal(expectedOfferType, offer.offerType);
- }
- };
-
- var offerReadAndQueryTest = function (isNameBased, isPartitionedCollection, offerThroughput, expectedCollectionSize, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: 'new database' }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- var collectionRequestOptions = { offerThroughput: offerThroughput };
- var collectionDefinition = "";
- if (isPartitionedCollection) {
- collectionDefinition = {
- 'id': Base.generateGuidId(),
- 'indexingPolicy': {
- 'includedPaths': [
- {
- 'path': '/',
- 'indexes': [
- {
- 'kind': 'Range',
- 'dataType': 'Number'
- },
- {
- 'kind': 'Range',
- 'dataType': 'String'
- }
- ]
- }
- ]
- },
- 'partitionKey': {
- 'paths': [
- '/id'
- ],
- 'kind': 'Hash'
- }
- };
- } else {
- collectionDefinition = { id: "sample collection" };
- }
- client.createCollection(getDatabaseLink(isNameBased, db), collectionDefinition, collectionRequestOptions, function (err, collection) {
- assert.equal(err, undefined, "error creating collection: " + JSON.stringify(err));
-
- client.readCollection(getCollectionLink(isNameBased, db, collection), { populateQuotaInfo: true }, function (err, collection, headers) {
- assert.equal(err, undefined, "error reading collection: " + JSON.stringify(err));
-
- // Validate the collection size quota
- assert.notEqual(headers[Constants.HttpHeaders.MaxResourceQuota], null);
- assert.notEqual(headers[Constants.HttpHeaders.MaxResourceQuota], "");
- var collectionSize = Number(headers[Constants.HttpHeaders.MaxResourceQuota].split(";")
- .reduce(function (map, obj) {
- var items = obj.split("=");
- map[items[0]] = items[1];
- return map
- }, {})[Constants.Quota.CollectionSize]);
- assert.equal(collectionSize, expectedCollectionSize, "Collection size is unexpected");
-
- client.readOffers({}).toArray(function (err, offers) {
- assert.equal(err, undefined, "error reading offers");
- assert.equal(offers.length, 1);
- var expectedOffer = offers[0];
- assert.equal(expectedOffer.content.offerThroughput, collectionRequestOptions.offerThroughput, "Expected offerThroughput to be " + collectionRequestOptions.offerThroughput);
- validateOfferResponseBody(expectedOffer, collection._self, undefined);
- // Read the offer
- client.readOffer(expectedOffer._self, function (err, readOffer) {
- assert.equal(err, undefined, "error reading offer");
- validateOfferResponseBody(readOffer, collection._self, undefined);
- // Check if the read offer is what we expected.
- assert.equal(expectedOffer.id, readOffer.id);
- assert.equal(expectedOffer._rid, readOffer._rid);
- assert.equal(expectedOffer._self, readOffer._self);
- assert.equal(expectedOffer.resource, readOffer.resource);
- // Read offer with a bad offer link.
- var badLink = expectedOffer._self.substring(0, expectedOffer._self.length - 1) + "x/";
- client.readOffer(badLink, function (err, _) {
- var notFoundErrorCode = 400;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
-
- // Query for offer.
- var querySpec = {
- query: "select * FROM root r WHERE r.id=@id",
- parameters: [
- {
- name: "@id",
- value: expectedOffer.id
- }
- ]
- };
- client.queryOffers(querySpec).toArray(function (err, offers) {
- assert.equal(err, undefined, "error querying offers");
- assert.equal(offers.length, 1);
- var oneOffer = offers[0];
- validateOfferResponseBody(oneOffer, collection._self, undefined);
- // Now delete the collection.
- client.deleteCollection(getCollectionLink(isNameBased, db, collection), function (err, _) {
- assert.equal(err, undefined, "error deleting collection");
- // read offer after deleting collection.
- client.readOffer(expectedOffer._self, function (err, _) {
- var notFoundErrorCode = 404;
- assert.equal(err.code, notFoundErrorCode, "response should return error code 404");
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- var mbInBytes = 1024 * 1024;
- var offerThroughputSinglePartitionCollection = 5000;
- var minOfferThroughputPCollectionWithMultiPartitions = 2000;
- var maxOfferThroughputPCollectionWithSinglePartition = minOfferThroughputPCollectionWithMultiPartitions - 100;
-
- it.skip("nativeApi Should do offer read and query operations successfully name based single partition collection", function (done) {
- offerReadAndQueryTest(true, false, offerThroughputSinglePartitionCollection, mbInBytes, done);
- });
-
- it.skip("nativeApi Should do offer read and query operations successfully rid based single partition collection", function (done) {
- offerReadAndQueryTest(false, false, offerThroughputSinglePartitionCollection, mbInBytes, done);
- });
-
- it.skip("nativeApi Should do offer read and query operations successfully w/ name based p-Collection w/ 1 partition", function (done) {
- offerReadAndQueryTest(true, true, maxOfferThroughputPCollectionWithSinglePartition, mbInBytes, done);
- });
-
- it.skip("nativeApi Should do offer read and query operations successfully w/ rid based p-Collection w/ 1 partition", function (done) {
- offerReadAndQueryTest(false, true, maxOfferThroughputPCollectionWithSinglePartition, mbInBytes, done);
- });
-
- it.skip("nativeApi Should do offer read and query operations successfully w/ name based p-Collection w/ multi partitions", function (done) {
- offerReadAndQueryTest(true, true, minOfferThroughputPCollectionWithMultiPartitions, 5 * mbInBytes, done);
- });
-
- it.skip("nativeApi Should do offer read and query operations successfully w/ rid based p-Collection w/ multi partitions", function (done) {
- offerReadAndQueryTest(false, true, minOfferThroughputPCollectionWithMultiPartitions, 5 * mbInBytes, done);
- });
-
- var offerReplaceTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- client.readOffers().toArray(function (err, offers) {
- assert.equal(err, undefined, "error reading offers");
- assert.equal(offers.length, 1);
- var expectedOffer = offers[0];
- validateOfferResponseBody(expectedOffer, collection._self, undefined);
- // Replace the offer.
- var offerToReplace = Base.extend({}, expectedOffer);
- var oldThroughput = offerToReplace.content.offerThroughput;
- offerToReplace.content.offerThroughput = oldThroughput + 100;
- client.replaceOffer(offerToReplace._self, offerToReplace, function (err, replacedOffer) {
- assert.equal(err, undefined, "error replacing offer");
- validateOfferResponseBody(replacedOffer, collection._self);
- // Check if the replaced offer is what we expect.
- assert.equal(replacedOffer.id, offerToReplace.id);
- assert.equal(replacedOffer._rid, offerToReplace._rid);
- assert.equal(replacedOffer._self, offerToReplace._self);
- assert.equal(replacedOffer.resource, offerToReplace.resource);
- assert.equal(replacedOffer.content.offerThroughput, offerToReplace.content.offerThroughput);
- // Replace an offer with a bad id.
- var offerBadId = Base.extend({}, offerToReplace);
- offerBadId._rid = "NotAllowed";
- client.replaceOffer(offerBadId._self, offerBadId, function (err, _) {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode);
- // Replace an offer with a bad rid.
- var offerBadRid = Base.extend({}, offerToReplace);
- offerBadRid._rid = "InvalidRid";
- client.replaceOffer(offerBadRid._self, offerBadRid, function (err, _) {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode);
- // Replace an offer with null id and rid.
- var offerNullId = Base.extend({}, offerToReplace);
- offerNullId.id = undefined;
- offerNullId._rid = undefined;
- client.replaceOffer(offerNullId._self, offerNullId, function (err, _) {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode);
- done();
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("nativeApi Should do offer replace operations successfully name based", function (done) {
- offerReplaceTest(true, done);
- });
-
- it("nativeApi Should do offer replace operations successfully rid based", function (done) {
- offerReplaceTest(false, done);
- });
-
- var createCollectionWithOfferTypeTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // create database
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- // create collection
- client.createCollection(getDatabaseLink(isNameBased, db), { id: "sample collection" }, { offerType: "S2" }, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- client.readOffers().toArray(function (err, offers) {
- assert.equal(err, undefined, "error reading offers");
- assert.equal(offers.length, 1);
- var expectedOffer = offers[0];
- assert.equal(expectedOffer.offerType, "S2");
- done();
- });
- });
- });
- };
-
- it("nativeApi Should create collection with specified offer type successfully name based", function (done) {
- createCollectionWithOfferTypeTest(true, done);
- });
-
- it("nativeApi Should create collection with specified offer type successfully rid based", function (done) {
- createCollectionWithOfferTypeTest(false, done);
- });
- });
-
- describe("validate database account functionality", function () {
- var databaseAccountTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- client.getDatabaseAccount(function (err, databaseAccount, headers) {
- assert.equal(err, undefined, "error getting database account");
- assert.equal(databaseAccount.DatabasesLink, "/dbs/");
- assert.equal(databaseAccount.MediaLink, "/media/");
- assert.equal(databaseAccount.MaxMediaStorageUsageInMB, headers["x-ms-max-media-storage-usage-mb"]);
- assert.equal(databaseAccount.CurrentMediaStorageUsageInMB, headers["x-ms-media-storage-usage-mb"]);
- assert(databaseAccount.ConsistencyPolicy.defaultConsistencyLevel !== undefined);
- done();
- });
- };
-
- it("nativeApi Should get database account successfully name based", function (done) {
- databaseAccountTest(true, done);
- });
-
- it("nativeApi Should get database account successfully rid based", function (done) {
- databaseAccountTest(false, done);
- });
- });
-
- describe("Validate response headers", function () {
- var createThenReadCollection = function (isNameBased, client, db, body, callback) {
- client.createCollection(getDatabaseLink(isNameBased, db), body, function (err, collection, headers) {
- assert.equal(err, undefined, "error creating collection");
- client.readCollection(getCollectionLink(isNameBased, db, collection), function (err, collection, headers) {
- assert.equal(err, undefined, "error reading collection");
- callback(collection, headers);
- });
- });
- };
-
- var indexProgressHeadersTest = function (isNameBased, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- client.createDatabase({ id: "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
- createThenReadCollection(isNameBased, client, db, { id: "consistent_coll" }, function (collection, headers) {
- assert.notEqual(headers[Constants.HttpHeaders.IndexTransformationProgress], undefined);
- assert.equal(headers[Constants.HttpHeaders.LazyIndexingProgress], undefined);
- var lazyCollectionDefinition = {
- id: "lazy_coll",
- indexingPolicy: { indexingMode: DocumentBase.IndexingMode.Lazy }
- };
- createThenReadCollection(isNameBased, client, db, lazyCollectionDefinition, function (collection, headers) {
- assert.notEqual(headers[Constants.HttpHeaders.IndexTransformationProgress], undefined);
- assert.notEqual(headers[Constants.HttpHeaders.LazyIndexingProgress], undefined);
- var noneCollectionDefinition = {
- id: "none_coll",
- indexingPolicy: { indexingMode: DocumentBase.IndexingMode.None, automatic: false }
- };
- createThenReadCollection(isNameBased, client, db, noneCollectionDefinition, function (collection, headers) {
- assert.notEqual(headers[Constants.HttpHeaders.IndexTransformationProgress], undefined);
- assert.equal(headers[Constants.HttpHeaders.LazyIndexingProgress], undefined);
- done();
- });
- });
- });
- });
- };
-
- it("nativeApi Validate index progress headers name based", function (done) {
- indexProgressHeadersTest(true, done);
- });
-
- it("nativeApi Validate index progress headers rid based", function (done) {
- indexProgressHeadersTest(false, done);
- });
- });
-
- describe("Validate Id validation", function () {
- it("nativeApi Should fail on illegal Ids.", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- // Id shoudn't end with a space.
- client.createDatabase({ id: "id_ends_with_space " }, function (err, db) {
- assert.equal("Id ends with a space.", err.message);
-
- // Id shoudn't contain "/".
- client.createDatabase({ id: "id_with_illegal/_char" }, function (err, db) {
- assert.equal("Id contains illegal chars.", err.message);
-
- // Id shoudn't contain "\\".
- client.createDatabase({ id: "id_with_illegal\\_char" }, function (err, db) {
- assert.equal("Id contains illegal chars.", err.message);
-
- // Id shoudn't contain "?".
- client.createDatabase({ id: "id_with_illegal?_?char" }, function (err, db) {
- assert.equal("Id contains illegal chars.", err.message);
-
- // Id shoudn't contain "#".
- client.createDatabase({ id: "id_with_illegal#_char" }, function (err, db) {
- assert.equal("Id contains illegal chars.", err.message);
- done();
- });
- });
- });
- });
- });
- });
- });
-
- describe("TTL tests", function () {
- this.timeout(60000);
-
- function createCollectionWithInvalidDefaultTtl(client, db, collectionDefinition, collId, defaultTtl, callback) {
- collectionDefinition.id = collId;
- collectionDefinition.defaultTtl = defaultTtl;
-
- client.createCollection(db._self, collectionDefinition, function (err) {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode, "response should return error code " + badRequestErrorCode);
- callback();
- });
- }
-
- function createDocumentWithInvalidTtl(client, collection, documentDefinition, docId, ttl, callback) {
- documentDefinition.id = docId;
- documentDefinition.ttl = ttl;
-
- client.createDocument(collection._self, documentDefinition, function (err) {
- var badRequestErrorCode = 400;
- assert.equal(err.code, badRequestErrorCode, "response should return error code " + badRequestErrorCode);
- callback();
- });
- }
-
- it("nativeApi Validate Collection and Document TTL values.", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- client.createDatabase({ "id": "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
-
- var collectionDefinition = {
- id: "sample collection1",
- defaultTtl: 5
- };
-
- client.createCollection(db._self, collectionDefinition, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
- assert.equal(collectionDefinition.defaultTtl, collection.defaultTtl);
-
- // null, 0, -10 are unsupported value for defaultTtl.Valid values are -1 or a non-zero positive 32-bit integer value
- createCollectionWithInvalidDefaultTtl(client, db, collectionDefinition, "sample collection2", null, function () {
- createCollectionWithInvalidDefaultTtl(client, db, collectionDefinition, "sample collection3", 0, function () {
- createCollectionWithInvalidDefaultTtl(client, db, collectionDefinition, "sample collection4", -10, function () {
-
- var documentDefinition = {
- id: "doc",
- name: "sample document",
- key: "value",
- ttl: 2
- };
-
- // 0, null, -10 are unsupported value for ttl.Valid values are -1 or a non-zero positive 32-bit integer value
- createDocumentWithInvalidTtl(client, collection, documentDefinition, "doc1", 0, function () {
- createDocumentWithInvalidTtl(client, collection, documentDefinition, "doc2", null, function () {
- createDocumentWithInvalidTtl(client, collection, documentDefinition, "doc3", -10, function () {
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
-
- function checkDocumentGone(client, collection, createdDocument, callback) {
- client.readDocument(createdDocument._self, function (err) {
- var badRequestErrorCode = 404;
- assert.equal(err.code, badRequestErrorCode, "response should return error code " + badRequestErrorCode);
- callback();
- });
- }
-
- function checkDocumentExists(client, collection, createdDocument, callback) {
- client.readDocument(createdDocument._self, function (err, readDocument) {
- assert.equal(err, undefined, "error reading document");
- assert.equal(readDocument.ttl, createdDocument.ttl);
- callback();
- });
- }
-
- function positiveDefaultTtlStep4(client, collection, createdDocument, callback) {
- // the created document should NOT be gone as it 's ttl value is set to 8 which overrides the collections' s defaultTtl value(5)
- checkDocumentExists(client, collection, createdDocument, function () {
- setTimeout(function () {
- // the created document should be gone now as we have waited for (6 + 4) secs which is greater than documents 's ttl value of 8
- checkDocumentGone(client, collection, createdDocument, function () {
- callback();
- });
- }, 4000);
- });
- }
-
- function positiveDefaultTtlStep3(client, collection, createdDocument, documentDefinition, callback) {
- // the created document should be gone now as it 's ttl value is set to 2 which overrides the collections' s defaultTtl value(5)
- checkDocumentGone(client, collection, createdDocument, function () {
- documentDefinition.id = "doc4";
- documentDefinition.ttl = 8;
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
-
- setTimeout(positiveDefaultTtlStep4, 6000, client, collection, createdDocument, callback);
- });
- });
- }
-
- function positiveDefaultTtlStep2(client, collection, createdDocument, documentDefinition, callback) {
- // the created document should NOT be gone as it 's ttl value is set to -1(never expire) which overrides the collections' s defaultTtl value
- checkDocumentExists(client, collection, createdDocument, function () {
- documentDefinition.id = "doc3";
- documentDefinition.ttl = 2;
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
-
- setTimeout(positiveDefaultTtlStep3, 4000, client, collection, createdDocument, documentDefinition, callback);
- });
- });
- }
-
- function positiveDefaultTtlStep1(client, collection, createdDocument, documentDefinition, callback) {
- // the created document should be gone now as it 's ttl value would be same as defaultTtl value of the collection
- checkDocumentGone(client, collection, createdDocument, function () {
- documentDefinition.id = "doc2";
- documentDefinition.ttl = -1;
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
-
- setTimeout(positiveDefaultTtlStep2, 5000, client, collection, createdDocument, documentDefinition, callback);
- });
- });
- }
-
- it("nativeApi Validate Document TTL with positive defaultTtl.", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- client.createDatabase({ "id": "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
-
- var collectionDefinition = {
- id: "sample collection",
- defaultTtl: 5
- };
-
- client.createCollection(db._self, collectionDefinition, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
-
- var documentDefinition = {
- id: "doc1",
- name: "sample document",
- key: "value"
- };
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
-
- setTimeout(positiveDefaultTtlStep1, 7000, client, collection, createdDocument, documentDefinition, function () {
- done();
- });
- });
- });
- });
- });
-
- function minusOneDefaultTtlStep1(client, collection, createdDocument1, createdDocument2, createdDocument3, callback) {
- // the created document should be gone now as it 's ttl value is set to 2 which overrides the collections' s defaultTtl value(-1)
- checkDocumentGone(client, collection, createdDocument3, function () {
-
- // The documents with id doc1 and doc2 will never expire
- client.readDocument(createdDocument1._self, function (err, readDocument) {
- assert.equal(err, undefined, "error reading document");
- assert.equal(readDocument.id, createdDocument1.id);
-
- client.readDocument(createdDocument2._self, function (err, readDocument) {
- assert.equal(err, undefined, "error reading document");
- assert.equal(readDocument.id, createdDocument2.id);
- callback();
- });
- });
- });
- }
-
- it("nativeApi Validate Document TTL with -1 defaultTtl.", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- client.createDatabase({ "id": "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
-
- var collectionDefinition = {
- id: "sample collection",
- defaultTtl: -1
- };
-
- client.createCollection(db._self, collectionDefinition, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
-
- var documentDefinition = {
- id: "doc1",
- name: "sample document",
- key: "value"
- };
-
- // the created document 's ttl value would be -1 inherited from the collection' s defaultTtl and this document will never expire
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument1) {
- assert.equal(err, undefined, "error creating document");
-
- // This document is also set to never expire explicitly
- documentDefinition.id = "doc2";
- documentDefinition.ttl = -1;
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument2) {
- assert.equal(err, undefined, "error creating document");
-
- documentDefinition.id = "doc3";
- documentDefinition.ttl = 2;
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument3) {
- assert.equal(err, undefined, "error creating document");
-
- setTimeout(minusOneDefaultTtlStep1, 4000, client, collection, createdDocument1, createdDocument2, createdDocument3, function () {
- done();
- });
- });
- });
- });
- });
- });
- });
-
- it("nativeApi Validate Document TTL with no defaultTtl.", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- client.createDatabase({ "id": "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
-
- var collectionDefinition = { id: "sample collection" }
-
- client.createCollection(db._self, collectionDefinition, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
-
- var documentDefinition = {
- id: "doc1",
- name: "sample document",
- key: "value",
- ttl: 5
- };
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
-
- // Created document still exists even after ttl time has passed since the TTL is disabled at collection level(no defaultTtl property defined)
- setTimeout(checkDocumentExists, 7000, client, collection, createdDocument, function () {
- done();
- });
- });
- });
- });
- });
-
- function miscCasesStep4(client, collection, createdDocument, documentDefinition, callback) {
- // Created document still exists even after ttl time has passed since the TTL is disabled at collection level
- checkDocumentExists(client, collection, createdDocument, function () {
- callback();
- });
- }
-
- function miscCasesStep3(client, collection, upsertedDocument, documentDefinition, callback) {
- // the upserted document should be gone now after 10 secs from the last write(upsert) of the document
- checkDocumentGone(client, collection, upsertedDocument, function () {
- var query = "SELECT * FROM root r";
- client.queryDocuments(collection._self, query).toArray(function (err, results) {
- assert.equal(err, undefined, "error querying databases");
- assert.equal(results.length, 0);
-
- // Use a collection definition without defaultTtl to disable ttl at collection level
- var collectionDefinition = { id: collection.id };
-
- client.replaceCollection(collection._self, collectionDefinition, function (err, replacedCollection) {
- assert.equal(err, undefined, "error replacing collection");
-
- documentDefinition.id = "doc2";
-
- client.createDocument(replacedCollection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
-
- setTimeout(miscCasesStep4, 5000, client, replacedCollection, createdDocument, documentDefinition, callback);
- });
- });
- });
- });
- }
-
- function miscCasesStep2(client, collection, documentDefinition, callback) {
- // Upsert the document after 3 secs to reset the document 's ttl
- documentDefinition.key = "value2";
- client.upsertDocument(collection._self, documentDefinition, function (err, upsertedDocument) {
- setTimeout(function () {
- // Upserted document still exists after (3+7)10 secs from document creation time( with collection 's defaultTtl set to 8) since it' s ttl was reset after 3 secs by upserting it
- checkDocumentExists(client, collection, upsertedDocument, function () {
- setTimeout(miscCasesStep3, 3000, client, collection, upsertedDocument, documentDefinition, callback);
- });
- }, 7000);
- });
- }
-
- function miscCasesStep1(client, collection, createdDocument, documentDefinition, callback) {
- // the created document should be gone now as the ttl time expired
- checkDocumentGone(client, collection, createdDocument, function () {
- // We can create a document with the same id after the ttl time has expired
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(documentDefinition.id, createdDocument.id);
- setTimeout(miscCasesStep2, 3000, client, collection, documentDefinition, callback);
- });
- });
- }
-
- it("nativeApi Validate Document TTL Misc cases.", function (done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- client.createDatabase({ "id": "sample database" }, function (err, db) {
- assert.equal(err, undefined, "error creating database");
-
- var collectionDefinition = {
- id: "sample collection",
- defaultTtl: 8
- };
-
- client.createCollection(db._self, collectionDefinition, function (err, collection) {
- assert.equal(err, undefined, "error creating collection");
-
- var documentDefinition = {
- id: "doc1",
- name: "sample document",
- key: "value"
- };
-
- client.createDocument(collection._self, documentDefinition, function (err, createdDocument) {
- assert.equal(err, undefined, "error creating document");
-
- setTimeout(miscCasesStep1, 10000, client, collection, createdDocument, documentDefinition, function () {
- done();
- });
- });
- });
- });
- });
- });
-
- describe("HashPartitionResolver", function () {
-
- var test = function (useUpsert, done) {
- var client = new DocumentDBClient(host, { masterKey: masterKey });
- var getPartitionResolver = function (collectionLink1, collectionLink2) {
- return new HashPartitionResolver("id", [collectionLink1, collectionLink2]);
- }
- var querySpec = {
- query: "SELECT * FROM root"
- };
-
- client.createDatabase({ id: "database" }, function (err, db) {
- client.createCollection(db._self, { id: "sample coll 1" }, function (err, collection1) {
- client.createCollection(db._self, { id: "sample coll 2" }, function (err, collection2) {
- var resolver = getPartitionResolver(collection1._self, collection2._self);
- client.partitionResolvers["foo"] = resolver;
-
- client.createDocument("foo", { id: "sample doc 1" }, function (err, doc1) {
- client.createDocument("foo", { id: "sample doc 2" }, function (err, doc2) {
- client.createDocument("foo", { id: "sample doc 11" }, function (err, doc3) {
- client.queryDocuments("foo", querySpec, { resolverPartitionKey: resolver.getPartitionKey(doc1) }).toArray(function (err, docs1) {
- var d1 = docs1.filter(function (d) { return (d.id === doc1.id); });
- assert(d1, "doc1 not found");
- assert.strictEqual(d1.length, 1);
- client.queryDocuments("foo", querySpec, { resolverPartitionKey: resolver.getPartitionKey(doc2) }).toArray(function (err, docs2) {
- var d2 = docs2.filter(function (d) { return (d.id === doc2.id); });
- assert(d2, "doc2 not found");
- assert.strictEqual(d2.length, 1);
- client.queryDocuments("foo", querySpec, { resolverPartitionKey: resolver.getPartitionKey(doc3) }).toArray(function (err, docs3) {
- var d3 = docs3.filter(function (d) { return (d.id === doc3.id); });
- assert(d3, "doc3 not found");
- assert.strictEqual(d3.length, 1);
- done();
- });
- });
- });
- });
- });
- });
- });
- });
- });
- };
-
- it("CRUD operations", function (done) { test(false, done) });
- it("CRUD operations with upsert", function (done) { test(true, done) });
- });
-});
-
-// describe.skip("retry policy tests", function () {
-// var request = require("../lib/request");
-// var AzureDocuments = require("../lib/documents");
-// var ResourceThrottleRetryPolicy = require("../lib/resourceThrottleRetryPolicy");
-
-// this.timeout(300000);
-
-// var collectionDefinition = {
-// id: "sample collection"
-// };
-
-// var documentDefinition = {
-// id: "doc",
-// name: "sample document",
-// key: "value"
-// };
-
-// var connectionPolicy = new AzureDocuments.ConnectionPolicy();
-
-// // mocked database account to return the WritableLocations and ReadableLocations
-// // set with the default endpoint
-// var mockGetDatabaseAccount = function (options, callback) {
-// var databaseAccount = new AzureDocuments.DatabaseAccount();
-// callback(undefined, databaseAccount);
-// }
-
-// var retryAfterInMilliseconds = 1000;
-// // mocked request object stub that calls the callback with 429 throttling error
-// var mockCreateRequestObjectStub = function (connectionPolicy, requestOptions, callback) {
-// callback({ code: 429, body: "Request rate is too large", retryAfterInMilliseconds: retryAfterInMilliseconds });
-// }
-
-// it("throttle retry policy test default retryAfter", function (done) {
-// connectionPolicy.RetryOptions = new RetryOptions(5);
-
-// var client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client.createDatabase({ "id": "sample database" }, function (err, db) {
-// assert.equal(err, undefined, "error creating database");
-
-// client.createCollection(db._self, collectionDefinition, function (err, collection) {
-// assert.equal(err, undefined, "error creating collection");
-
-// var originalGetDatabaseAccount = client.getDatabaseAccount;
-// client.getDatabaseAccount = mockGetDatabaseAccount;
-
-// var originalCreateRequestObjectStub = request._createRequestObjectStub;
-// request._createRequestObjectStub = mockCreateRequestObjectStub;
-
-// client.createDocument(collection._self, documentDefinition, function (err, createdDocument, responseHeaders) {
-// assert.equal(err.code, 429, "invalid error code");
-// assert.equal(responseHeaders[Constants.ThrottleRetryCount], connectionPolicy.RetryOptions.MaxRetryAttemptCount, "Current retry attempts not maxed out");
-// assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs] >= connectionPolicy.RetryOptions.MaxRetryAttemptCount * retryAfterInMilliseconds);
-
-// request._createRequestObjectStub = originalCreateRequestObjectStub;
-// client.getDatabaseAccount = originalGetDatabaseAccount;
-
-// done();
-// });
-// });
-// });
-// });
-
-// it("throttle retry policy test fixed retryAfter", function (done) {
-// connectionPolicy.RetryOptions = new RetryOptions(5, 2000);
-
-// var client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client.createDatabase({ "id": "sample database" }, function (err, db) {
-// assert.equal(err, undefined, "error creating database");
-
-// client.createCollection(db._self, collectionDefinition, function (err, collection) {
-// assert.equal(err, undefined, "error creating collection");
-
-// var originalGetDatabaseAccount = client.getDatabaseAccount;
-// client.getDatabaseAccount = mockGetDatabaseAccount;
-
-// var originalCreateRequestObjectStub = request._createRequestObjectStub;
-// request._createRequestObjectStub = mockCreateRequestObjectStub;
-
-// client.createDocument(collection._self, documentDefinition, function (err, createdDocument, responseHeaders) {
-// assert.equal(err.code, 429, "invalid error code");
-// assert.equal(responseHeaders[Constants.ThrottleRetryCount], connectionPolicy.RetryOptions.MaxRetryAttemptCount, "Current retry attempts not maxed out");
-// assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs] >= connectionPolicy.RetryOptions.MaxRetryAttemptCount * connectionPolicy.RetryOptions.FixedRetryIntervalInMilliseconds);
-
-// request._createRequestObjectStub = originalCreateRequestObjectStub;
-// client.getDatabaseAccount = originalGetDatabaseAccount;
-
-// done();
-// });
-// });
-// });
-// });
-
-// it("throttle retry policy test max wait time", function (done) {
-// connectionPolicy.RetryOptions = new RetryOptions(5, 2000, 3);
-
-// var client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client.createDatabase({ "id": "sample database" }, function (err, db) {
-// assert.equal(err, undefined, "error creating database");
-
-// client.createCollection(db._self, collectionDefinition, function (err, collection) {
-// assert.equal(err, undefined, "error creating collection");
-
-// var originalGetDatabaseAccount = client.getDatabaseAccount;
-// client.getDatabaseAccount = mockGetDatabaseAccount;
-
-// var originalCreateRequestObjectStub = request._createRequestObjectStub;
-// request._createRequestObjectStub = mockCreateRequestObjectStub;
-
-// client.createDocument(collection._self, documentDefinition, function (err, createdDocument, responseHeaders) {
-// assert.equal(err.code, 429, "invalid error code");
-// assert.ok(responseHeaders[Constants.ThrottleRetryWaitTimeInMs] >= connectionPolicy.RetryOptions.MaxWaitTimeInSeconds * 1000);
-
-// request._createRequestObjectStub = originalCreateRequestObjectStub;
-// client.getDatabaseAccount = originalGetDatabaseAccount;
-
-// done();
-// });
-// });
-// });
-// });
-// });
-// });
-
-// describe.skip("GlobalDBTests", function () {
-// var RetryUtility = require("../lib/retryUtility");
-// var request = require("../lib/request");
-// var AzureDocuments = require("../lib/documents");
-// var EndpointDiscoveryRetryPolicy = require("../lib/endpointDiscoveryRetryPolicy");
-
-// var host = "https://localhost:443/";
-// var writeLocationHost = "https://localhost:443/";
-// var readLocationHost = "https://localhost:1045/";
-// var readLocation2Host = "https://localhost:1050/";
-// var masterKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
-
-// var writeLocation = "South Central US";
-// var readLocation = "West US";
-// var readLocation2 = "East US";
-
-// var testDatabase = "testdb";
-// var testCollection = "testcoll";
-// var testdb, testcoll;
-
-// beforeEach(function (done) {
-// var client = new DocumentDBClient(host, { masterKey: masterKey });
-// client.readDatabase("dbs/" + testDatabase, function (err, db) {
-// assert.equal(err, undefined, "error reading database");
-// testdb = db;
-// client.readCollection("dbs/" + testDatabase + "/colls/" + testCollection, function (err, coll) {
-// assert.equal(err, undefined, "error reading collection");
-// testcoll = coll;
-// done();
-// });
-// });
-// });
-
-// afterEach(function (done) {
-// var client = new DocumentDBClient(host, { masterKey: masterKey });
-// client.readDatabase("dbs/" + testDatabase, function (err, db) {
-// assert.equal(err, undefined, "error reading database");
-// client.readCollection("dbs/" + testDatabase + "/colls/" + testCollection, function (err, coll) {
-// assert.equal(err, undefined, "error reading collection");
-// client.readDocuments(coll._self).toArray(function (err, documents) {
-// assert.equal(err, undefined, "error reading documents");
-// var length = documents.length;
-// if (length === 0)
-// done();
-// var count = 0;
-// documents.forEach(function (document) {
-// client.deleteDocument(document._self, function (err, db) {
-// assert.equal(err, undefined, "error deleting document");
-// count++;
-// if (count == length)
-// done();
-// });
-// });
-// });
-// });
-// });
-// });
-
-// describe("globaldb tests", function () {
-// this.timeout(60000);
-
-// // This test fails intermittently with document not able to replicate to read region
-// it.skip("Test Read Write endpoints", function (done) {
-// var connectionPolicy = new DocumentBase.ConnectionPolicy();
-// connectionPolicy.EnableEndpointDiscovery = false;
-
-// var client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// var documentDefinition = {
-// id: "doc",
-// name: "sample document",
-// key: "value"
-// };
-
-// // When EnableEndpointDiscovery is False, WriteEndpoint is set to the endpoint passed while creatingthe client instance
-// client.createDocument(testcoll._self, documentDefinition, function (err, createdDocument) {
-// assert.equal(err, undefined, "error creating document");
-
-// client.getWriteEndpoint(function (endpoint) {
-// assert.equal(endpoint, host);
-
-// // Delay to get these resources replicated to read location due to Eventual consistency
-// setTimeout(function () {
-// client.readDocument(createdDocument._self, function (err, document) {
-// assert.equal(err, undefined, "error reading document");
-
-// client.getReadEndpoint(function (endpoint) {
-// assert.equal(endpoint, host);
-
-// connectionPolicy.EnableEndpointDiscovery = true;
-// documentDefinition.id = "doc2";
-
-// client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client.createDocument(testcoll._self, documentDefinition, function (err, createdDocument) {
-// assert.equal(err, undefined, "error creating document");
-
-// // When EnableEndpointDiscovery is True, WriteEndpoint is set to the write endpoint
-// client.getWriteEndpoint(function (endpoint) {
-// assert.equal(endpoint, writeLocationHost);
-
-// // Delay to get these resources replicated to read location due to Eventual consistency
-// setTimeout(function () {
-// client.readDocument(createdDocument._self, function (err, document) {
-// assert.equal(err, undefined, "error reading document");
-
-// // If no preferred locations is set, we return the write endpoint as ReadEndpoint for better latency performance
-// client.getReadEndpoint(function (endpoint) {
-// assert.equal(endpoint, writeLocationHost);
-// done();
-// });
-// });
-// }, 20000);
-// });
-// });
-// });
-// });
-// }, 20000);
-// });
-// });
-// });
-
-// it("Test Endpoint discovery", function (done) {
-// var connectionPolicy = new DocumentBase.ConnectionPolicy();
-// connectionPolicy.EnableEndpointDiscovery = false;
-
-// var readClient = new DocumentDBClient(readLocationHost, { masterKey: masterKey }, connectionPolicy);
-
-// var documentDefinition = {
-// id: "doc",
-// name: "sample document",
-// key: "value"
-// };
-
-// // Create Document will fail for the read location client since it has EnableEndpointDiscovery set to false, and hence the request will directly go to
-// // the endpoint that was used to create the client instance(which happens to be a read endpoint)
-// readClient.createDocument(testcoll._self, documentDefinition, function (err, document) {
-// if (!(err.code === 403 && err.substatus === 3)) {
-// assert.ok(false, "Create Document should have failed");
-// }
-
-// var querySpec = {
-// query: "SELECT * FROM root r WHERE r.id=@id",
-// parameters: [
-// {
-// name: "@id",
-// value: testdb.id
-// }
-// ]
-// };
-
-// // Query databases will pass for the read location client as it's a GET operation
-// readClient.queryDatabases(querySpec).toArray(function (err, results) {
-// assert.equal(err, undefined, "error querying databases");
-
-// connectionPolicy.EnableEndpointDiscovery = true;
-// readClient = new DocumentDBClient(readLocationHost, { masterKey: masterKey }, connectionPolicy);
-
-// // CreateDocument call will go to the WriteEndpoint as EnableEndpointDiscovery is set to True and client will resolve the right endpoint based on the operation
-// readClient.createDocument(testcoll._self, documentDefinition, function (err, createdDocument) {
-// assert.equal(err, undefined, "error creating document");
-
-// assert.equal(createdDocument.id, documentDefinition.id);
-// done();
-// });
-// });
-// });
-// });
-
-// it("Test Preferred locations", function (done) {
-// var connectionPolicy = new DocumentBase.ConnectionPolicy();
-// connectionPolicy.EnableEndpointDiscovery = true;
-
-// var client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// var documentDefinition = {
-// id: "doc",
-// name: "sample document",
-// key: "value"
-// };
-
-// client.createDocument(testcoll._self, documentDefinition, function (err, createdDocument) {
-// assert.equal(err, undefined, "error creating document");
-
-// // Delay to get these resources replicated to read location due to Eventual consistency
-// setTimeout(function () {
-// client.readDocument(createdDocument._self, function (err, document) {
-// assert.equal(err, undefined, "error reading document");
-
-// // If no preferred locations is set, we return the write endpoint as ReadEndpoint for better latency performance
-// client.getReadEndpoint(function (endpoint) {
-// assert.equal(endpoint, writeLocationHost);
-
-// connectionPolicy.PreferredLocations = [readLocation2]
-// documentDefinition.id = "doc2";
-
-// client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client.createDocument(testcoll._self, documentDefinition, function (err, createdDocument) {
-// assert.equal(err, undefined, "error creating document");
-
-// // Delay to get these resources replicated to read location due to Eventual consistency
-// setTimeout(function () {
-// client.readDocument(createdDocument._self, function (err, document) {
-// assert.equal(err, undefined, "error reading document");
-
-// // Test that the preferred location is set as ReadEndpoint instead of default write endpoint when no preference is set
-// client.getReadEndpoint(function (endpoint) {
-// assert.equal(endpoint, readLocation2Host);
-// done();
-// });
-// });
-// }, 20000);
-// });
-// });
-// });
-// }, 20000);
-// });
-// });
-
-// it("Test Endpoint assignments", function (done) {
-// var connectionPolicy = new DocumentBase.ConnectionPolicy();
-// connectionPolicy.EnableEndpointDiscovery = false;
-
-// var client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// // When EnableEndpointDiscovery is set to False, both Read and Write Endpoints point to endpoint passed while creating the client instance
-// client._globalEndpointManager.getWriteEndpoint(function (writeEndpoint) {
-// assert.equal(writeEndpoint, host);
-
-// client._globalEndpointManager.getReadEndpoint(function (readEndpoint) {
-// assert.equal(readEndpoint, host);
-
-// connectionPolicy.EnableEndpointDiscovery = true;
-// client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// // If no preferred locations is set, we return the write endpoint as ReadEndpoint for better latency performance, write endpoint is set as expected
-// client._globalEndpointManager.getWriteEndpoint(function (writeEndpoint) {
-// assert.equal(writeEndpoint, writeLocationHost);
-
-// client._globalEndpointManager.getReadEndpoint(function (readEndpoint) {
-// assert.equal(readEndpoint, writeLocationHost);
-
-// connectionPolicy.PreferredLocations = [readLocation2];
-// client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// // Test that the preferred location is set as ReadEndpoint instead of default write endpoint when no preference is set
-// client._globalEndpointManager.getWriteEndpoint(function (writeEndpoint) {
-// assert.equal(writeEndpoint, writeLocationHost);
-
-// client._globalEndpointManager.getReadEndpoint(function (readEndpoint) {
-// assert.equal(readEndpoint, readLocation2Host);
-// done();
-// });
-// });
-// });
-// });
-// });
-// });
-// });
-
-// it("Test locations cache", function (done) {
-// var client = new DocumentDBClient(host, { masterKey: masterKey });
-
-// var writableLocations = [{ name: writeLocation, databaseAccountEndpoint: writeLocationHost }];
-// var readableLocations = [{ name: readLocation, databaseAccountEndpoint: readLocationHost }, { name: readLocation2, databaseAccountEndpoint: readLocation2Host }];
-
-// client._globalEndpointManager._updateLocationsCache(writableLocations, readableLocations, function (endpoints) {
-// // If no preferred locations is set, we return the write endpoint as ReadEndpoint for better latency performance, write endpoint is set as expected
-// assert.equal(endpoints[0], writeLocationHost);
-// assert.equal(endpoints[1], writeLocationHost);
-
-// writableLocations = [];
-// readableLocations = [];
-
-// client._globalEndpointManager._updateLocationsCache(writableLocations, readableLocations, function (endpoints) {
-// // If writableLocations and readableLocations are empty, both Read and Write Endpoints point to endpoint passed while creating the client instance
-// assert.equal(endpoints[0], host);
-// assert.equal(endpoints[1], host);
-
-// writableLocations = [{ name: writeLocation, databaseAccountEndpoint: writeLocationHost }];
-// readableLocations = [];
-
-// client._globalEndpointManager._updateLocationsCache(writableLocations, readableLocations, function (endpoints) {
-// // If there are no readableLocations, we use the write endpoint as ReadEndpoint
-// assert.equal(endpoints[0], writeLocationHost);
-// assert.equal(endpoints[1], writeLocationHost);
-
-// writableLocations = [];
-// readableLocations = [{ name: readLocation, databaseAccountEndpoint: readLocationHost }];
-
-// client._globalEndpointManager._updateLocationsCache(writableLocations, readableLocations, function (endpoints) {
-// // If there are no writableLocations, both Read and Write Endpoints point to endpoint passed while creating the client instance
-// assert.equal(endpoints[0], host);
-// assert.equal(endpoints[1], host);
-
-// writableLocations = [{ name: writeLocation, databaseAccountEndpoint: writeLocationHost }];
-// readableLocations = [{ name: readLocation, databaseAccountEndpoint: readLocationHost }, { name: readLocation2, databaseAccountEndpoint: readLocation2Host }];
-
-// var connectionPolicy = new DocumentBase.ConnectionPolicy();
-// connectionPolicy.PreferredLocations = [readLocation2];
-
-// client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client._globalEndpointManager._updateLocationsCache(writableLocations, readableLocations, function (endpoints) {
-// // Test that the preferred location is set as ReadEndpoint instead of default write endpoint when no preference is set
-// assert.equal(endpoints[0], writeLocationHost);
-// assert.equal(endpoints[1], readLocation2Host);
-
-// writableLocations = [{ name: writeLocation, databaseAccountEndpoint: writeLocationHost }, { name: readLocation2, databaseAccountEndpoint: readLocation2Host }];
-// readableLocations = [{ name: readLocation, databaseAccountEndpoint: readLocationHost }];
-
-// connectionPolicy = new DocumentBase.ConnectionPolicy();
-// connectionPolicy.PreferredLocations = [readLocation2];
-
-// client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client._globalEndpointManager._updateLocationsCache(writableLocations, readableLocations, function (endpoints) {
-// // Test that the preferred location is chosen from the WriteLocations if it 's not present in the ReadLocations
-// assert.equal(endpoints[0], writeLocationHost);
-// assert.equal(endpoints[1], readLocation2Host);
-
-// writableLocations = [{ name: writeLocation, databaseAccountEndpoint: writeLocationHost }];
-// readableLocations = [{ name: readLocation, databaseAccountEndpoint: readLocationHost }, { name: readLocation2, databaseAccountEndpoint: readLocation2Host }];
-
-// connectionPolicy.EnableEndpointDiscovery = false;
-// client = new DocumentDBClient(host, { masterKey: masterKey }, connectionPolicy);
-
-// client._globalEndpointManager._updateLocationsCache(writableLocations, readableLocations, function (endpoints) {
-// // If EnableEndpointDiscovery is False, both Read and Write Endpoints point to endpoint passed while creating the client instance
-// assert.equal(endpoints[0], host);
-// assert.equal(endpoints[1], host);
-// done();
-// });
-// });
-// });
-// });
-// });
-// });
-// });
-// });
-
-// it("Test Locational Endpoint parser", function (done) {
-// var client = new DocumentDBClient(host, { masterKey: masterKey });
-
-// var urlEndpoint = "https://contoso.documents.azure.com:443/";
-// var locationName = "East US";
-
-// // Creating a locational endpoint from the location name using the parser method
-// var locationalEndpoint = client._globalEndpointManager._getLocationalEndpoint(urlEndpoint, locationName);
-// assert.equal(locationalEndpoint, "https://contoso-EastUS.documents.azure.com:443/");
-
-// urlEndpoint = "https://Contoso.documents.azure.com:443/";
-// locationName = "East US";
-
-// // Note that the host name gets lowercased as the urlparser in Python doesn 't retains the casing
-// locationalEndpoint = client._globalEndpointManager._getLocationalEndpoint(urlEndpoint, locationName);
-// assert.equal(locationalEndpoint, "https://contoso-EastUS.documents.azure.com:443/");
-
-// done();
-// });
-
-// it("Test endpoint discovery retry policy", function (done) {
-// var client = new DocumentDBClient(host, { masterKey: masterKey });
-
-// // mocked request object stub that calls the callback with 403.3 error
-// var mockCreateRequestObjectStub = function (connectionPolicy, requestOptions, callback) {
-// callback({ code: 403, substatus: 3, body: "Write Forbidden" });
-// }
-
-// // mocked database account to return the WritableLocations and ReadableLocations
-// // set with the default endpoint
-// var mockGetDatabaseAccount = function (options, callback) {
-// var databaseAccount = new AzureDocuments.DatabaseAccount();
-// callback(undefined, databaseAccount);
-// }
-
-// var documentDefinition = {
-// id: "doc",
-// name: "sample document",
-// key: "value"
-// };
-
-// var originalCreateRequestObjectStub = request._createRequestObjectStub;
-// request._createRequestObjectStub = mockCreateRequestObjectStub;
-
-// var originalGetDatabaseAccount = client.getDatabaseAccount;
-// client.getDatabaseAccount = mockGetDatabaseAccount;
-
-// var startDate = new Date();
-// var maxRetryAttemptCount = 10;
-// var retryAfterInMilliseconds = 1000;
-// var retryFinishCallback = function (currentRetryAttemptCount, maxRetryAttemptCount, callback) {
-// assert.equal(currentRetryAttemptCount, maxRetryAttemptCount, "Current retry attempts not maxed out");
-// callback();
-// }
-
-// // configuring maxRetryAttemptCount and retryAfterInMilliseconds for testing purposes
-// EndpointDiscoveryRetryPolicy.maxRetryAttemptCount = maxRetryAttemptCount;
-// EndpointDiscoveryRetryPolicy.retryAfterInMilliseconds = retryAfterInMilliseconds;
-// EndpointDiscoveryRetryPolicy.retryFinishCallback = retryFinishCallback;
-// client.createDocument(testcoll._self, documentDefinition, function (err, createdDocument) {
-// assert.equal(err.code, 403, "invalid error code");
-// assert.equal(err.substatus, 3, "invalid error substatus");
-
-// var endDate = new Date();
-
-// // Test that it took at least (maxRetryAttemptCount * retryAfterInMilliseconds) milliseconds for the request
-// assert.ok(endDate.valueOf() - startDate.valueOf() > maxRetryAttemptCount * retryAfterInMilliseconds);
-
-// request._createRequestObjectStub = originalCreateRequestObjectStub;
-// client.getDatabaseAccount = originalGetDatabaseAccount;
-// done();
-// });
-// });
-// });
-// });
diff --git a/src/test/legacy/uriFactoryTests.js b/src/test/legacy/uriFactoryTests.js
deleted file mode 100644
index 489ff4f..0000000
--- a/src/test/legacy/uriFactoryTests.js
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-"use strict";
-
-var lib = require("../..//"),
- assert = require("assert"),
- testConfig = require("./_testConfig"),
- UriFactory = require("../..//").UriFactory, // TODO: Shouldn't be using direct path
- DocumentDBClient = lib.DocumentClient;
-
-var host = testConfig.host;
-var masterKey = testConfig.masterKey;
-
-
-describe("URI Factory Tests", function () {
-
- var executeExceptionThrowingFunction = function (func) {
- var isThrown = false;
- try {
- func();
- }
- catch (err) {
- isThrown = true;
- }
- assert(isThrown, "function did not throw an exception");
- }
-
- describe("Create Database URI", function () {
- var createDatabaseUriTest = function (dbId, expectedUri) {
- assert.equal(UriFactory.createDatabaseUri(dbId), expectedUri, "error invalid database URI");
- }
-
- it("Normal database Id", function () {
- createDatabaseUriTest("database1", "dbs/database1");
- });
-
- it("Empty database Id", function () {
- executeExceptionThrowingFunction(function () {
- createDatabaseUriTest("", "exception")
- });
- });
-
- it("Database Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createDatabaseUriTest("db?1", "exception");
- });
- });
- });
-
- describe("Create Collection URI", function () {
- var createCollectionUriTest = function (dbId, collId, expectedUri) {
- assert.equal(UriFactory.createDocumentCollectionUri(dbId, collId), expectedUri);
- }
-
- it("Normal database & collection IDs", function () {
- createCollectionUriTest("db1", "col1", "dbs/db1/colls/col1");
- });
-
- it("Empty collection Id", function () {
- executeExceptionThrowingFunction(function () {
- createCollectionUriTest("db1", "", "must throw exception");
- });
- });
-
- it("Collection Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createCollectionUriTest("db1", "coll?", "exception");
- });
- });
- });
-
- describe("Create User URI", function () {
- var createUserUriTest = function (dbId, userId, expectedUri) {
- assert.equal(UriFactory.createUserUri(dbId, userId), expectedUri);
- };
-
- it("Noramal Database Id & User Id", function () {
- createUserUriTest("db1", "user1", "dbs/db1/users/user1");
- });
-
- it("Empty user Id", function () {
- executeExceptionThrowingFunction(function () {
- createUserUriTest("db1", null, "exception");
- });
- });
-
- it("User Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createUserUriTest("db1", "user\\1", "exception");
- });
- });
-
- });
-
- describe("Create Document URI", function () {
- var createDocumentUriTest = function (dbId, collId, docId, expectedUri) {
- assert.equal(UriFactory.createDocumentUri(dbId, collId, docId), expectedUri);
- }
-
- it("Normal database Id, collection Id and, document Id", function () {
- createDocumentUriTest("db1", "coll1", "doc1", "dbs/db1/colls/coll1/docs/doc1");
- });
-
- it("Empty document Id", function () {
- executeExceptionThrowingFunction(function () {
- createDocumentUriTest("db1", "coll1", undefined, "exception");
- });
- });
-
- it("Document Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createDocumentUriTest("db1", "coll1", "?doc1", "exception");
- });
- });
- });
-
- describe("Create Permission URI", function () {
- var createPermissionUriTest = function (dbId, userId, permId, expectedUri) {
- assert.equal(UriFactory.createPermissionUri(dbId, userId, permId), expectedUri);
- }
-
- it("Normal database Id, user Id and, permission Id", function () {
- createPermissionUriTest("db1", "user1", "perm1", "dbs/db1/users/user1/permissions/perm1");
- });
-
- it("Empty permission Id", function () {
- executeExceptionThrowingFunction(function () {
- createPermissionUriTest("db1", "user1", " ", "exception");
- });
- });
-
- it("Permission Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createPermissionUriTest("db1", "user1", "perm/1", "exception");
- });
- });
- });
-
- describe("Create StoredProcedure URI", function () {
- var createStoredProcedureUriTest = function (dbId, collId, sprocId, expectedUri) {
- assert.equal(UriFactory.createStoredProcedureUri(dbId, collId, sprocId), expectedUri);
- }
-
- it("Normal database Id, collection Id and, storedProcedure Id", function () {
- createStoredProcedureUriTest("db1", "col1", "sproc1", "dbs/db1/colls/col1/sprocs/sproc1");
- });
-
- it("Empty storedProcedure Id", function () {
- executeExceptionThrowingFunction(function () {
- createStoredProcedureUriTest("db1", "col1", "", "exception");
- });
- });
-
- it("StoredProcedure Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createStoredProcedureUriTest("db1", "col1", "\sproc 1", "exception");
- });
- });
- });
-
- describe("Create Trigger URI", function () {
- var createTriggerUriTest = function (dbId, collId, trgId, expectedUri) {
- assert.equal(UriFactory.createTriggerUri(dbId, collId, trgId), expectedUri);
- }
-
- it("Normal database Id, collection Id and, trigger Id", function () {
- createTriggerUriTest("db1", "col1", "trig1", "dbs/db1/colls/col1/triggers/trig1");
- });
-
- it("Empty trigger Id", function () {
- executeExceptionThrowingFunction(function () {
- createTriggerUriTest("db1", "col1", null, "exception");
- });
- });
-
- it("trigger Id with illegals chars", function () {
- executeExceptionThrowingFunction(function () {
- createTriggerUriTest("db1", "col1", "tr?iger", "exception");
- });
- });
- });
-
- describe("Create User-Defined-Function URI", function () {
- var createUserDefinedFunctionUriTest = function (dbId, collId, udfId, expectedUri) {
- assert.equal(UriFactory.createUserDefinedFunctionUri(dbId, collId, udfId), expectedUri);
- }
-
- it("Normal database Id, collection Id and, UDF Id", function () {
- createUserDefinedFunctionUriTest("db1", "col1", "udf1", "dbs/db1/colls/col1/udfs/udf1");
- });
-
- it("Empty UDF Id", function () {
- executeExceptionThrowingFunction(function () {
- createUserDefinedFunctionUriTest("db1", "col1", undefined, "exception");
- });
- });
-
- it("UDF Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createUserDefinedFunctionUriTest("db1", "col1", "u/df1/", "exception");
- });
- });
- });
-
- describe("Create Conflict URI", function () {
- var createConflictUriTest = function (dbId, collId, confId, expectedUri) {
- assert.equal(UriFactory.createConflictUri(dbId, collId, confId), expectedUri);
- }
-
- it("Normal database Id, collection Id and, conflict Id", function () {
- createConflictUriTest("db1", "col1", "conf1", "dbs/db1/colls/col1/conflicts/conf1");
- });
-
- it("Empty conflict Id", function () {
- executeExceptionThrowingFunction(function () {
- createConflictUriTest("db1", "col1", " ", "exception");
- });
- });
-
- it("Conflict Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createConflictUriTest("db1", "col1", "\\conf\\1", "exception");
- });
- });
- });
-
- describe("Create Attachment URI", function () {
- var createAttachmentUriTest = function (dbId, collId, docId, atchId, expectedUri) {
- assert.equal(UriFactory.createAttachmentUri(dbId, collId, docId, atchId), expectedUri);
- }
-
- it("Normal database Id, collection Id and, document Id, attachmentId", function () {
- createAttachmentUriTest("db1", "coll1", "doc1", "atch1", "dbs/db1/colls/coll1/docs/doc1/attachments/atch1");
- });
-
- it("Empty attachment Id", function () {
- executeExceptionThrowingFunction(function () {
- createAttachmentUriTest("db1", "coll1", "doc1", null, "exception");
- });
- });
-
- it("Attachment Id with illegal chars", function () {
- executeExceptionThrowingFunction(function () {
- createAttachmentUriTest("db1", "coll1", "d ?oc1", "atch?#1", "exception");
- });
- });
- });
-
- describe("Create PartitionKeyRanges URI", function () {
- var createPartitionKeyRangesUriTest = function (dbId, collId, expectedUir) {
- assert.equal(UriFactory.createPartitionKeyRangesUri(dbId, collId), expectedUir);
- }
-
- it("Normal database & collection IDs", function () {
- createPartitionKeyRangesUriTest("db1", "col1", "dbs/db1/colls/col1/pkranges");
- });
- });
-
- describe("Use uriFactory in integration with other methods", function () {
- var testDatabaseId = "uriFactoryTestDb";
-
- var client = new DocumentDBClient(host, { masterKey: masterKey });
-
- var deleteDatabases = function (done) {
- client.readDatabases().toArray(function (err, databases) {
- if (err) {
- console.log("error occured reading databases", err);
- return done();
- }
-
- var index = databases.length;
- if (index === 0) {
- return done();
- }
-
- databases.forEach(function (database) {
- index--;
- if (database.id === testDatabaseId) {
- client.deleteDatabase(database._self, function (err, db) {
- if (err) {
- console.log("error occured deleting databases", err);
- return done();
- }
- });
- }
- if (index === 0) {
- return done();
- }
- });
- });
- }
-
- var createDocumentUsingUriFactory = function (databaseId, collectionId, documentId, done) {
- client.createDatabase({ id: databaseId }, function (err, database) {
- assert.equal(err, undefined, "error creating database");
- assert.equal(database.id, databaseId, "invalid database Id");
-
- var databaseUri = UriFactory.createDatabaseUri(databaseId);
- var collectionBody = {
- id: collectionId,
- indexingPolicy: { indexingMode: "Lazy" } //Modes : Lazy, Consistent
- };
- client.createCollection(databaseUri, collectionBody, function (err, collection) {
- assert.equal(err, undefined, "error creating collection" + err);
- assert.equal(collection.id, collectionBody.id, "invalid collection Id");
-
- var collectionUri = UriFactory.createDocumentCollectionUri(databaseId, collectionId);
- var documentBody = {
- id: documentId,
- context: "something to consume space"
- };
- client.createDocument(collectionUri, documentBody, function (err, document) {
- assert.equal(err, undefined, "error creating document");
- assert.equal(document.id, documentId, "invalid document Id");
- done();
- });
- });
- });
- }
-
- afterEach(function (done) { deleteDatabases(done) });
- beforeEach(function (done) { deleteDatabases(done) });
-
- it("check uriFactory generates valid URIs when resource Ids contain unicode", function (done) {
- createDocumentUsingUriFactory(testDatabaseId, "डेटाबेस پایگاه داده 数据库", "doc1", done);
- });
- });
-});
-
diff --git a/src/test/integration/sessionContainer.spec.ts b/src/test/unit/sessionContainer.spec.ts
similarity index 99%
rename from src/test/integration/sessionContainer.spec.ts
rename to src/test/unit/sessionContainer.spec.ts
index a60d1c7..18629b7 100644
--- a/src/test/integration/sessionContainer.spec.ts
+++ b/src/test/unit/sessionContainer.spec.ts
@@ -1,6 +1,4 @@
import * as assert from "assert";
-import * as sinon from "sinon";
-import { Base } from "../../";
import { ResourceId } from "../../common";
import { SessionContainer } from "../../sessionContainer";
import testConfig from "./../common/_testConfig";
diff --git a/src/test/unit/smartRoutingMapProvider.spec.ts b/src/test/unit/smartRoutingMapProvider.spec.ts
index 7e68728..222b344 100644
--- a/src/test/unit/smartRoutingMapProvider.spec.ts
+++ b/src/test/unit/smartRoutingMapProvider.spec.ts
@@ -1,7 +1,6 @@
import * as assert from "assert";
-import { Base } from "../../";
import {
- CollectionRoutingMapFactory, PartitionKeyRangeCache,
+ PartitionKeyRangeCache,
QueryRange,
SmartRoutingMapProvider,
} from "../../routing";
@@ -9,8 +8,8 @@ import { MockedDocumentClient } from "./../common/MockDocumentClient";
describe("Smart Routing Map Provider OverlappingRanges", function () {
- const collectionLink = "dbs/7JZZAA==/colls/7JZZAOS-JQA=/";
- const collectionId = "my collection";
+ const containerLink = "dbs/7JZZAA==/colls/7JZZAOS-JQA=/";
+ const containerId = "my container";
const partitionKeyRanges = [
{ id: "0", minInclusive: "", maxExclusive: "05C1C9CD673398" },
@@ -19,7 +18,7 @@ describe("Smart Routing Map Provider OverlappingRanges", function () {
{ id: "3", minInclusive: "05C1E399CD6732", maxExclusive: "05C1E9CD673398" },
{ id: "4", minInclusive: "05C1E9CD673398", maxExclusive: "FF" }];
- const mockedDocumentClient = new MockedDocumentClient(partitionKeyRanges, collectionId);
+ const mockedDocumentClient = new MockedDocumentClient(partitionKeyRanges, containerId);
const smartRoutingMapProvider = new SmartRoutingMapProvider(mockedDocumentClient);
const partitionKeyRangeCache = new PartitionKeyRangeCache(mockedDocumentClient);
@@ -28,13 +27,13 @@ describe("Smart Routing Map Provider OverlappingRanges", function () {
it('query ranges: ["", ""FF)', function () {
// query range is the whole partition key range
const pkRange = new QueryRange("", "FF", true, false);
- validateOverlappingRanges([pkRange], partitionKeyRanges);
+ return validateOverlappingRanges([pkRange], partitionKeyRanges);
});
it('query ranges: ("", ""FF)', function () {
// query range is the whole partition key range
const pkRange = new QueryRange("", "FF", false, false);
- validateOverlappingRanges([pkRange], partitionKeyRanges);
+ return validateOverlappingRanges([pkRange], partitionKeyRanges);
});
});
@@ -212,12 +211,12 @@ describe("Smart Routing Map Provider OverlappingRanges", function () {
results1 = results2 = null;
err1 = err2 = null;
try {
- results1 = await smartRoutingMapProvider.getOverlappingRanges(collectionLink, queryRanges);
+ results1 = await smartRoutingMapProvider.getOverlappingRanges(containerLink, queryRanges);
} catch (err) {
err1 = err;
}
try {
- results2 = await partitionKeyRangeCache.getOverlappingRanges(collectionLink, queryRanges);
+ results2 = await partitionKeyRangeCache.getOverlappingRanges(containerLink, queryRanges);
} catch (err) {
err2 = err;
}
@@ -257,12 +256,12 @@ describe("Smart Routing Map Provider OverlappingRanges", function () {
provider: SmartRoutingMapProvider, queryRanges1: any, queryRanges2: any) {
let results1: any; let results2: any; let err1: any; let err2: any;
try {
- results1 = await provider.getOverlappingRanges(collectionLink, queryRanges1);
+ results1 = await provider.getOverlappingRanges(containerLink, queryRanges1);
} catch (err) {
err1 = err;
}
try {
- results2 = await provider.getOverlappingRanges(collectionLink, queryRanges2);
+ results2 = await provider.getOverlappingRanges(containerLink, queryRanges2);
} catch (err) {
err2 = err;
}
@@ -278,7 +277,7 @@ describe("Smart Routing Map Provider OverlappingRanges", function () {
expectedResults: any, errorExpected?: any) {
errorExpected = errorExpected || false;
try {
- const results = await provider.getOverlappingRanges(collectionLink, queryRanges);
+ const results = await provider.getOverlappingRanges(containerLink, queryRanges);
assert.deepEqual(results, expectedResults);
} catch (err) {
if (errorExpected) {
diff --git a/tsconfig.json b/tsconfig.json
index 3b9d766..47c95bb 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -10,6 +10,10 @@
"target": "es6",
"sourceMap": true,
"newLine": "LF",
+ "lib": [
+ "es6",
+ "esnext.asynciterable"
+ ]
},
"include": [
"./src/**/*",
diff --git a/tslint.json b/tslint.json
index ca0141f..f81d384 100644
--- a/tslint.json
+++ b/tslint.json
@@ -1,10 +1,11 @@
{
- "extends": "tslint:latest",
+ "extends": "tslint:recommended",
"exclude": "./node_modules",
"rules": {
"interface-name": false,
"no-string-literal": false,
"object-literal-sort-keys": false,
- "member-ordering": false // TODO: might want to look at this eventually...
+ "member-ordering": false, // TODO: might want to look at this eventually...
+ "no-floating-promises": true
}
}
\ No newline at end of file