8000 Add shorthand tests for `sortBy` and `over` methods. · lodash/lodash@201ea9a · GitHub
[go: up one dir, main page]
Skip to content
8000

Commit 201ea9a

Browse files
jdaltonjdalton
committed
Add shorthand tests for sortBy and over methods.
1 parent 2469af6 commit 201ea9a

File tree

2 files changed

+106
-40
lines changed

2 files changed

+106
-40
lines changed

‎lodash.js

+1-1
Original file line numberDiff line numberDiff line change
@@ -8999,7 +8999,7 @@
89998999
} else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
90009000
iteratees = [iteratees[0]];
90019001
}
9002-
iteratees = (length == 1 && isArray(iteratees[0]))
9002+
iteratees = (iteratees.length == 1 && isArray(iteratees[0]))
90039003
? iteratees[0]
90049004
: baseFlatten(iteratees, 1, isFlattenableIteratee);
90059005
< 8000 br>

‎test/test.js

+105-39
Original file line numberDiff line numberDiff line change
@@ -15622,6 +15622,44 @@
1562215622
assert.deepEqual(over(5, 10), [10, 100]);
1562315623
});
1562415624

15625+
QUnit.test('should use `_.identity` when a predicate is nullish', function(assert) {
15626+
assert.expect(1);
15627+
15628+
var over = _.overArgs(fn, undefined, null);
15629+
assert.deepEqual(over('a', 'b'), ['a', 'b']);
15630+
});
15631+
15632+
QUnit.test('should work with `_.property` shorthands', function(assert) {
15633+
assert.expect(1);
15634+
15635+
var over = _.overArgs(fn, 'b', 'a');
15636+
assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [2, 1]);
15637+
});
15638+
15639+
QUnit.test('should work with `_.matches` shorthands', function(assert) {
15640+
assert.expect(1);
15641+
15642+
var over = _.overArgs(fn, { 'b': 1 }, { 'a': 1 });
15643+
assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [false, true]);
15644+
});
15645+
15646+
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
15647+
assert.expect(1);
15648+
15649+
var over = _.overArgs(fn, ['b', 1], [['a', 1]]);
15650+
assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [false, true]);
15651+
});
15652+
15653+
QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) {
15654+
assert.expect(2);
15655+
15656+
var over = _.overArgs(fn, ['a', 1]);
15657+
assert.deepEqual(over({ 'a': 1 }, { '1': 2 }), [1, 2]);
15658+
15659+
over = _.overArgs(fn, [['a', 1]]);
15660+
assert.deepEqual(over({ 'a': 1 }), [true]);
15661+
});
15662+
1562515663
QUnit.test('should flatten `transforms`', function(assert) {
1562615664
assert.expect(1);
1562715665

@@ -16125,28 +16163,38 @@
1612516163
QUnit.test('should work with `_.property` shorthands', function(assert) {
1612616164
assert.expect(1);
1612716165

16128-
var object = { 'a': 1, 'b': 2 },
16129-
over = _.over('b', 'a');
16130-
16131-
assert.deepEqual(over(object), [2, 1]);
16166+
var over = _.over('b', 'a');
16167+
assert.deepEqual(over({ 'a': 1, 'b': 2 }), [2, 1]);
1613216168
});
1613316169

1613416170
QUnit.test('should work with `_.matches` shorthands', function(assert) {
1613516171
assert.expect(1);
1613616172

16137-
var object = { 'a': 1, 'b': 2 },
16138-
over = _.over({ 'c': 3 }, { 'a': 1 });
16139-
16140-
assert.deepEqual(over(object), [false, true]);
16173+
var over = _.over({ 'b': 1 }, { 'a': 1 });
16174+
assert.deepEqual(over({ 'a': 1, 'b': 2 }), [false, true]);
1614116175
});
1614216176

1614316177
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
1614416178
assert.expect(2);
1614516179

16146-
var over = _.over(['a', 2], [['b', 2]]);
16180+
var over = _.over(['b', 2], [['a', 2]]);
1614716181

16148-
assert.deepEqual(over({ 'a': 1, 'b': 2 }), [false, true]);
16149-
assert.deepEqual(over({ 'a': 2, 'b': 1 }), [true, false]);
16182+
assert.deepEqual(over({ 'a': 1, 'b': 2 }), [true, false]);
16183+
assert.deepEqual(over({ 'a': 2, 'b': 1 }), [false, true]);
16184+
});
16185+
16186+
QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) {
16187+
assert.expect(4);
16188+
16189+
var over = _.over(['a', 1]);
16190+
16191+
assert.deepEqual(over({ 'a': 1, '1': 2 }), [1, 2]);
16192+
assert.deepEqual(over({ 'a': 2, '1': 1 }), [2, 1]);
16193+
16194+
over = _.over([['a', 1]]);
16195+
16196+
assert.deepEqual(over({ 'a': 1 }), [true]);
16197+
assert.deepEqual(over({ 'a': 2 }), [false]);
1615016198
});
1615116199

1615216200
QUnit.test('should provide arguments to predicates', function(assert) {
@@ -16205,34 +16253,43 @@
1620516253
QUnit.test('should work with `_.property` shorthands', function(assert) {
1620616254
assert.expect(2);
1620716255

16208-
var object = { 'a': 1, 'b': 2 },
16209-
over = _.overEvery('a', 'c');
16256+
var over = _.overEvery('b', 'a');
1621016257

16211-
assert.strictEqual(over(object), false);
16212-
16213-
over = _.overEvery('b', 'a');
16214-
assert.strictEqual(over(object), true);
16258+
assert.strictEqual(over({ 'a': 1, 'b': 1 }), true);
16259+
assert.strictEqual(over({ 'a': 0, 'b': 1 }), false);
1621516260
});
1621616261

1621716262
QUnit.test('should work with `_.matches` shorthands', function(assert) {
1621816263
assert.expect(2);
1621916264

16220-
var object = { 'a': 1, 'b': 2 },
16221-
over = _.overEvery({ 'b': 2 }, { 'a': 1 });
16222-
16223-
assert.strictEqual(over(object), true);
16265+
var over = _.overEvery({ 'b': 2 }, { 'a': 1 });
1622416266

16225-
over = _.overEvery({ 'a': 1 }, { 'c': 3 });
16226-
assert.strictEqual(over(object), false);
16267+
assert.strictEqual(over({ 'a': 1, 'b': 2 }), true);
16268+
assert.strictEqual(over({ 'a': 0, 'b': 2 }), false);
1622716269
});
1622816270

1622916271
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
1623016272
assert.expect(2);
1623116273

16232-
var over = _.overEvery(['a', 1], [['b', 2]]);
16274+
var over = _.overEvery(['b', 2], [['a', 1]]);
1623316275

1623416276
assert.strictEqual(over({ 'a': 1, 'b': 2 }), true);
16235-
assert.strictEqual(over({ 'a': 1, 'b': -2 }), false);
16277+
assert.strictEqual(over({ 'a': 0, 'b': 2 }), false);
16278+
});
16279+
16280+
QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) {
16281+
assert.expect(5);
16282+
16283+
var over = _.overEvery(['a', 1]);
16284+
16285+
assert.strictEqual(over({ 'a': 1, '1': 1 }), true);
16286+
assert.strictEqual(over({ 'a': 1, '1': 0 }), false);
16287+
assert.strictEqual(over({ 'a': 0, '1': 1 }), false);
16288+
16289+
over = _.overEvery([['a', 1]]);
16290+
16291+
assert.strictEqual(over({ 'a': 1 }), true);
16292+
assert.strictEqual(over({ 'a': 2 }), false);
1623616293
});
1623716294

1623816295
QUnit.test('should flatten `predicates`', function(assert) {
@@ -16317,34 +16374,43 @@
1631716374
QUnit.test('should work with `_.property` shorthands', function(assert) {
1631816375
assert.expect(2);
1631916376

16320-
var object = { 'a': 1, 'b': 2 },
16321-
over = _.overSome('c', 'a');
16322-
16323-
assert.strictEqual(over(object), true);
16377+
var over = _.overSome('b', 'a');
1632416378

16325-
over = _.overSome('d', 'c');
16326-
assert.strictEqual(over(object), false);
16379+
assert.strictEqual(over({ 'a': 1, 'b': 0 }), true);
16380+
assert.strictEqual(over({ 'a': 0, 'b': 0 }), false);
1632716381
});
1632816382

1632916383
QUnit.test('should work with `_.matches` shorthands', function(assert) {
1633016384
assert.expect(2);
1633116385

16332-
var object = { 'a': 1, 'b': 2 },
16333-
over = _.overSome({ 'c': 3 }, { 'a': 1 });
16334-
16335-
assert.strictEqual(over(object), true);
16386+
var over = _.overSome({ 'b': 2 }, { 'a': 1 });
1633616387

16337-
over = _.overSome({ 'b': 1 }, { 'a': 2 });
16338-
assert.strictEqual(over(object), false);
16388+
assert.strictEqual(over({ 'a': 0, 'b': 2 }), true);
16389+
assert.strictEqual(over({ 'a': 0, 'b': 0 }), false);
1633916390
});
1634016391

1634116392
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
1634216393
assert.expect(2);
1634316394

1634416395
var over = _.overSome(['a', 1], [['b', 2]]);
1634516396

16346-
assert.strictEqual(over({ 'a': 3, 'b': 2 }), true);
16347-
assert.strictEqual(over({ 'a': 2, 'b': 3 }), false);
16397+
assert.strictEqual(over({ 'a': 0, 'b': 2 }), true);
16398+
assert.strictEqual(over({ 'a': 0, 'b': 0 }), false);
16399+
});
16400+
16401+
QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) {
16402+
assert.expect(5);
16403+
16404+
var over = _.overSome(['a', 1]);
16405+
16406+
assert.strictEqual(over({ 'a': 0, '1': 0 }), false);
16407+
assert.strictEqual(over({ 'a': 1, '1': 0 }), true);
16408+
assert.strictEqual(over({ 'a': 0, '1': 1 }), true);
16409+
16410+
over = _.overSome([['a', 1]]);
16411+
16412+
assert.strictEqual(over({ 'a': 1 }), true);
16413+
assert.strictEqual(over({ 'a': 2 }), false);
1634816414
});
1634916415

1635016416
QUnit.test('should flatten `predicates`', function(assert) {

0 commit comments

Comments
 (0)
0