implement requested changes to new test

Author: stephenarosaj

packages/data-connect/test/unit/QueryManager.test.ts

@@ -15,80 +15,52 @@
  * limitations under the License.
  */
 
-import { initializeApp } from '@firebase/app';
-import { FirebaseAuthTokenData } from '@firebase/auth-interop-types';
+import { deleteApp, FirebaseApp, initializeApp } from '@firebase/app';
 import { expect } from 'chai';
 import * as chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 
 import {
+  DataConnect,
   DataConnectOptions,
+  executeQuery,
   getDataConnect,
-  MUTATION_STR,
-  QUERY_STR,
-  QueryRef
+  mutationRef,
+  queryRef,
 } from '../../src';
 import { Code, DataConnectError } from '../../src/core/error';
-import {
-  AuthTokenListener,
-  AuthTokenProvider
-} from '../../src/core/FirebaseAuthProvider';
-import { QueryManager } from '../../src/core/QueryManager';
-import { RESTTransport } from '../../src/network/transport/rest';
 chai.use(chaiAsPromised);
 const options: DataConnectOptions = {
   connector: 'c',
   location: 'l',
   projectId: 'p',
   service: 's'
 };
-const INITIAL_TOKEN = 'initial token';
-class FakeAuthProvider implements AuthTokenProvider {
-  private token: string | null = INITIAL_TOKEN;
-  addTokenChangeListener(listener: AuthTokenListener): void {}
-  getToken(forceRefresh: boolean): Promise<FirebaseAuthTokenData | null> {
-    if (!forceRefresh) {
-      return Promise.resolve({ accessToken: this.token! });
-    }
-    return Promise.resolve({ accessToken: 'testToken' });
-  }
-  setToken(_token: string | null): void {
-    this.token = _token;
-  }
-}
 
 describe('Query Manager Tests', () => {
-  it('should refuse to make requests to execute non-query operations', async () => {
-    const authProvider = new FakeAuthProvider();
-    const rt = new RESTTransport(options, undefined, undefined, authProvider);
-    const qm = new QueryManager(rt);
-    const app = initializeApp({ projectId: 'p' });
-    const dc = getDataConnect(app, {
-      connector: 'c',
-      location: 'l',
-      service: 's'
-    });
+  let dc: DataConnect;
+  let app: FirebaseApp;
 
-    const mutationRef: QueryRef<string, string> = {
-      name: 'm',
-      variables: 'v',
-      dataConnect: dc,
-      refType: MUTATION_STR as 'query'
-    };
+  beforeEach(() => {
+    app = initializeApp({ projectId: 'p' });
+    dc = getDataConnect(app, options);
+  });
+  afterEach(async () => {
+    await dc._delete();
+    await deleteApp(app);
+  });
 
-    const queryRef: QueryRef<string, string> = {
-      name: 'm',
-      variables: 'v',
-      dataConnect: dc,
-      refType: QUERY_STR
-    };
+  it('should refuse to make requests to execute non-query operations', async () => {
+    const query = queryRef<string>(dc, 'q');
+    const mutation = mutationRef<string>(dc, 'm');
 
     const error = new DataConnectError(
       Code.INVALID_ARGUMENT,
       `ExecuteQuery can only execute query operation`
     );
 
-    expect(() => qm.executeQuery(mutationRef)).to.throw(error.message);
-    expect(() => qm.executeQuery(queryRef)).to.not.throw(error.message);
+    // @ts-ignore
+    expect(() => executeQuery(mutation)).to.throw(error.message);
+    expect(() => executeQuery(query)).to.not.throw(error.message);
   });
 });