card-mod-date 0.15.4 → 0.15.6

data/vendor/moment/src/test/moment/min_max.js

@@ -0,0 +1,72 @@
+import { module, test } from '../qunit';
+import moment from '../../moment';
+
+module('min max');
+
+test('min', function (assert) {
+    var now = moment(),
+        future = now.clone().add(1, 'month'),
+        past = now.clone().subtract(1, 'month'),
+        invalid = moment.invalid();
+
+    assert.equal(moment.min(now, future, past), past, 'min(now, future, past)');
+    assert.equal(moment.min(future, now, past), past, 'min(future, now, past)');
+    assert.equal(moment.min(future, past, now), past, 'min(future, past, now)');
+    assert.equal(moment.min(past, future, now), past, 'min(past, future, now)');
+    assert.equal(moment.min(now, past), past, 'min(now, past)');
+    assert.equal(moment.min(past, now), past, 'min(past, now)');
+    assert.equal(moment.min(now), now, 'min(now, past)');
+
+    assert.equal(
+        moment.min([now, future, past]),
+        past,
+        'min([now, future, past])'
+    );
+    assert.equal(moment.min([now, past]), past, 'min(now, past)');
+    assert.equal(moment.min([now]), now, 'min(now)');
+
+    assert.equal(moment.min([now, invalid]), invalid, 'min(now, invalid)');
+    assert.equal(moment.min([invalid, now]), invalid, 'min(invalid, now)');
+});
+
+test('max', function (assert) {
+    var now = moment(),
+        future = now.clone().add(1, 'month'),
+        past = now.clone().subtract(1, 'month'),
+        invalid = moment.invalid();
+
+    assert.equal(
+        moment.max(now, future, past),
+        future,
+        'max(now, future, past)'
+    );
+    assert.equal(
+        moment.max(future, now, past),
+        future,
+        'max(future, now, past)'
+    );
+    assert.equal(
+        moment.max(future, past, now),
+        future,
+        'max(future, past, now)'
+    );
+    assert.equal(
+        moment.max(past, future, now),
+        future,
+        'max(past, future, now)'
+    );
+    assert.equal(moment.max(now, past), now, 'max(now, past)');
+    assert.equal(moment.max(past, now), now, 'max(past, now)');
+    assert.equal(moment.max(now), now, 'max(now, past)');
+
+    assert.equal(
+        moment.max([now, future, past]),
+        future,
+        'max([now, future, past])'
+    );
+    assert.equal(moment.max([now, past]), now, 'max(now, past)');
+    assert.equal(moment.max([now]), now, 'max(now)');
+
+    assert.equal(moment.max([now, invalid]), invalid, 'max(now, invalid)');
+    assert.equal(moment.max([invalid, now]), invalid, 'max(invalid, now)');
+});

data/vendor/moment/src/test/moment/mutable.js

@@ -0,0 +1,26 @@
+import { module, test } from '../qunit';
+import moment from '../../moment';
+
+module('mutable');
+
+test('manipulation methods', function (assert) {
+    var m = moment();
+
+    assert.equal(m, m.year(2011), 'year() should be mutable');
+    assert.equal(m, m.month(1), 'month() should be mutable');
+    assert.equal(m, m.hours(7), 'hours() should be mutable');
+    assert.equal(m, m.minutes(33), 'minutes() should be mutable');
+    assert.equal(m, m.seconds(44), 'seconds() should be mutable');
+    assert.equal(m, m.milliseconds(55), 'milliseconds() should be mutable');
+    assert.equal(m, m.day(2), 'day() should be mutable');
+    assert.equal(m, m.startOf('week'), 'startOf() should be mutable');
+    assert.equal(m, m.add(1, 'days'), 'add() should be mutable');
+    assert.equal(m, m.subtract(2, 'years'), 'subtract() should be mutable');
+    assert.equal(m, m.local(), 'local() should be mutable');
+    assert.equal(m, m.utc(), 'utc() should be mutable');
+});
+
+test('non mutable methods', function (assert) {
+    var m = moment();
+    assert.notEqual(m, m.clone(), 'clone() should not be mutable');
+});

data/vendor/moment/src/test/moment/normalize_units.js

@@ -0,0 +1,83 @@
+import { module, test } from '../qunit';
+import moment from '../../moment';
+
+module('normalize units');
+
+test('normalize units', function (assert) {
+    var fullKeys = [
+            'year',
+            'quarter',
+            'month',
+            'isoWeek',
+            'week',
+            'day',
+            'hour',
+            'minute',
+            'second',
+            'millisecond',
+            'date',
+            'dayOfYear',
+            'weekday',
+            'isoWeekday',
+            'weekYear',
+            'isoWeekYear',
+        ],
+        aliases = [
+            'y',
+            'Q',
+            'M',
+            'W',
+            'w',
+            'd',
+            'h',
+            'm',
+            's',
+            'ms',
+            'D',
+            'DDD',
+            'e',
+            'E',
+            'gg',
+            'GG',
+        ],
+        length = fullKeys.length,
+        fullKey,
+        fullKeyCaps,
+        fullKeyPlural,
+        fullKeyCapsPlural,
+        alias,
+        index;
+
+    for (index = 0; index < length; index += 1) {
+        fullKey = fullKeys[index];
+        fullKeyCaps = fullKey.toUpperCase();
+        fullKeyPlural = fullKey + 's';
+        fullKeyCapsPlural = fullKeyCaps + 's';
+        alias = aliases[index];
+        assert.equal(
+            moment.normalizeUnits(fullKey),
+            fullKey,
+            'Testing full key ' + fullKey
+        );
+        assert.equal(
+            moment.normalizeUnits(fullKeyCaps),
+            fullKey,
+            'Testing full key capitalised ' + fullKey
+        );
+        assert.equal(
+            moment.normalizeUnits(fullKeyPlural),
+            fullKey,
+            'Testing full key plural ' + fullKey
+        );
+        assert.equal(
+            moment.normalizeUnits(fullKeyCapsPlural),
+            fullKey,
+            'Testing full key capitalised and plural ' + fullKey
+        );
+        assert.equal(
+            moment.normalizeUnits(alias),
+            fullKey,
+            'Testing alias ' + fullKey
+        );
+    }
+});

data/vendor/moment/src/test/moment/now.js

@@ -0,0 +1,100 @@
+import { module, test } from '../qunit';
+import moment from '../../moment';
+
+module('now');
+
+test('now', function (assert) {
+    var startOfTest = new Date().valueOf(),
+        momentNowTime = moment.now(),
+        afterMomentCreationTime = new Date().valueOf();
+
+    assert.ok(
+        startOfTest <= momentNowTime,
+        'moment now() time should be now, not in the past'
+    );
+    assert.ok(
+        momentNowTime <= afterMomentCreationTime,
+        'moment now() time should be now, not in the future'
+    );
+});
+
+test('now - Date mocked', function (assert) {
+    var RealDate = Date,
+        customTimeMs = moment('2015-01-01T01:30:00.000Z').valueOf();
+
+    function MockDate() {
+        return new RealDate(customTimeMs);
+    }
+
+    MockDate.now = function () {
+        return new MockDate().valueOf();
+    };
+
+    MockDate.prototype = RealDate.prototype;
+
+    // eslint-disable-next-line
+    Date = MockDate;
+
+    try {
+        assert.equal(
+            moment().valueOf(),
+            customTimeMs,
+            'moment now() time should use the global Date object'
+        );
+    } finally {
+        // eslint-disable-next-line
+        Date = RealDate;
+    }
+});
+
+test('now - custom value', function (assert) {
+    var customTimeStr = '2015-01-01T01:30:00.000Z',
+        customTime = moment(customTimeStr, moment.ISO_8601).valueOf(),
+        oldFn = moment.now;
+
+    moment.now = function () {
+        return customTime;
+    };
+
+    try {
+        assert.equal(
+            moment().toISOString(),
+            customTimeStr,
+            'moment() constructor should use the function defined by moment.now, but it did not'
+        );
+        assert.equal(
+            moment.utc().toISOString(),
+            customTimeStr,
+            'moment() constructor should use the function defined by moment.now, but it did not'
+        );
+    } finally {
+        moment.now = oldFn;
+    }
+});
+
+test('empty object, empty array', function (assert) {
+    function assertIsNow(gen, msg) {
+        var before = +new Date(),
+            mid = gen(),
+            after = +new Date();
+        assert.ok(before <= +mid && +mid <= after, 'should be now : ' + msg);
+    }
+    assertIsNow(function () {
+        return moment();
+    }, 'moment()');
+    assertIsNow(function () {
+        return moment([]);
+    }, 'moment([])');
+    assertIsNow(function () {
+        return moment({});
+    }, 'moment({})');
+    assertIsNow(function () {
+        return moment.utc();
+    }, 'moment.utc()');
+    assertIsNow(function () {
+        return moment.utc([]);
+    }, 'moment.utc([])');
+    assertIsNow(function () {
+        return moment.utc({});
+    }, 'moment.utc({})');
+});