Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

15.5 KB
Raw Blame
import util from './util';

// Mock dependencies
jest.mock('./browser', () => ({ isMobile: false }));
jest.mock('./events', () => ({ on: jest.fn(), off: jest.fn() }));
jest.mock('./load', () => jest.fn());
jest.mock('./local-storage', () => ({
  keys: { COORDINATE_FORMAT: 'COORDINATE_FORMAT' },
  getItem: jest.fn(),
  setItem: jest.fn(),
}));

import safeLocalStorage from './local-storage';

describe('util', () => {
  describe('repeat', () => {
    it('repeats value n times', () => expect(util.repeat('x', 3)).toBe('xxx'));
    it('returns empty string for length 0', () => expect(util.repeat('x', 0)).toBe(''));
  });

  describe('pad', () => {
    it('pads string to given width', () => expect(util.pad('5', 3, '0')).toBe('005'));
    it('does not pad if already at width', () => expect(util.pad('123', 3, '0')).toBe('123'));
    it('converts number to string', () => expect(util.pad(7, 2, '0')).toBe('07'));
  });

  describe('fromQueryString', () => {
    it('parses query string', () => expect(util.fromQueryString('?foo=a&bar=b')).toEqual({ foo: 'a', bar: 'b' }));
    it('returns empty object for empty string', () => expect(util.fromQueryString('')).toEqual({}));
    it('decodes URI components', () => expect(util.fromQueryString('?path=%2Ffoo')).toEqual({ path: '/foo' }));
    it('handles string without leading ?', () => expect(util.fromQueryString('foo=a')).toEqual({ foo: 'a' }));
  });

  describe('toQueryString', () => {
    it('converts object to query string', () => expect(util.toQueryString({ foo: 'a', bar: 'b' })).toBe('?foo=a&bar=b'));
    it('returns empty string for empty object', () => expect(util.toQueryString({})).toBe(''));
    it('skips falsy values', () => expect(util.toQueryString({ foo: 'a', bar: null })).toBe('?foo=a'));
    it('applies exceptions', () => expect(util.toQueryString({ format: 'image/png' }, ['%2F'])).toBe('?format=image/png'));
  });

  describe('parseDateUTC', () => {
    it('parses YYYY-MM-DD', () => {
      const d = util.parseDateUTC('2020-01-15');
      expect(d.getUTCFullYear()).toBe(2020);
      expect(d.getUTCMonth()).toBe(0);
      expect(d.getUTCDate()).toBe(15);
    });
    it('parses YYYY-MM-DDTHH:MM:SS', () => {
      const d = util.parseDateUTC('2020-06-01T12:30:45');
      expect(d.getUTCHours()).toBe(12);
      expect(d.getUTCMinutes()).toBe(30);
      expect(d.getUTCSeconds()).toBe(45);
    });
    it('throws on invalid date', () => {
      expect(() => util.parseDateUTC('not-a-date')).toThrow();
    });
  });

  describe('parseTimestampUTC', () => {
    it('delegates to parseDateUTC', () => {
      const d = util.parseTimestampUTC('2021-03-10T00:00:00Z');
      expect(d.getUTCFullYear()).toBe(2021);
    });
  });

  describe('appendAttributesForURL', () => {
    it('returns id with no attributes', () => expect(util.appendAttributesForURL({ id: 'layer1', attributes: [] })).toBe('layer1'));
    it('appends attributes', () => expect(util.appendAttributesForURL({ id: 'layer1', attributes: [{ id: 'style', value: 'red' }] })).toBe('layer1(style=red)'));
    it('appends attribute without value', () => expect(util.appendAttributesForURL({ id: 'layer1', attributes: [{ id: 'flag' }] })).toBe('layer1(flag)'));
    it('returns empty string for non-object', () => expect(util.appendAttributesForURL('not-an-object')).toBe(''));
  });

  describe('toISOStringDate', () => {
    it('returns YYYY-MM-DD from date', () => expect(util.toISOStringDate(new Date('2020-05-10T00:00:00Z'))).toBe('2020-05-10'));
    it('returns YYYY-MM-DD from string', () => expect(util.toISOStringDate('2020-05-10T00:00:00Z')).toBe('2020-05-10'));
  });

  describe('toISOStringSeconds', () => {
    it('returns ISO string without milliseconds', () => expect(util.toISOStringSeconds(new Date('2020-05-10T12:30:45.123Z'))).toBe('2020-05-10T12:30:45Z'));
    it('clears time when shouldRemoveTime is true', () => expect(util.toISOStringSeconds(new Date('2020-05-10T12:30:45Z'), true)).toBe('2020-05-10T00:00:00Z'));
  });

  describe('clearTimeUTC', () => {
    it('sets UTC time to midnight', () => {
      const d = util.clearTimeUTC(new Date('2020-05-10T15:30:00Z'));
      expect(d.getUTCHours()).toBe(0);
      expect(d.getUTCMinutes()).toBe(0);
      expect(d.getUTCSeconds()).toBe(0);
    });
  });

  describe('dateAdd', () => {
    const base = new Date('2020-01-15T12:00:00Z');
    it('adds minutes', () => expect(util.dateAdd(base, 'minute', 30).getUTCMinutes()).toBe(30));
    it('adds hours', () => expect(util.dateAdd(base, 'hour', 3).getUTCHours()).toBe(15));
    it('adds days', () => expect(util.dateAdd(base, 'day', 5).getUTCDate()).toBe(20));
    it('adds months', () => expect(util.dateAdd(base, 'month', 2).getUTCMonth()).toBe(2));
    it('adds years', () => expect(util.dateAdd(base, 'year', 1).getUTCFullYear()).toBe(2021));
    it('throws on invalid interval', () => expect(() => util.dateAdd(base, 'week', 1)).toThrow());
  });

  describe('clamp', () => {
    it('returns value when in range', () => expect(util.clamp(5, 1, 10)).toBe(5));
    it('returns min when below', () => expect(util.clamp(-1, 0, 10)).toBe(0));
    it('returns max when above', () => expect(util.clamp(15, 0, 10)).toBe(10));
  });

  describe('cleanId', () => {
    it('replaces non-word chars with underscores', () => expect(util.cleanId('foo bar.baz')).toBe('foo_bar_baz'));
  });

  describe('encodeId / decodeId', () => {
    it('encodes special characters', () => expect(util.encodeId('foo.bar:baz,qux')).toBe('foo__2E__bar__3A__baz__2C__qux'));
    it('decodes back to original', () => expect(util.decodeId(util.encodeId('foo.bar:baz'))).toBe('foo.bar:baz'));
  });

  describe('hexToRGB', () => {
    it('converts hex to rgb string', () => expect(util.hexToRGB('ff0080')).toBe('rgb(255,0,128)'));
  });

  describe('hexToRGBA', () => {
    it('converts hex to rgba string', () => expect(util.hexToRGBA('ff008080')).toBe('rgba(255,0,128,128)'));
  });

  describe('rgbaToHex', () => {
    it('converts rgb to hex string', () => expect(util.rgbaToHex(255, 0, 128)).toBe('ff0080ff'));
  });

  describe('hexColorDelta', () => {
    it('returns 0 for identical colors', () => expect(util.hexColorDelta('ff0000', 'ff0000')).toBe(0));
    it('returns non-zero for different colors', () => expect(util.hexColorDelta('ff0000', '0000ff')).toBeGreaterThan(0));
  });

  describe('objectLength', () => {
    it('returns number of keys', () => expect(util.objectLength({ a: 1, b: 2 })).toBe(2));
    it('returns 0 for empty object', () => expect(util.objectLength({})).toBe(0));
  });

  describe('giveWeekDay', () => {
    it('returns correct day name', () => expect(util.giveWeekDay(new Date('2020-01-06T00:00:00Z'))).toBe('Monday'));
  });

  describe('giveMonth', () => {
    it('returns correct month name', () => expect(util.giveMonth(new Date('2020-06-01T00:00:00Z'))).toBe('June'));
  });

  describe('daysInYear', () => {
    it('returns Julian day as 3-char string', () => expect(util.daysInYear(new Date('2020-01-01T00:00:00Z'))).toBe('001'));
    it('returns correct day for non-first day', () => expect(util.daysInYear(new Date('2020-02-01T00:00:00Z'))).toBe('032'));
  });

  describe('format', () => {
    it('replaces placeholders', () => expect(util.format('Hello {1} and {2}', 'World', 'Moon')).toBe('Hello World and Moon'));
  });

  describe('toArray', () => {
    it('wraps non-array in array', () => expect(util.toArray('foo')).toEqual(['foo']));
    it('returns array as-is', () => expect(util.toArray([1, 2])).toEqual([1, 2]));
    it('returns empty array for falsy', () => expect(util.toArray(null)).toEqual([]));
  });

  describe('stringInArray', () => {
    it('returns index when found', () => expect(util.stringInArray(['a', 'b', 'c'], 'b')).toBe(1));
    it('returns false when not found', () => expect(util.stringInArray(['a', 'b'], 'z')).toBe(false));
  });

  describe('closestToIndex', () => {
    it('returns index of closest date', () => {
      const dates = [new Date('2020-01-01'), new Date('2020-06-01'), new Date('2020-12-01')];
      expect(util.closestToIndex(dates, new Date('2020-05-15').getTime())).toBe(1);
    });
  });

  describe('yearDiff', () => {
    it('returns year difference', () => expect(util.yearDiff(new Date('2015-01-01'), new Date('2020-01-01'))).toBe(5));
  });

  describe('monthDiff', () => {
    it('returns month difference', () => expect(util.monthDiff(new Date('2020-02-01'), new Date('2020-08-01'))).toBe(6));
  });

  describe('dayDiff', () => {
    it('returns day difference', () => expect(util.dayDiff(new Date('2020-01-01'), new Date('2020-01-11'))).toBe(10));
  });

  describe('minuteDiff', () => {
    it('returns minute difference', () => expect(util.minuteDiff(new Date('2020-01-01T00:00:00Z'), new Date('2020-01-01T01:00:00Z'))).toBe(60));
  });

  describe('normalizeWrappedLongitude', () => {
    it('returns unchanged value within -180 to 180', () => expect(util.normalizeWrappedLongitude(90)).toBe(90));
    it('normalizes value above 180', () => expect(util.normalizeWrappedLongitude(270)).toBe(-90));
    it('normalizes value below -180', () => expect(util.normalizeWrappedLongitude(-270)).toBe(90));
  });

  describe('getUTCNumbers', () => {
    it('returns prefixed UTC date parts', () => {
      const result = util.getUTCNumbers(new Date('2020-06-15T10:30:00Z'), 'min');
      expect(result).toMatchObject({
        minYear: 2020,
        minMonth: 5,
        minDay: 15,
        minHour: 10,
        minMinute: 30,
      });
    });
  });

  describe('getTimezoneOffsetDate', () => {
    it('returns offset date', () => {
      const d = new Date('2020-01-01T00:00:00Z');
      const result = util.getTimezoneOffsetDate(d);
      expect(result.getTime()).toBe(d.getTime() - d.getTimezoneOffset() * 60000);
    });
  });

  describe('roundTimeOneMinute', () => {
    it('rounds seconds up to next minute', () => {
      const d = new Date('2020-01-01T00:00:45.000Z');
      const result = util.roundTimeOneMinute(d);
      expect(result.getUTCSeconds()).toBe(0);
    });
  });

  describe('roundTimeQuarterHour', () => {
    it('rounds minutes to nearest quarter', () => {
      const d = new Date('2020-01-01T00:07:00.000Z');
      const result = util.roundTimeQuarterHour(d);
      expect(result.getUTCMinutes() % 15).toBe(0);
    });
  });

  describe('setCoordinateFormat / getCoordinateFormat', () => {
    it('sets valid format', () => {
      util.setCoordinateFormat('latlon-dms');
      expect(safeLocalStorage.setItem).toHaveBeenCalledWith('COORDINATE_FORMAT', 'latlon-dms');
    });
    it('throws on invalid format', () => {
      expect(() => util.setCoordinateFormat('invalid')).toThrow();
    });
    it('returns stored format', () => {
      safeLocalStorage.getItem.mockReturnValue('latlon-dms');
      expect(util.getCoordinateFormat()).toBe('latlon-dms');
    });
    it('defaults to latlon-dd when no stored value', () => {
      safeLocalStorage.getItem.mockReturnValue(null);
      expect(util.getCoordinateFormat()).toBe('latlon-dd');
    });
  });

  describe('formatCoordinate', () => {
    it('formats as decimal degrees by default', () => {
      safeLocalStorage.getItem.mockReturnValue(null);
      expect(util.formatCoordinate([10.1234, 20.5678])).toBe('20.5678°, 10.1234°');
    });
    it('formats as DMS', () => {
      const result = util.formatCoordinate([0, 0], 'latlon-dms');
      expect(result).toContain('°');
    });
    it('formats as DM', () => {
      const result = util.formatCoordinate([0, 0], 'latlon-dm');
      expect(result).toContain('°');
    });
  });

  describe('now', () => {
    it('returns date approximately 40 minutes behind current time', () => {
      const before = Date.now();
      const result = util.now().getTime();
      const after = Date.now();
      const offset = 40 * 60000;
      expect(result).toBeGreaterThanOrEqual(before - offset - 100);
      expect(result).toBeLessThanOrEqual(after - offset + 100);
    });
  });

  describe('yesterday', () => {
    it('returns date one day before now', () => {
      const result = util.yesterday();
      const now = util.now();
      expect(now.getTime() - result.getTime()).toBeGreaterThanOrEqual(86400000 - 1000);
    });
  });

  describe('wrap', () => {
    it('returns function result on success', () => {
      const wrapped = util.wrap((x) => x * 2);
      expect(wrapped(5)).toBe(10);
    });
    it('catches and logs errors', () => {
      const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
      const wrapped = util.wrap(() => { throw new Error('oops'); });
      wrapped();
      expect(spy).toHaveBeenCalled();
      spy.mockRestore();
    });
  });

  describe('errorReport', () => {
    it('logs each error with cause', () => {
      const warnSpy = jest.spyOn(util, 'warn').mockImplementation(() => {});
      util.errorReport([{ message: 'Error1', cause: 'reason' }, { message: 'Error2' }]);
      expect(warnSpy).toHaveBeenCalledWith('Error1: reason');
      expect(warnSpy).toHaveBeenCalledWith('Error2');
      warnSpy.mockRestore();
    });
  });

  describe('getTextWidth', () => {
    it('returns measured text width', () => {
      const mockMeasure = jest.fn().mockReturnValue({ width: 42 });
      jest.spyOn(document, 'createElement').mockReturnValue({
        getContext: () => ({ measureText: mockMeasure, font: '' }),
      });
      expect(util.getTextWidth('hello', '14px Arial')).toBe(42);
    });
  });

  describe('earliestValidDate', () => {
    it('returns the input date if after earliest valid', () => {
      const d = new Date('2020-01-01');
      expect(util.earliestValidDate(d).getUTCFullYear()).toBe(2020);
    });
    it('returns earliest valid date if before', () => {
      const d = new Date('1900-01-01');
      expect(util.earliestValidDate(d).getUTCFullYear()).toBe(1948);
    });
  });

  describe('fetch', () => {
    it('resolves with json on application/json mimeType', async () => {
      global.fetch = jest.fn().mockResolvedValue({ json: () => Promise.resolve({ ok: true }) });
      await expect(util.fetch('/url', 'application/json')).resolves.toEqual({ ok: true });
    });
    it('resolves with text for other mimeTypes', async () => {
      global.fetch = jest.fn().mockResolvedValue({ text: () => Promise.resolve('raw') });
      await expect(util.fetch('/url', 'text/plain')).resolves.toBe('raw');
    });
    it('rejects on fetch error', async () => {
      global.fetch = jest.fn().mockRejectedValue(new Error('fail'));
      await expect(util.fetch('/url')).rejects.toThrow('fail');
    });
  });

  describe('get', () => {
    it('resolves on 200 status', async () => {
      const mockXHR = {
        open: jest.fn(),
        send: jest.fn(),
        status: 200,
        response: 'data',
        onload: null,
        onerror: null,
      };
      jest.spyOn(global, 'XMLHttpRequest').mockImplementation(() => mockXHR);
      const promise = util.get('/url');
      mockXHR.onload();
      await expect(promise).resolves.toBe('data');
    });
    it('rejects on non-200 status', async () => {
      const mockXHR = {
        open: jest.fn(),
        send: jest.fn(),
        status: 404,
        statusText: 'Not Found',
        onload: null,
        onerror: null,
      };
      jest.spyOn(global, 'XMLHttpRequest').mockImplementation(() => mockXHR);
      const promise = util.get('/url');
      mockXHR.onload();
      await expect(promise).rejects.toThrow('Not Found');
    });
    it('rejects on network error', async () => {
      const mockXHR = {
        open: jest.fn(),
        send: jest.fn(),
        onload: null,
        onerror: null,
      };
      jest.spyOn(global, 'XMLHttpRequest').mockImplementation(() => mockXHR);
      const promise = util.get('/url');
      mockXHR.onerror();
      await expect(promise).rejects.toThrow('Network Error');
    });
  });
});