8000 Merge pull request #750 from facebook/es6-ts · githubsheng/immutable-js@b4ef6da · GitHub
[go: up one dir, main page]
Skip to content

Commit b4ef6da

Browse files
leebyronleebyron
committed
Merge pull request immutable-js#750 from facebook/es6-ts
Use javascript import syntax in tests
2 parents 820a8a1 + 2fec9ca commit b4ef6da

31 files changed

+383
-406
lines changed

‎__tests__/ArraySeq.ts

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -2,38 +2,38 @@
22
///<reference path='../dist/immutable.d.ts'/>
33
jest.autoMockOff();
44

5-
import Immutable = require('immutable');
5+
import { Seq } from 'immutable';
66

77
describe('ArraySequence', () => {
88

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

1515
it('some is true when predicate is true for any entry', () => {
16-
expect(Immutable.Seq([]).some(() => true)).toBe(false);
17-
expect(Immutable.Seq([1,2,3]).some(v => v > 0)).toBe(true);
18-
expect(Immutable.Seq([1,2,3]).some(v => v < 3)).toBe(true);
19-
expect(Immutable.Seq([1,2,3]).some(v => v > 1)).toBe(true);
20-
expect(Immutable.Seq([1,2,3]).some(v => v < 0)).toBe(false);
16+
expect(Seq([]).some(() => true)).toBe(false);
17+
expect(Seq([1,2,3]).some(v => v > 0)).toBe(true);
18+
expect(Seq([1,2,3]).some(v => v < 3)).toBe(true);
19+
expect(Seq([1,2,3]).some(v => v > 1)).toBe(true);
20+
expect(Seq([1,2,3]).some(v => v < 0)).toBe(false);
2121
});
2222

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

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

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

4444
it('counts from the end of the sequence on negative index', () => {
45-
var i = Immutable.Seq.of(1, 2, 3, 4, 5, 6, 7);
45+
var i = Seq.of(1, 2, 3, 4, 5, 6, 7);
4646
expect(i.get(-1)).toBe(7);
4747
expect(i.get(-5)).toBe(3);
4848
expect(i.get(-9)).toBe(undefined);
@@ -52,7 +52,7 @@ describe('ArraySequence', () => {
5252
it('handles trailing holes', () => {
5353
var a = [1,2,3];
5454
a.length = 10;
55-
var seq = Immutable.Seq(a);
55+
var seq = Seq(a);
5656
expect(seq.size).toBe(10);
5757
expect(seq.toArray().length).toBe(10);
5858
expect(seq.map(x => x*x).size).toBe(10);
@@ -68,7 +68,7 @@ describe('ArraySequence', () => {
6868

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

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

82-
var firstReverse = Immutable.Seq(seq.toArray().reverse());
83-
var secondReverse = Immutable.Seq(seq.toArray().reverse());
82+
var firstReverse = Seq(seq.toArray().reverse());
83+
var secondReverse = Seq(seq.toArray().reverse());
8484

8585
expect(firstReverse.get(0)).toEqual('C');
8686
expect(secondReverse.get(0)).toEqual('C');

‎__tests__/Conversion.ts

Lines changed: 13 additions & 16 deletions
< 10000 /tr>
Original file line numberDiff line numberDiff line change
@@ -3,13 +3,10 @@
33

44
jest.autoMockOff();
55

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

9-
import Immutable = require('immutable');
10-
import Map = Immutable.Map;
11-
import OrderedMap = Immutable.OrderedMap;
12-
import List = Immutable.List;
9+
import { Map, OrderedMap, List, Record, is, fromJS } from 'immutable';
1310

1411
declare function expect(val: any): ExpectWithIs;
1512

@@ -23,7 +20,7 @@ describe('Conversion', () => {
2320
beforeEach(function () {
2421
this.addMatchers({
2522
is: function(expected) {
26-
return Immutable.is(this.actual, expected);
23+
return is(this.actual, expected);
2724
}
2825
});
2926
});
@@ -51,7 +48,7 @@ describe('Conversion', () => {
5148
list: [1, 2, 3]
5249
};
5350

54-
var Point = Immutable.Record({x:0, y:0}, 'Point');
51+
var Point = Record({x:0, y:0}, 'Point');
5552

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

125122
it('Converts deep JS to deep immutable sequences', () => {
126-
expect(Immutable.fromJS(js)).is(immutableData);
123+
expect(fromJS(js)).is(immutableData);
127124
});
128125

129126
it('Converts deep JSON with custom conversion', () => {
130-
var seq = Immutable.fromJS(js, function (key, sequence) {
127+
var seq = fromJS(js, function (key, sequence) {
131128
if (key === 'point') {
132129
return new Point(sequence);
133130
}
@@ -152,25 +149,25 @@ describe('Conversion', () => {
152149
});
153150

154151
it('JSON.stringify() respects toJSON methods on values', () => {
155-
var Model = Immutable.Record({});
152+
var Model = Record({});
156153
Model.prototype.toJSON = function() { return 'model'; }
157154
expect(
158-
Immutable.Map({ a: new Model() }).toJS()
155+
Map({ a: new Model() }).toJS()
159156
).toEqual({ "a": {} });
160157
expect(
161-
JSON.stringify(Immutable.Map({ a: new Model() }))
158+
JSON.stringify(Map({ a: new Model() }))
162159
).toEqual('{"a":"model"}');
163160
});
164161

165162
it('is conservative with array-likes, only accepting true Arrays.', () => {
166-
expect(Immutable.fromJS({1: 2, length: 3})).is(
167-
Immutable.Map().set('1', 2).set('length', 3)
163+
expect(fromJS({1: 2, length: 3})).is(
164+
Map().set('1', 2).set('length', 3)
168165
);
169-
expect(Immutable.fromJS('string')).toEqual('string');
166+
expect(fromJS('string')).toEqual('string');
170167
});
171168

172169
check.it('toJS isomorphic value', {maxSize: 30}, [gen.JSONValue], (js) => {
173-
var imm = Immutable.fromJS(js);
170+
var imm = fromJS(js);
174171
expect(imm && imm.toJS ? imm.toJS() : imm).toEqual(js);
175172
});
176173

‎__tests__/Equality.ts

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -3,24 +3,24 @@
33

44
jest.autoMockOff();
55

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

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

1111
describe('Equality', () => {
1212

1313
function expectIs(left, right) {
14-
var comparison = Immutable.is(left, right);
14+
var comparison = is(left, right);
1515
expect(comparison).toBe(true);
16-
var commutative = Immutable.is(right, left);
16+
var commutative = is(right, left);
1717
expect(commutative).toBe(true);
1818
}
1919

2020
function expectIsNot(left, right) {
21-
var comparison = Immutable.is(left, right);
21+
var comparison = is(left, right);
2222
expect(comparison).toBe(false);
23-
var commutative = Immutable.is(right, left);
23+
var commutative = is(right, left);
2424
expect(commutative).toBe(false);
2525
}
2626

@@ -38,7 +38,7 @@ describe('Equality', () => {
3838
expectIs(NaN, NaN);
3939
expectIs(0, 0);
4040
expectIs(-0, -0);
41-
// Note: Unlike Object.is, Immutable.is assumes 0 and -0 are the same value,
41+
// Note: Unlike Object.is, is assumes 0 and -0 are the same value,
4242
// matching the behavior of ES6 Map key equality.
4343
expectIs(0, -0);
4444
expectIs(NaN, 0/0);
@@ -88,12 +88,12 @@ describe('Equality', () => {
8888
});
8989

9090
it('compares sequences', () => {
91-
var arraySeq = Immutable.Seq.of(1,2,3);
92-
var arraySeq2 = Immutable.Seq([1,2,3]);
91+
var arraySeq = Seq.of(1,2,3);
92+
var arraySeq2 = Seq([1,2,3]);
9393
expectIs(arraySeq, arraySeq);
94-
expectIs(arraySeq, Immutable.Seq.of(1,2,3));
94+
expectIs(arraySeq, Seq.of(1,2,3));
9595
expectIs(arraySeq2, arraySeq2);
96-
expectIs(arraySeq2, Immutable.Seq([1,2,3]));
96+
expectIs(arraySeq2, Seq([1,2,3]));
9797
expectIsNot(arraySeq, [1,2,3]);
9898
expectIsNot(arraySeq2, [1,2,3]);
9999
expectIs(arraySeq, arraySeq2);
@@ -102,12 +102,12 @@ describe('Equality', () => {
102102
});
103103

104104
it('compares lists', () => {
105-
var list = Immutable.List.of(1,2,3);
105+
var list = List.of(1,2,3);
106106
expectIs(list, list);
107107
expectIsNot(list, [1,2,3]);
108108

109-
expectIs(list, Immutable.Seq.of(1,2,3));
110-
expectIs(list, Immutable.List.of(1,2,3));
109+
expectIs(list, Seq.of(1,2,3));
110+
expectIs(list, List.of(1,2,3));
111111

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

121121
var genVal = gen.oneOf([
122-
gen.map(Immutable.List, gen.array(genSimpleVal, 0, 4)),
123-
gen.map(Immutable.Set, gen.array(genSimpleVal, 0, 4)),
124-
gen.map(Immutable.Map, gen.array(gen.array(genSimpleVal, 2), 0, 4))
122+
gen.map(List, gen.array(genSimpleVal, 0, 4)),
123+
gen.map(Set, gen.array(genSimpleVal, 0, 4)),
124+
gen.map(Map, gen.array(gen.array(genSimpleVal, 2), 0, 4))
125125
]);
126126

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

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

139139
it('differentiates decimals', () => {
140140
expect(
141-
Immutable.Seq.of(1.5).hashCode()
141+
Seq.of(1.5).hashCode()
142142
).not.toBe(
143-
Immutable.Seq.of(1.6).hashCode()
143+
Seq.of(1.6).hashCode()
144144
);
145145
});
146146

‎__tests__/IndexedSeq.ts

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2,15 +2,15 @@
22
///<reference path='../dist/immutable.d.ts'/>
33
jest.autoMockOff();
44

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

8-
import Immutable = require('immutable');
8+
import { Seq } from 'immutable';
99

1010
describe('IndexedSequence', () => {
1111

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

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

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

3030
// This is what we expect for IndexedSequences
3131
var operated = seq.reverse();

0 commit comments

Comments
 (0)
0