Refactor some function names & comment lines.

Author: mohammad0-0ahmad

test/document.test.js

@@ -11285,8 +11285,8 @@ describe('document', function() {
   });
 });
 
-describe('Check if instance functions that is supplied in schema option is availabe (m0_0a)', function() {
-  it('should give an instance function back rather than undefined', function M0_0aModelJS() {
+describe('Check if instance functions that is supplied in schema option is availabe', function() {
+  it('should give an instance function back rather than undefined', function ModelJS() {
     const testSchema = new mongoose.Schema({}, { methods: { instanceFn() { return 'Returned from DocumentInstanceFn'; } } });
     const TestModel = mongoose.model('TestModel', testSchema);
     const TestDocument = new TestModel({});

test/model.test.js

@@ -8491,8 +8491,8 @@ describe('Model', function() {
   });
 });
 
-describe('Check if statics functions that is supplied in schema option is availabe (m0_0a)', function() {
-  it('should give a static function back rather than undefined', function M0_0aModelJS() {
+describe('Check if statics functions that is supplied in schema option is availabe', function() {
+  it('should give a static function back rather than undefined', function ModelJS() {
     const testSchema = new mongoose.Schema({}, { statics: { staticFn() { return 'Returned from staticFn'; } } });
     const TestModel = mongoose.model('TestModel', testSchema);
     assert.equal(TestModel.staticFn(), 'Returned from staticFn');

test/query.test.js

@@ -3964,7 +3964,9 @@ describe('Query', function() {
     Model.create({ userName: 'test' }, function(error) {
       assert.ifError(error);
       Model.find().byUserName('test').exec(function(error, docs) {
-        assert.ifError(error);
+        if (error instanceof Error) {
+          return done(error);
+        }
         assert.equal(docs.length, 1);
         assert.equal(docs[0].userName, 'test');
         done();

test/types/document.test.ts

@@ -1,7 +1,7 @@
 import { Schema, model, Model, Document, Error, Types } from 'mongoose';
 import { expectAssignable, expectError, expectType } from 'tsd';
 import { autoTypedModel } from './models.test';
-import { M0_0aAutoTypedSchemaType } from './schema.test';
+import { AutoTypedSchemaType } from './schema.test';
 
 const schema: Schema = new Schema({ name: { type: 'String', required: true }, address: new Schema({ city: { type: String, required: true } }) });
 
@@ -169,20 +169,17 @@ function gh11435() {
   });
 }
 
-function m0_0aDocument() {
+function autoTypedDocument() {
   const AutoTypedModel = autoTypedModel();
   const AutoTypeModelInstance = new AutoTypedModel({ unExistProperty: 1, description: 2 });
 
-  expectType<M0_0aAutoTypedSchemaType['schema']['userName']>(AutoTypeModelInstance.userName);
-  expectType<M0_0aAutoTypedSchemaType['schema']['favoritDrink']>(AutoTypeModelInstance.favoritDrink);
-  expectType<M0_0aAutoTypedSchemaType['schema']['favoritColorMode']>(AutoTypeModelInstance.favoritColorMode);
+  expectType<AutoTypedSchemaType['schema']['userName']>(AutoTypeModelInstance.userName);
+  expectType<AutoTypedSchemaType['schema']['favoritDrink']>(AutoTypeModelInstance.favoritDrink);
+  expectType<AutoTypedSchemaType['schema']['favoritColorMode']>(AutoTypeModelInstance.favoritColorMode);
   expectType<number>(AutoTypeModelInstance.unExistProperty);
   expectType<number>(AutoTypeModelInstance.description);
 
-  /* -------------------------------------------------------------------------- */
-  /*                           Document-Methods-tests                           */
-  /* -------------------------------------------------------------------------- */
-
-  expectType<ReturnType<M0_0aAutoTypedSchemaType['methods']['instanceFn']>>(new AutoTypedModel().instanceFn());
+  // Document-Methods-tests
+  expectType<ReturnType<AutoTypedSchemaType['methods']['instanceFn']>>(new AutoTypedModel().instanceFn());
 
 }

test/types/models.test.ts

@@ -1,6 +1,6 @@
 import { Schema, Document, Model, Types, connection, model } from 'mongoose';
 import { expectError, expectType } from 'tsd';
-import { M0_0aAutoTypedSchemaType, autoTypedSchema } from './schema.test';
+import { AutoTypedSchemaType, autoTypedSchema } from './schema.test';
 
 function conventionalSyntax(): void {
   interface ITest extends Document {
@@ -219,31 +219,26 @@ export function autoTypedModel() {
   const AutoTypedModel = model('AutoTypeModel', AutoTypedSchema);
 
   (async() => {
-  /* -------------------------------------------------------------------------- */
-  /*                            Model-functions-test                            */
-  /* -------------------------------------------------------------------------- */
+  // Model-functions-test
   // Create should works with arbitrary objects.
     const randomObject = await AutoTypedModel.create({ unExistKey: 'unExistKey', description: 'st' });
     expectType<string>(randomObject.unExistKey);
-    expectType<M0_0aAutoTypedSchemaType['schema']['userName']>(randomObject.userName);
+    expectType<AutoTypedSchemaType['schema']['userName']>(randomObject.userName);
 
     const testDoc1 = await AutoTypedModel.create({ userName: 'M0_0a' });
-    expectType<M0_0aAutoTypedSchemaType['schema']['userName']>(testDoc1.userName);
-    expectType<M0_0aAutoTypedSchemaType['schema']['description']>(testDoc1.description);
+    expectType<AutoTypedSchemaType['schema']['userName']>(testDoc1.userName);
+    expectType<AutoTypedSchemaType['schema']['description']>(testDoc1.description);
 
     const testDoc2 = await AutoTypedModel.insertMany([{ userName: 'M0_0a' }]);
-    expectType<M0_0aAutoTypedSchemaType['schema']['userName']>(testDoc2[0].userName);
-    expectType<M0_0aAutoTypedSchemaType['schema']['description'] | undefined>(testDoc2[0]?.description);
+    expectType<AutoTypedSchemaType['schema']['userName']>(testDoc2[0].userName);
+    expectType<AutoTypedSchemaType['schema']['description'] | undefined>(testDoc2[0]?.description);
 
     const testDoc3 = await AutoTypedModel.findOne({ userName: 'M0_0a' });
-    expectType<M0_0aAutoTypedSchemaType['schema']['userName'] | undefined>(testDoc3?.userName);
-    expectType<M0_0aAutoTypedSchemaType['schema']['description'] | undefined>(testDoc3?.description);
+    expectType<AutoTypedSchemaType['schema']['userName'] | undefined>(testDoc3?.userName);
+    expectType<AutoTypedSchemaType['schema']['description'] | undefined>(testDoc3?.description);
 
-    /* -------------------------------------------------------------------------- */
-    /*                      Model-statics-functions-test                          */
-    /* -------------------------------------------------------------------------- */
-
-    expectType<ReturnType<M0_0aAutoTypedSchemaType['statics']['staticFn']>>(AutoTypedModel.staticFn());
+    // Model-statics-functions-test
+    expectType<ReturnType<AutoTypedSchemaType['statics']['staticFn']>>(AutoTypedModel.staticFn());
 
   })();
   return AutoTypedModel;

test/types/queries.test.ts

@@ -2,7 +2,7 @@ import { HydratedDocument, Schema, model, Document, Types, Query, Model, QueryWi
 import { ObjectId } from 'mongodb';
 import { expectError, expectType } from 'tsd';
 import { autoTypedModel } from './models.test';
-import { M0_0aAutoTypedSchemaType } from './schema.test';
+import { AutoTypedSchemaType } from './schema.test';
 
 interface QueryHelpers {
   _byName(this: QueryWithHelpers<any, ITest, QueryHelpers>, name: string): QueryWithHelpers<Array<ITest>, ITest, QueryHelpers>;

test/types/schema.test.ts

@@ -461,34 +461,34 @@ export function autoTypedSchema() {
   }, {
     statics: {
       staticFn() {
-        expectType<Model<M0_0aAutoTypedSchemaType['schema']>>(this);
+        expectType<Model<AutoTypedSchemaType['schema']>>(this);
         return 'Returned from staticFn' as const;
       }
     },
     methods: {
       instanceFn() {
-        expectType<HydratedDocument<M0_0aAutoTypedSchemaType['schema']>>(this);
+        expectType<HydratedDocument<AutoTypedSchemaType['schema']>>(this);
         return 'Returned from DocumentInstanceFn' as const;
       }
     },
     query: {
       byUserName(userName) {
-        expectAssignable<Query<unknown, M0_0aAutoTypedSchemaType['schema']>>(this);
+        expectAssignable<Query<unknown, AutoTypedSchemaType['schema']>>(this);
         return this.where({ userName });
       }
     }
   });
 
   type InferredSchemaType = InferSchemaType<typeof AutoTypedSchema>;
 
-  expectType<M0_0aAutoTypedSchemaType['schema']>({} as InferredSchemaType);
+  expectType<AutoTypedSchemaType['schema']>({} as InferredSchemaType);
 
-  expectError<M0_0aAutoTypedSchemaType['schema'] & { doesNotExist: boolean; }>({} as InferredSchemaType);
+  expectError<AutoTypedSchemaType['schema'] & { doesNotExist: boolean; }>({} as InferredSchemaType);
 
   return AutoTypedSchema;
 }
 
-export type M0_0aAutoTypedSchemaType = {
+export type AutoTypedSchemaType = {
   schema: {
     userName: string;
     description?: string;