sleuthing test failures

shells/tests/arcs/ts/runtime/plan-consumer-test.ts

@@ -32,7 +32,7 @@ async function storeResults(consumer: PlanConsumer, suggestions: Suggestion[]) {
   await new Promise(resolve => setTimeout(resolve, 100));
 }
 
-describe('planFOOB consumer', () => {
+describe('plan consumer', () => {
   it('consumes', async () => {
     const manifestText = `
       import './shells/tests/artifacts/Products/Products.recipes'

src/runtime/storage/drivers/driver-factory.ts

@@ -21,14 +21,15 @@ export interface StorageDriverProvider {
 let staticDriverFactory;
 
 export class DriverFactory {
-  static register({driverFactory}, storageDriverProvider: StorageDriverProvider) {
-    driverFactory.register(storageDriverProvider);
-  }
+  //name;
   providers: Set<StorageDriverProvider> = new Set();
   constructor() {
     staticDriverFactory = this;
+    //this.name = Math.floor(Math.random()*90) + 10;
+    //console.warn('DriverFactory constructed: ', this.name);
   }
   register(storageDriverProvider: StorageDriverProvider) {
+    //console.warn(`DriverFactory(${this.name}).register`); //, storageDriverProvider);
     this.providers.add(storageDriverProvider);
   }
   unregister(storageDriverProvider: StorageDriverProvider) {
@@ -49,6 +50,10 @@ export class DriverFactory {
     }
     return null;
   }
+  // statics
+  static register({driverFactory}, storageDriverProvider: StorageDriverProvider) {
+    driverFactory.register(storageDriverProvider);
+  }
   static async driverInstance<Data>(storageKey: StorageKey, exists: Exists) {
     return staticDriverFactory.driverInstance(storageKey, exists);
   }

src/runtime/storage/drivers/firebase.ts

@@ -206,7 +206,6 @@ export class FirebaseDriver<Data> extends Driver<Data> {
   }
 }
 
-
 export class FirebaseStorageDriverProvider implements StorageDriverProvider {
   protected readonly cacheService: RuntimeCacheService;
 

src/runtime/storage/testing/mock-firebase.ts

@@ -353,8 +353,8 @@ export class MockFirebaseStorageDriverProvider extends FirebaseStorageDriverProv
     //DriverFactory.register(new MockFirebaseStorageDriverProvider(cacheService));
     //StorageKeyParser.addParser(FirebaseStorageKey.protocol, FirebaseStorageKey.fromString);
     //const {projectId, domain, apiKey} = mockFirebaseStorageKeyOptions;
-    driverFactory.register(new FirebaseStorageDriverProvider(cacheService));
-    storageKeyParser.addParser(FirebaseStorageKey.protocol, FirebaseStorageKey.fromString);
+    driverFactory.register(new MockFirebaseStorageDriverProvider(cacheService));
+    storageKeyParser.addParser(MockFirebaseStorageKey.protocol, MockFirebaseStorageKey.fromString);
   }
 
   static getValueForTesting(cacheService: RuntimeCacheService, storageKey: MockFirebaseStorageKey) {

src/runtime/storage/tests/firebase-store-integration-test.ts

@@ -27,15 +27,14 @@ async function createStore(storageKey: StorageKey, exists: Exists): Promise<Acti
   return store as ActiveStore<CRDTCountTypeRecord>;
 }
 
-describe('Firebase + Store Integration', async () => {
+describe('Firebase + Store Integration', async function() {
   let runtime;
   beforeEach(() => {
     runtime = new Runtime();
     MockFirebaseStorageDriverProvider.register(runtime, runtime.getCacheService());
   });
 
-  it('FLOOB will store a sequence of model and operation updates as models', async () => {
-    debugger;
+  it('will store a sequence of model and operation updates as models', async () => {
     const storageKey = new MockFirebaseStorageKey('location');
     const activeStore = await createStore(storageKey, Exists.ShouldCreate);
 

src/runtime/storage/tests/reference-mode-store-integration-test.ts

@@ -25,22 +25,21 @@ describe('ReferenceModeStore Integration', async () => {
 
   it('will store and retrieve entities through referenceModeStores (separate stores)', async () => {
     const storageKey = new ReferenceModeStorageKey(new RamDiskStorageKey('backing'), new RamDiskStorageKey('container'));
-
     const type = new EntityType(new Schema(['AnEntity'], {foo: 'Text'})).collectionOf();
 
     // Use newHandle here rather than setting up a store inside the arc, as this ensures writeHandle and readHandle
     // are on top of different storage stacks.
-    const writeHandle = await newHandle(new StoreInfo({storageKey, type, id: 'write-handle'}),
-        new Runtime().newArc('testWritesArc'));
-    const readHandle = await newHandle(new StoreInfo({storageKey, type, id: 'read-handle'}),
-        new Runtime().newArc('testReadArc'));
+    const writeInfo = new StoreInfo({storageKey, type, id: 'write-handle'});
+    const writeHandle = await newHandle(writeInfo, new Runtime().newArc('testWritesArc'));
+
+    const readInfo = new StoreInfo({storageKey, type, id: 'read-handle'});
+    const readHandle = await newHandle(readInfo, new Runtime().newArc('testReadArc'));
 
     readHandle.particle = new Particle();
     const returnPromise = new Promise((resolve, reject) => {
-
       let state = 0;
-
       readHandle.particle['onHandleSync'] = async (handle, model) => {
+        console.warn('onHandleSync', model);
         if (state === 0) {
           assert.deepEqual(model, []);
           state = 1;
@@ -50,9 +49,10 @@ describe('ReferenceModeStore Integration', async () => {
           resolve();
         }
       };
-
     });
 
+    console.warn('writeHandle.addFromData');
+    //debugger;
     await writeHandle.addFromData({foo: 'This is text in foo'});
     return returnPromise;
   });

src/runtime/tests/arc-test.ts

@@ -64,7 +64,7 @@ async function setup(storageKeyPrefix:  (arcId: ArcId) => StorageKey) {
 }
 
 describe('Arc new storage', () => {
-  it('preserves data when round-tripping through serialization', async () => {
+  it('FLOOB preserves data when round-tripping through serialization', async () => {
     // TODO(shans): deserialization currently uses a RamDisk store to deserialize into because we don't differentiate
     // between parsing a manifest for public consumption (e.g. with RamDisk resources in it) and parsing a serialized
     // arc (with an @activeRecipe). We'll fix this by adding a 'private' keyword to store serializations which will
@@ -130,15 +130,17 @@ describe('Arc new storage', () => {
     await arc.instantiate(recipe);
 
     const serialization = await arc.serialize();
-    console.log(serialization);
+    console.warn(serialization);
     arc.dispose();
 
     await varHandle.clear();
     await colHandle.clear();
     await refVarHandle.clear();
 
     const {context, storageManager, driverFactory} = opts;
+    debugger;
     const arc2 = await Arc.deserialize({fileName: '', serialization, loader, context, storageManager, driverFactory});
+    debugger;
     const varStore2 = arc2.findStoreById(varStore.id) as StoreInfo<SingletonEntityType>;
     const colStore2 = arc2.findStoreById(colStore.id) as StoreInfo<CollectionEntityType>;
     const refVarStore2 = arc2.findStoreById(refVarStore.id) as StoreInfo<SingletonEntityType>;

tools/sigh.ts

@@ -68,6 +68,7 @@ const buildShells = () => globalOptions.bazel ? true : buildPkg('shells');
 const steps: {[index: string]: ((args?: string[]) => boolean|Promise<boolean>)[]} = {
   peg: [peg, railroad],
   test: [peg, build, buildShells, runTestsOrHealthOnCron],
+  justTest: [runTestsOrHealthOnCron],
   testShells: [peg, build, buildShells, webpack, webpackStorage, devServerAsync, testWdioShells],
   testWdioShells: [testWdioShells],
   webpack: [peg, build, buildShells, webpack],