Set up tests, add comments

Author: hsubox76

packages/storage/compat/task.ts

@@ -26,7 +26,7 @@ import {
   Subscribe,
   Unsubscribe
 } from '../src/implementation/observer';
-import { UploadTaskSnapshot } from '../src/tasksnapshot';
+import { UploadTaskResumableSnapshot } from '../src/tasksnapshot';
 import { ReferenceCompat } from './reference';
 import { FirebaseStorageError } from '../src/implementation/error';
 
@@ -75,19 +75,19 @@ export class UploadTaskCompat implements types.UploadTask {
     completed?: CompleteFn | null
   ): Unsubscribe | Subscribe<UploadTaskSnapshotCompat> {
     let wrappedNextOrObserver:
-      | StorageObserver<UploadTaskSnapshot>
+      | StorageObserver<UploadTaskResumableSnapshot>
       | undefined
-      | ((a: UploadTaskSnapshot) => unknown) = undefined;
+      | ((a: UploadTaskResumableSnapshot) => unknown) = undefined;
     if (!!nextOrObserver) {
       if (typeof nextOrObserver === 'function') {
-        wrappedNextOrObserver = (taskSnapshot: UploadTaskSnapshot) =>
+        wrappedNextOrObserver = (taskSnapshot: UploadTaskResumableSnapshot) =>
           nextOrObserver(
             new UploadTaskSnapshotCompat(taskSnapshot, this, this._ref)
           );
       } else {
         wrappedNextOrObserver = {
           next: !!nextOrObserver.next
-            ? (taskSnapshot: UploadTaskSnapshot) =>
+            ? (taskSnapshot: UploadTaskResumableSnapshot) =>
                 nextOrObserver.next!(
                   new UploadTaskSnapshotCompat(taskSnapshot, this, this._ref)
                 )

packages/storage/compat/tasksnapshot.ts

@@ -18,12 +18,12 @@
 import * as types from '@firebase/storage-types';
 import { ReferenceCompat } from './reference';
 import { UploadTaskCompat } from './task';
-import { UploadTaskSnapshot } from '../src/tasksnapshot';
+import { UploadTaskResumableSnapshot } from '../src/tasksnapshot';
 import { Metadata } from '../src/metadata';
 
 export class UploadTaskSnapshotCompat implements types.UploadTaskSnapshot {
   constructor(
-    readonly _delegate: UploadTaskSnapshot,
+    readonly _delegate: UploadTaskResumableSnapshot,
     readonly task: UploadTaskCompat,
     readonly ref: ReferenceCompat
   ) {}

packages/storage/karma.conf.js

@@ -31,12 +31,28 @@ module.exports = function (config) {
 };
 
 function getTestFiles(argv) {
+  let unitTestFiles = [];
+  let integrationTestFiles = [];
+  if (argv.exp) {
+    unitTestFiles = ['test/unit/*'].filter(
+      filename => !filename.includes('.compat.')
+    );
+    integrationTestFiles = ['test/integration/*exp*'];
+  } else if (argv.compat) {
+    unitTestFiles = ['test/unit/*'].filter(
+      filename => !filename.includes('.exp.')
+    );
+    integrationTestFiles = ['test/integration/*compat*'];
+  } else {
+    console.log('Specify "exp" or "compat" option for karma command.');
+    return;
+  }
   if (argv.unit) {
-    return ['test/unit/*'];
+    return unitTestFiles;
   } else if (argv.integration) {
-    return ['test/integration/*'];
+    return integrationTestFiles;
   } else {
-    return ['test/**/*'];
+    return [...unitTestFiles, ...integrationTestFiles];
   }
 }
 

packages/storage/package.json

@@ -17,11 +17,15 @@
     "build:exp": "rollup -c rollup.config.exp.js",
     "build:deps": "lerna run --scope @firebase/storage --include-dependencies build",
     "dev": "rollup -c -w",
-    "test": "run-p test:browser lint",
-    "test:ci": "node ../../scripts/run_tests_in_ci.js -s test:browser",
-    "test:browser:unit": "karma start --single-run --unit",
-    "test:browser:integration": "karma start --single-run --integration",
-    "test:browser": "karma start --single-run",
+    "test": "run-p test:browser:compat lint",
+    "test:exp": "run-p test:browser:exp lint",
+    "test:ci": "node ../../scripts/run_tests_in_ci.js -s test:browser:compat",
+    "test:browser:compat:unit": "karma start --single-run --unit",
+    "test:browser:exp:unit": "karma start --single-run --exp --unit",
+    "test:browser:compat:integration": "karma start --single-run --integration",
+    "test:browser:exp:integration": "karma start --single-run --exp --integration",
+    "test:browser:compat": "karma start --single-run --compat",
+    "test:browser:exp": "karma start --single-run --exp",
     "prepare": "yarn build",
     "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
     "api-report": "api-extractor run --local --verbose"

packages/storage/src/implementation/metadata.ts

@@ -187,7 +187,7 @@ export function downloadUrlFromResourceString(
 }
 
 export function toResourceString(
-  metadata: Metadata,
+  metadata: { [key: string]: unknown },
   mappings: Mappings
 ): string {
   const resource: {

packages/storage/src/implementation/requests.ts

@@ -217,7 +217,7 @@ export function getDownloadUrl(
 export function updateMetadata(
   service: StorageService,
   location: Location,
-  metadata: Metadata,
+  metadata: { [key: string]: unknown },
   mappings: MetadataUtils.Mappings
 ): RequestInfo<Metadata> {
   const urlPart = location.fullServerUrl();
@@ -279,6 +279,9 @@ export function metadataForUpload_(
   return metadataClone;
 }
 
+/**
+ * Prepare RequestInfo for non-resumable uploads as Content-Type: octet-stream.
+ */
 export function simpleUpload(
   service: StorageService,
   location: Location,
@@ -308,7 +311,9 @@ export function simpleUpload(
   requestInfo.errorHandler = sharedErrorHandler(location);
   return requestInfo;
 }
-
+/**
+ * Prepare RequestInfo for resumable uploads as Content-Type: multipart.
+ */
 export function multipartUpload(
   service: StorageService,
   location: Location,

packages/storage/src/reference.ts

@@ -37,7 +37,7 @@ import { ListOptions, ListResult } from './list';
 import { UploadTask } from './task';
 import { invalidRootOperation, noDownloadURL } from './implementation/error';
 import { validateNumber } from './implementation/type';
-import { UploadTaskNonResumableSnapshot } from './tasksnapshot';
+import { UploadTaskSnapshot } from './tasksnapshot';
 import * as fbsRequests from './implementation/requests';
 
 /**
@@ -126,14 +126,13 @@ export class Reference {
  * @param ref - Storage Reference where data should be uploaded.
  * @param data - The data to upload.
  * @param metadata - Metadata for the newly uploaded string.
- * @returns An UploadTask that lets you control and
- *     observe the upload.
+ * @returns An UploadTaskNonResumableSnapshot
  */
 export async function uploadBytes(
   ref: Reference,
   data: Blob | Uint8Array | ArrayBuffer,
   metadata: Metadata | null = null
-): Promise<UploadTaskNonResumableSnapshot> {
+): Promise<UploadTaskSnapshot> {
   ref._throwIfRoot('uploadBytes');
   const authToken = await ref.storage.getAuthToken();
   const requestInfo = fbsRequests.simpleUpload(
@@ -143,9 +142,9 @@ export async function uploadBytes(
     new FbsBlob(data),
     metadata
   );
-  const multipartRequest = ref.storage.makeRequest(requestInfo, authToken);
-  const finalMetadata = metadata || (await multipartRequest.getPromise());
-  return new UploadTaskNonResumableSnapshot(finalMetadata, ref);
+  const request = ref.storage.makeRequest(requestInfo, authToken);
+  const finalMetadata = metadata || (await request.getPromise());
+  return new UploadTaskSnapshot(finalMetadata, ref);
 }
 
 /**
@@ -183,7 +182,7 @@ export function uploadString(
   format: StringFormat = StringFormat.RAW,
   metadata?: Metadata
 ): UploadTask {
-  ref._throwIfRoot('putString');
+  ref._throwIfRoot('uploadString');
   const data = dataFromString(format, value);
   const metadataClone = { ...metadata } as Metadata;
   if (metadataClone['contentType'] == null && data.contentType != null) {
@@ -322,7 +321,7 @@ export async function getMetadata(ref: Reference): Promise<Metadata> {
  */
 export async function updateMetadata(
   ref: Reference,
-  metadata: Metadata
+  metadata: { [key: string]: unknown }
 ): Promise<Metadata> {
   ref._throwIfRoot('updateMetadata');
   const authToken = await ref.storage.getAuthToken();

packages/storage/src/task.ts

@@ -36,7 +36,7 @@ import {
   Unsubscribe
 } from './implementation/observer';
 import { Request } from './implementation/request';
-import { UploadTaskSnapshot } from './tasksnapshot';
+import { UploadTaskResumableSnapshot } from './tasksnapshot';
 import { async as fbsAsync } from './implementation/async';
 import * as fbsMetadata from './implementation/metadata';
 import * as fbsRequests from './implementation/requests';
@@ -64,7 +64,7 @@ export class UploadTask {
   _transferred: number = 0;
   private _needToFetchStatus: boolean = false;
   private _needToFetchMetadata: boolean = false;
-  private _observers: Array<StorageObserver<UploadTaskSnapshot>> = [];
+  private _observers: Array<StorageObserver<UploadTaskResumableSnapshot>> = [];
   private _resumable: boolean;
   /**
    * @internal
@@ -76,9 +76,9 @@ export class UploadTask {
   private _chunkMultiplier: number = 1;
   private _errorHandler: (p1: FirebaseStorageError) => void;
   private _metadataErrorHandler: (p1: FirebaseStorageError) => void;
-  private _resolve?: (p1: UploadTaskSnapshot) => void = undefined;
+  private _resolve?: (p1: UploadTaskResumableSnapshot) => void = undefined;
   private _reject?: (p1: FirebaseStorageError) => void = undefined;
-  private _promise: Promise<UploadTaskSnapshot>;
+  private _promise: Promise<UploadTaskResumableSnapshot>;
 
   /**
    * @param ref - The firebaseStorage.Reference object this task came
@@ -429,9 +429,9 @@ export class UploadTask {
     }
   }
 
-  get snapshot(): UploadTaskSnapshot {
+  get snapshot(): UploadTaskResumableSnapshot {
     const externalState = taskStateFromInternalTaskState(this._state);
-    return new UploadTaskSnapshot(
+    return new UploadTaskResumableSnapshot(
       this._transferred,
       this._blob.size(),
       externalState,
@@ -448,11 +448,11 @@ export class UploadTask {
   on(
     type: TaskEvent,
     nextOrObserver?:
-      | StorageObserver<UploadTaskSnapshot>
-      | ((a: UploadTaskSnapshot) => unknown),
+      | StorageObserver<UploadTaskResumableSnapshot>
+      | ((a: UploadTaskResumableSnapshot) => unknown),
     error?: ErrorFn,
     completed?: CompleteFn
-  ): Unsubscribe | Subscribe<UploadTaskSnapshot> {
+  ): Unsubscribe | Subscribe<UploadTaskResumableSnapshot> {
     const observer = new Observer(nextOrObserver, error, completed);
     this._addObserver(observer);
     return () => {
@@ -467,13 +467,15 @@ export class UploadTask {
    * @param onRejected - The rejection callback.
    */
   then<U>(
-    onFulfilled?: ((value: UploadTaskSnapshot) => U | Promise<U>) | null,
+    onFulfilled?:
+      | ((value: UploadTaskResumableSnapshot) => U | Promise<U>)
+      | null,
     onRejected?: ((error: FirebaseStorageError) => U | Promise<U>) | null
   ): Promise<U> {
     // These casts are needed so that TypeScript can infer the types of the
     // resulting Promise.
     return this._promise.then<U>(
-      onFulfilled as (value: UploadTaskSnapshot) => U | Promise<U>,
+      onFulfilled as (value: UploadTaskResumableSnapshot) => U | Promise<U>,
       onRejected as ((error: unknown) => Promise<never>) | null
     );
   }
@@ -490,15 +492,17 @@ export class UploadTask {
   /**
    * Adds the given observer.
    */
-  private _addObserver(observer: Observer<UploadTaskSnapshot>): void {
+  private _addObserver(observer: Observer<UploadTaskResumableSnapshot>): void {
     this._observers.push(observer);
     this._notifyObserver(observer);
   }
 
   /**
    * Removes the given observer.
    */
-  private _removeObserver(observer: Observer<UploadTaskSnapshot>): void {
+  private _removeObserver(
+    observer: Observer<UploadTaskResumableSnapshot>
+  ): void {
     const i = this._observers.indexOf(observer);
     if (i !== -1) {
       this._observers.splice(i, 1);
@@ -536,7 +540,9 @@ export class UploadTask {
     }
   }
 
-  private _notifyObserver(observer: Observer<UploadTaskSnapshot>): void {
+  private _notifyObserver(
+    observer: Observer<UploadTaskResumableSnapshot>
+  ): void {
     const externalState = taskStateFromInternalTaskState(this._state);
     switch (externalState) {
       case TaskState.RUNNING:

packages/storage/src/tasksnapshot.ts

@@ -19,7 +19,7 @@ import { Metadata } from './metadata';
 import { Reference } from './reference';
 import { UploadTask } from './task';
 
-export class UploadTaskSnapshot {
+export class UploadTaskResumableSnapshot {
   constructor(
     readonly bytesTransferred: number,
     readonly totalBytes: number,
@@ -29,6 +29,6 @@ export class UploadTaskSnapshot {
     readonly ref: Reference
   ) {}
 }
-export class UploadTaskNonResumableSnapshot {
+export class UploadTaskSnapshot {
   constructor(readonly metadata: Metadata, readonly ref: Reference) {}
 }