253 lines
9.3 KiB
TypeScript
253 lines
9.3 KiB
TypeScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
import RNUtils from '@mattermost/rnutils';
|
|
|
|
import {IMAGE_MAX_HEIGHT, IMAGE_MIN_DIMENSION} from '@constants/image';
|
|
|
|
import {
|
|
calculateDimensions,
|
|
getViewPortWidth,
|
|
isGifTooLarge,
|
|
} from './index';
|
|
|
|
jest.mock('@mattermost/rnutils', () => ({
|
|
getWindowDimensions: jest.fn(() => ({width: 800, height: 600})),
|
|
}));
|
|
|
|
jest.mock('@constants/image', () => ({
|
|
IMAGE_MAX_HEIGHT: 800,
|
|
IMAGE_MIN_DIMENSION: 50,
|
|
MAX_GIF_SIZE: 1000000,
|
|
VIEWPORT_IMAGE_OFFSET: 20,
|
|
VIEWPORT_IMAGE_REPLY_OFFSET: 40,
|
|
}));
|
|
|
|
jest.mock('@constants', () => ({
|
|
View: {
|
|
TABLET_SIDEBAR_WIDTH: 100,
|
|
},
|
|
}));
|
|
|
|
describe('calculateDimensions', () => {
|
|
it('should return 0 dimensions when height and width are not provided', () => {
|
|
const result = calculateDimensions();
|
|
expect(result).toEqual({height: 0, width: 0});
|
|
});
|
|
|
|
it('should return correct dimensions when width exceeds viewport width', () => {
|
|
const result = calculateDimensions(200, 400, 300);
|
|
expect(result).toEqual({height: 150, width: 300});
|
|
});
|
|
|
|
it('should assign imageHeight as IMAGE_MAX_HEIGHT when imageHeight exceeds IMAGE_MAX_HEIGHT and viewPortHeight is undefined', () => {
|
|
const result = calculateDimensions(900, 400, 600);
|
|
expect(result).toEqual({
|
|
height: IMAGE_MAX_HEIGHT,
|
|
width: IMAGE_MAX_HEIGHT * (400 / 900),
|
|
});
|
|
});
|
|
|
|
it('should return minimum dimensions when width is less than IMAGE_MIN_DIMENSION', () => {
|
|
const result = calculateDimensions(20, 30, 100);
|
|
expect(result).toEqual({height: 50, width: 75});
|
|
});
|
|
|
|
it('should return correct dimensions when height exceeds IMAGE_MAX_HEIGHT', () => {
|
|
const result = calculateDimensions(900, 500, 600, 700);
|
|
expect(result).toEqual({height: 700, width: 388.8888888888889});
|
|
});
|
|
|
|
it('should return minimum dimensions when height is less than IMAGE_MIN_DIMENSION', () => {
|
|
const result = calculateDimensions(30, 40, 100);
|
|
expect(result).toEqual({height: 50, width: 66.66666666666666});
|
|
});
|
|
|
|
it('should assign imageHeight as viewPortHeight when imageHeight exceeds viewPortHeight and viewPortHeight is less than IMAGE_MAX_HEIGHT', () => {
|
|
const result = calculateDimensions(900, 400, 600, 700);
|
|
expect(result).toEqual({
|
|
height: 700,
|
|
width: 700 * (400 / 900),
|
|
});
|
|
});
|
|
|
|
it('should assign imageHeight and imageWidth based on IMAGE_MIN_DIMENSION when imageHeight is less than IMAGE_MIN_DIMENSION and fits within viewPortWidth', () => {
|
|
const result = calculateDimensions(20, 40, 100);
|
|
expect(result).toEqual({
|
|
height: 50,
|
|
width: 50 * (40 / 20),
|
|
});
|
|
});
|
|
|
|
it('should assign imageHeight and imageWidth based on viewPortHeight when imageHeight exceeds viewPortHeight', () => {
|
|
const result = calculateDimensions(600, 400, 500, 300);
|
|
expect(result).toEqual({
|
|
height: 300,
|
|
width: 300 * (400 / 600),
|
|
});
|
|
});
|
|
|
|
it('should assign imageHeight and imageWidth based on viewPortHeight when imageHeight exceeds viewPortHeight and previous conditions are not met', () => {
|
|
const result = calculateDimensions(1700, 900, 1000, 900);
|
|
expect(result).toEqual({
|
|
height: 900,
|
|
width: 900 * (900 / 1700),
|
|
});
|
|
});
|
|
|
|
it('should handle negative image dimensions gracefully', () => {
|
|
const result = calculateDimensions(-100, -200, 300);
|
|
expect(result.height).toBeGreaterThanOrEqual(0);
|
|
expect(result.width).toBeGreaterThanOrEqual(0);
|
|
});
|
|
|
|
it('should handle zero viewport width', () => {
|
|
const result = calculateDimensions(100, 200, 0);
|
|
expect(result).toEqual({height: 0, width: 0});
|
|
});
|
|
|
|
it('should handle square images', () => {
|
|
const result = calculateDimensions(100, 100, 50);
|
|
expect(result).toEqual({height: 50, width: 50});
|
|
});
|
|
|
|
it('should handle extremely large images', () => {
|
|
const result = calculateDimensions(10000, 5000, 1000, 800);
|
|
expect(result.height).toBeLessThanOrEqual(800);
|
|
expect(result.width).toBeLessThanOrEqual(1000);
|
|
});
|
|
|
|
it('should handle extremely small images', () => {
|
|
const result = calculateDimensions(1, 1, 100);
|
|
expect(result.height).toBeGreaterThanOrEqual(IMAGE_MIN_DIMENSION);
|
|
expect(result.width).toBeGreaterThanOrEqual(IMAGE_MIN_DIMENSION);
|
|
});
|
|
|
|
it('should handle when only width is provided', () => {
|
|
const result = calculateDimensions(undefined, 200, 300);
|
|
expect(result).toEqual({height: 0, width: 0});
|
|
});
|
|
|
|
it('should handle when only height is provided', () => {
|
|
const result = calculateDimensions(200, undefined, 300);
|
|
expect(result).toEqual({height: 0, width: 0});
|
|
});
|
|
|
|
it('should handle when all parameters are undefined', () => {
|
|
const result = calculateDimensions(undefined, undefined, undefined, undefined);
|
|
expect(result).toEqual({height: 0, width: 0});
|
|
});
|
|
|
|
it('should fit portrait image to viewport height when matchViewPort is true', () => {
|
|
const result = calculateDimensions(800, 400, 600, 900, true);
|
|
expect(result.height).toBe(900);
|
|
expect(result.width).toBe(450);
|
|
});
|
|
|
|
it('should fit landscape image to viewport width when matchViewPort is true', () => {
|
|
const result = calculateDimensions(400, 800, 600, 900, true);
|
|
expect(result.width).toBe(600);
|
|
expect(result.height).toBe(300);
|
|
});
|
|
|
|
it('should fit square image to viewport width when matchViewPort is true', () => {
|
|
const result = calculateDimensions(500, 500, 300, 700, true);
|
|
expect(result.width).toBe(300);
|
|
expect(result.height).toBe(300);
|
|
});
|
|
|
|
it('should not fit to viewport if matchViewPort is false', () => {
|
|
const result = calculateDimensions(800, 400, 600, 900, false);
|
|
expect(result.height).not.toBe(900);
|
|
expect(result.width).not.toBe(450);
|
|
});
|
|
|
|
it('should handle when viewPortHeight is 0', () => {
|
|
const result = calculateDimensions(800, 400, 600, 0, true);
|
|
expect(result.height).not.toBe(0);
|
|
expect(result.width).not.toBe(0);
|
|
});
|
|
|
|
it('should handle when matchViewPort is true and image is smaller than viewport', () => {
|
|
const result = calculateDimensions(100, 80, 300, 300, true);
|
|
expect(result.width).toBe(240);
|
|
expect(result.height).toBe(300);
|
|
});
|
|
|
|
it('should handle when matchViewPort is true and image is square', () => {
|
|
const result = calculateDimensions(100, 100, 200, 300, true);
|
|
expect(result.width).toBe(200);
|
|
expect(result.height).toBe(200);
|
|
});
|
|
|
|
it('should handle when matchViewPort is true and image is wider than tall', () => {
|
|
const result = calculateDimensions(100, 200, 150, 300, true);
|
|
expect(result.width).toBe(150);
|
|
expect(result.height).toBe(75);
|
|
});
|
|
|
|
it('should handle when matchViewPort is true and image is taller than wide', () => {
|
|
const result = calculateDimensions(200, 100, 150, 300, true);
|
|
expect(result.height).toBe(300);
|
|
expect(result.width).toBe(150);
|
|
});
|
|
|
|
it('should handle when matchViewPort is true and image is exactly viewport size', () => {
|
|
const result = calculateDimensions(300, 300, 300, 300, true);
|
|
expect(result.width).toBe(300);
|
|
expect(result.height).toBe(300);
|
|
});
|
|
});
|
|
|
|
describe('getViewPortWidth', () => {
|
|
beforeEach(() => {
|
|
(RNUtils.getWindowDimensions as jest.Mock).mockReturnValue({width: 800, height: 600});
|
|
});
|
|
|
|
it('should calculate viewport width for normal post', () => {
|
|
const result = getViewPortWidth(false);
|
|
expect(result).toBe(580);
|
|
});
|
|
|
|
it('should calculate viewport width for reply post', () => {
|
|
const result = getViewPortWidth(true);
|
|
expect(result).toBe(540);
|
|
});
|
|
|
|
it('should calculate viewport width for tablet offset', () => {
|
|
const result = getViewPortWidth(false, true);
|
|
expect(result).toBe(480);
|
|
});
|
|
|
|
it('should calculate viewport width for reply post with tablet offset', () => {
|
|
const result = getViewPortWidth(true, true);
|
|
expect(result).toBe(440);
|
|
});
|
|
});
|
|
|
|
describe('isGifTooLarge', () => {
|
|
it('should return false if image is not a gif', () => {
|
|
const result = isGifTooLarge({format: 'jpg', frame_count: 1, height: 500, width: 500});
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('should return false if image metadata is undefined', () => {
|
|
const result = isGifTooLarge(undefined);
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('should return true if gif is too large', () => {
|
|
const result = isGifTooLarge({format: 'gif', frame_count: 100, height: 1000, width: 1000});
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('should return false if gif is not too large', () => {
|
|
const result = isGifTooLarge({format: 'gif', frame_count: 10, height: 100, width: 100});
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('should return false if gif does not specify frame count', () => {
|
|
const result = isGifTooLarge({format: 'gif', height: 100, width: 100});
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|