182 lines
6.1 KiB
TypeScript
182 lines
6.1 KiB
TypeScript
import axios from "axios"
|
|
import faker from "faker"
|
|
import { config } from '../config'
|
|
import { CertificateRunner } from '../models/CertificateRunner'
|
|
import { DistanceDonation } from '../models/DistanceDonation'
|
|
import { Donor } from '../models/Donor'
|
|
import { Runner } from '../models/Runner'
|
|
import { RunnerCard } from '../models/RunnerCard'
|
|
import { RunnerGroup } from '../models/RunnerGroup'
|
|
|
|
const baseurl = "http://localhost:4010"
|
|
const key = config.api_key;
|
|
|
|
axios.interceptors.request.use((config) => {
|
|
config.headers['request-startTime'] = process.hrtime()
|
|
return config
|
|
})
|
|
|
|
axios.interceptors.response.use((response) => {
|
|
const start = response.config.headers['request-startTime']
|
|
const end = process.hrtime(start)
|
|
const milliseconds = Math.round((end[0] * 1000) + (end[1] / 1000000))
|
|
response.headers['request-duration'] = milliseconds
|
|
return response
|
|
})
|
|
|
|
function generateRunners(amount: number): Runner[] {
|
|
let runners: Runner[] = new Array<Runner>();
|
|
let group = new RunnerGroup();
|
|
let runner = new Runner();
|
|
for (var i = 0; i < amount; i++) {
|
|
group.name = faker.company.bsBuzz();
|
|
group.id = Math.floor(Math.random() * (9999999 - 1) + 1);
|
|
runner.firstname = faker.name.firstName();
|
|
runner.lastname = faker.name.lastName();
|
|
runner.id = Math.floor(Math.random() * (9999999 - 1) + 1);
|
|
runners.push(runner);
|
|
}
|
|
return runners;
|
|
}
|
|
|
|
function generateCards(amount: number): RunnerCard[] {
|
|
let cards: RunnerCard[] = new Array<RunnerCard>();
|
|
let card = new RunnerCard();
|
|
for (let runner of generateRunners(amount)) {
|
|
card.id = runner.id;
|
|
card.code = idToEan13(card.id);
|
|
card.runner = runner;
|
|
cards.push(card);
|
|
}
|
|
return cards;
|
|
}
|
|
|
|
function generateCertificateRunners(amount: number): CertificateRunner[] {
|
|
let runners: CertificateRunner[] = new Array<CertificateRunner>();
|
|
let group = new RunnerGroup();
|
|
let runner = new CertificateRunner();
|
|
let donor = new Donor();
|
|
let donation = new DistanceDonation();
|
|
for (var i = 0; i < amount; i++) {
|
|
group.name = faker.company.bsBuzz();
|
|
group.id = Math.floor(Math.random() * (9999999 - 1) + 1);
|
|
|
|
donor.firstname = faker.name.firstName();
|
|
donor.lastname = faker.name.lastName();
|
|
donor.id = Math.floor(Math.random() * (9999999 - 1) + 1);
|
|
|
|
runner.firstname = faker.name.firstName();
|
|
runner.lastname = faker.name.lastName();
|
|
runner.id = Math.floor(Math.random() * (9999999 - 1) + 1);
|
|
runner.distance = Math.floor(Math.random() * (9999999 - 1) + 1);
|
|
|
|
donation.id = Math.floor(Math.random() * (9999999 - 1) + 1);
|
|
donation.donor = donor;
|
|
donation.runner = runner;
|
|
donation.amountPerDistance = Math.floor(Math.random() * (10000 - 1) + 1);
|
|
|
|
runner.distanceDonations = [donation, donation]
|
|
runners.push(runner);
|
|
}
|
|
return runners;
|
|
}
|
|
|
|
function idToEan13(id): string {
|
|
const multiply = [1, 3];
|
|
id = id.toString();
|
|
|
|
if (id.length > 12) {
|
|
throw new Error("id too long");
|
|
}
|
|
while (id.length < 12) { id = '0' + id; }
|
|
|
|
let total = 0;
|
|
id.split('').forEach((letter, index) => {
|
|
total += parseInt(letter, 10) * multiply[index % 2];
|
|
});
|
|
const checkSum = (Math.ceil(total / 10) * 10) - total;
|
|
return id + checkSum.toString();
|
|
}
|
|
|
|
async function postContracts(runners: Runner[]): Promise<Measurement> {
|
|
const res = await axios.post(`${baseurl}/contracts?key=${key}`, runners);
|
|
return new Measurement("contract", runners.length, parseInt(res.headers['request-duration']))
|
|
}
|
|
|
|
async function postCards(cards: RunnerCard[]): Promise<Measurement> {
|
|
const res = await axios.post(`${baseurl}/cards?key=${key}`, cards);
|
|
return new Measurement("card", cards.length, parseInt(res.headers['request-duration']))
|
|
}
|
|
|
|
async function postCertificates(runners: CertificateRunner[]): Promise<Measurement> {
|
|
const res = await axios.post(`${baseurl}/certificates?key=${key}`, runners);
|
|
return new Measurement("certificate", runners.length, parseInt(res.headers['request-duration']))
|
|
}
|
|
|
|
async function testContracts(sizes): Promise<Measurement[]> {
|
|
let measurements = new Array<Measurement>();
|
|
console.log("#### Testing contracts ####");
|
|
|
|
for (let size of sizes) {
|
|
const m = await postContracts(generateRunners(size));
|
|
console.log(m.toString());
|
|
measurements.push(m);
|
|
}
|
|
return measurements;
|
|
}
|
|
|
|
async function testCards(sizes): Promise<Measurement[]> {
|
|
let measurements = new Array<Measurement>();
|
|
console.log("#### Testing Cards ####");
|
|
|
|
for (let size of sizes) {
|
|
const m = await postCards(generateCards(size));
|
|
console.log(m.toString());
|
|
measurements.push(m);
|
|
}
|
|
return measurements;
|
|
}
|
|
|
|
async function testCertificates(sizes): Promise<Measurement[]> {
|
|
let measurements = new Array<Measurement>();
|
|
console.log("#### Testing Certificates ####");
|
|
|
|
for (let size of sizes) {
|
|
const m = await postCertificates(generateCertificateRunners(size));
|
|
console.log(m.toString());
|
|
measurements.push(m);
|
|
}
|
|
return measurements;
|
|
}
|
|
|
|
async function main() {
|
|
const sizes = [1, 10, 50, 100]
|
|
console.log("########### Speedtest ###########");
|
|
console.log(`Document server version (according to the api): ${(await axios.get("http://localhost:4010/version")).data.version}`);
|
|
console.log("####### Running tests #######");
|
|
const contractResults = await testContracts(sizes);
|
|
const cardResults = await testCards(sizes);
|
|
const certificateResults = await testCertificates(sizes);
|
|
console.log("####### Results #######");
|
|
console.table(contractResults);
|
|
console.table(cardResults);
|
|
console.table(certificateResults);
|
|
}
|
|
|
|
main();
|
|
|
|
class Measurement {
|
|
public type: string;
|
|
public inputcount: number;
|
|
public responsetime: number;
|
|
|
|
constructor(type: string, input: number, time: number) {
|
|
this.type = type;
|
|
this.inputcount = input;
|
|
this.responsetime = time;
|
|
}
|
|
|
|
public toString(): string {
|
|
return `It took ${this.responsetime}ms to generate ${this.inputcount} pdfs for the type ${this.type}.`
|
|
}
|
|
} |