Skip to content

Commit ba3c903

Browse files
etpinardetpinard
committed
adapt test to new getAutoRange API
1 parent e77cacc commit ba3c903

File tree

4 files changed

+174
-220
lines changed

4 files changed

+174
-220
lines changed

‎test/jasmine/tests/axes_test.js

Lines changed: 153 additions & 179 deletions
Original file line numberDiff line numberDiff line change
@@ -1421,234 +1421,208 @@ describe('Test axes', function() {
14211421

14221422
describe('getAutoRange', function() {
14231423
var getAutoRange = Axes.getAutoRange;
1424-
var ax;
1424+
var gd, ax;
14251425

1426-
it('returns reasonable range without explicit rangemode or autorange', function() {
1427-
ax = {
1428-
_min: [
1429-
// add in an extrapad to verify that it gets used on _min
1430-
// with a _length of 100, extrapad increases pad by 5
1431-
{val: 1, pad: 15, extrapad: true},
1432-
{val: 3, pad: 0},
1433-
{val: 2, pad: 10}
1434-
],
1435-
_max: [
1436-
{val: 6, pad: 10},
1437-
{val: 7, pad: 0},
1438-
{val: 5, pad: 20},
1439-
],
1426+
function mockGd(min, max) {
1427+
return {
1428+
_fullData: [{
1429+
type: 'scatter',
1430+
visible: true,
1431+
xaxis: 'x',
1432+
_extremes: {
1433+
x: {min: min, max: max}
1434+
}
1435+
}],
1436+
_fullLayout: {}
1437+
};
1438+
}
1439+
1440+
function mockAx() {
1441+
return {
1442+
_id: 'x',
14401443
type: 'linear',
14411444
_length: 100
14421445
};
1446+
}
14431447

1444-
expect(getAutoRange(ax)).toEqual([-0.5, 7]);
1448+
it('returns reasonable range without explicit rangemode or autorange', function() {
1449+
gd = mockGd([
1450+
// add in an extrapad to verify that it gets used on _min
1451+
// with a _length of 100, extrapad increases pad by 5
1452+
{val: 1, pad: 15, extrapad: true},
1453+
{val: 3, pad: 0},
1454+
{val: 2, pad: 10}
1455+
], [
1456+
{val: 6, pad: 10},
1457+
{val: 7, pad: 0},
1458+
{val: 5, pad: 20}
1459+
]);
1460+
ax = mockAx();
1461+
1462+
expect(getAutoRange(gd, ax)).toEqual([-0.5, 7]);
14451463
});
14461464

14471465
it('reverses axes', function() {
1448-
ax = {
1449-
_min: [
1450-
{val: 1, pad: 20},
1451-
{val: 3, pad: 0},
1452-
{val: 2, pad: 10}
1453-
],
1454-
_max: [
1455-
{val: 6, pad: 10},
1456-
{val: 7, pad: 0},
1457-
{val: 5, pad: 20},
1458-
],
1459-
type: 'linear',
1460-
autorange: 'reversed',
1461-
rangemode: 'normal',
1462-
_length: 100
1463-
};
1466+
gd = mockGd([
1467+
{val: 1, pad: 20},
1468+
{val: 3, pad: 0},
1469+
{val: 2, pad: 10}
1470+
], [
1471+
{val: 6, pad: 10},
1472+
{val: 7, pad: 0},
1473+
{val: 5, pad: 20}
1474+
]);
1475+
ax = mockAx();
1476+
ax.autorange = 'reversed';
1477+
ax.rangemode = 'normarl';
14641478

1465-
expect(getAutoRange(ax)).toEqual([7, -0.5]);
1479+
expect(getAutoRange(gd, ax)).toEqual([7, -0.5]);
14661480
});
14671481

14681482
it('expands empty range', function() {
1469-
ax = {
1470-
_min: [
1471-
{val: 2, pad: 0}
1472-
],
1473-
_max: [
1474-
{val: 2, pad: 0}
1475-
],
1476-
type: 'linear',
1477-
rangemode: 'normal',
1478-
_length: 100
1479-
};
1483+
gd = mockGd([
1484+
{val: 2, pad: 0}
1485+
], [
1486+
{val: 2, pad: 0}
1487+
]);
1488+
ax = mockAx();
1489+
ax.rangemode = 'normal';
14801490

1481-
expect(getAutoRange(ax)).toEqual([1, 3]);
1491+
expect(getAutoRange(gd, ax)).toEqual([1, 3]);
14821492
});
14831493

14841494
it('returns a lower bound of 0 on rangemode tozero with positive points', function() {
1485-
ax = {
1486-
_min: [
1487-
{val: 1, pad: 20},
1488-
{val: 3, pad: 0},
1489-
{val: 2, pad: 10}
1490-
],
1491-
_max: [
1492-
{val: 6, pad: 10},
1493-
{val: 7, pad: 0},
1494-
{val: 5, pad: 20},
1495-
],
1496-
type: 'linear',
1497-
rangemode: 'tozero',
1498-
_length: 100
1499-
};
1495+
gd = mockGd([
1496+
{val: 1, pad: 20},
1497+
{val: 3, pad: 0},
1498+
{val: 2, pad: 10}
1499+
], [
1500+
{val: 6, pad: 10},
1501+
{val: 7, pad: 0},
1502+
{val: 5, pad: 20}
1503+
]);
1504+
ax = mockAx();
1505+
ax.rangemode = 'tozero';
15001506

1501-
expect(getAutoRange(ax)).toEqual([0, 7]);
1507+
expect(getAutoRange(gd, ax)).toEqual([0, 7]);
15021508
});
15031509

15041510
it('returns an upper bound of 0 on rangemode tozero with negative points', function() {
1505-
ax = {
1506-
_min: [
1507-
{val: -10, pad: 20},
1508-
{val: -8, pad: 0},
1509-
{val: -9, pad: 10}
1510-
],
1511-
_max: [
1512-
{val: -5, pad: 20},
1513-
{val: -4, pad: 0},
1514-
{val: -6, pad: 10},
1515-
],
1516-
type: 'linear',
1517-
rangemode: 'tozero',
1518-
_length: 100
1519-
};
1511+
gd = mockGd([
1512+
{val: -10, pad: 20},
1513+
{val: -8, pad: 0},
1514+
{val: -9, pad: 10}
1515+
], [
1516+
{val: -5, pad: 20},
1517+
{val: -4, pad: 0},
1518+
{val: -6, pad: 10},
1519+
]);
1520+
ax = mockAx();
1521+
ax.rangemode = 'tozero';
15201522

1521-
expect(getAutoRange(ax)).toEqual([-12.5, 0]);
1523+
expect(getAutoRange(gd, ax)).toEqual([-12.5, 0]);
15221524
});
15231525

15241526
it('returns a positive and negative range on rangemode tozero with positive and negative points', function() {
1525-
ax = {
1526-
_min: [
1527-
{val: -10, pad: 20},
1528-
{val: -8, pad: 0},
1529-
{val: -9, pad: 10}
1530-
],
1531-
_max: [
1532-
{val: 6, pad: 10},
1533-
{val: 7, pad: 0},
1534-
{val: 5, pad: 20},
1535-
],
1536-
type: 'linear',
1537-
rangemode: 'tozero',
1538-
_length: 100
1539-
};
1527+
gd = mockGd([
1528+
{val: -10, pad: 20},
1529+
{val: -8, pad: 0},
1530+
{val: -9, pad: 10}
1531+
], [
1532+
{val: 6, pad: 10},
1533+
{val: 7, pad: 0},
1534+
{val: 5, pad: 20}
1535+
]);
1536+
ax = mockAx();
1537+
ax.rangemode = 'tozero';
15401538

1541-
expect(getAutoRange(ax)).toEqual([-15, 10]);
1539+
expect(getAutoRange(gd, ax)).toEqual([-15, 10]);
15421540
});
15431541

15441542
it('reverses range after applying rangemode tozero', function() {
1545-
ax = {
1546-
_min: [
1547-
{val: 1, pad: 20},
1548-
{val: 3, pad: 0},
1549-
{val: 2, pad: 10}
1550-
],
1551-
_max: [
1552-
// add in an extrapad to verify that it gets used on _max
1553-
{val: 6, pad: 15, extrapad: true},
1554-
{val: 7, pad: 0},
1555-
{val: 5, pad: 10},
1556-
],
1557-
type: 'linear',
1558-
autorange: 'reversed',
1559-
rangemode: 'tozero',
1560-
_length: 100
1561-
};
1543+
gd = mockGd([
1544+
{val: 1, pad: 20},
1545+
{val: 3, pad: 0},
1546+
{val: 2, pad: 10}
1547+
], [
1548+
// add in an extrapad to verify that it gets used on _max
1549+
{val: 6, pad: 15, extrapad: true},
1550+
{val: 7, pad: 0},
1551+
{val: 5, pad: 10}
1552+
]);
1553+
ax = mockAx();
1554+
ax.autorange = 'reversed';
1555+
ax.rangemode = 'tozero';
15621556

1563-
expect(getAutoRange(ax)).toEqual([7.5, 0]);
1557+
expect(getAutoRange(gd, ax)).toEqual([7.5, 0]);
15641558
});
15651559

15661560
it('expands empty positive range to something including 0 with rangemode tozero', function() {
1567-
ax = {
1568-
_min: [
1569-
{val: 5, pad: 0}
1570-
],
1571-
_max: [
1572-
{val: 5, pad: 0}
1573-
],
1574-
type: 'linear',
1575-
rangemode: 'tozero',
1576-
_length: 100
1577-
};
1561+
gd = mockGd([
1562+
{val: 5, pad: 0}
1563+
], [
1564+
{val: 5, pad: 0}
1565+
]);
1566+
ax = mockAx();
1567+
ax.rangemode = 'tozero';
15781568

1579-
expect(getAutoRange(ax)).toEqual([0, 6]);
1569+
expect(getAutoRange(gd, ax)).toEqual([0, 6]);
15801570
});
15811571

15821572
it('expands empty negative range to something including 0 with rangemode tozero', function() {
1583-
ax = {
1584-
_min: [
1585-
{val: -5, pad: 0}
1586-
],
1587-
_max: [
1588-
{val: -5, pad: 0}
1589-
],
1590-
type: 'linear',
1591-
rangemode: 'tozero',
1592-
_length: 100
1593-
};
1573+
gd = mockGd([
1574+
{val: -5, pad: 0}
1575+
], [
1576+
{val: -5, pad: 0}
1577+
]);
1578+
ax = mockAx();
1579+
ax.rangemode = 'tozero';
15941580

1595-
expect(getAutoRange(ax)).toEqual([-6, 0]);
1581+
expect(getAutoRange(gd, ax)).toEqual([-6, 0]);
15961582
});
15971583

15981584
it('never returns a negative range when rangemode nonnegative is set with positive and negative points', function() {
1599-
ax = {
1600-
_min: [
1601-
{val: -10, pad: 20},
1602-
{val: -8, pad: 0},
1603-
{val: -9, pad: 10}
1604-
],
1605-
_max: [
1606-
{val: 6, pad: 20},
1607-
{val: 7, pad: 0},
1608-
{val: 5, pad: 10},
1609-
],
1610-
type: 'linear',
1611-
rangemode: 'nonnegative',
1612-
_length: 100
1613-
};
1585+
gd = mockGd([
1586+
{val: -10, pad: 20},
1587+
{val: -8, pad: 0},
1588+
{val: -9, pad: 10}
1589+
], [
1590+
{val: 6, pad: 20},
1591+
{val: 7, pad: 0},
1592+
{val: 5, pad: 10}
1593+
]);
1594+
ax = mockAx();
1595+
ax.rangemode = 'nonnegative';
16141596

1615-
expect(getAutoRange(ax)).toEqual([0, 7.5]);
1597+
expect(getAutoRange(gd, ax)).toEqual([0, 7.5]);
16161598
});
16171599

16181600
it('never returns a negative range when rangemode nonnegative is set with only negative points', function() {
1619-
ax = {
1620-
_min: [
1621-
{val: -10, pad: 20},
1622-
{val: -8, pad: 0},
1623-
{val: -9, pad: 10}
1624-
],
1625-
_max: [
1626-
{val: -5, pad: 20},
1627-
{val: -4, pad: 0},
1628-
{val: -6, pad: 10},
1629-
],
1630-
type: 'linear',
1631-
rangemode: 'nonnegative',
1632-
_length: 100
1633-
};
1601+
gd = mockGd([
1602+
{val: -10, pad: 20},
1603+
{val: -8, pad: 0},
1604+
{val: -9, pad: 10}
1605+
], [
1606+
{val: -5, pad: 20},
1607+
{val: -4, pad: 0},
1608+
{val: -6, pad: 10}
1609+
]);
1610+
ax = mockAx();
1611+
ax.rangemode = 'nonnegative';
16341612

1635-
expect(getAutoRange(ax)).toEqual([0, 1]);
1613+
expect(getAutoRange(gd, ax)).toEqual([0, 1]);
16361614
});
16371615

16381616
it('expands empty range to something nonnegative with rangemode nonnegative', function() {
1639-
ax = {
1640-
_min: [
1641-
{val: -5, pad: 0}
1642-
],
1643-
_max: [
1644-
{val: -5, pad: 0}
1645-
],
1646-
type: 'linear',
1647-
rangemode: 'nonnegative',
1648-
_length: 100
1649-
};
1617+
gd = mockGd([
1618+
{val: -5, pad: 0}
1619+
], [
1620+
{val: -5, pad: 0}
1621+
]);
1622+
ax = mockAx();
1623+
ax.rangemode = 'nonnegative';
16501624

1651-
expect(getAutoRange(ax)).toEqual([0, 1]);
1625+
expect(getAutoRange(gd, ax)).toEqual([0, 1]);
16521626
});
16531627
});
16541628

0 commit comments

Comments
 (0)