9322638257

Committed 31 May 2024 12:49AM UTC coverage: 31.899% (-0.006%) from 31.905%

Build # 9322638257

Build Type

Pull #9346

github

Committed by

darkruby501

Commit Message

queue up more users once user starts processing suggestions

Pull Request Pull Request #9346: Subscribed feed launch

Run Details

4805 of 39284 branches covered (12.23%)

Branch coverage included in aggregate %.

42 of 145 new or added lines in 14 files covered. (28.97%)

110 existing lines in 9 files now uncovered.

27954 of 63413 relevant lines covered (44.08%)

179.53 hits per line

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

80.56

/packages/lesswrong/integrationTests/utils.ts

import { createMutator, runQuery, setOnGraphQLError, waitUntilCallbacksFinished } 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';

// 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}

export const createDummyPost = async (user?: AtLeast<DbUser, '_id'> | null, data?: TestPost) => {
  let user_ = user || await createDefaultUser()
  const defaultData = {
    _id: randomId(),
    userId: user_._id,
    title: randomId(),
    "contents_latest": randomId(),
    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
}

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

ForumMagnum / ForumMagnum / 9322638257

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