sipwise
/
ngcp-csc-ui
mirror of https://github.com/sipwise/ngcp-csc-ui.git
1
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'mr13.1'
${ noResults }
ngcp-csc-ui/test/jest/__tests__/helpers/kamailio-timesets-converter...

968 lines
32 KiB
Raw Permalink Blame History

/* eslint-disable */
import { assert } from 'chai'
import _ from 'lodash'
import {
getHumanTimesetsNormalized,
humanDatesetToKamailio,
humanTimesetToKamailio,
kamailioDatesetToHuman,
kamailioTimesetToHuman
} from 'src/helpers/kamailio-timesets-converter'
function deepEqualCheckAndInputDataMutationCheck (data, expectedResult, actionFn) {
const clonnedData = _.cloneDeep(data)
assert.deepEqual(actionFn(clonnedData), expectedResult)
assert.deepEqual(clonnedData, data, 'Original data were mutated')
}
describe('function getHumanTimesetsNormalized', function () {
it('case: resort', function () {
const options = [
{ weekday: 3, from: '9:00', to: '10:00' },
{ weekday: 2, from: '11:25', to: '15:00' },
{ weekday: 2, from: '9:12', to: '9:22' },
{ weekday: 2, from: '9:00', to: '9:10' }
]
const convertedData = [
{ weekday: 2, from: '9:00', to: '9:10' },
{ weekday: 2, from: '9:12', to: '9:22' },
{ weekday: 2, from: '11:25', to: '15:00' },
{ weekday: 3, from: '9:00', to: '10:00' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => getHumanTimesetsNormalized(data))
})
it('case: combine chunks and remove duplicates', function () {
const options = [
{ weekday: 2, from: '9:00', to: '10:00' },
{ weekday: 2, from: '10:00', to: '12:00' },
{ weekday: 3, from: '11:25', to: '15:00' },
{ weekday: 3, from: '11:25', to: '15:00' },
{ weekday: 3, from: '9:00', to: '9:30' },
{ weekday: 3, from: '9:10', to: '11:30' },
{ weekday: 3, from: '10:00', to: '11:30' },
{ weekday: 3, from: '8:00', to: '8:59' }
]
const convertedData = [
{ weekday: 2, from: '9:00', to: '12:00' },
{ weekday: 3, from: '8:00', to: '8:59' },
{ weekday: 3, from: '9:00', to: '15:00' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => getHumanTimesetsNormalized(data))
})
})
describe('Human readable timesets to Kamailio format converter helpers', function () {
it('case: an empty set', function () {
const options = []
const convertedData = []
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
const options2 = undefined
const convertedData2 = []
deepEqualCheckAndInputDataMutationCheck(options2, convertedData2, data => humanTimesetToKamailio(data))
})
it('case: required field', function () {
let options = [{}]
assert.throws(() => humanTimesetToKamailio(options))
options = [{ weekday: 1 }]
assert.throws(() => humanTimesetToKamailio(options))
options = [{ weekday: 1, from: '1:00' }]
assert.throws(() => humanTimesetToKamailio(options))
options = [{ weekday: 1, to: '1:00' }]
assert.throws(() => humanTimesetToKamailio(options))
options = [{ weekday: 1, from: '1:00', to: '2:00' }]
assert.doesNotThrow(() => humanTimesetToKamailio(options))
})
it('case: Mon 6:00-6:05', function () {
const options = [
{ weekday: 2, from: '6:00', to: '6:05' }
]
const convertedData = [
{ wday: 2, hour: '6', minute: '0-4' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: Mon 14:05-15:00', function () {
const options = [
{ weekday: 2, from: '14:05', to: '15:00' }
]
const convertedData = [
{ wday: 2, hour: '14', minute: '5-59' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: Mon 6:00-15:00', function () {
const options = [
{ weekday: 2, from: '6:00', to: '15:00' }
]
const convertedData = [
{ wday: 2, hour: '6-14' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: Fri 3:02-21:41', function () {
const options = [
{ weekday: 6, from: '3:02', to: '21:41' }
]
const convertedData = [
{ wday: 6, hour: '3', minute: '2-59' },
{ wday: 6, hour: '4-20' },
{ wday: 6, hour: '21', minute: '0-40' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: Mon 9:01-10:00, Mon 14:05-15:00, Mon 11:00-11:29', function () {
const options = [
{ weekday: 2, from: '9:01', to: '10:00' },
{ weekday: 2, from: '14:05', to: '15:00' },
{ weekday: 2, from: '11:00', to: '11:29' }
]
const convertedData = [
{ wday: 2, hour: '9', minute: '1-59' },
{ wday: 2, hour: '11', minute: '0-28' },
{ wday: 2, hour: '14', minute: '5-59' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: Mon 0:00-23:59, Tue 0:00-23:58', function () {
// NOTE: 23:59 should be treated as 24:00 for TO field in interval
const options = [
{ weekday: 2, from: '0:00', to: '23:59' },
{ weekday: 3, from: '0:00', to: '23:58' }
]
const convertedData = [
{ wday: 2, hour: '0-23' },
{ wday: 3, hour: '0-22' },
{ wday: 3, hour: '23', minute: '0-57' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: automatic combining time intervals', function () {
const options = [
{ weekday: 3, from: '6:22', to: '7:44' },
{ weekday: 3, from: '5:10', to: '8:00' },
{ weekday: 3, from: '4:00', to: '7:00' },
{ weekday: 3, from: '8:30', to: '11:00' },
{ weekday: 3, from: '8:00', to: '9:30' },
{ weekday: 2, from: '2:00', to: '20:00' }
]
const convertedData = [
{ wday: 2, hour: '2-19' },
{ wday: 3, hour: '4-10' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: wday range', function () {
const options = [
{ weekday: 6, from: '8:00', to: '17:00' },
{ weekday: 7, from: '8:00', to: '17:00' },
{ weekday: 1, from: '8:00', to: '17:00' },
{ weekday: 2, from: '8:00', to: '17:30' },
{ weekday: 3, from: '8:00', to: '17:30' },
{ weekday: 4, from: '8:00', to: '17:30' }
]
const convertedData = [
{ wday: '1-4', hour: '8-16' },
{ wday: '2-4', hour: '17', minute: '0-29' },
{ wday: '6-7', hour: '8-16' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
it('case: hour range', function () {
const options = [
{ weekday: 2, from: '9:05', to: '9:30' },
{ weekday: 2, from: '10:05', to: '10:30' },
{ weekday: 2, from: '11:05', to: '11:30' },
{ weekday: 3, from: '9:05', to: '9:30' },
{ weekday: 3, from: '10:05', to: '10:30' },
{ weekday: 3, from: '11:05', to: '11:30' },
{ weekday: 4, from: '9:05', to: '9:30' },
{ weekday: 4, from: '10:05', to: '10:30' },
{ weekday: 4, from: '11:05', to: '11:30' }
]
const convertedData = [
{ wday: '2-4', hour: '9-11', minute: '5-29' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanTimesetToKamailio(data))
})
})
describe('Kamailio format to Human readable timesets converter helpers', function () {
it('case: an empty set', function () {
const options = []
const convertedData = []
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
const options2 = undefined
const convertedData2 = []
deepEqualCheckAndInputDataMutationCheck(options2, convertedData2, data => kamailioTimesetToHuman(data))
})
it('case: required field', function () {
const options = [{}]
assert.throws(() => kamailioTimesetToHuman(options))
const options2 = [{ wday: 1 }]
assert.doesNotThrow(() => kamailioTimesetToHuman(options2))
})
it('case: not supported fields', function () {
// There is not exception if we have empty not supported fields
const options = [
{
wday: 1, hour: '1', minute: '1',
second: '', month: '', year: null, week: '', yday: '', mday: ''
}
]
assert.doesNotThrow(() => kamailioTimesetToHuman(options))
// There should be an exception if we have a not empty not supported field
const options2 = [
{
weekday: 1, from: '1:00', to: '2:00',
second: '1', month: '1'
}
]
assert.throws(() => kamailioTimesetToHuman(options2))
})
it('case: Mon 6:00-6:05', function () {
const options = [
{ wday: 2, hour: '6', minute: '0-4' }
]
const convertedData = [
{ weekday: 2, from: '6:00', to: '6:05' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: Mon 14:05-15:00', function () {
const options = [
{ wday: 2, hour: '14', minute: '5-59' }
]
const convertedData = [
{ weekday: 2, from: '14:05', to: '15:00' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: Mon 6:00-15:00', function () {
const options = [
{ wday: 2, hour: '6-14' }
]
const convertedData = [
{ weekday: 2, from: '6:00', to: '15:00' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: Fri 3:02-21:41', function () {
const options = [
{ wday: 6, hour: '3', minute: '2-59' },
{ wday: 6, hour: '4-20' },
{ wday: 6, hour: '21', minute: '0-40' }
]
const convertedData = [
{ weekday: 6, from: '3:02', to: '21:41' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: Mon Mon 11:00-11:29, 9:01-10:00, Mon 14:05-15:00', function () {
const options = [
{ wday: 2, hour: '11', minute: '0-28' },
{ wday: 2, hour: '9', minute: '1-59' },
{ wday: 2, hour: '14', minute: '5-59' }
]
const convertedData = [
{ weekday: 2, from: '9:01', to: '10:00' },
{ weekday: 2, from: '11:00', to: '11:29' },
{ weekday: 2, from: '14:05', to: '15:00' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: Mon 0:00-23:59, Tue 0:00-23:58', function () {
// NOTE: 23:59 should be treated as 24:00 for TO field in interval
const options = [
{ wday: 2, hour: '0-23' },
{ wday: 3, hour: '0-22' },
{ wday: 3, hour: '23', minute: '0-57' }
]
const convertedData = [
{ weekday: 2, from: '0:00', to: '23:59' },
{ weekday: 3, from: '0:00', to: '23:58' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: automatic combining time intervals', function () {
const options = [
{ wday: 7, hour: '9-13' },
{ wday: 2, hour: '10-13' },
{ wday: 2, hour: '9', minute: '0-29' },
{ wday: 2, hour: '9', minute: '30-59' },
{ wday: 2, hour: '11-12', minute: '5-20' }
]
const convertedData = [
{ weekday: 2, from: '9:00', to: '14:00' },
{ weekday: 7, from: '9:00', to: '14:00' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: wday range', function () {
const options = [
{ wday: '1-4', hour: '8-16' },
{ wday: '2-4', hour: '17', minute: '0-29' },
{ wday: '6-7', hour: '8-16' }
]
const convertedData = [
{ weekday: 1, from: '8:00', to: '17:00' },
{ weekday: 2, from: '8:00', to: '17:30' },
{ weekday: 3, from: '8:00', to: '17:30' },
{ weekday: 4, from: '8:00', to: '17:30' },
{ weekday: 6, from: '8:00', to: '17:00' },
{ weekday: 7, from: '8:00', to: '17:00' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
it('case: hour range', function () {
const options = [
{ wday: '2-4', hour: '9-11', minute: '5-29' }
]
const convertedData = [
{ weekday: 2, from: '9:05', to: '9:30' },
{ weekday: 2, from: '10:05', to: '10:30' },
{ weekday: 2, from: '11:05', to: '11:30' },
{ weekday: 3, from: '9:05', to: '9:30' },
{ weekday: 3, from: '10:05', to: '10:30' },
{ weekday: 3, from: '11:05', to: '11:30' },
{ weekday: 4, from: '9:05', to: '9:30' },
{ weekday: 4, from: '10:05', to: '10:30' },
{ weekday: 4, from: '11:05', to: '11:30' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioTimesetToHuman(data))
})
})
// ---- implementation for date ranges ----
// ------------------------------------------
describe('Human readable datesets to Kamailio format converter helpers', function () {
it('case: an empty set', function () {
const options = []
const convertedData = []
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
const options2 = undefined
const convertedData2 = []
deepEqualCheckAndInputDataMutationCheck(options2, convertedData2, data => humanDatesetToKamailio(data))
})
it('case: required field have correct format', function () {
let options = [{}]
assert.throws(() => humanDatesetToKamailio(options))
options = [{ from: '', to: '' }]
assert.throws(() => humanDatesetToKamailio(options))
options = [{ from: '2020/01/01' }]
assert.throws(() => humanDatesetToKamailio(options))
options = [{ to: '2020/01/01' }]
assert.throws(() => humanDatesetToKamailio(options))
options = [{ from: '1:00', to: '2:00' }]
assert.throws(() => humanDatesetToKamailio(options))
options = [{ from: '2020/01/00', to: '2020/01/33' }]
assert.throws(() => humanDatesetToKamailio(options))
options = [{ from: '2020/01/01', to: '2020/01/02' }]
assert.doesNotThrow(() => humanDatesetToKamailio(options))
})
it('case: "from" date should be equal or less than "to" date', function () {
let options = [{ from: '2020/01/02', to: '2020/01/01' }]
assert.throws(() => humanDatesetToKamailio(options))
options = [{ from: '2020/01/01', to: '2020/01/01' }]
assert.doesNotThrow(() => humanDatesetToKamailio(options))
options = [{ from: '2020/01/01', to: '2020/01/23' }]
assert.doesNotThrow(() => humanDatesetToKamailio(options))
})
it('case: 2020/05/28', function () {
const options = [
{ from: '2020/05/28', to: '2020/05/28' }
]
const convertedData = [
{ year: 2020, month: 5, mday: 28 }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/04/05 and 2021/02/28', function () {
const options = [
{ from: '2021/02/28', to: '2021/02/28' },
{ from: '2020/04/05', to: '2020/04/05' }
]
const convertedData = [
{ year: 2020, month: 4, mday: 5 },
{ year: 2021, month: 2, mday: 28 }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: no leading zeroes 2020/1/2', function () {
const options = [
{ from: '2020/1/2', to: '2020/1/2' }
]
const convertedData = [
{ year: 2020, month: 1, mday: 2 }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/03/01-2020/03/31', function () {
const options = [
{ from: '2020/03/01', to: '2020/03/31' }
]
const convertedData = [
{ year: 2020, month: 3 }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/02/02-2020/02/11', function () {
const options = [
{ from: '2020/02/02', to: '2020/02/11' }
]
const convertedData = [
{ year: 2020, month: 2, mday: '2-11' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/01-2020/02/29', function () {
const options = [
{ from: '2020/01/01', to: '2020/02/29' }
]
const convertedData = [
{ year: 2020, month: '1-2' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/02-2020/02/15', function () {
const options = [
{ from: '2020/01/02', to: '2020/02/15' }
]
const convertedData = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: 2, mday: '1-15' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/01-2020/03/31', function () {
const options = [
{ from: '2020/01/01', to: '2020/03/31' }
]
const convertedData = [
{ year: 2020, month: '1-3' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/02-2020/03/31', function () {
const options = [
{ from: '2020/01/02', to: '2020/03/31' }
]
const convertedData = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-3' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/02-2020/03/23', function () {
const options = [
{ from: '2020/01/02', to: '2020/03/23' }
]
const convertedData = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: 2 },
{ year: 2020, month: 3, mday: '1-23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/02-2021/03/23', function () {
const options = [
{ from: '2020/01/02', to: '2021/03/23' }
]
const convertedData = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-12' },
{ year: 2021, month: '1-2' },
{ year: 2021, month: 3, mday: '1-23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/02-2022/03/23', function () {
const options = [
{ from: '2020/01/02', to: '2022/03/23' }
]
const convertedData = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-12' },
{ year: 2021 },
{ year: 2022, month: '1-2' },
{ year: 2022, month: 3, mday: '1-23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: merge 2020/01/02-2022/03/23, 2021/01/02-2023/03/23', function () {
const options = [
{ from: '2021/01/02', to: '2023/03/23' },
{ from: '2020/01/02', to: '2022/03/23' }
]
const convertedData = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-12' },
{ year: '2021-2022' },
{ year: 2023, month: '1-2' },
{ year: 2023, month: 3, mday: '1-23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: merge 2020/01/02-2021/02/28, 2021/03/01-2023/03/23', function () {
const options = [
{ from: '2021/03/01', to: '2023/03/23' },
{ from: '2020/01/02', to: '2021/02/28' }
]
const convertedData = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-12' },
{ year: '2021-2022' },
{ year: 2023, month: '1-2' },
{ year: 2023, month: 3, mday: '1-23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
it('case: 2020/01/02-2020/02/28 and 2021/01/02-2021/02/28 and 2022/01/02-2022/02/28', function () {
const options = [
{ from: '2021/01/02', to: '2021/02/28' },
{ from: '2020/01/02', to: '2020/02/28' },
{ from: '2022/01/02', to: '2022/02/28' }
]
const convertedData = [
{ year: '2020-2022', month: 1, mday: '2-31' },
{ year: 2020, month: 2, mday: '1-28' },
{ year: '2021-2022', month: 2 }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => humanDatesetToKamailio(data))
})
})
describe('Kamailio format to Human readable datesets converter helpers', function () {
it('case: an empty set', function () {
const options = []
const convertedData = []
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
const options2 = undefined
const convertedData2 = []
deepEqualCheckAndInputDataMutationCheck(options2, convertedData2, data => kamailioDatesetToHuman(data))
})
it('case: required field have correct format', function () {
let options = [{}]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ year: '', month: '', mday: '' }]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ month: '1', mday: '2' }]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ year: 2020, month: 2, mday: 3 }]
assert.doesNotThrow(() => kamailioDatesetToHuman(options))
options = [{ year: '2020-2023', month: '3-10', mday: '5-15' }]
assert.doesNotThrow(() => kamailioDatesetToHuman(options))
})
it('case: allowed values for ranges', function () {
let options = [{ year: '2020', month: '0' }]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ year: '2020', month: '13' }]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ year: '2020', month: '1', mday: '0' }]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ year: '2020', month: '1', mday: '32' }]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ year: '2021', month: '2', mday: '1-31' }]
assert.doesNotThrow(() => kamailioDatesetToHuman(options))
})
it('case: ranges with not existing dates', function () {
// Note: we are considering that even a Kamailio date range contains some rules withs not existing dates
// it's ok and it is might be some part of Kamailio format optimizations for smaller ruleset.
// So we just skipping not existing dates in output or normalizing
let options = [
{ year: '2020', month: '2', mday: '31' }
]
let convertedData = []
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
options = [
{ year: '2020', month: '1-2', mday: '31' }
]
convertedData = [
{ from: '2020/01/31', to: '2020/01/31' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
options = [
{ year: '2021', month: '2', mday: '1-31' }
]
convertedData = [
{ from: '2021/02/01', to: '2021/02/28' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
options = [
{ year: '2020-2021', month: '2', mday: '29-31' }
]
convertedData = [
{ from: '2020/02/29', to: '2020/02/29' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: reverse ranges', function () {
let options = [{ year: '2021', month: '10-2' }]
assert.throws(() => kamailioDatesetToHuman(options))
options = [{ year: '2021', mday: '30-1' }]
assert.throws(() => kamailioDatesetToHuman(options))
})
it('case: 2020/05/28', function () {
const options = [
{ year: 2020, month: 5, mday: 28 }
]
const convertedData = [
{ from: '2020/05/28', to: '2020/05/28' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/04/05 and 2021/02/28', function () {
const options = [
{ year: 2021, month: 2, mday: 28 },
{ year: 2020, month: 4, mday: 5 }
]
const convertedData = [
{ from: '2020/04/05', to: '2020/04/05' },
{ from: '2021/02/28', to: '2021/02/28' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: leading zeroes in string 2020/01/02', function () {
const options = [
{ year: '2020', month: '01', mday: '02' }
]
const convertedData = [
{ from: '2020/01/02', to: '2020/01/02' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/03/01-2020/03/31', function () {
const options = [
{ year: 2020, month: 3 }
]
const convertedData = [
{ from: '2020/03/01', to: '2020/03/31' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/02/02-2020/02/11', function () {
const options = [
{ year: 2020, month: 2, mday: '2-11' }
]
const convertedData = [
{ from: '2020/02/02', to: '2020/02/11' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/01-2020/02/29', function () {
const options = [
{ year: 2020, month: '1-2' }
]
const convertedData = [
{ from: '2020/01/01', to: '2020/02/29' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/02-2020/02/15', function () {
const options = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: 2, mday: '1-15' }
]
const convertedData = [
{ from: '2020/01/02', to: '2020/02/15' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/01-2020/03/31', function () {
const options = [
{ year: 2020, month: '1-3' }
]
const convertedData = [
{ from: '2020/01/01', to: '2020/03/31' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/02-2020/03/31', function () {
const options = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-3' }
]
const convertedData = [
{ from: '2020/01/02', to: '2020/03/31' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/02-2020/03/23', function () {
const options = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: 2 },
{ year: 2020, month: 3, mday: '1-23' }
]
const convertedData = [
{ from: '2020/01/02', to: '2020/03/23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/02-2021/03/23', function () {
const options = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-12' },
{ year: 2021, month: '1-2' },
{ year: 2021, month: 3, mday: '1-23' }
]
const convertedData = [
{ from: '2020/01/02', to: '2021/03/23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/02-2022/03/23', function () {
const options = [
{ year: 2020, month: 1, mday: '2-31' },
{ year: 2020, month: '2-12' },
{ year: 2021 },
{ year: 2022, month: '1-2' },
{ year: 2022, month: 3, mday: '1-23' }
]
const convertedData = [
{ from: '2020/01/02', to: '2022/03/23' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: merge 2020/01/01-2020/01/15 and 2020/01/05-2020/01/31', function () {
const options = [
{ year: 2020, month: 1, mday: '5-31' },
{ year: 2020, month: 1, mday: '5-31' },
{ year: 2020, month: 1, mday: '1-15' },
{ year: 2020, month: 1, mday: '1-15' }
]
const convertedData = [
{ from: '2020/01/01', to: '2020/01/31' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
it('case: 2020/01/02-2020/02/28 and 2021/01/02-2021/02/28 and 2022/01/02-2022/02/28', function () {
const options = [
{ year: '2021-2022', month: 2 },
{ year: 2020, month: 2, mday: '1-28' },
{ year: '2020-2022', month: 1, mday: '2-31' }
]
const convertedData = [
{ from: '2020/01/02', to: '2020/02/28' },
{ from: '2021/01/02', to: '2021/02/28' },
{ from: '2022/01/02', to: '2022/02/28' }
]
deepEqualCheckAndInputDataMutationCheck(options, convertedData, data => kamailioDatesetToHuman(data))
})
})
Reference in new issue View Git Blame Copy Permalink