@nocobase/plugin-backups 2.0.56

package/dist/node_modules/cron-parser/test/parser.js

@@ -0,0 +1,46 @@
+var test = require('tap').test;
+var CronParser = require('../lib/parser');
+
+// Globals
+
+test('load crontab file', function(t) {
+  CronParser.parseFile(__dirname + '/crontab.example', function(err, result) {
+    t.error(err, 'File read error');
+    t.ok(result, 'Crontab parsed parsed');
+
+    t.equal(Object.keys(result.variables).length, 2, 'variables length matches');
+    t.equal(Object.keys(result.errors).length, 0, 'errors length matches');
+    t.equal(result.expressions.length, 3, 'expressions length matches');
+
+    // Parse expressions
+    var next = null;
+
+    t.equal(result.expressions[0].hasNext(), true);
+    next = result.expressions[0].next();
+    t.ok(next, 'first date');
+
+    next = result.expressions[1].next();
+    t.ok(next, 'second date');
+
+    next = result.expressions[2].next();
+    t.ok(next, 'third date');
+
+    t.end();
+  });
+});
+
+test('no next date', function(t) {
+  var options = {
+    currentDate: new Date(2014, 0, 1),
+    endDate: new Date(2014, 0, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('* * 2 * *', options);
+    t.equal(interval.hasNext(), false);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});

package/dist/node_modules/cron-parser/test/parser_crondate_formats.js

@@ -0,0 +1,145 @@
+var luxon = require('luxon');
+var test = require('tap').test;
+var CronDate = require('../lib/date');
+
+test('parse cron date formats with local timezone', (t) => {
+  // Some tests need the local offset to be compatible without invoking timezone management.
+  // Local offset is dependent on what the system being tested on is
+  var offset = new Date().getTimezoneOffset();
+  var offsetHours = Math.abs(Math.floor(offset/60));
+  var offsetMinutes = offset % 60;
+  var offsetSign = offset < 0 ? '-' : '+';
+
+  var expectedTime = new Date(2021, 0, 4, 10, 0, 0).toString();
+
+  test('undefined date', (t) => {
+    const realDate = new Date();
+    var d = new CronDate();
+
+    t.equal(d.toDate().toString(), realDate.toString());
+
+    t.end();
+  });
+
+  test('JS Date', (t) => {
+    var d = new CronDate(new Date(2021, 0, 4, 10, 0, 0));
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('ISO 8601', (t) => {
+    var d = new CronDate('2021-01-04T10:00:00');
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('ISO 8601 date', (t) => {
+
+    var d = new CronDate('2021-01-04');
+    var expectedTime = new Date(2021, 0, 4, 0, 0, 0).toString();
+
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('RFC2822', (t) => {
+    var offsetString = offsetSign + String(offsetHours).padStart(2, 0) + String(offsetMinutes).padStart(2, 0);
+
+    var d = new CronDate('Mon, 4 Jan 2021 10:00:00 ' + offsetString);
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('RFC2822-like without timezone offset', (t) => {
+    var d = new CronDate('Mon, 4 Jan 2021 10:00:00');
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('SQL', (t) => {
+    var d = new CronDate('2021-01-04 10:00:00');
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('milliseconds', (t) => {
+    var d = new CronDate(new Date('2021-01-04 10:00:00').valueOf());
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('CronDate', (t) => {
+    var date = new CronDate('Mon, 4 Jan 2021 10:00:00');
+    var d = new CronDate(date);
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('invalid', (t) => {
+    t.throws(() => {
+      var d = new CronDate('2021-01-4 10:00:00');
+    });
+
+    t.end();
+  });
+
+  t.end();
+});
+
+test('parse cron date formats with another timezone', (t) => {
+  test('ISO 8601 without offset', (t) => {
+    // implies format already in timezone
+    var d = new CronDate('2021-01-04T10:00:00', 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T08:00:00.000Z');
+
+    t.end();
+  });
+
+  test('ISO 8601 with non-local offset', (t) => {
+    var d = new CronDate('2021-01-04T10:00:00+01:00', 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
+
+    t.end();
+  });
+
+  test('RFC2822 with non-local offset', (t) => {
+    var d = new CronDate('Mon, 4 Jan 2021 10:00:00 +0100', 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
+
+    t.end();
+  });
+
+  test('milliseconds', (t) => {
+    var date = luxon.DateTime.fromISO('2021-01-04T11:00:00.000+02:00').valueOf();
+    var d = new CronDate(date, 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
+
+    t.end();
+  });
+
+  test('CronDate with same timezone', (t) => {
+    var date = new CronDate('Mon, 4 Jan 2021 10:00:00', 'Europe/Athens');
+    var d = new CronDate(date);
+    t.equal(d.toISOString(), '2021-01-04T08:00:00.000Z');
+
+    t.end();
+  });
+
+  test('CronDate with different timezone', (t) => {
+    var date = new CronDate('Mon, 4 Jan 2021 10:00:00', 'America/New_York');
+    var d = new CronDate(date, 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T15:00:00.000Z');
+
+    t.end();
+  });
+
+  t.end('crondate input should');
+});

package/dist/node_modules/cron-parser/test/parser_day_of_month.js

@@ -0,0 +1,169 @@
+var test = require('tap').test;
+var CronParser = require('../lib/parser');
+
+test('parse cron with last day in a month', function(t) {
+  var options = {
+    currentDate: new Date(2014, 0, 1),
+    endDate: new Date(2014, 10, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 L * *', options);
+    t.equal(interval.hasNext(), true);
+
+    for (i = 0; i < 10; ++i) {
+      var next = interval.next();
+      t.ok(next, 'has a date');
+    }
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parse cron with last day in feb', function(t) {
+  var options = {
+    currentDate: new Date(2016, 0, 1),
+    endDate: new Date(2016, 10, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 6-20/2,L 2 *', options);
+    t.equal(interval.hasNext(), true);
+    var next = null;
+    var items = 9;
+    var i = 0;
+    while(interval.hasNext()) {
+      next = interval.next();
+      i += 1;
+      t.ok(next, 'has a date');
+    }
+    //leap year
+    t.equal(next.getDate(), 29);
+    t.equal(i, items);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parse cron with last day in feb', function(t) {
+  var options = {
+    currentDate: new Date(2014, 0, 1),
+    endDate: new Date(2014, 10, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 1,3,6-10,L 2 *', options);
+    t.equal(interval.hasNext(), true);
+    var next = null;
+    while(interval.hasNext()) {
+      next = interval.next();
+      t.ok(next, 'has a date');
+    }
+    //common year
+    t.equal(next.getDate(), 28);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parse cron with last weekday of the month', function(t) {
+  var options = {
+    currentDate: new Date(2021, 8, 1),
+    endDate: new Date(2021, 11, 1)
+  };
+
+  var testCases = [
+    { expression: '0 0 0 * * 1L', expectedDate: 27 },
+    { expression: '0 0 0 * * 2L', expectedDate: 28 },
+    { expression: '0 0 0 * * 3L', expectedDate: 29 },
+    { expression: '0 0 0 * * 4L', expectedDate: 30 },
+    { expression: '0 0 0 * * 5L', expectedDate: 24 },
+    { expression: '0 0 0 * * 6L', expectedDate: 25 },
+    { expression: '0 0 0 * * 0L', expectedDate: 26 },
+    { expression: '0 0 0 * * 7L', expectedDate: 26 }
+  ];
+
+  testCases.forEach(function({ expression, expectedDate }) {
+    t.test(expression, function(t) {
+      try {
+        var interval = CronParser.parseExpression(expression, options);
+
+        t.equal(interval.hasNext(), true);
+
+        var next = interval.next();
+
+        t.equal(next.getDate(), expectedDate);
+      } catch (err) {
+        t.error(err, 'Parse read error');
+      }
+
+      t.end();
+    });
+  });
+
+  t.end();
+});
+
+test('parses expression that runs on both last monday and friday of the month', function(t) {
+  var options = {
+    currentDate: new Date(2021, 8, 1),
+    endDate: new Date(2021, 11, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 0 * * 1L,5L', options);
+
+    t.equal(interval.next().getDate(), 24);
+    t.equal(interval.next().getDate(), 27);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parses expression that runs on both every monday and last friday of mont', function(t) {
+  var options = {
+    currentDate: new Date(2021, 8, 1),
+    endDate: new Date(2021, 8, 30)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 0 * * 1,5L', options);
+
+    var dates = [];
+
+    while(true) {
+      try {
+        dates.push(interval.next().getDate());
+      } catch (e) {
+        if (e.message !== 'Out of the timespan range') {
+          throw e;
+        }
+
+        break;
+      }
+    }
+
+    t.same(dates, [6, 13, 20, 24, 27]);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('fails to parse for invalid last weekday of month expression', function(t) {
+  t.throws(function() {
+    var interval = CronParser.parseExpression('0 0 0 * * L');
+    interval.next();
+  });
+
+  t.end();
+});

package/dist/node_modules/cron-parser/test/prev_date.js

@@ -0,0 +1,32 @@
+var test = require('tap').test;
+var CronExpression = require('../lib/expression');
+
+test('prev should match correctly (issue #98) when milliseconds are greater than 0', function(t) {
+  var options = {
+    currentDate: new Date('2017-06-13T18:21:25.002Z')
+  };
+
+  var interval = CronExpression.parse('*/5 * * * * *', options);
+  var prev = interval.prev();
+  t.equal(prev.getSeconds(), 25);
+
+  t.end();
+});
+
+test('prev should match correctly (issue #98) when milliseconds are equal to 0', function(t) {
+  var interval = CronExpression.parse('59 59 23 * * *',{
+    currentDate : new Date('2012-12-26 14:38:53')
+  });
+
+  [25, 24, 23, 22].forEach(function(date) {
+    var prev = interval.prev();
+    t.equal(prev.getFullYear(), 2012);
+    t.equal(prev.getMonth(), 11);
+    t.equal(prev.getDate(), date);
+    t.equal(prev.getHours(), 23);
+    t.equal(prev.getMinutes(), 59);
+    t.equal(prev.getSeconds(), 59);
+  });
+
+  t.end();
+});