immutable-transform-matrix/dist/index.spec.js

A matrix library using ImmutableJS data structutes

'use strict';

var _index = require('../src/index.js');

var _index2 = _interopRequireDefault(_index);

var _immutable = require('immutable');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _global = global,
    describe = _global.describe,
    it = _global.it,
    expect = _global.expect;


var mockMatrix = new _index2.default(1, 2, 3, 4, 5, 6);

describe('constructor', function () {
  it('should extend an Immutable Map', function () {
    var matrix = mockMatrix;
    expect(matrix instanceof _immutable.Map).toBe(true);
  });

  it('should create an identity Matrix', function () {
    var matrix = new _index2.default();
    expect(matrix.get('a')).toBe(1);
    expect(matrix.get('b')).toBe(0);
    expect(matrix.get('c')).toBe(0);
    expect(matrix.get('d')).toBe(1);
    expect(matrix.get('e')).toBe(0);
    expect(matrix.get('f')).toBe(0);
  });

  it('should create the specified Matrix', function () {
    var matrix = mockMatrix;
    expect(matrix.get('a')).toBe(1);
    expect(matrix.get('b')).toBe(2);
    expect(matrix.get('c')).toBe(3);
    expect(matrix.get('d')).toBe(4);
    expect(matrix.get('e')).toBe(5);
    expect(matrix.get('f')).toBe(6);
  });
});

describe('scale', function () {
  it('should scale the Matrix', function () {
    var matrix = mockMatrix.scale(2, 3);
    expect(matrix.get('a')).toBe(2);
    expect(matrix.get('b')).toBe(4);
    expect(matrix.get('c')).toBe(9);
    expect(matrix.get('d')).toBe(12);
    expect(matrix.get('e')).toBe(5);
    expect(matrix.get('f')).toBe(6);
  });

  it('should scale the Matrix', function () {
    var matrix = mockMatrix.scale(2);
    expect(matrix.get('a')).toBe(2);
    expect(matrix.get('b')).toBe(4);
    expect(matrix.get('c')).toBe(6);
    expect(matrix.get('d')).toBe(8);
    expect(matrix.get('e')).toBe(5);
    expect(matrix.get('f')).toBe(6);
  });
});

describe('translate', function () {
  it('should translate the Matrix', function () {
    var matrix = mockMatrix.translate(2, 4);
    expect(matrix.get('a')).toBe(1);
    expect(matrix.get('b')).toBe(2);
    expect(matrix.get('c')).toBe(3);
    expect(matrix.get('d')).toBe(4);
    expect(matrix.get('e')).toBe(19);
    expect(matrix.get('f')).toBe(26);
  });
});

describe('rotate', function () {
  it('should rotate the Matrix', function () {
    var matrix = mockMatrix.rotate(1);
    expect(matrix.get('a')).toBe(3.064715260291829);
    expect(matrix.get('b')).toBe(4.4464885509678655);
    expect(matrix.get('c')).toBe(0.7794359327965228);
    expect(matrix.get('d')).toBe(0.47826725385676605);
    expect(matrix.get('e')).toBe(5);
    expect(matrix.get('f')).toBe(6);
  });
});

describe('rotateDeg', function () {
  it('should rotate the Matrix', function () {
    var matrix = mockMatrix.rotateDeg(180);
    expect(matrix.get('a')).toBe(-0.9999999999999997);
    expect(matrix.get('b')).toBe(-1.9999999999999996);
    expect(matrix.get('c')).toBe(-3);
    expect(matrix.get('d')).toBe(-4);
    expect(matrix.get('e')).toBe(5);
    expect(matrix.get('f')).toBe(6);
  });
});

describe('multiply', function () {
  it('should multiply the Matrix', function () {
    var matrix = mockMatrix.multiply(mockMatrix);
    expect(matrix.get('a')).toBe(7);
    expect(matrix.get('b')).toBe(10);
    expect(matrix.get('c')).toBe(15);
    expect(matrix.get('d')).toBe(22);
    expect(matrix.get('e')).toBe(28);
    expect(matrix.get('f')).toBe(40);
  });
});

describe('isIdentity', function () {
  expect(mockMatrix.isIdentity()).toBe(false);
  expect(new _index2.default().isIdentity()).toBe(true);
});

describe('toString', function () {
  it('should return a matrix string', function () {
    var str = mockMatrix.toString();
    expect(str).toBe('matrix(1,2,3,4,5,6)');

    str = new _index2.default(6, 5, 4, 3, 2, 1).toString();
    expect(str).toBe('matrix(6,5,4,3,2,1)');
  });
});

describe('determinant', function () {
  expect(mockMatrix.determinant()).toBe(-2);
  expect(new _index2.default().determinant()).toBe(1);
  expect(new _index2.default(1, 1, 1, 1, 0, 0).determinant()).toBe(0);
});

describe('isInvertable', function () {
  expect(mockMatrix.isInvertible()).toBe(true);
  expect(new _index2.default().isInvertible()).toBe(true);
  expect(new _index2.default(1, 1, 1, 1, 0, 0).isInvertible()).toBe(false);
});

describe('inverse', function () {
  var mockMatrixInverted = new _index2.default(-2, 1, 1.5, -0.5, 1, -2);

  expect(mockMatrix.inverse().equals(mockMatrixInverted)).toBe(true);
  expect(new _index2.default().inverse().equals(new _index2.default())).toBe(true);
  expect(function () {
    new _index2.default(1, 1, 1, 1, 0, 0).inverse();
  }).toThrow();
});

describe('divide', function () {
  it('should divide the matrix', function () {
    var test1 = mockMatrix.divide(mockMatrix).isIdentity();
    expect(test1).toBe(true);

    var test2 = mockMatrix.divide(new _index2.default()).equals(mockMatrix);
    expect(test2).toBe(true);
  });

  it('should throw an Error', function () {
    expect(function () {
      mockMatrix.divide(5);
    }).toThrow();

    expect(function () {
      mockMatrix.divide(new _index2.default(1, 1, 1, 1, 0, 0));
    }).toThrow();
  });
});

describe('#applyToPoint', function () {
  it('should compute the dot product and return a plain object', function () {
    var x = 5;
    var y = 6;
    expect(new _index2.default().applyToPoint(x, y)).toEqual({ x: x, y: y });
  });
});

describe('fromCTM', function () {
  it('should return a new Matrix', function () {
    var actual = _index2.default.fromCTM({
      a: 1,
      b: 2,
      c: 3,
      d: 4,
      e: 5,
      f: 6
    });
    var expected = new _index2.default(1, 2, 3, 4, 5, 6);
    expect(actual).toEqual(expected);
  });
});