@applica-software-guru/crud-client/src/tests/multiSort.test.ts

Libreria per l'accesso ai servizi REST di Applica.

import { parseFilters, parseSort } from '../utils';
import { describe, expect, it } from 'vitest';

describe('Multi-sort functionality', () => {
  describe('parseSort', () => {
    it('should handle single sort field', () => {
      const result = parseSort({ field: 'name', order: 'ASC' });
      expect(result).toEqual([
        {
          property: 'name',
          descending: false
        }
      ]);
    });

    it('should handle single sort field with DESC order', () => {
      const result = parseSort({ field: 'createdAt', order: 'DESC' });
      expect(result).toEqual([
        {
          property: 'createdAt',
          descending: true
        }
      ]);
    });

    it('should handle multi-sort with comma-separated fields', () => {
      const result = parseSort({ field: 'name,createdAt', order: 'ASC,DESC' });
      expect(result).toEqual([
        {
          property: 'name',
          descending: false
        },
        {
          property: 'createdAt',
          descending: true
        }
      ]);
    });

    it('should handle multi-sort with different order combinations', () => {
      const result = parseSort({ field: 'priority,name,createdAt', order: 'DESC,ASC,DESC' });
      expect(result).toEqual([
        {
          property: 'priority',
          descending: true
        },
        {
          property: 'name',
          descending: false
        },
        {
          property: 'createdAt',
          descending: true
        }
      ]);
    });

    it('should default to ASC when order is missing for multi-sort', () => {
      const result = parseSort({ field: 'name,createdAt', order: 'DESC' });
      expect(result).toEqual([
        {
          property: 'name',
          descending: true
        },
        {
          property: 'createdAt',
          descending: false
        }
      ]);
    });

    it('should trim whitespace from field names', () => {
      const result = parseSort({ field: 'name , createdAt , updatedAt', order: 'ASC,DESC,ASC' });
      expect(result).toEqual([
        {
          property: 'name',
          descending: false
        },
        {
          property: 'createdAt',
          descending: true
        },
        {
          property: 'updatedAt',
          descending: false
        }
      ]);
    });

    it('should handle undefined sort parameter', () => {
      const result = parseSort(undefined);
      expect(result).toEqual([
        {
          property: 'id',
          descending: true
        }
      ]);
    });

    it('should be case-insensitive for order values', () => {
      const result = parseSort({ field: 'name,createdAt', order: 'asc,desc' });
      expect(result).toEqual([
        {
          property: 'name',
          descending: false
        },
        {
          property: 'createdAt',
          descending: true
        }
      ]);
    });
  });

  describe('parseFilters', () => {
    it('should handle inline type notation', () => {
      const result = parseFilters({ 'description.it__like': 'test' });
      expect(result).toEqual([
        {
          property: 'description.it',
          value: 'test',
          type: 'like'
        }
      ]);
    });

    it('should handle object notation', () => {
      const result = parseFilters({ name: { like: 'test' } });
      expect(result).toEqual([
        {
          property: 'name',
          value: 'test',
          type: 'like'
        }
      ]);
    });

    it('should default to eq type', () => {
      const result = parseFilters({ id: 123 });
      expect(result).toEqual([
        {
          property: 'id',
          value: 123,
          type: 'eq'
        }
      ]);
    });

    it('should skip keyword field', () => {
      const result = parseFilters({ keyword: 'search', name: 'test' });
      expect(result).toEqual([
        {
          property: 'name',
          value: 'test',
          type: 'eq'
        }
      ]);
    });

    it('should handle multiple filters', () => {
      const result = parseFilters({
        name__like: 'test',
        status__eq: 'active',
        priority: { gte: 5 }
      });
      expect(result).toEqual([
        {
          property: 'name',
          value: 'test',
          type: 'like'
        },
        {
          property: 'status',
          value: 'active',
          type: 'eq'
        },
        {
          property: 'priority',
          value: 5,
          type: 'gte'
        }
      ]);
    });

    it('should return empty array for undefined filter', () => {
      const result = parseFilters(undefined);
      expect(result).toEqual([]);
    });

    it('should return empty array for null filter', () => {
      const result = parseFilters(null);
      expect(result).toEqual([]);
    });
  });
});