als-mongo-list/tests/sort.test.js

A flexible, lightweight MongoDB query utility for Node.js applications. Simplifies database operations with intuitive filtering, pagination, sorting, and field selection. Ideal for REST API endpoints, providing a primary List class that abstracts complex

const Sort = require('../lib/sort/sort');
const assert = require('node:assert');
const { describe, it } = require('node:test');

describe('Sort', () => {
   const tree = {
      name: { type: String },
      age: { type: Number },
      isActive: { type: Boolean },
      createdAt: { type: Date },
   };

   const sortKeys = ['name', 'age', 'isActive', 'createdAt'];
   const sort = new Sort({ tree, sortKeys });

   describe('Initialization', () => {
      it('should create a valid input object', () => {
         assert.deepStrictEqual(sort.input.name, 'orderBy');
         assert.ok(Array.isArray(sort.input.options));
         assert.strictEqual(sort.input.options.length, 8);
      });

      it('should create sorting options for all fields', () => {
         const expected = {
            tag: 'select',
            name: 'orderBy',
            options: [
               { value: 'name', text: 'a_z', key: 'name' },
               { value: '-name', text: 'z_a', key: 'name' },
               { value: '-age', text: 'small_big', key: 'age' },
               { value: 'age', text: 'big_small', key: 'age' },
               { value: 'isActive', text: 'yes_first', key: 'isActive' },
               { value: '-isActive', text: 'no_first', key: 'isActive' },
               { value: '-createdAt', text: 'new_first', key: 'createdAt' },
               { value: 'createdAt', text: 'old_first', key: 'createdAt' }
            ]
         }
         assert.deepStrictEqual(sort.input,expected)
      });

   });

   describe('getSort', () => {
      it('should return valid sort for String fields', () => {
         const query = { orderBy: 'name' };
         const result = sort.getSort(query);
         assert.deepStrictEqual(result, { name: 1 });

         const queryDesc = { orderBy: '-name' };
         const resultDesc = sort.getSort(queryDesc);
         assert.deepStrictEqual(resultDesc, { name: -1 });
      });

      it('should return valid sort for Number fields', () => {
         const query = { orderBy: 'age' };
         const result = sort.getSort(query);
         assert.deepStrictEqual(result, { age: 1 });

         const queryDesc = { orderBy: '-age' };
         const resultDesc = sort.getSort(queryDesc);
         assert.deepStrictEqual(resultDesc, { age: -1 });
      });

      it('should return valid sort for Boolean fields', () => {
         const query = { orderBy: 'isActive' };
         const result = sort.getSort(query);
         assert.deepStrictEqual(result, { isActive: 1 });

         const queryDesc = { orderBy: '-isActive' };
         const resultDesc = sort.getSort(queryDesc);
         assert.deepStrictEqual(resultDesc, { isActive: -1 });
      });

      it('should return valid sort for Date fields', () => {
         const query = { orderBy: 'createdAt' };
         const result = sort.getSort(query);
         assert.deepStrictEqual(result, { createdAt: 1 });

         const queryDesc = { orderBy: '-createdAt' };
         const resultDesc = sort.getSort(queryDesc);
         assert.deepStrictEqual(resultDesc, { createdAt: -1 });
      });

      it('should return null for invalid orderBy', () => {
         const query = { orderBy: 'invalidField' };
         const result = sort.getSort(query);
         assert.strictEqual(result, null);
      });

      it('should return null for missing orderBy', () => {
         const query = {};
         const result = sort.getSort(query);
         assert.strictEqual(result, null);
      });
   });

   describe('Edge cases', () => {
      it('should handle empty sortKeys gracefully', () => {
         const sortEmpty = new Sort({ tree, sortKeys: new Set() });
         assert.strictEqual(sortEmpty.input, null);
      });

      it('should ignore fields with unsupported types', () => {
         const customTree = {
            unsupportedField: { type: Array }, // Unsupported type
            name: { type: String },
         };
         const sortCustom = new Sort({ tree: customTree, sortKeys: ['unsupportedField', 'name'] });
         const options = sortCustom.input.options;
         assert.strictEqual(options.length, 2); // Only `name` options
         assert.deepStrictEqual(options[0].key, 'name');
      });
   });
});