8000 Use javascript import syntax in tests by leebyron · Pull Request #750 · immutable-js/immutable-js · GitHub
[go: up one dir, main page]
Skip to content

Use javascript import syntax in tests #750

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jan 8, 2016
Merged

Use javascript import syntax in tests #750

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
36 changes: 18 additions & 18 deletions __tests__/ArraySeq.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,38 +2,38 @@
///<reference path='../dist/immutable.d.ts'/>
jest.autoMockOff();

import Immutable = require('immutable');
import { Seq } from 'immutable';

describe('ArraySequence', () => {

it('every is true when predicate is true for all entries', () => {
expect(Immutable.Seq([]).every(() => false)).toBe(true);
expect(Immutable.Seq([1,2,3]).every(v => v > 0)).toBe(true);
expect(Immutable.Seq([1,2,3]).every(v => v < 3)).toBe(false);
expect(Seq([]).every(() => false)).toBe(true);
expect(Seq([1,2,3]).every(v => v > 0)).toBe(true);
expect(Seq([1,2,3]).every(v => v < 3)).toBe(false);
});

it('some is true when predicate is true for any entry', () => {
expect(Immutable.Seq([]).some(() => true)).toBe(false);
expect(Immutable.Seq([1,2,3]).some(v => v > 0)).toBe(true);
expect(Immutable.Seq([1,2,3]).some(v => v < 3)).toBe(true);
expect(Immutable.Seq([1,2,3]).some(v => v > 1)).toBe(true);
expect(Immutable.Seq([1,2,3]).some(v => v < 0)).toBe(false);
expect(Seq([]).some(() => true)).toBe(false);
expect(Seq([1,2,3]).some(v => v > 0)).toBe(true);
expect(Seq([1,2,3]).some(v => v < 3)).toBe(true);
expect(Seq([1,2,3]).some(v => v > 1)).toBe(true);
expect(Seq([1,2,3]).some(v => v < 0)).toBe(false);
});

it('maps', () => {
var i = Immutable.Seq([1,2,3]);
var i = Seq([1,2,3]);
var m = i.map(x => x + x).toObject();
expect(m).toEqual([2,4,6]);
});

it('reduces', () => {
var i = Immutable.Seq([1,2,3]);
var i = Seq([1,2,3]);
var r = i.reduce<number>((r, x) => r + x);
expect(r).toEqual(6);
});

it('efficiently chains iteration methods', () => {
var i = Immutable.Seq('abcdefghijklmnopqrstuvwxyz'.split(''));
var i = Seq('abcdefghijklmnopqrstuvwxyz'.split(''));
function studly(letter, index) {
return index % 2 === 0 ? letter : letter.toUpperCase();
}
Expand All @@ -42,7 +42,7 @@ describe('ArraySequence', () => {
});

it('counts from the end of the sequence on negative index', () => {
var i = Immutable.Seq.of(1, 2, 3, 4, 5, 6, 7);
var i = Seq.of(1, 2, 3, 4, 5, 6, 7);
expect(i.get(-1)).toBe(7);
expect(i.get(-5)).toBe(3);
expect(i.get(-9)).toBe(undefined);
Expand All @@ -52,7 +52,7 @@ describe('ArraySequence', () => {
it('handles trailing holes', () => {
var a = [1,2,3];
a.length = 10;
var seq = Immutable.Seq(a);
var seq = Seq(a);
expect(seq.size).toBe(10);
expect(seq.toArray().length).toBe(10);
expect(seq.map(x => x*x).size).toBe(10);
Expand All @@ -68,7 +68,7 @@ describe('ArraySequence', () => {

it('can be iterated', () => {
var a = [1,2,3];
var seq = Immutable.Seq(a);
var seq = Seq(a);
var entries = seq.entries();
expect(entries.next()).toEqual({ value: [0, 1], done: false });
expect(entries.next()).toEqual({ value: [1, 2], done: false });
Expand All @@ -77,10 +77,10 @@ describe('ArraySequence', () => {
});

it('cannot be mutated after calling toArray', () => {
var seq = Immutable.Seq(['A', 'B', 'C']);
var seq = Seq(['A', 'B', 'C']);

var firstReverse = Immutable.Seq(seq.toArray().reverse());
var secondReverse = Immutable.Seq(seq.toArray().reverse());
var firstReverse = Seq(seq.toArray().reverse());
var secondReverse = Seq(seq.toArray().reverse());

expect(firstReverse.get(0)).toEqual('C');
expect(secondReverse.get(0)).toEqual('C');
Expand Down
29 changes: 13 additions & 16 deletions __tests__/Conversion.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,13 +3,10 @@

jest.autoMockOff();

import jasmineCheck = require('jasmine-check');
import * as jasmineCheck from 'jasmine-check';
jasmineCheck.install();

import Immutable = require('immutable');
import Map = Immutable.Map;
import OrderedMap = Immutable.OrderedMap;
import List = Immutable.List;
import { Map, OrderedMap, List, Record, is, fromJS } from 'immutable';

declare function expect(val: any): ExpectWithIs;

Expand All @@ -23,7 +20,7 @@ describe('Conversion', () => {
beforeEach(function () {
this.addMatchers({
is: function(expected) {
return Immutable.is(this.actual, expected);
return is(this.actual, expected);
}
});
});
Expand Down Expand Up @@ -51,7 +48,7 @@ describe('Conversion', () => {
list: [1, 2, 3]
};

var Point = Immutable.Record({x:0, y:0}, 'Point');
var Point = Record({x:0, y:0}, 'Point');

var immutableData = Map({
deepList: List.of(
Expand Down Expand Up @@ -123,11 +120,11 @@ describe('Conversion', () => {
var nonStringKeyMapString = 'OrderedMap { 1: true, false: "foo" }';

it('Converts deep JS to deep immutable sequences', () => {
expect(Immutable.fromJS(js)).is(immutableData);
expect(fromJS(js)).is(immutableData);
});

it('Converts deep JSON with custom conversion', () => {
var seq = Immutable.fromJS(js, function (key, sequence) {
var seq = fromJS(js, function (key, sequence) {
if (key === 'point') {
return new Point(sequence);
}
Expand All @@ -152,25 +149,25 @@ describe('Conversion', () => {
});

it('JSON.stringify() respects toJSON methods on values', () => {
var Model = Immutable.Record({});
var Model = Record({});
Model.prototype.toJSON = function() { return 'model'; }
expect(
Immutable.Map({ a: new Model() }).toJS()
Map({ a: new Model() }).toJS()
).toEqual({ "a": {} });
expect(
JSON.stringify(Immutable.Map({ a: new Model() }))
JSON.stringify(Map({ a: new Model() }))
).toEqual('{"a":"model"}');
});

it('is conservative with array-likes, only accepting true Arrays.', () => {
expect(Immutable.fromJS({1: 2, length: 3})).is(
Immutable.Map().set('1', 2).set('length', 3)
expect(fromJS({1: 2, length: 3})).is(
Map().set('1', 2).set('length', 3)
);
expect(Immutable.fromJS('string')).toEqual('string');
expect(fromJS('string')).toEqual('string');
});

check.it('toJS isomorphic value', {maxSize: 30}, [gen.JSONValue], (js) => {
var imm = Immutable.fromJS(js);
var imm = fromJS(js);
expect(imm && imm.toJS ? imm.toJS() : imm).toEqual(js);
});

Expand Down
42 changes: 21 additions & 21 deletions __tests__/Equality.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,24 +3,24 @@

jest.autoMockOff();

import jasmineCheck = require('jasmine-check');
import * as jasmineCheck from 'jasmine-check';
jasmineCheck.install();

import Immutable = require('immutable');
import { List, Map, Set, Seq, is } from 'immutable';

describe('Equality', () => {

function expectIs(left, right) {
var comparison = Immutable.is(left, right);
var comparison = is(left, right);
expect(comparison).toBe(true);
var commutative = Immutable.is(right, left);
var commutative = is(right, left);
expect(commutative).toBe(true);
}

function expectIsNot(left, right) {
var comparison = Immutable.is(left, right);
var comparison = is(left, right);
expect(comparison).toBe(false);
var commutative = Immutable.is(right, left);
var commutative = is(right, left);
expect(commutative).toBe(false);
}

Expand All @@ -38,7 +38,7 @@ describe('Equality', () => {
expectIs(NaN, NaN);
expectIs(0, 0);
expectIs(-0, -0);
// Note: Unlike Object.is, Immutable.is assumes 0 and -0 are the same value,
// Note: Unlike Object.is, is assumes 0 and -0 are the same value,
// matching the behavior of ES6 Map key equality.
expectIs(0, -0);
expectIs(NaN, 0/0);
Expand Down Expand Up @@ -88,12 +88,12 @@ describe('Equality', () => {
});

it('compares sequences', () => {
var arraySeq = Immutable.Seq.of(1,2,3);
var arraySeq2 = Immutable.Seq([1,2,3]);
var arraySeq = Seq.of(1,2,3);
var arraySeq2 = Seq([1,2,3]);
expectIs(arraySeq, arraySeq);
expectIs(arraySeq, Immutable.Seq.of(1,2,3));
expectIs(arraySeq, Seq.of(1,2,3));
expectIs(arraySeq2, arraySeq2);
expectIs(arraySeq2, Immutable.Seq([1,2,3]));
expectIs(arraySeq2, Seq([1,2,3]));
expectIsNot(arraySeq, [1,2,3]);
expectIsNot(arraySeq2, [1,2,3]);
expectIs(arraySeq, arraySeq2);
Expand All @@ -102,12 +102,12 @@ describe('Equality', () => {
});

it('compares lists', () => {
var list = Immutable.List.of(1,2,3);
var list = List.of(1,2,3);
expectIs(list, list);
expectIsNot(list, [1,2,3]);

expectIs(list, Immutable.Seq.of(1,2,3));
expectIs(list, Immutable.List.of(1,2,3));
expectIs(list, Seq.of(1,2,3));
expectIs(list, List.of(1,2,3));

var listLonger = list.push(4);
expectIsNot(list, listLonger);
Expand All @@ -119,17 +119,17 @@ describe('Equality', () => {
var genSimpleVal = gen.returnOneOf(['A', 1]);

var genVal = gen.oneOf([
gen.map(Immutable.List, gen.array(genSimpleVal, 0, 4)),
gen.map(Immutable.Set, gen.array(genSimpleVal, 0, 4)),
gen.map(Immutable.Map, gen.array(gen.array(genSimpleVal, 2), 0, 4))
gen.map(List, gen.array(genSimpleVal, 0, 4)),
gen.map(Set, gen.array(genSimpleVal, 0, 4)),
gen.map(Map, gen.array(gen.array(genSimpleVal, 2), 0, 4))
]);

check.it('has symmetric equality', {times: 1000}, [genVal, genVal], (a, b) => {
expect(Immutable.is(a, b)).toBe(Immutable.is(b, a));
expect(is(a, b)).toBe(is(b, a));
});

check.it('has hash equality', {times: 1000}, [genVal, genVal], (a, b) => {
if (Immutable.is(a, b)) {
if (is(a, b)) {
expect(a.hashCode()).toBe(b.hashCode());
}
});
Expand All @@ -138,9 +138,9 @@ describe('Equality', () => {

it('differentiates decimals', () => {
expect(
Immutable.Seq.of(1.5).hashCode()
Seq.of(1.5).hashCode()
).not.toBe(
Immutable.Seq.of(1.6).hashCode()
Seq.of(1.6).hashCode()
);
});

Expand Down
8 changes: 4 additions & 4 deletions __tests__/IndexedSeq.ts
View file
Open in desktop
9B8D
Original file line number Diff line number Diff line change
Expand Up @@ -2,15 +2,15 @@
///<reference path='../dist/immutable.d.ts'/>
jest.autoMockOff();

import jasmineCheck = require('jasmine-check');
import * as jasmineCheck from 'jasmine-check';
jasmineCheck.install();

import Immutable = require('immutable');
import { Seq } from 'immutable';

describe('IndexedSequence', () => {

it('maintains skipped offset', () => {
var seq = Immutable.Seq(['A', 'B', 'C', 'D', 'E']);
var seq = Seq(['A', 'B', 'C', 'D', 'E']);

// This is what we expect for IndexedSequences
var operated = seq.skip(1);
Expand All @@ -25,7 +25,7 @@ describe('IndexedSequence', () => {
});

it('reverses correctly', () => {
var seq = Immutable.Seq(['A', 'B', 'C', 'D', 'E']);
var seq = Seq(['A', 'B', 'C', 'D', 'E']);

// This is what we expect for IndexedSequences
var operated = seq.reverse();
Expand Down
Loading
0