10817711445

Committed 11 Sep 2024 06:42PM UTC coverage: 31.85% (-0.02%) from 31.871%

Build # 10817711445

Build Type

Pull #9740

github

Committed by

darkruby501

Commit Message

new tab with hybrid embedding recommendations

Pull Request Pull Request #9740: new tab with hybrid embedding recommendations

Run Details

5070 of 41350 branches covered (12.26%)

Branch coverage included in aggregate %.

21 of 76 new or added lines in 7 files covered. (27.63%)

143 existing lines in 7 files now uncovered.

29421 of 66941 relevant lines covered (43.95%)

184.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.62

/packages/lesswrong/integrationTests/utils.ts

import { createMutator, runQuery, setOnGraphQLError } from '../server/vulcan-lib';
import Users from '../lib/collections/users/collection';
import { Posts } from '../lib/collections/posts'
import { Comments } from '../lib/collections/comments'
import { Votes } from '../lib/collections/votes'
import Tags from '../lib/collections/tags/collection'
import Revisions from '../lib/collections/revisions/collection'
import Conversations from '../lib/collections/conversations/collection';
import Messages from '../lib/collections/messages/collection';
import {ContentState, convertToRaw} from 'draft-js';
import { randomId } from '../lib/random';
import type { PartialDeep } from 'type-fest'
import { asyncForeachSequential } from '../lib/utils/asyncUtils';
import Localgroups from '../lib/collections/localgroups/collection';
import { UserRateLimits } from '../lib/collections/userRateLimits';
import { callbacksArePending } from '@/server/utils/callbackHooks';
import { isAnyQueryPending as isAnyPostgresQueryPending } from "@/server/sql/PgCollection";

// Hooks Vulcan's runGraphQL to handle errors differently. By default, Vulcan
// would dump errors to stderr; instead, we want to (a) suppress that output,
// (b) assert that particular errors are present in unit tests, and (c) if no
// error was asserted to be present, assert that there were no errors.
//
// This should be called in unit tests from inside describe() but outside of
// it(). For example:
//
//   describe('Thing that uses GraphQL', () => {
//     let graphQLErrorCatcher = catchGraphQLErrors();
//
//     it('produces a permission-denied error', async () => {
//       // Do a thing that produces an error
//
//       graphQLErrorCatcher.getErrors().should.equal(["app.mutation_not_allowed"]);
//     })
//
//     it('does not produce errors', async () => {
//       // Do a thing that should not produce errors
//       // Because this test does not interact with graphQLErrorCatcher, when
//       // it returns, it will implicitly assert that there were no errors.
//     })
//   });
export const catchGraphQLErrors = function(before?: any, after?: any) {
  class ErrorCatcher {
    errors: Array<any>
    errorsRetrieved: boolean

    constructor() {
      this.errors = [];
      this.errorsRetrieved = false;
    }

    getErrors() {
      this.errorsRetrieved = true;
      return this.errors;
    }
    cleanup() {
      if (!this.errorsRetrieved && this.errors.length>0) {
        //eslint-disable-next-line no-console
        console.error("Unexpected GraphQL errors in test:");
        //eslint-disable-next-line no-console
        console.error(this.errors);
        this.errors = [];
        this.errorsRetrieved = false;
        throw new Error(this.errors as any);
      }
      this.errors = [];
      this.errorsRetrieved = false;
    }
    addError(error: any) {
      if (Array.isArray(error)) {
        for (let i=0; i<error.length; i++) {
          this.errors.push(error);
        }
      } else {
        this.errors.push(error);
      }
    }
  }

  let errorCatcher = new ErrorCatcher();

  (before ? before : beforeEach)(() => {
    setOnGraphQLError((errors: any) => {
      errorCatcher.addError(errors);
    });
  });
  (after ? after : afterEach)(() => {
    errorCatcher.cleanup();
    setOnGraphQLError(null);
  });

  return errorCatcher;
};

// Given an error thrown from GraphQL, assert that it is permissions-flavored
// (as opposed to a type error, syntax error, or random unrecognized thing). If
// given an array of errors, asserts that all of them are permissions flavored.
export const assertIsPermissionsFlavoredError = (error: any): void => {
  if (!isPermissionsFlavoredError(error)) {
    //eslint-disable-next-line no-console
    console.error(JSON.stringify(error));
    throw new Error("Error is not permissions-flavored");
  }
}

const isPermissionsFlavoredError = (error: any): boolean => {
  if (Array.isArray(error)) {
    if (error.length === 0)
      return false;
    for(let i=0; i<error.length; i++) {
      if (!isPermissionsFlavoredError(error[i]))
        return false;
    }
    return true;
  }
  if (!error) {
    return false;
  }

  if ("app.validation_error" in error) {
    return true;
  }

  if (!error.message)
    return false;
  if (isPermissionsFlavoredErrorString(error.message))
    return true;

  let errorData: any = null;
  try {
    errorData = JSON.parse(error.message);
  } catch(e) {
    return false;
  }
  if (!errorData) return false;
  if (Array.isArray(errorData)) errorData = errorData[0];
  if (isPermissionsFlavoredErrorString(errorData)) return true;
  if (errorData.id && isPermissionsFlavoredErrorString(errorData.id)) return true;

  return false;
};

const isPermissionsFlavoredErrorString = (str: any): boolean => {
  switch (str)
  {
  case 'errors.disallowed_property_detected':
  case 'app.operation_not_allowed':
  case 'app.mutation_not_allowed':
  case 'app.user_cannot_moderate_post':
    return true;
  default:
    return false;
  }
}

export const createDefaultUser = async() => {
  // Creates defaultUser if they don't already exist
  const defaultUser = await Users.findOne({username:"defaultUser"})
  if (!defaultUser) {
    return createDummyUser({username:"defaultUser"})
  } else {
    return defaultUser
  }
}

// Posts can be created pretty flexibly
type TestPost = Omit<PartialDeep<DbPost>, 'postedAt'> & {
  postedAt?: Date | number,
  contents?: Partial<EditableFieldContents> | null,
}

export const createDummyPost = async (user?: AtLeast<DbUser, '_id'> | null, data?: TestPost) => {
  user ||= await createDefaultUser()
  const postId = data?._id ?? randomId();
  const revision = await createDummyRevision(user as DbUser, {
    _id: randomId(),
    collectionName: "Posts",
    documentId: postId,
    fieldName: "contents",
    editedAt: new Date(),
    updateType: "initial",
    version: "1.0.0",
    commitMessage: "",
    userId: user!._id,
    draft: false,
    ...data?.contents,
  });
  const defaultData = {
    _id: postId,
    userId: user!._id,
    title: randomId(),
    "contents_latest": revision._id,
    fmCrosspost: {isCrosspost: false},
    createdAt: new Date(),
  }
  const postData = {...defaultData, ...data};
  const newPostResponse = await createMutator({
    collection: Posts,
    // Not the best, createMutator should probably be more flexible about what
    // it accepts, as long as validate is false
    document: postData as DbPost,
    // As long as user has a _id it should be fine
    currentUser: user as DbUser,
    validate: false,
  });
  return newPostResponse.data
}

export const createDummyUser = async (data?: any) => {
  const testUsername = randomId()
  const defaultData = {
    _id: randomId(),
    username: testUsername,
    email: testUsername + "@test.lesserwrong.com",
    reviewedByUserId: "fakeuserid", // TODO: make this user_id correspond to something real that would hold up if we had proper validation
    previousDisplayName: randomId(),
    acceptedTos: true,
  }
  const userData = {...defaultData, ...data};
  const newUserResponse = await createMutator({
    collection: Users,
    document: userData,
    validate: false,
  })
  return newUserResponse.data;
}
export const createDummyComment = async (user: any, data?: any) => {
  const defaultUser = await createDefaultUser();
  let defaultData: any = {
    _id: randomId(),
    userId: (user || defaultUser)._id,
    contents: {
      originalContents: {
        type: "markdown",
        data: "This is a test comment"
      }
    },
  }
  if (!data.postId) {
    const randomPost = await Posts.findOne()
    if (!randomPost) throw Error("Can't find any post to generate random comment for")
    defaultData.postId = randomPost._id; // By default, just grab ID from a random post
  }
  const commentData = {...defaultData, ...data};
  const newCommentResponse = await createMutator({
    collection: Comments,
    document: commentData,
    currentUser: user || defaultUser,
    validate: false,
  });
  return newCommentResponse.data
}

export const createDummyConversation = async (user: any, data?: any) => {
  let defaultData = {
    _id: randomId(),
    title: user.displayName,
    participantIds: [user._id],
  }
  const conversationData = {...defaultData, ...data};
  const newConversationResponse = await createMutator({
    collection: Conversations,
    document: conversationData,
    currentUser: user,
    validate: false,
  });
  return newConversationResponse.data
}

export const createDummyMessage = async (user: any, data?: any) => {
  let defaultData = {
    _id: randomId(),
    contents: convertToRaw(ContentState.createFromText('Dummy Message Content')),
    userId: user._id,
  }
  const messageData = {...defaultData, ...data};
  const newMessageResponse = await createMutator({
    collection: Messages,
    document: messageData,
    currentUser: user,
    validate: false,
  });
  return newMessageResponse.data
}

export const createDummyLocalgroup = async (data?: any) => {
  let defaultData = {
    _id: randomId(),
    name: randomId(),
    organizerIds: [],
  }
  const groupData = {...defaultData, ...data};
  const groupResponse = await createMutator({
    collection: Localgroups,
    document: groupData,
    validate: false,
  });
  return groupResponse.data
}

const generateDummyVoteData = (user: DbUser, data?: Partial<DbVote>): DbVote => {
  const defaultData = {
    _id: randomId(),
    documentId: randomId(),
    collectionName: "Posts" as const,
    voteType: "smallUpvote",
    userId: user._id,
    authorIds: [],
    power: 1,
    cancelled: false,
    isUnvote: false,
    votedAt: new Date(),
    silenceNotification: false,
    documentIsAf: false,
    createdAt: new Date(),
    schemaVersion: 1,
    extendedVoteType: null,
    afPower: null,
    legacyData: null,
  };
  return {...defaultData, ...data};
}

export const createDummyVote = async (user: DbUser, data?: Partial<DbVote>) => {
  const voteData = generateDummyVoteData(user, data);
  const newVoteResponse = await createMutator({
    collection: Votes,
    document: voteData,
    currentUser: user,
    validate: false,
  });
  return newVoteResponse.data;
}

export const createManyDummyVotes = async (count: number, user: DbUser, data?: Partial<DbVote>) => {
  const thirtyMinsAgo = Date.now() - (30 * 60 * 1000);
  const votes = Array.from(new Array(count).keys()).map((i: number) => generateDummyVoteData(
    user,
    {...data, votedAt: new Date(thirtyMinsAgo + i)},
  ));
  await Votes.rawCollection().bulkWrite(votes.map((document) => ({
    insertOne: {document},
  })));
  return votes;
}

export const createDummyTag = async (user: DbUser, data?: Partial<DbTag>) => {
  const defaultData = {
    _id: randomId(),
    name: "Test Tag",
    userId: user._id,
    deleted: false,
    adminOnly: false,
    postCount: 0,
    createdAt: new Date(Date.now()),
  };
  const tagData = {...defaultData, ...data};
  const newTagResponse = await createMutator({
    collection: Tags,
    document: tagData,
    currentUser: user,
    validate: false,
  });
  return newTagResponse.data;
}

export const createDummyRevision = async (user: DbUser, data?: Partial<DbRevision>) => {
  const defaultData = {
    _id: randomId(),
    userId: user._id,
    inactive: false,
    editedAt: new Date(Date.now()),
    version: "1.0.0",
    changeMetrics: {} // not nullable field
  };
  const revisionData = {...defaultData, ...data};
  const newRevisionResponse = await createMutator({
    collection: Revisions,
    document: revisionData,
    currentUser: user,
    validate: false,
  });
  return newRevisionResponse.data;
}

export const createDummyUserRateLimit = async (user: DbUser, data: Partial<DbUserRateLimit>) => {
  const userRateLimit = await createMutator({
    collection: UserRateLimits,
    document: data,
    currentUser: user,
    validate: false,
  });
  return {...userRateLimit};
}

export const clearDatabase = async () => {
  await asyncForeachSequential(await Users.find().fetch(), async (i) => {
    await Users.rawRemove(i._id)
  });
  await asyncForeachSequential(await Posts.find().fetch(), async (i) => {
    await Posts.rawRemove(i._id)
  });
  await asyncForeachSequential(await Comments.find().fetch(), async (i) => {
    await Comments.rawRemove(i._id)
  });
}

// Replacement for JSON.stringify, because that puts quotes around keys, and GraphQL does not
// accept objects with quotes around the keys. 
// Copied from here: https://stackoverflow.com/a/11233515/8083739

// Jim's note: This will not work on objects that contain arrays that contain objects
function stringifyObject(obj_from_json: any): string {
  if(typeof obj_from_json !== "object" || Array.isArray(obj_from_json) || obj_from_json instanceof Date){
      // not an object or is a Date, stringify using native function
      return JSON.stringify(obj_from_json);
  }
  // Implements recursive object serialization according to JSON spec
  // but without quotes around the keys.
  let props = Object
      .keys(obj_from_json)
      .map((key: any) => `${key}:${stringifyObject(obj_from_json[key])}`)
      .join(",");
  return `{${props}}`;
}

export const userUpdateFieldFails = async ({user, document, fieldName, newValue, collectionType, fragment}: any) => {
  if (newValue === undefined) {
    newValue = randomId()
  }

  let newValueString = JSON.stringify(newValue)
  if (typeof newValue === "object") {
    newValueString = stringifyObject(newValue)
  } 

  const query = `
    mutation {
      update${collectionType}(selector: {_id:"${document._id}"},data:{${fieldName}:${newValueString}}) {
        data {
          ${fragment || fieldName}
        }
      }
    }
  `;
  await withNoLogs(async () => {
    const response = runQuery(query,{},{currentUser:user})
    await (response as any).should.be.rejected;
  });
}

export const userUpdateFieldSucceeds = async ({user, document, fieldName, collectionType, newValue, fragment}: any) => {
  let comparedValue = newValue

  if (newValue === undefined) {
    comparedValue = randomId()
    newValue = comparedValue;
  }

  let newValueString = JSON.stringify(newValue)
  if (typeof newValue === "object") {
    newValueString = stringifyObject(newValue)
  }

  const query = `
      mutation {
        update${collectionType}(selector: {_id:"${document._id}"},data:{${fieldName}:${newValueString}}) {
          data {
            ${fragment || fieldName}
          }
        }
      }
    `;
  const response = runQuery(query,{},{currentUser:user})
  const expectedOutput = { data: { [`update${collectionType}`]: { data: { [fieldName]: comparedValue} }}}
  return (response as any).should.eventually.deep.equal(expectedOutput);
}

/**
 * Please don't use this unless the test is actually expecting an error
 */
export const withNoLogs = async (fn: () => Promise<void>) => {
  const {log, warn, error, info} = console;
  //eslint-disable-next-line no-console
  console.log = console.warn = console.error = console.info = () => {}
  await fn();
  await waitUntilCallbacksFinished();
  console.log = log; //eslint-disable-line no-console
  console.warn = warn; //eslint-disable-line no-console
  console.error = error; //eslint-disable-line no-console
  console.info = info; //eslint-disable-line no-console
}

/**
 * Wait (in 20ms incremements) until there are no callbacks
 * in progress. Many database operations trigger asynchronous callbacks to do
 * things like generate notifications and add to search indexes; if you have a
 * unit test that depends on the results of these async callbacks, writing them
 * the naive way would create a race condition. But if you insert an
 * `await waitUntilCallbacksFinished()`, it will wait for all the background
 * processing to finish before proceeding with the rest of the test.
 *
 * This is NOT suitable for production (non-unit-test) use, because if other
 * threads/fibers are doing things which trigger callbacks, it could wait for
 * a long time. It DOES wait for callbacks that were triggered after
 * `waitUntilCallbacksFinished` was called, and that were triggered from
 * unrelated contexts.
 *
 * What this tracks specifically is that all callbacks which were registered
 * with `addCallback` and run with `runCallbacksAsync` have returned. Note that
 * it is possible for a callback to bypass this, by calling a function that
 * should have been await'ed without the await, effectively spawning a new
 * thread which isn't tracked.
 */
export const waitUntilCallbacksFinished = () => {
  return new Promise<void>(resolve => {
    function finishOrWait() {
      if (callbacksArePending() || isAnyPostgresQueryPending()) {
        setTimeout(finishOrWait, 20);
      } else {
        resolve();
      }
    }
    
    finishOrWait();
  });
}

1	import { createMutator, runQuery, setOnGraphQLError } from '../server/vulcan-lib';	721✔
2	import Users from '../lib/collections/users/collection';	17✔
3	import { Posts } from '../lib/collections/posts'	17✔
4	import { Comments } from '../lib/collections/comments'	17✔
5	import { Votes } from '../lib/collections/votes'	17✔
6	import Tags from '../lib/collections/tags/collection'	17✔
7	import Revisions from '../lib/collections/revisions/collection'	17✔
8	import Conversations from '../lib/collections/conversations/collection';	17✔
9	import Messages from '../lib/collections/messages/collection';	17✔
10	import {ContentState, convertToRaw} from 'draft-js';	17✔
11	import { randomId } from '../lib/random';	17✔
12	import type { PartialDeep } from 'type-fest'
13	import { asyncForeachSequential } from '../lib/utils/asyncUtils';	17✔
14	import Localgroups from '../lib/collections/localgroups/collection';	17✔
15	import { UserRateLimits } from '../lib/collections/userRateLimits';	17✔
16	import { callbacksArePending } from '@/server/utils/callbackHooks';	17✔
17	import { isAnyQueryPending as isAnyPostgresQueryPending } from "@/server/sql/PgCollection";	17✔
18
19	// Hooks Vulcan's runGraphQL to handle errors differently. By default, Vulcan
20	// would dump errors to stderr; instead, we want to (a) suppress that output,
21	// (b) assert that particular errors are present in unit tests, and (c) if no
22	// error was asserted to be present, assert that there were no errors.
23	//
24	// This should be called in unit tests from inside describe() but outside of
25	// it(). For example:
26	//
27	// describe('Thing that uses GraphQL', () => {
28	// let graphQLErrorCatcher = catchGraphQLErrors();
29	//
30	// it('produces a permission-denied error', async () => {
31	// // Do a thing that produces an error
32	//
33	// graphQLErrorCatcher.getErrors().should.equal(["app.mutation_not_allowed"]);
34	// })
35	//
36	// it('does not produce errors', async () => {
37	// // Do a thing that should not produce errors
38	// // Because this test does not interact with graphQLErrorCatcher, when
39	// // it returns, it will implicitly assert that there were no errors.
40	// })
41	// });
42	export const catchGraphQLErrors = function(before?: any, after?: any) {	17✔
43	class ErrorCatcher {
44	errors: Array<any>
45	errorsRetrieved: boolean
46
47	constructor() {
48	this.errors = [];	11✔
49	this.errorsRetrieved = false;	11✔
50	}
51
52	getErrors() {
53	this.errorsRetrieved = true;	23✔
54	return this.errors;	23✔
55	}
56	cleanup() {
57	if (!this.errorsRetrieved && this.errors.length>0) {	44!
58	//eslint-disable-next-line no-console
59	console.error("Unexpected GraphQL errors in test:");	×
60	//eslint-disable-next-line no-console
61	console.error(this.errors);	×
62	this.errors = [];	×
63	this.errorsRetrieved = false;	×
64	throw new Error(this.errors as any);	×
65	}
66	this.errors = [];	44✔
67	this.errorsRetrieved = false;	44✔
68	}
69	addError(error: any) {
70	if (Array.isArray(error)) {	23!
71	for (let i=0; i<error.length; i++) {	23✔
72	this.errors.push(error);	23✔
73	}
74	} else {
75	this.errors.push(error);	×
76	}
77	}
78	}
79
80	let errorCatcher = new ErrorCatcher();	11✔
81
82	(before ? before : beforeEach)(() => {	11✔
83	setOnGraphQLError((errors: any) => {	44✔
84	errorCatcher.addError(errors);	23✔
85	});
86	});
87	(after ? after : afterEach)(() => {	11✔
88	errorCatcher.cleanup();	44✔
89	setOnGraphQLError(null);	44✔
90	});
91
92	return errorCatcher;	11✔
93	};
94
95	// Given an error thrown from GraphQL, assert that it is permissions-flavored
96	// (as opposed to a type error, syntax error, or random unrecognized thing). If
97	// given an array of errors, asserts that all of them are permissions flavored.
98	export const assertIsPermissionsFlavoredError = (error: any): void => {	17✔
99	if (!isPermissionsFlavoredError(error)) {	19!
100	//eslint-disable-next-line no-console
101	console.error(JSON.stringify(error));	×
102	throw new Error("Error is not permissions-flavored");	×
103	}
104	}
105
106	const isPermissionsFlavoredError = (error: any): boolean => {	17✔
107	if (Array.isArray(error)) {	57✔
108	if (error.length === 0)	38!
109	return false;	×
110	for(let i=0; i<error.length; i++) {	38✔
111	if (!isPermissionsFlavoredError(error[i]))	38!
112	return false;	×
113	}
114	return true;	38✔
115	}
116	if (!error) {	19!
117	return false;	×
118	}
119
120	if ("app.validation_error" in error) {	19!
121	return true;	×
122	}
123
124	if (!error.message)	19!
125	return false;	×
126	if (isPermissionsFlavoredErrorString(error.message))	19✔
127	return true;	9✔
128
129	let errorData: any = null;	10✔
130	try {	10✔
131	errorData = JSON.parse(error.message);	10✔
132	} catch(e) {
133	return false;	×
134	}
135	if (!errorData) return false;	10!
136	if (Array.isArray(errorData)) errorData = errorData[0];	10✔
137	if (isPermissionsFlavoredErrorString(errorData)) return true;	10!
138	if (errorData.id && isPermissionsFlavoredErrorString(errorData.id)) return true;	10!
139
140	return false;	×
141	};
142
143	const isPermissionsFlavoredErrorString = (str: any): boolean => {	17✔
144	switch (str)	39✔
145	{
146	case 'errors.disallowed_property_detected':
147	case 'app.operation_not_allowed':
148	case 'app.mutation_not_allowed':
149	case 'app.user_cannot_moderate_post':
150	return true;	19✔
151	default:
152	return false;	20✔
153	}
154	}
155
156	export const createDefaultUser = async() => {	17✔
157	// Creates defaultUser if they don't already exist
158	const defaultUser = await Users.findOne({username:"defaultUser"})	46✔
159	if (!defaultUser) {	46✔
160	return createDummyUser({username:"defaultUser"})	7✔
161	} else {
162	return defaultUser	39✔
163	}
164	}
165
166	// Posts can be created pretty flexibly
167	type TestPost = Omit<PartialDeep<DbPost>, 'postedAt'> & {
168	postedAt?: Date \| number,
169	contents?: Partial<EditableFieldContents> \| null,
170	}
171
172	export const createDummyPost = async (user?: AtLeast<DbUser, '_id'> \| null, data?: TestPost) => {	17✔
173	user \|\|= await createDefaultUser()	103✔
174	const postId = data?._id ?? randomId();	103!
175	const revision = await createDummyRevision(user as DbUser, {	103✔
176	_id: randomId(),
177	collectionName: "Posts",
178	documentId: postId,
179	fieldName: "contents",
180	editedAt: new Date(),
181	updateType: "initial",
182	version: "1.0.0",
183	commitMessage: "",
184	userId: user!._id,
185	draft: false,
186	...data?.contents,	103✔
187	});
188	const defaultData = {	103✔
189	_id: postId,
190	userId: user!._id,
191	title: randomId(),
192	"contents_latest": revision._id,
193	fmCrosspost: {isCrosspost: false},
194	createdAt: new Date(),
195	}
196	const postData = {...defaultData, ...data};	103✔
197	const newPostResponse = await createMutator({	103✔
198	collection: Posts,
199	// Not the best, createMutator should probably be more flexible about what
200	// it accepts, as long as validate is false
201	document: postData as DbPost,
202	// As long as user has a _id it should be fine
203	currentUser: user as DbUser,
204	validate: false,
205	});
206	return newPostResponse.data	103✔
207	}
208
209	export const createDummyUser = async (data?: any) => {	17✔
210	const testUsername = randomId()	168✔
211	const defaultData = {	168✔
212	_id: randomId(),
213	username: testUsername,
214	email: testUsername + "@test.lesserwrong.com",
215	reviewedByUserId: "fakeuserid", // TODO: make this user_id correspond to something real that would hold up if we had proper validation
216	previousDisplayName: randomId(),
217	acceptedTos: true,
218	}
219	const userData = {...defaultData, ...data};	168✔
220	const newUserResponse = await createMutator({	168✔
221	collection: Users,
222	document: userData,
223	validate: false,
224	})
225	return newUserResponse.data;	168✔
226	}
227	export const createDummyComment = async (user: any, data?: any) => {	17✔
228	const defaultUser = await createDefaultUser();	19✔
229	let defaultData: any = {	19✔
230	_id: randomId(),
231	userId: (user \|\| defaultUser)._id,	22✔
232	contents: {
233	originalContents: {
234	type: "markdown",
235	data: "This is a test comment"
236	}
237	},
238	}
239	if (!data.postId) {	19!
240	const randomPost = await Posts.findOne()	×
241	if (!randomPost) throw Error("Can't find any post to generate random comment for")	×
242	defaultData.postId = randomPost._id; // By default, just grab ID from a random post	×
243	}
244	const commentData = {...defaultData, ...data};	19✔
245	const newCommentResponse = await createMutator({	19✔
246	collection: Comments,
247	document: commentData,
248	currentUser: user \|\| defaultUser,	22✔
249	validate: false,
250	});
251	return newCommentResponse.data	19✔
252	}
253
254	export const createDummyConversation = async (user: any, data?: any) => {	17✔
255	let defaultData = {	×
256	_id: randomId(),
257	title: user.displayName,
258	participantIds: [user._id],
259	}
260	const conversationData = {...defaultData, ...data};	×
261	const newConversationResponse = await createMutator({	×
262	collection: Conversations,
263	document: conversationData,
264	currentUser: user,
265	validate: false,
266	});
267	return newConversationResponse.data	×
268	}
269
270	export const createDummyMessage = async (user: any, data?: any) => {	17✔
271	let defaultData = {	×
272	_id: randomId(),
273	contents: convertToRaw(ContentState.createFromText('Dummy Message Content')),
274	userId: user._id,
275	}
276	const messageData = {...defaultData, ...data};	×
277	const newMessageResponse = await createMutator({	×
278	collection: Messages,
279	document: messageData,
280	currentUser: user,
281	validate: false,
282	});
283	return newMessageResponse.data	×
284	}
285
286	export const createDummyLocalgroup = async (data?: any) => {	17✔
287	let defaultData = {	2✔
288	_id: randomId(),
289	name: randomId(),
290	organizerIds: [],
291	}
292	const groupData = {...defaultData, ...data};	2✔
293	const groupResponse = await createMutator({	2✔
294	collection: Localgroups,
295	document: groupData,
296	validate: false,
297	});
298	return groupResponse.data	2✔
299	}
300
301	const generateDummyVoteData = (user: DbUser, data?: Partial<DbVote>): DbVote => {	17✔
302	const defaultData = {	200✔
303	_id: randomId(),
304	documentId: randomId(),
305	collectionName: "Posts" as const,
306	voteType: "smallUpvote",
307	userId: user._id,
308	authorIds: [],
309	power: 1,
310	cancelled: false,
311	isUnvote: false,
312	votedAt: new Date(),
313	silenceNotification: false,
314	documentIsAf: false,
315	createdAt: new Date(),
316	schemaVersion: 1,
317	extendedVoteType: null,
318	afPower: null,
319	legacyData: null,
320	};
321	return {...defaultData, ...data};	200✔
322	}
323
324	export const createDummyVote = async (user: DbUser, data?: Partial<DbVote>) => {	17✔
325	const voteData = generateDummyVoteData(user, data);	×
326	const newVoteResponse = await createMutator({	×
327	collection: Votes,
328	document: voteData,
329	currentUser: user,
330	validate: false,
331	});
332	return newVoteResponse.data;	×
333	}
334
335	export const createManyDummyVotes = async (count: number, user: DbUser, data?: Partial<DbVote>) => {	17✔
336	const thirtyMinsAgo = Date.now() - (30 * 60 * 1000);	2✔
337	const votes = Array.from(new Array(count).keys()).map((i: number) => generateDummyVoteData(	200✔
338	user,
339	{...data, votedAt: new Date(thirtyMinsAgo + i)},
340	));
341	await Votes.rawCollection().bulkWrite(votes.map((document) => ({	200✔
342	insertOne: {document},
343	})));
344	return votes;	2✔
345	}
346
347	export const createDummyTag = async (user: DbUser, data?: Partial<DbTag>) => {	17✔
348	const defaultData = {	1✔
349	_id: randomId(),
350	name: "Test Tag",
351	userId: user._id,
352	deleted: false,
353	adminOnly: false,
354	postCount: 0,
355	createdAt: new Date(Date.now()),
356	};
357	const tagData = {...defaultData, ...data};	1✔
358	const newTagResponse = await createMutator({	1✔
359	collection: Tags,
360	document: tagData,
361	currentUser: user,
362	validate: false,
363	});
364	return newTagResponse.data;	1✔
365	}
366
367	export const createDummyRevision = async (user: DbUser, data?: Partial<DbRevision>) => {	17✔
368	const defaultData = {	104✔
369	_id: randomId(),
370	userId: user._id,
371	inactive: false,
372	editedAt: new Date(Date.now()),
373	version: "1.0.0",
374	changeMetrics: {} // not nullable field
375	};
376	const revisionData = {...defaultData, ...data};	104✔
377	const newRevisionResponse = await createMutator({	104✔
378	collection: Revisions,
379	document: revisionData,
380	currentUser: user,
381	validate: false,
382	});
383	return newRevisionResponse.data;	104✔
384	}
385
386	export const createDummyUserRateLimit = async (user: DbUser, data: Partial<DbUserRateLimit>) => {	17✔
387	const userRateLimit = await createMutator({	1✔
388	collection: UserRateLimits,
389	document: data,
390	currentUser: user,
391	validate: false,
392	});
393	return {...userRateLimit};	1✔
394	}
395
396	export const clearDatabase = async () => {	17✔
UNCOV 397	await asyncForeachSequential(await Users.find().fetch(), async (i) => {	×
398	await Users.rawRemove(i._id)	×
399	});
UNCOV 400	await asyncForeachSequential(await Posts.find().fetch(), async (i) => {	×
401	await Posts.rawRemove(i._id)	×
402	});
UNCOV 403	await asyncForeachSequential(await Comments.find().fetch(), async (i) => {	×
404	await Comments.rawRemove(i._id)	×
405	});
406	}
407
408	// Replacement for JSON.stringify, because that puts quotes around keys, and GraphQL does not
409	// accept objects with quotes around the keys.
410	// Copied from here: https://stackoverflow.com/a/11233515/8083739
411
412	// Jim's note: This will not work on objects that contain arrays that contain objects
413	function stringifyObject(obj_from_json: any): string {
414	if(typeof obj_from_json !== "object" \|\| Array.isArray(obj_from_json) \|\| obj_from_json instanceof Date){	11✔
415	// not an object or is a Date, stringify using native function
416	return JSON.stringify(obj_from_json);	7✔
417	}
418	// Implements recursive object serialization according to JSON spec
419	// but without quotes around the keys.
420	let props = Object	4✔
421	.keys(obj_from_json)
422	.map((key: any) => `${key}:${stringifyObject(obj_from_json[key])}`)	6✔
423	.join(",");
424	return `{${props}}`;	4✔
425	}
426
427	export const userUpdateFieldFails = async ({user, document, fieldName, newValue, collectionType, fragment}: any) => {	17✔
428	if (newValue === undefined) {	10✔
429	newValue = randomId()	2✔
430	}
431
432	let newValueString = JSON.stringify(newValue)	10✔
433	if (typeof newValue === "object") {	10✔
434	newValueString = stringifyObject(newValue)	4✔
435	}
436
437	const query = `	10✔
438	mutation {
439	update${collectionType}(selector: {_id:"${document._id}"},data:{${fieldName}:${newValueString}}) {
440	data {
441	${fragment \|\| fieldName}	19✔
442	}
443	}
444	}
445	`;
446	await withNoLogs(async () => {	10✔
447	const response = runQuery(query,{},{currentUser:user})	10✔
448	await (response as any).should.be.rejected;	10✔
449	});
450	}
451
452	export const userUpdateFieldSucceeds = async ({user, document, fieldName, collectionType, newValue, fragment}: any) => {	17✔
453	let comparedValue = newValue	7✔
454
455	if (newValue === undefined) {	7✔
456	comparedValue = randomId()	3✔
457	newValue = comparedValue;	3✔
458	}
459
460	let newValueString = JSON.stringify(newValue)	7✔
461	if (typeof newValue === "object") {	7✔
462	newValueString = stringifyObject(newValue)	1✔
463	}
464
465	const query = `	7✔
466	mutation {
467	update${collectionType}(selector: {_id:"${document._id}"},data:{${fieldName}:${newValueString}}) {
468	data {
469	${fragment \|\| fieldName}	13✔
470	}
471	}
472	}
473	`;
474	const response = runQuery(query,{},{currentUser:user})	7✔
475	const expectedOutput = { data: { [`update${collectionType}`]: { data: { [fieldName]: comparedValue} }}}	7✔
476	return (response as any).should.eventually.deep.equal(expectedOutput);	7✔
477	}
478
479	/**
480	* Please don't use this unless the test is actually expecting an error
481	*/
482	export const withNoLogs = async (fn: () => Promise<void>) => {	17✔
483	const {log, warn, error, info} = console;	17✔
484	//eslint-disable-next-line no-console
485	console.log = console.warn = console.error = console.info = () => {}	17✔
486	await fn();	17✔
487	await waitUntilCallbacksFinished();	17✔
488	console.log = log; //eslint-disable-line no-console	17✔
489	console.warn = warn; //eslint-disable-line no-console	17✔
490	console.error = error; //eslint-disable-line no-console	17✔
491	console.info = info; //eslint-disable-line no-console	17✔
492	}
493
494	/**
495	* Wait (in 20ms incremements) until there are no callbacks
496	* in progress. Many database operations trigger asynchronous callbacks to do
497	* things like generate notifications and add to search indexes; if you have a
498	* unit test that depends on the results of these async callbacks, writing them
499	* the naive way would create a race condition. But if you insert an
500	* `await waitUntilCallbacksFinished()`, it will wait for all the background
501	* processing to finish before proceeding with the rest of the test.
502	*
503	* This is NOT suitable for production (non-unit-test) use, because if other
504	* threads/fibers are doing things which trigger callbacks, it could wait for
505	* a long time. It DOES wait for callbacks that were triggered after
506	* `waitUntilCallbacksFinished` was called, and that were triggered from
507	* unrelated contexts.
508	*
509	* What this tracks specifically is that all callbacks which were registered
510	* with `addCallback` and run with `runCallbacksAsync` have returned. Note that
511	* it is possible for a callback to bypass this, by calling a function that
512	* should have been await'ed without the await, effectively spawning a new
513	* thread which isn't tracked.
514	*/
515	export const waitUntilCallbacksFinished = () => {	17✔
516	return new Promise<void>(resolve => {	343✔
517	function finishOrWait() {
518	if (callbacksArePending() \|\| isAnyPostgresQueryPending()) {	481✔
519	setTimeout(finishOrWait, 20);	138✔
520	} else {
521	resolve();	343✔
522	}
523	}
524
525	finishOrWait();	343✔
526	});
527	}

ForumMagnum / ForumMagnum / 10817711445

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous