test: Add comprehensive tests for mongoFieldToParseSchemaField type validation

- Add tests for valid field type conversions
- Add tests for invalid type handling (null, undefined, non-string values)
- Ensure Parse.Error is thrown for invalid inputs
- Test coverage for the type validation improvements

Author: rgunindi

spec/MongoSchemaCollectionAdapter.spec.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const Parse = require('parse/node');
 const MongoSchemaCollection = require('../lib/Adapters/Storage/Mongo/MongoSchemaCollection')
   .default;
 
@@ -96,4 +97,95 @@ describe('MongoSchemaCollection', () => {
     });
     done();
   });
+
+  describe('mongoFieldToParseSchemaField function', () => {
+    // Test successful type conversions
+    it('should convert valid mongo field types to parse schema fields', () => {
+      const testCases = [
+        { input: 'string', expected: { type: 'String' } },
+        { input: 'number', expected: { type: 'Number' } },
+        { input: 'boolean', expected: { type: 'Boolean' } },
+        { input: 'date', expected: { type: 'Date' } },
+        { input: 'map', expected: { type: 'Object' } },
+        { input: 'object', expected: { type: 'Object' } },
+        { input: 'array', expected: { type: 'Array' } },
+        { input: 'geopoint', expected: { type: 'GeoPoint' } },
+        { input: 'file', expected: { type: 'File' } },
+        { input: 'bytes', expected: { type: 'Bytes' } },
+        { input: 'polygon', expected: { type: 'Polygon' } },
+        { input: '*_User', expected: { type: 'Pointer', targetClass: '_User' } },
+        { input: '*Post', expected: { type: 'Pointer', targetClass: 'Post' } },
+        { input: 'relation<_User>', expected: { type: 'Relation', targetClass: '_User' } },
+        { input: 'relation<Post>', expected: { type: 'Relation', targetClass: 'Post' } },
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = MongoSchemaCollection._TESTmongoSchemaToParseSchema({
+          _id: 'TestClass',
+          testField: input,
+        });
+
+        expect(result.fields.testField).toEqual(expected);
+      });
+    });
+
+    // Test error handling for invalid types (non-string values)
+    it('should throw Parse.Error for invalid field types', () => {
+      const invalidInputs = [
+        null,
+        undefined,
+        123,
+        true,
+        false,
+        {},
+        [],
+        '',
+      ];
+
+      invalidInputs.forEach(invalidInput => {
+        expect(() => {
+          MongoSchemaCollection._TESTmongoSchemaToParseSchema({
+            _id: 'TestClass',
+            testField: invalidInput,
+          });
+        }).toThrow(Parse.Error);
+      });
+    });
+
+    it('should throw Parse.Error with correct error code and message for null input', () => {
+      expect(() => {
+        MongoSchemaCollection._TESTmongoSchemaToParseSchema({
+          _id: 'TestClass',
+          testField: null,
+        });
+      }).toThrow(Parse.Error);
+    });
+
+    it('should throw Parse.Error with correct error code and message for undefined input', () => {
+      expect(() => {
+        MongoSchemaCollection._TESTmongoSchemaToParseSchema({
+          _id: 'TestClass',
+          testField: undefined,
+        });
+      }).toThrow(Parse.Error);
+    });
+
+    it('should throw Parse.Error with correct error code and message for non-string input', () => {
+      expect(() => {
+        MongoSchemaCollection._TESTmongoSchemaToParseSchema({
+          _id: 'TestClass',
+          testField: 123,
+        });
+      }).toThrow(Parse.Error);
+    });
+
+    it('should throw Parse.Error with correct error code and message for empty string input', () => {
+      expect(() => {
+        MongoSchemaCollection._TESTmongoSchemaToParseSchema({
+          _id: 'TestClass',
+          testField: '',
+        });
+      }).toThrow(Parse.Error);
+    });
+  });
 });