mirror of
https://github.com/misskey-dev/misskey.git
synced 2024-12-21 04:35:09 +01:00
487 lines
11 KiB
TypeScript
487 lines
11 KiB
TypeScript
process.env.NODE_ENV = 'test';
|
|
|
|
import * as assert from 'assert';
|
|
import * as lolex from '@sinonjs/fake-timers';
|
|
import { async, initTestDb } from './utils';
|
|
import TestChart from '../src/services/chart/charts/test';
|
|
import TestGroupedChart from '../src/services/chart/charts/test-grouped';
|
|
import TestUniqueChart from '../src/services/chart/charts/test-unique';
|
|
import * as _TestChart from '../src/services/chart/charts/entities/test';
|
|
import * as _TestGroupedChart from '../src/services/chart/charts/entities/test-grouped';
|
|
import * as _TestUniqueChart from '../src/services/chart/charts/entities/test-unique';
|
|
|
|
describe('Chart', () => {
|
|
let testChart: TestChart;
|
|
let testGroupedChart: TestGroupedChart;
|
|
let testUniqueChart: TestUniqueChart;
|
|
let clock: lolex.Clock;
|
|
|
|
beforeEach(async(async () => {
|
|
await initTestDb(false, [
|
|
_TestChart.entity.hour, _TestChart.entity.day,
|
|
_TestGroupedChart.entity.hour, _TestGroupedChart.entity.day,
|
|
_TestUniqueChart.entity.hour, _TestUniqueChart.entity.day,
|
|
]);
|
|
|
|
testChart = new TestChart();
|
|
testGroupedChart = new TestGroupedChart();
|
|
testUniqueChart = new TestUniqueChart();
|
|
|
|
clock = lolex.install({
|
|
now: new Date(Date.UTC(2000, 0, 1, 0, 0, 0))
|
|
});
|
|
}));
|
|
|
|
afterEach(async(async () => {
|
|
clock.uninstall();
|
|
}));
|
|
|
|
it('Can updates', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('Can updates (dec)', async(async () => {
|
|
await testChart.decrement();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [1, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [-1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [1, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [-1, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('Empty chart', async(async () => {
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [0, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [0, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('Can updates at multiple times at same time', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.increment();
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [3, 0, 0],
|
|
total: [3, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [3, 0, 0],
|
|
total: [3, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('複数回saveされてもデータの更新は一度だけ', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
await testChart.save();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('Can updates at different times', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
clock.tick('01:00:00');
|
|
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 1, 0],
|
|
total: [2, 1, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [2, 0, 0],
|
|
total: [2, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
// 仕様上はこうなってほしいけど、実装は難しそうなのでskip
|
|
/*
|
|
it('Can updates at different times without save', async(async () => {
|
|
await testChart.increment();
|
|
|
|
clock.tick('01:00:00');
|
|
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 1, 0],
|
|
total: [2, 1, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [2, 0, 0],
|
|
total: [2, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
*/
|
|
|
|
it('Can padding', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
clock.tick('02:00:00');
|
|
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 1],
|
|
total: [2, 1, 1]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [2, 0, 0],
|
|
total: [2, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
// 要求された範囲にログがひとつもない場合でもパディングできる
|
|
it('Can padding from past range', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
clock.tick('05:00:00');
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [1, 1, 1]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
// 要求された範囲の最も古い箇所に位置するログが存在しない場合でもパディングできる
|
|
// Issue #3190
|
|
it('Can padding from past range 2', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
clock.tick('05:00:00');
|
|
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [2, 1, 1]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [2, 0, 0],
|
|
total: [2, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('Can specify offset', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
clock.tick('01:00:00');
|
|
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, new Date(Date.UTC(2000, 0, 1, 0, 0, 0)));
|
|
const chartDays = await testChart.getChart('day', 3, new Date(Date.UTC(2000, 0, 1, 0, 0, 0)));
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [2, 0, 0],
|
|
total: [2, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('Can specify offset (floor time)', async(async () => {
|
|
clock.tick('00:30:00');
|
|
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
clock.tick('01:30:00');
|
|
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, new Date(Date.UTC(2000, 0, 1, 0, 0, 0)));
|
|
const chartDays = await testChart.getChart('day', 3, new Date(Date.UTC(2000, 0, 1, 0, 0, 0)));
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [2, 0, 0],
|
|
total: [2, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
describe('Grouped', () => {
|
|
it('Can updates', async(async () => {
|
|
await testGroupedChart.increment('alice');
|
|
await testGroupedChart.save();
|
|
|
|
const aliceChartHours = await testGroupedChart.getChart('hour', 3, null, 'alice');
|
|
const aliceChartDays = await testGroupedChart.getChart('day', 3, null, 'alice');
|
|
const bobChartHours = await testGroupedChart.getChart('hour', 3, null, 'bob');
|
|
const bobChartDays = await testGroupedChart.getChart('day', 3, null, 'bob');
|
|
|
|
assert.deepStrictEqual(aliceChartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(aliceChartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(bobChartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [0, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(bobChartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [0, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
});
|
|
|
|
describe('Unique increment', () => {
|
|
it('Can updates', async(async () => {
|
|
await testUniqueChart.uniqueIncrement('alice');
|
|
await testUniqueChart.uniqueIncrement('alice');
|
|
await testUniqueChart.uniqueIncrement('bob');
|
|
await testUniqueChart.save();
|
|
|
|
const chartHours = await testUniqueChart.getChart('hour', 3, null);
|
|
const chartDays = await testUniqueChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: [2, 0, 0],
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: [2, 0, 0],
|
|
});
|
|
}));
|
|
});
|
|
|
|
describe('Resync', () => {
|
|
it('Can resync', async(async () => {
|
|
testChart.total = 1;
|
|
|
|
await testChart.resync();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 0, 0],
|
|
total: [1, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
|
|
it('Can resync (2)', async(async () => {
|
|
await testChart.increment();
|
|
await testChart.save();
|
|
|
|
clock.tick('01:00:00');
|
|
|
|
testChart.total = 100;
|
|
|
|
await testChart.resync();
|
|
|
|
const chartHours = await testChart.getChart('hour', 3, null);
|
|
const chartDays = await testChart.getChart('day', 3, null);
|
|
|
|
assert.deepStrictEqual(chartHours, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [0, 1, 0],
|
|
total: [100, 1, 0]
|
|
},
|
|
});
|
|
|
|
assert.deepStrictEqual(chartDays, {
|
|
foo: {
|
|
dec: [0, 0, 0],
|
|
inc: [1, 0, 0],
|
|
total: [100, 0, 0]
|
|
},
|
|
});
|
|
}));
|
|
});
|
|
});
|