lfk/backend
2
0
Fork 0
Code Issues 1 Pull Requests Actions Projects Releases 40 Activity

Merge branch 'dev' into feature/104-contacts

Browse Source
This commit is contained in:
Nicolai Ort 2021-01-19 16:44:34 +01:00
commit 703b4f89a6
26 changed files with 1761 additions and 1497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.env.ci
View File

@ -6,4 +6,4 @@ DB_USER=unused
DB_PASSWORD=bla DB_PASSWORD=bla
DB_NAME=./test.sqlite DB_NAME=./test.sqlite
NODE_ENV=dev NODE_ENV=dev
POSTALCODE_COUNTRYCODE=null POSTALCODE_COUNTRYCODE=DE

27
CHANGELOG.md
View File

@ -2,8 +2,35 @@
All notable changes to this project will be documented in this file. Dates are displayed in UTC. All notable changes to this project will be documented in this file. Dates are displayed in UTC.
#### [v0.1.1](https://git.odit.services/lfk/backend/compare/v0.1.1...v0.1.1)
- Merge pull request 'Fully implemented addresses feature/105-addresses' (#107) from feature/105-addresses into dev [`5e36855`](https://git.odit.services/lfk/backend/commit/5e368552ea810ea1d3963b1207ba98f7b46c4abc)
- Cleaned up var names [`a3c93f0`](https://git.odit.services/lfk/backend/commit/a3c93f0d394833f1a6f78d862b094ca751c85561)
- Added address update ivalid tests [`427dfaa`](https://git.odit.services/lfk/backend/commit/427dfaafabd243e94aba27c2dec2705fd8ed5d64)
- Added first address update tests [`4d40225`](https://git.odit.services/lfk/backend/commit/4d40225a4491e8eb3f41ef0fd558a599f63729be)
- Added address update valid tests [`230cdb0`](https://git.odit.services/lfk/backend/commit/230cdb0e37e2b7a21e7feb156f2b91a69ad200fd)
- Implemented deep address validation [`9dc9ce3`](https://git.odit.services/lfk/backend/commit/9dc9ce37d8fbfc92842e4e05bbde68398324a186)
- Removed old create address class [`2a465f8`](https://git.odit.services/lfk/backend/commit/2a465f88c58c0b4be3ecd99d96a04c177a40b312)
- Switched the create classes over to the new address implementation [`2cd15d2`](https://git.odit.services/lfk/backend/commit/2cd15d25e934a5439bfea4de901f136e360e17f6)
- Test's now accept the new address format [`8dbee32`](https://git.odit.services/lfk/backend/commit/8dbee32eeec8ee3d013e4446e8f53544ee4cb577)
- Removed the IAddressUser Interface entity [`e265172`](https://git.odit.services/lfk/backend/commit/e2651728c5abf2273bf51a7652c51d55d8fa0a2f)
- Switched Address to embedded entity [`7fbe649`](https://git.odit.services/lfk/backend/commit/7fbe649dc90f4bb9f240c5a80fed447048e5e105)
- Removed the address errors [`58ae9b5`](https://git.odit.services/lfk/backend/commit/58ae9b589aef3580f4b8558c3d5ddbd7171e7915)
- Switched the update classes over to the new address implementation [`d0df5dd`](https://git.odit.services/lfk/backend/commit/d0df5dd641ac17f1fd8ad6bd8b46afa9dd2745c3)
- Implemented adress deletion (through reset) [`57b9c2b`](https://git.odit.services/lfk/backend/commit/57b9c2babcd68d69d1cbb240a86c2897717ba758)
- Fixed donor address check [`4824547`](https://git.odit.services/lfk/backend/commit/4824547dde4d7f90e9e2377a26df34cabf082fdb)
- Updated the responseclasses to use the new address implementation [`dafac06`](https://git.odit.services/lfk/backend/commit/dafac06bc84d1b237096a561b3adcd3ca5cb1dd8)
- Removed (now useless) relations [`673dea2`](https://git.odit.services/lfk/backend/commit/673dea2e5754e99ff77f7556d4fc03d4cca28a94)
- Added address validity check [`ae7c5ff`](https://git.odit.services/lfk/backend/commit/ae7c5ff0c387e9337d01a9dd819a4dddc208f6dd)
- 🧾New changelog file version [CI SKIP] [skip ci] [`f53894b`](https://git.odit.services/lfk/backend/commit/f53894b16ac1c06ecbeeb0b63a56ac438b2fbe1b)
- Updated comments [`8bc01d3`](https://git.odit.services/lfk/backend/commit/8bc01d3f2406ce8e58c2ab2963c858495c510dcf)
- Set country code for the ci env to DE [`30b585c`](https://git.odit.services/lfk/backend/commit/30b585c0c12b3b9818778110d33d5b3ab84d4192)
- Implemented postal code validation for the validaton function [`f245840`](https://git.odit.services/lfk/backend/commit/f245840cde5726611197b00730aca72ea133c427)
#### [v0.1.1](https://git.odit.services/lfk/backend/compare/v0.1.0...v0.1.1) #### [v0.1.1](https://git.odit.services/lfk/backend/compare/v0.1.0...v0.1.1)
> 16 January 2021
- Merge pull request 'Alpha Release 0.1.1 - Hotfix release' (#106) from dev into main [`7533c34`](https://git.odit.services/lfk/backend/commit/7533c349ef98ed328151259fca68621b3eb5fd98) - Merge pull request 'Alpha Release 0.1.1 - Hotfix release' (#106) from dev into main [`7533c34`](https://git.odit.services/lfk/backend/commit/7533c349ef98ed328151259fca68621b3eb5fd98)
- 🚀Bumped version to v0.1.1 [`9445c6f`](https://git.odit.services/lfk/backend/commit/9445c6f21e376329b9200664a44a94ba1f1dd463) - 🚀Bumped version to v0.1.1 [`9445c6f`](https://git.odit.services/lfk/backend/commit/9445c6f21e376329b9200664a44a94ba1f1dd463)
- 🧾New changelog file version [CI SKIP] [skip ci] [`1b9d296`](https://git.odit.services/lfk/backend/commit/1b9d2969ebdca4dca84898b1e8307be7b781b90b) - 🧾New changelog file version [CI SKIP] [skip ci] [`1b9d296`](https://git.odit.services/lfk/backend/commit/1b9d2969ebdca4dca84898b1e8307be7b781b90b)

10
src/controllers/RunnerOrganisationController.ts
View File

@ -29,7 +29,7 @@ export class RunnerOrganisationController {
@OpenAPI({ description: 'Lists all organisations. <br> This includes their address, contact and teams (if existing/associated).' }) @OpenAPI({ description: 'Lists all organisations. <br> This includes their address, contact and teams (if existing/associated).' })
async getAll() { async getAll() {
let responseTeams: ResponseRunnerOrganisation[] = new Array<ResponseRunnerOrganisation>(); let responseTeams: ResponseRunnerOrganisation[] = new Array<ResponseRunnerOrganisation>();
const runners = await this.runnerOrganisationRepository.find({ relations: ['address', 'contact', 'teams'] }); const runners = await this.runnerOrganisationRepository.find({ relations: ['contact', 'teams'] });
runners.forEach(runner => { runners.forEach(runner => {
responseTeams.push(new ResponseRunnerOrganisation(runner)); responseTeams.push(new ResponseRunnerOrganisation(runner));
}); });
@ -43,7 +43,7 @@ export class RunnerOrganisationController {
@OnUndefined(RunnerOrganisationNotFoundError) @OnUndefined(RunnerOrganisationNotFoundError)
@OpenAPI({ description: 'Lists all information about the organisation whose id got provided.' }) @OpenAPI({ description: 'Lists all information about the organisation whose id got provided.' })
async getOne(@Param('id') id: number) { async getOne(@Param('id') id: number) {
let runnerOrg = await this.runnerOrganisationRepository.findOne({ id: id }, { relations: ['address', 'contact', 'teams'] }); let runnerOrg = await this.runnerOrganisationRepository.findOne({ id: id }, { relations: ['contact', 'teams'] });
if (!runnerOrg) { throw new RunnerOrganisationNotFoundError(); } if (!runnerOrg) { throw new RunnerOrganisationNotFoundError(); }
return new ResponseRunnerOrganisation(runnerOrg); return new ResponseRunnerOrganisation(runnerOrg);
} }
@ -62,7 +62,7 @@ export class RunnerOrganisationController {
runnerOrganisation = await this.runnerOrganisationRepository.save(runnerOrganisation); runnerOrganisation = await this.runnerOrganisationRepository.save(runnerOrganisation);
return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(runnerOrganisation, { relations: ['address', 'contact', 'teams'] })); return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(runnerOrganisation, { relations: ['contact', 'teams'] }));
} }
@Put('/:id') @Put('/:id')
@ -84,7 +84,7 @@ export class RunnerOrganisationController {
await this.runnerOrganisationRepository.save(await updateOrganisation.update(oldRunnerOrganisation)); await this.runnerOrganisationRepository.save(await updateOrganisation.update(oldRunnerOrganisation));
return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(id, { relations: ['address', 'contact', 'teams'] })); return new ResponseRunnerOrganisation(await this.runnerOrganisationRepository.findOne(id, { relations: ['contact', 'teams'] }));
} }
@Delete('/:id') @Delete('/:id')
@ -98,7 +98,7 @@ export class RunnerOrganisationController {
async remove(@Param("id") id: number, @QueryParam("force") force: boolean) { async remove(@Param("id") id: number, @QueryParam("force") force: boolean) {
let organisation = await this.runnerOrganisationRepository.findOne({ id: id }); let organisation = await this.runnerOrganisationRepository.findOne({ id: id });
if (!organisation) { return null; } if (!organisation) { return null; }
let runnerOrganisation = await this.runnerOrganisationRepository.findOne(organisation, { relations: ['address', 'contact', 'runners', 'teams'] }); let runnerOrganisation = await this.runnerOrganisationRepository.findOne(organisation, { relations: ['contact', 'runners', 'teams'] });
if (!force) { if (!force) {
if (runnerOrganisation.teams.length != 0) { if (runnerOrganisation.teams.length != 0) {

79
src/errors/AddressErrors.ts
View File

@ -1,24 +1,57 @@
import { IsString } from 'class-validator'; import { IsString } from 'class-validator';
import { NotAcceptableError, NotFoundError } from 'routing-controllers'; import { BadRequestError } from 'routing-controllers';
/** /**
* Error to throw, when to provided address doesn't belong to the accepted types. * Error to throw when an address's postal code fails validation.
*/ */
export class AddressWrongTypeError extends NotAcceptableError { export class AddressPostalCodeInvalidError extends BadRequestError {
@IsString() @IsString()
name = "AddressWrongTypeError" name = "AddressPostalCodeInvalidError"
@IsString() @IsString()
message = "The address must be an existing address's id. \n You provided a object of another type." message = "The postal code you provided is invalid. \n Please check if your postal code follows the postal code validation guidelines."
} }
/** /**
* Error to throw, when a non-existent address get's loaded. * Error to throw when an non-empty address's first line isn't set.
*/ */
export class AddressNotFoundError extends NotFoundError { export class AddressFirstLineEmptyError extends BadRequestError {
@IsString() @IsString()
name = "AddressNotFoundError" name = "AddressFirstLineEmptyError"
@IsString() @IsString()
message = "The address you provided couldn't be located in the system. \n Please check your request." message = "You provided a empty first address line. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
}
/**
* Error to throw when an non-empty address's postal code isn't set.
*/
export class AddressPostalCodeEmptyError extends BadRequestError {
@IsString()
name = "AddressPostalCodeEmptyError"
@IsString()
message = "You provided a empty postal code. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
}
/**
* Error to throw when an non-empty address's city isn't set.
*/
export class AddressCityEmptyError extends BadRequestError {
@IsString()
name = "AddressCityEmptyError"
@IsString()
message = "You provided a empty city. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
}
/**
* Error to throw when an non-empty address's country isn't set.
*/
export class AddressCountryEmptyError extends BadRequestError {
@IsString()
name = "AddressCountryEmptyError"
@IsString()
message = "You provided a empty country. \n If you want an empty address please set all propertys to null. \n For non-empty addresses the following fields have to be set: address1, postalcode, city, country"
} }

69
src/models/actions/create/CreateAddress.ts
View File

@ -1,69 +0,0 @@
import { IsNotEmpty, IsOptional, IsPostalCode, IsString } from 'class-validator';
import { config } from '../../../config';
import { Address } from '../../entities/Address';
/**
* This classed is used to create a new Address entity from a json body (post request).
*/
export class CreateAddress {
/**
* The newaddress's description.
*/
@IsString()
@IsOptional()
description?: string;
/**
* The new address's first line.
* Containing the street and house number.
*/
@IsString()
@IsNotEmpty()
address1: string;
/**
* The new address's second line.
* Containing optional information.
*/
@IsString()
@IsOptional()
address2?: string;
/**
* The new address's postal code.
* This will get checked against the postal code syntax for the configured country.
*/
@IsString()
@IsNotEmpty()
@IsPostalCode(config.postalcode_validation_countrycode)
postalcode: string;
/**
* The new address's city.
*/
@IsString()
@IsNotEmpty()
city: string;
/**
* The new address's country.
*/
@IsString()
@IsNotEmpty()
country: string;
/**
* Creates a new Address entity from this.
*/
public async toEntity(): Promise<Address> {
let newAddress: Address = new Address();
newAddress.address1 = this.address1;
newAddress.address2 = this.address2;
newAddress.postalcode = this.postalcode;
newAddress.city = this.city;
newAddress.country = this.country;
return newAddress;
}
}

75
src/models/actions/create/CreateDonor.ts
View File

@ -1,38 +1,39 @@
import { IsBoolean, IsOptional } from 'class-validator'; import { IsBoolean, IsOptional } from 'class-validator';
import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors'; import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors';
import { Donor } from '../../entities/Donor'; import { Address } from '../../entities/Address';
import { CreateParticipant } from './CreateParticipant'; import { Donor } from '../../entities/Donor';
import { CreateParticipant } from './CreateParticipant';
/**
* This classed is used to create a new Donor entity from a json body (post request). /**
*/ * This classed is used to create a new Donor entity from a json body (post request).
export class CreateDonor extends CreateParticipant { */
export class CreateDonor extends CreateParticipant {
/**
* Does this donor need a receipt? /**
*/ * Does this donor need a receipt?
@IsBoolean() */
@IsOptional() @IsBoolean()
receiptNeeded?: boolean = false; @IsOptional()
receiptNeeded?: boolean = false;
/**
* Creates a new Donor entity from this. /**
*/ * Creates a new Donor entity from this.
public async toEntity(): Promise<Donor> { */
let newDonor: Donor = new Donor(); public async toEntity(): Promise<Donor> {
let newDonor: Donor = new Donor();
newDonor.firstname = this.firstname;
newDonor.middlename = this.middlename; newDonor.firstname = this.firstname;
newDonor.lastname = this.lastname; newDonor.middlename = this.middlename;
newDonor.phone = this.phone; newDonor.lastname = this.lastname;
newDonor.email = this.email; newDonor.phone = this.phone;
newDonor.address = await this.getAddress(); newDonor.email = this.email;
newDonor.receiptNeeded = this.receiptNeeded; newDonor.receiptNeeded = this.receiptNeeded;
newDonor.address = this.address;
if (this.receiptNeeded == true && this.address == null) { Address.validate(newDonor.address);
throw new DonorReceiptAddressNeededError() if (this.receiptNeeded == true && Address.isValidAddress(newDonor.address) == false) {
} throw new DonorReceiptAddressNeededError()
}
return newDonor;
} return newDonor;
}
} }

144
src/models/actions/create/CreateGroupContact.ts
View File

@ -1,78 +1,68 @@
import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator'; import { IsEmail, IsNotEmpty, IsObject, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
import { getConnectionManager } from 'typeorm'; import { config } from '../../../config';
import { config } from '../../../config'; import { Address } from '../../entities/Address';
import { AddressNotFoundError } from '../../../errors/AddressErrors'; import { GroupContact } from '../../entities/GroupContact';
import { Address } from '../../entities/Address';
import { GroupContact } from '../../entities/GroupContact'; /**
* This classed is used to create a new Group entity from a json body (post request).
/** */
* This classed is used to create a new Group entity from a json body (post request). export class CreateGroupContact {
*/ /**
export class CreateGroupContact { * The new contact's first name.
/** */
* The new contact's first name. @IsNotEmpty()
*/ @IsString()
@IsNotEmpty() firstname: string;
@IsString()
firstname: string; /**
* The new contact's middle name.
/** */
* The new contact's middle name. @IsOptional()
*/ @IsString()
@IsOptional() middlename?: string;
@IsString()
middlename?: string; /**
* The new contact's last name.
/** */
* The new contact's last name. @IsNotEmpty()
*/ @IsString()
@IsNotEmpty() lastname: string;
@IsString()
lastname: string; /**
* The new contact's address.
/** */
* The new contact's address's id. @IsOptional()
*/ @IsObject()
@IsInt() address?: Address;
@IsOptional()
address?: number; /**
* The contact's phone number.
/** * This will be validated against the configured country phone numer syntax (default: international).
* The contact's phone number. */
* This will be validated against the configured country phone numer syntax (default: international). @IsOptional()
*/ @IsPhoneNumber(config.phone_validation_countrycode)
@IsOptional() phone?: string;
@IsPhoneNumber(config.phone_validation_countrycode)
phone?: string; /**
* The contact's email address.
/** */
* The contact's email address. @IsOptional()
*/ @IsEmail()
@IsOptional() email?: string;
@IsEmail()
email?: string;
/**
/** * Creates a new Address entity from this.
* Gets the new contact's address by it's id. */
*/ public async toEntity(): Promise<GroupContact> {
public async getAddress(): Promise<Address> { let contact: GroupContact = new GroupContact();
if (!this.address) { return null; } contact.firstname = this.firstname;
let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address }); contact.middlename = this.middlename;
if (!address) { throw new AddressNotFoundError; } contact.lastname = this.lastname;
return address; contact.email = this.email;
} contact.phone = this.phone;
contact.address = this.address;
/** Address.validate(contact.address);
* Creates a new Address entity from this. return contact;
*/ }
public async toEntity(): Promise<GroupContact> {
let contact: GroupContact = new GroupContact();
contact.firstname = this.firstname;
contact.middlename = this.middlename;
contact.lastname = this.lastname;
contact.email = this.email;
contact.phone = this.phone;
contact.address = await this.getAddress();
return null;
}
} }

116
src/models/actions/create/CreateParticipant.ts
View File

@ -1,65 +1,53 @@
import { IsEmail, IsInt, IsNotEmpty, IsOptional, IsPhoneNumber, IsString } from 'class-validator'; import { IsEmail, IsNotEmpty, IsObject, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
import { getConnectionManager } from 'typeorm'; import { config } from '../../../config';
import { config } from '../../../config'; import { Address } from '../../entities/Address';
import { AddressNotFoundError } from '../../../errors/AddressErrors';
import { Address } from '../../entities/Address'; /**
* This classed is used to create a new Participant entity from a json body (post request).
/** */
* This classed is used to create a new Participant entity from a json body (post request). export abstract class CreateParticipant {
*/ /**
export abstract class CreateParticipant { * The new participant's first name.
/** */
* The new participant's first name. @IsString()
*/ @IsNotEmpty()
@IsString() firstname: string;
@IsNotEmpty()
firstname: string; /**
* The new participant's middle name.
/** */
* The new participant's middle name. @IsString()
*/ @IsOptional()
@IsString() middlename?: string;
@IsOptional()
middlename?: string; /**
* The new participant's last name.
/** */
* The new participant's last name. @IsString()
*/ @IsNotEmpty()
@IsString() lastname: string;
@IsNotEmpty()
lastname: string; /**
* The new participant's phone number.
/** * This will be validated against the configured country phone numer syntax (default: international).
* The new participant's phone number. */
* This will be validated against the configured country phone numer syntax (default: international). @IsString()
*/ @IsOptional()
@IsString() @IsPhoneNumber(config.phone_validation_countrycode)
@IsOptional() phone?: string;
@IsPhoneNumber(config.phone_validation_countrycode)
phone?: string; /**
* The new participant's e-mail address.
/** */
* The new participant's e-mail address. @IsString()
*/ @IsOptional()
@IsString() @IsEmail()
@IsOptional() email?: string;
@IsEmail()
email?: string; /**
* The new participant's address.
/** */
* The new participant's address's id. @IsOptional()
*/ @IsObject()
@IsInt() address?: Address;
@IsOptional()
address?: number;
/**
* Gets the new participant's address by it's id.
*/
public async getAddress(): Promise<Address> {
if (!this.address) { return null; }
let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address });
if (!address) { throw new AddressNotFoundError; }
return address;
}
} }

106
src/models/actions/create/CreateRunner.ts
View File

@ -1,53 +1,55 @@
import { IsInt } from 'class-validator'; import { IsInt } from 'class-validator';
import { getConnectionManager } from 'typeorm'; import { getConnectionManager } from 'typeorm';
import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors'; import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
import { RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors'; import { RunnerOrganisationWrongTypeError } from '../../../errors/RunnerOrganisationErrors';
import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors'; import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
import { Runner } from '../../entities/Runner'; import { Address } from '../../entities/Address';
import { RunnerGroup } from '../../entities/RunnerGroup'; import { Runner } from '../../entities/Runner';
import { CreateParticipant } from './CreateParticipant'; import { RunnerGroup } from '../../entities/RunnerGroup';
import { CreateParticipant } from './CreateParticipant';
/**
* This classed is used to create a new Runner entity from a json body (post request). /**
*/ * This classed is used to create a new Runner entity from a json body (post request).
export class CreateRunner extends CreateParticipant { */
export class CreateRunner extends CreateParticipant {
/**
* The new runner's group's id. /**
*/ * The new runner's group's id.
@IsInt() */
group: number; @IsInt()
group: number;
/**
* Creates a new Runner entity from this. /**
*/ * Creates a new Runner entity from this.
public async toEntity(): Promise<Runner> { */
let newRunner: Runner = new Runner(); public async toEntity(): Promise<Runner> {
let newRunner: Runner = new Runner();
newRunner.firstname = this.firstname;
newRunner.middlename = this.middlename; newRunner.firstname = this.firstname;
newRunner.lastname = this.lastname; newRunner.middlename = this.middlename;
newRunner.phone = this.phone; newRunner.lastname = this.lastname;
newRunner.email = this.email; newRunner.phone = this.phone;
newRunner.group = await this.getGroup(); newRunner.email = this.email;
newRunner.address = await this.getAddress(); newRunner.group = await this.getGroup();
newRunner.address = this.address;
return newRunner; Address.validate(newRunner.address);
}
return newRunner;
/** }
* Gets the new runner's group by it's id.
*/ /**
public async getGroup(): Promise<RunnerGroup> { * Gets the new runner's group by it's id.
if (this.group === undefined || this.group === null) { */
throw new RunnerTeamNeedsParentError(); public async getGroup(): Promise<RunnerGroup> {
} if (this.group === undefined || this.group === null) {
if (!isNaN(this.group)) { throw new RunnerTeamNeedsParentError();
let group = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: this.group }); }
if (!group) { throw new RunnerGroupNotFoundError; } if (!isNaN(this.group)) {
return group; let group = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: this.group });
} if (!group) { throw new RunnerGroupNotFoundError; }
return group;
throw new RunnerOrganisationWrongTypeError; }
}
throw new RunnerOrganisationWrongTypeError;
}
} }

69
src/models/actions/create/CreateRunnerOrganisation.ts
View File

@ -1,41 +1,30 @@
import { IsInt, IsOptional } from 'class-validator'; import { IsObject, IsOptional } from 'class-validator';
import { getConnectionManager } from 'typeorm'; import { Address } from '../../entities/Address';
import { AddressNotFoundError } from '../../../errors/AddressErrors'; import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
import { Address } from '../../entities/Address'; import { CreateRunnerGroup } from './CreateRunnerGroup';
import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
import { CreateRunnerGroup } from './CreateRunnerGroup'; /**
* This classed is used to create a new RunnerOrganisation entity from a json body (post request).
/** */
* This classed is used to create a new RunnerOrganisation entity from a json body (post request). export class CreateRunnerOrganisation extends CreateRunnerGroup {
*/ /**
export class CreateRunnerOrganisation extends CreateRunnerGroup { * The new organisation's address.
/** */
* The new organisation's address's id. @IsOptional()
*/ @IsObject()
@IsInt() address?: Address;
@IsOptional()
address?: number; /**
* Creates a new RunnerOrganisation entity from this.
/** */
* Gets the org's address by it's id. public async toEntity(): Promise<RunnerOrganisation> {
*/ let newRunnerOrganisation: RunnerOrganisation = new RunnerOrganisation();
public async getAddress(): Promise<Address> {
if (!this.address) { return null; } newRunnerOrganisation.name = this.name;
let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address }); newRunnerOrganisation.contact = await this.getContact();
if (!address) { throw new AddressNotFoundError; } newRunnerOrganisation.address = this.address;
return address; Address.validate(newRunnerOrganisation.address);
}
return newRunnerOrganisation;
/** }
* Creates a new RunnerOrganisation entity from this.
*/
public async toEntity(): Promise<RunnerOrganisation> {
let newRunnerOrganisation: RunnerOrganisation = new RunnerOrganisation();
newRunnerOrganisation.name = this.name;
newRunnerOrganisation.contact = await this.getContact();
newRunnerOrganisation.address = await this.getAddress();
return newRunnerOrganisation;
}
} }

88
src/models/actions/update/UpdateDonor.ts
View File

@ -1,44 +1,46 @@
import { IsBoolean, IsInt, IsOptional } from 'class-validator'; import { IsBoolean, IsInt, IsOptional } from 'class-validator';
import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors'; import { DonorReceiptAddressNeededError } from '../../../errors/DonorErrors';
import { Donor } from '../../entities/Donor'; import { Address } from '../../entities/Address';
import { CreateParticipant } from '../create/CreateParticipant'; import { Donor } from '../../entities/Donor';
import { CreateParticipant } from '../create/CreateParticipant';
/**
* This class is used to update a Donor entity (via put request). /**
*/ * This class is used to update a Donor entity (via put request).
export class UpdateDonor extends CreateParticipant { */
export class UpdateDonor extends CreateParticipant {
/**
* The updated donor's id. /**
* This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to). * The updated donor's id.
*/ * This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to).
@IsInt() */
id: number; @IsInt()
id: number;
/**
* Does the updated donor need a receipt? /**
*/ * Does the updated donor need a receipt?
@IsBoolean() */
@IsOptional() @IsBoolean()
receiptNeeded?: boolean; @IsOptional()
receiptNeeded?: boolean;
/**
* Updates a provided Donor entity based on this. /**
*/ * Updates a provided Donor entity based on this.
public async update(donor: Donor): Promise<Donor> { */
donor.firstname = this.firstname; public async update(donor: Donor): Promise<Donor> {
donor.middlename = this.middlename; donor.firstname = this.firstname;
donor.lastname = this.lastname; donor.middlename = this.middlename;
donor.phone = this.phone; donor.lastname = this.lastname;
donor.email = this.email; donor.phone = this.phone;
donor.receiptNeeded = this.receiptNeeded; donor.email = this.email;
donor.address = await this.getAddress(); donor.receiptNeeded = this.receiptNeeded;
if (!this.address) { donor.address.reset(); }
if (this.receiptNeeded == true && this.address == null) { else { donor.address = this.address; }
throw new DonorReceiptAddressNeededError() Address.validate(donor.address);
} if (this.receiptNeeded == true && Address.isValidAddress(donor.address) == false) {
throw new DonorReceiptAddressNeededError()
return donor; }
}
return donor;
}
} }

109
src/models/actions/update/UpdateRunner.ts
View File

@ -1,54 +1,57 @@
import { IsInt, IsPositive } from 'class-validator'; import { IsInt, IsPositive } from 'class-validator';
import { getConnectionManager } from 'typeorm'; import { getConnectionManager } from 'typeorm';
import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors'; import { RunnerGroupNotFoundError } from '../../../errors/RunnerGroupErrors';
import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors'; import { RunnerTeamNeedsParentError } from '../../../errors/RunnerTeamErrors';
import { Runner } from '../../entities/Runner'; import { Address } from '../../entities/Address';
import { RunnerGroup } from '../../entities/RunnerGroup'; import { Runner } from '../../entities/Runner';
import { CreateParticipant } from '../create/CreateParticipant'; import { RunnerGroup } from '../../entities/RunnerGroup';
import { CreateParticipant } from '../create/CreateParticipant';
/**
* This class is used to update a Runner entity (via put request). /**
*/ * This class is used to update a Runner entity (via put request).
export class UpdateRunner extends CreateParticipant { */
export class UpdateRunner extends CreateParticipant {
/**
* The updated runner's id. /**
* This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to). * The updated runner's id.
*/ * This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to).
@IsInt() */
id: number; @IsInt()
id: number;
/**
* The updated runner's group's id. /**
*/ * The updated runner's group's id.
@IsInt() */
@IsPositive() @IsInt()
group: number; @IsPositive()
group: number;
/**
* Updates a provided Runner entity based on this. /**
*/ * Updates a provided Runner entity based on this.
public async update(runner: Runner): Promise<Runner> { */
runner.firstname = this.firstname; public async update(runner: Runner): Promise<Runner> {
runner.middlename = this.middlename; runner.firstname = this.firstname;
runner.lastname = this.lastname; runner.middlename = this.middlename;
runner.phone = this.phone; runner.lastname = this.lastname;
runner.email = this.email; runner.phone = this.phone;
runner.group = await this.getGroup(); runner.email = this.email;
runner.address = await this.getAddress(); runner.group = await this.getGroup();
if (!this.address) { runner.address.reset(); }
return runner; else { runner.address = this.address; }
} Address.validate(runner.address);
/** return runner;
* Loads the updated runner's group based on it's id. }
*/
public async getGroup(): Promise<RunnerGroup> { /**
if (this.group === undefined || this.group === null) { * Loads the updated runner's group based on it's id.
throw new RunnerTeamNeedsParentError(); */
} public async getGroup(): Promise<RunnerGroup> {
let group = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: this.group }); if (this.group === undefined || this.group === null) {
if (!group) { throw new RunnerGroupNotFoundError; } throw new RunnerTeamNeedsParentError();
return group; }
} let group = await getConnectionManager().get().getRepository(RunnerGroup).findOne({ id: this.group });
if (!group) { throw new RunnerGroupNotFoundError; }
return group;
}
} }

84
src/models/actions/update/UpdateRunnerOrganisation.ts
View File

@ -1,48 +1,38 @@
import { IsInt, IsOptional } from 'class-validator'; import { IsInt, IsObject, IsOptional } from 'class-validator';
import { getConnectionManager } from 'typeorm'; import { Address } from '../../entities/Address';
import { AddressNotFoundError } from '../../../errors/AddressErrors'; import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
import { Address } from '../../entities/Address'; import { CreateRunnerGroup } from '../create/CreateRunnerGroup';
import { RunnerOrganisation } from '../../entities/RunnerOrganisation';
import { CreateRunnerGroup } from '../create/CreateRunnerGroup'; /**
* This class is used to update a RunnerOrganisation entity (via put request).
/** */
* This class is used to update a RunnerOrganisation entity (via put request). export class UpdateRunnerOrganisation extends CreateRunnerGroup {
*/
export class UpdateRunnerOrganisation extends CreateRunnerGroup { /**
* The updated orgs's id.
/** * This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to).
* The updated orgs's id. */
* This shouldn't have changed but it is here in case anyone ever wants to enable id changes (whyever they would want to). @IsInt()
*/ id: number;
@IsInt()
id: number; /**
* The updated organisation's address.
/** */
* The updated organisation's address's id. @IsOptional()
*/ @IsObject()
@IsInt() address?: Address;
@IsOptional()
address?: number; /**
* Updates a provided RunnerOrganisation entity based on this.
/** */
* Loads the organisation's address based on it's id. public async update(organisation: RunnerOrganisation): Promise<RunnerOrganisation> {
*/
public async getAddress(): Promise<Address> { organisation.name = this.name;
if (!this.address) { return null; } organisation.contact = await this.getContact();
let address = await getConnectionManager().get().getRepository(Address).findOne({ id: this.address }); if (!this.address) { organisation.address.reset(); }
if (!address) { throw new AddressNotFoundError; } else { organisation.address = this.address; }
return address; Address.validate(organisation.address);
}
return organisation;
/** }
* Updates a provided RunnerOrganisation entity based on this.
*/
public async update(organisation: RunnerOrganisation): Promise<RunnerOrganisation> {
organisation.name = this.name;
organisation.contact = await this.getContact();
organisation.address = await this.getAddress();
return organisation;
}
} }

183
src/models/entities/Address.ts
View File

@ -1,90 +1,93 @@
import { import {
IsInt, IsNotEmpty,
IsNotEmpty, IsOptional,
IsOptional, IsPostalCode,
IsPostalCode, IsString
IsString } from "class-validator";
} from "class-validator"; import { Column } from "typeorm";
import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm"; import ValidatorJS from 'validator';
import { config } from '../../config'; import { config } from '../../config';
import { IAddressUser } from './IAddressUser'; import { AddressCityEmptyError, AddressCountryEmptyError, AddressFirstLineEmptyError, AddressPostalCodeEmptyError, AddressPostalCodeInvalidError } from '../../errors/AddressErrors';
/** /**
* Defines the Address entity. * Defines the Address class.
* Implemented this way to prevent any formatting differences. * Implemented this way to prevent any formatting differences.
*/ */
@Entity() export class Address {
export class Address { /**
/** * The address's first line.
* Autogenerated unique id (primary key). * Containing the street and house number.
*/ */
@PrimaryGeneratedColumn() @Column()
@IsInt() @IsString()
id: number; @IsNotEmpty()
address1: string;
/**
* The address's description. /**
* Optional and mostly for UX. * The address's second line.
*/ * Containing optional information.
@Column({ nullable: true }) */
@IsString() @Column({ nullable: true })
@IsOptional() @IsString()
description?: string; @IsOptional()
address2?: string;
/**
* The address's first line. /**
* Containing the street and house number. * The address's postal code.
*/ * This will get checked against the postal code syntax for the configured country.
@Column() */
@IsString() @Column()
@IsNotEmpty() @IsString()
address1: string; @IsNotEmpty()
@IsPostalCode(config.postalcode_validation_countrycode)
/** postalcode: string;
* The address's second line.
* Containing optional information. /**
*/ * The address's city.
@Column({ nullable: true }) */
@IsString() @Column()
@IsOptional() @IsString()
address2?: string; @IsNotEmpty()
city: string;
/**
* The address's postal code. /**
* This will get checked against the postal code syntax for the configured country. * The address's country.
*/ */
@Column() @Column()
@IsString() @IsString()
@IsNotEmpty() @IsNotEmpty()
@IsPostalCode(config.postalcode_validation_countrycode) country: string;
postalcode: string;
public reset() {
/** this.address1 = null;
* The address's city. this.address2 = null;
*/ this.city = null;
@Column() this.country = null;
@IsString() this.postalcode = null;
@IsNotEmpty() }
city: string;
/**
/** * Checks if this is a valid address
* The address's country. */
*/ public static isValidAddress(address: Address): Boolean {
@Column() if (address == null) { return false; }
@IsString() if (address.address1 == null || address.city == null || address.country == null || address.postalcode == null) { return false; }
@IsNotEmpty() if (ValidatorJS.isPostalCode(address.postalcode, config.postalcode_validation_countrycode) == false) { return false; }
country: string; return true;
}
/**
* Used to link the address to participants. /**
*/ * This function validates addresses.
@OneToMany(() => IAddressUser, addressUser => addressUser.address, { nullable: true }) * This is a workaround for non-existant class validation for embedded entities.
addressUsers: IAddressUser[]; * @param address The address that shall get validated.
*/
/** public static validate(address: Address) {
* Turns this entity into it's response class. if (address == null) { return; }
*/ if (address.address1 == null && address.city == null && address.country == null && address.postalcode == null) { return; }
public toResponse() { if (address.address1 == null) { throw new AddressFirstLineEmptyError(); }
return new Error("NotImplemented"); if (address.postalcode == null) { throw new AddressPostalCodeEmptyError(); }
} if (address.city == null) { throw new AddressCityEmptyError(); }
} if (address.country == null) { throw new AddressCountryEmptyError(); }
if (ValidatorJS.isPostalCode(address.postalcode.toString(), config.postalcode_validation_countrycode) == false) { throw new AddressPostalCodeInvalidError(); }
}
}

7
src/models/entities/GroupContact.ts
View File

@ -7,11 +7,10 @@ import {
IsString IsString
} from "class-validator"; } from "class-validator";
import { Column, Entity, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm"; import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
import { config } from '../../config'; import { config } from '../../config';
import { ResponseGroupContact } from '../responses/ResponseGroupContact'; import { ResponseGroupContact } from '../responses/ResponseGroupContact';
import { Address } from "./Address"; import { Address } from "./Address";
import { IAddressUser } from './IAddressUser';
import { RunnerGroup } from "./RunnerGroup"; import { RunnerGroup } from "./RunnerGroup";
/** /**
@ -19,7 +18,7 @@ import { RunnerGroup } from "./RunnerGroup";
* Mainly it's own class to reduce duplicate code and enable contact's to be associated with multiple groups. * Mainly it's own class to reduce duplicate code and enable contact's to be associated with multiple groups.
*/ */
@Entity() @Entity()
export class GroupContact implements IAddressUser { export class GroupContact {
/** /**
* Autogenerated unique id (primary key). * Autogenerated unique id (primary key).
*/ */
@ -56,7 +55,7 @@ export class GroupContact implements IAddressUser {
* This is a address object to prevent any formatting differences. * This is a address object to prevent any formatting differences.
*/ */
@IsOptional() @IsOptional()
@ManyToOne(() => Address, address => address.addressUsers, { nullable: true }) @Column(type => Address)
address?: Address; address?: Address;
/** /**

20
src/models/entities/IAddressUser.ts
View File

@ -1,20 +0,0 @@
import { Entity, ManyToOne, PrimaryColumn } from 'typeorm';
import { Address } from './Address';
/**
* The interface(tm) all entities using addresses have to implement.
* This is a abstract class, because apparently typeorm can't really work with interfaces :/
*/
@Entity()
export abstract class IAddressUser {
@PrimaryColumn()
id: number;
@ManyToOne(() => Address, address => address.addressUsers, { nullable: true })
address?: Address
/**
* Turns this entity into it's response class.
*/
public abstract toResponse();
}

7
src/models/entities/Participant.ts
View File

@ -7,11 +7,10 @@ import {
IsString IsString
} from "class-validator"; } from "class-validator";
import { Column, Entity, ManyToOne, PrimaryGeneratedColumn, TableInheritance } from "typeorm"; import { Column, Entity, PrimaryGeneratedColumn, TableInheritance } from "typeorm";
import { config } from '../../config'; import { config } from '../../config';
import { ResponseParticipant } from '../responses/ResponseParticipant'; import { ResponseParticipant } from '../responses/ResponseParticipant';
import { Address } from "./Address"; import { Address } from "./Address";
import { IAddressUser } from './IAddressUser';
/** /**
* Defines the Participant entity. * Defines the Participant entity.
@ -19,7 +18,7 @@ import { IAddressUser } from './IAddressUser';
*/ */
@Entity() @Entity()
@TableInheritance({ column: { name: "type", type: "varchar" } }) @TableInheritance({ column: { name: "type", type: "varchar" } })
export abstract class Participant implements IAddressUser { export abstract class Participant {
/** /**
* Autogenerated unique id (primary key). * Autogenerated unique id (primary key).
*/ */
@ -55,7 +54,7 @@ export abstract class Participant implements IAddressUser {
* The participant's address. * The participant's address.
* This is a address object to prevent any formatting differences. * This is a address object to prevent any formatting differences.
*/ */
@ManyToOne(() => Address, address => address.addressUsers, { nullable: true }) @Column(type => Address)
address?: Address; address?: Address;
/** /**

127
src/models/entities/RunnerOrganisation.ts
View File

@ -1,65 +1,64 @@
import { IsInt, IsOptional } from "class-validator"; import { IsInt, IsOptional } from "class-validator";
import { ChildEntity, ManyToOne, OneToMany } from "typeorm"; import { ChildEntity, Column, OneToMany } from "typeorm";
import { ResponseRunnerOrganisation } from '../responses/ResponseRunnerOrganisation'; import { ResponseRunnerOrganisation } from '../responses/ResponseRunnerOrganisation';
import { Address } from './Address'; import { Address } from './Address';
import { IAddressUser } from './IAddressUser'; import { Runner } from './Runner';
import { Runner } from './Runner'; import { RunnerGroup } from "./RunnerGroup";
import { RunnerGroup } from "./RunnerGroup"; import { RunnerTeam } from "./RunnerTeam";
import { RunnerTeam } from "./RunnerTeam";
/**
/** * Defines the RunnerOrganisation entity.
* Defines the RunnerOrganisation entity. * This usually is a school, club or company.
* This usually is a school, club or company. */
*/ @ChildEntity()
@ChildEntity() export class RunnerOrganisation extends RunnerGroup {
export class RunnerOrganisation extends RunnerGroup implements IAddressUser {
/**
/** * The organisations's address.
* The organisations's address. */
*/ @IsOptional()
@IsOptional() @Column(type => Address)
@ManyToOne(() => Address, address => address.addressUsers, { nullable: true }) address?: Address;
address?: Address;
/**
/** * The organisation's teams.
* The organisation's teams. * Used to link teams to a organisation.
* Used to link teams to a organisation. */
*/ @OneToMany(() => RunnerTeam, team => team.parentGroup, { nullable: true })
@OneToMany(() => RunnerTeam, team => team.parentGroup, { nullable: true }) teams: RunnerTeam[];
teams: RunnerTeam[];
/**
/** * Returns all runners associated with this organisation (directly or indirectly via teams).
* Returns all runners associated with this organisation (directly or indirectly via teams). */
*/ public get allRunners(): Runner[] {
public get allRunners(): Runner[] { let returnRunners: Runner[] = new Array<Runner>();
let returnRunners: Runner[] = new Array<Runner>(); returnRunners.push(...this.runners);
returnRunners.push(...this.runners); for (let team of this.teams) {
for (let team of this.teams) { returnRunners.push(...team.runners)
returnRunners.push(...team.runners) }
} return returnRunners;
return returnRunners; }
}
/**
/** * Returns the total distance ran by this group's runners based on all their valid scans.
* Returns the total distance ran by this group's runners based on all their valid scans. */
*/ @IsInt()
@IsInt() public get distance(): number {
public get distance(): number { return this.allRunners.reduce((sum, current) => sum + current.distance, 0);
return this.allRunners.reduce((sum, current) => sum + current.distance, 0); }
}
/**
/** * Returns the total donations a runner has collected based on his linked donations and distance ran.
* Returns the total donations a runner has collected based on his linked donations and distance ran. */
*/ @IsInt()
@IsInt() public get distanceDonationAmount(): number {
public get distanceDonationAmount(): number { return this.allRunners.reduce((sum, current) => sum + current.distanceDonationAmount, 0);
return this.allRunners.reduce((sum, current) => sum + current.distanceDonationAmount, 0); }
}
/**
/** * Turns this entity into it's response class.
* Turns this entity into it's response class. */
*/ public toResponse(): ResponseRunnerOrganisation {
public toResponse(): ResponseRunnerOrganisation { return new ResponseRunnerOrganisation(this);
return new ResponseRunnerOrganisation(this); }
}
} }

121
src/models/responses/ResponseParticipant.ts
View File

@ -1,56 +1,65 @@
import { IsInt, IsString } from "class-validator"; import { IsInt, IsObject, IsOptional, IsString } from "class-validator";
import { Participant } from '../entities/Participant'; import { Address } from '../entities/Address';
import { Participant } from '../entities/Participant';
/**
* Defines the participant response. /**
*/ * Defines the participant response.
export abstract class ResponseParticipant { */
/** export abstract class ResponseParticipant {
* The participant's id. /**
*/ * The participant's id.
@IsInt() */
id: number; @IsInt()
id: number;
/**
* The participant's first name. /**
*/ * The participant's first name.
@IsString() */
firstname: string; @IsString()
firstname: string;
/**
* The participant's middle name. /**
*/ * The participant's middle name.
@IsString() */
middlename?: string; @IsString()
middlename?: string;
/**
* The participant's last name. /**
*/ * The participant's last name.
@IsString() */
lastname: string; @IsString()
lastname: string;
/**
* The participant's phone number. /**
*/ * The participant's phone number.
@IsString() */
phone?: string; @IsString()
phone?: string;
/**
* The participant's e-mail address. /**
*/ * The participant's e-mail address.
@IsString() */
email?: string; @IsString()
email?: string;
/**
* Creates a ResponseParticipant object from a participant. /**
* @param participant The participant the response shall be build for. * The participant's address.
*/ */
public constructor(participant: Participant) { @IsOptional()
this.id = participant.id; @IsObject()
this.firstname = participant.firstname; address?: Address;
this.middlename = participant.middlename;
this.lastname = participant.lastname; /**
this.phone = participant.phone; * Creates a ResponseParticipant object from a participant.
this.email = participant.email; * @param participant The participant the response shall be build for.
} */
} public constructor(participant: Participant) {
this.id = participant.id;
this.firstname = participant.firstname;
this.middlename = participant.middlename;
this.lastname = participant.lastname;
this.phone = participant.phone;
this.email = participant.email;
this.address = participant.address;
}
}

176
src/tests/donors/donor_add.spec.ts
View File

@ -1,94 +1,84 @@
import axios from 'axios'; import axios from 'axios';
import { config } from '../../config'; import { config } from '../../config';
const base = "http://localhost:" + config.internal_port const base = "http://localhost:" + config.internal_port
let access_token; let access_token;
let axios_config; let axios_config;
beforeAll(async () => { beforeAll(async () => {
const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" }); const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
access_token = res.data["access_token"]; access_token = res.data["access_token"];
axios_config = { axios_config = {
headers: { "authorization": "Bearer " + access_token }, headers: { "authorization": "Bearer " + access_token },
validateStatus: undefined validateStatus: undefined
}; };
}); });
// --------------- // ---------------
describe('POST /api/donors with errors', () => { describe('POST /api/donors with errors', () => {
it('creating a new donor without any parameters should return 400', async () => { it('creating a new donor without any parameters should return 400', async () => {
const res1 = await axios.post(base + '/api/donors', null, axios_config); const res1 = await axios.post(base + '/api/donors', null, axios_config);
expect(res1.status).toEqual(400); expect(res1.status).toEqual(400);
expect(res1.headers['content-type']).toContain("application/json") expect(res1.headers['content-type']).toContain("application/json")
}); });
it('creating a new donor without a last name should return 400', async () => { it('creating a new donor without a last name should return 400', async () => {
const res2 = await axios.post(base + '/api/donors', { const res2 = await axios.post(base + '/api/donors', {
"firstname": "first", "firstname": "first",
"middlename": "middle" "middlename": "middle"
}, axios_config); }, axios_config);
expect(res2.status).toEqual(400); expect(res2.status).toEqual(400);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('creating a new donor with a invalid address should return 404', async () => { it('creating a new donor with a invalid phone number should return 400', async () => {
const res2 = await axios.post(base + '/api/donors', { const res2 = await axios.post(base + '/api/donors', {
"firstname": "first", "firstname": "first",
"middlename": "middle", "middlename": "middle",
"lastname": "last", "lastname": "last",
"address": 99999999999999999999999999 "phone": "123"
}, axios_config); }, axios_config);
expect(res2.status).toEqual(404); expect(res2.status).toEqual(400);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('creating a new donor with a invalid phone number should return 400', async () => { it('creating a new donor with a invalid mail address should return 400', async () => {
const res2 = await axios.post(base + '/api/donors', { const res2 = await axios.post(base + '/api/donors', {
"firstname": "first", "firstname": "string",
"middlename": "middle", "middlename": "string",
"lastname": "last", "lastname": "string",
"phone": "123" "phone": null,
}, axios_config); "email": "123",
expect(res2.status).toEqual(400); }, axios_config);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.status).toEqual(400);
}); expect(res2.headers['content-type']).toContain("application/json")
it('creating a new donor with a invalid mail address should return 400', async () => { });
const res2 = await axios.post(base + '/api/donors', { it('creating a new donor without an address but with receiptNeeded=true 406', async () => {
"firstname": "string", const res2 = await axios.post(base + '/api/donors', {
"middlename": "string", "firstname": "string",
"lastname": "string", "middlename": "string",
"phone": null, "lastname": "string",
"email": "123", "receiptNeeded": true
}, axios_config); }, axios_config);
expect(res2.status).toEqual(400); expect(res2.status).toEqual(406);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('creating a new donor without an address but with receiptNeeded=true 406', async () => { });
const res2 = await axios.post(base + '/api/donors', { // ---------------
"firstname": "string", describe('POST /api/donors working', () => {
"middlename": "string", it('creating a new donor with only needed params should return 200', async () => {
"lastname": "string", const res2 = await axios.post(base + '/api/donors', {
"receiptNeeded": true "firstname": "first",
}, axios_config); "lastname": "last"
expect(res2.status).toEqual(406); }, axios_config);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.status).toEqual(200);
}); expect(res2.headers['content-type']).toContain("application/json")
}); });
// --------------- it('creating a new donor with all non-relationship optional params should return 200', async () => {
describe('POST /api/donors working', () => { const res3 = await axios.post(base + '/api/donors', {
it('creating a new donor with only needed params should return 200', async () => { "firstname": "first",
const res2 = await axios.post(base + '/api/donors', { "middlename": "middle",
"firstname": "first", "lastname": "last",
"lastname": "last" "receiptNeeded": false
}, axios_config); }, axios_config);
expect(res2.status).toEqual(200); expect(res3.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
}); });
it('creating a new donor with all non-relationship optional params should return 200', async () => {
const res3 = await axios.post(base + '/api/donors', {
"firstname": "first",
"middlename": "middle",
"lastname": "last",
"receiptNeeded": false
}, axios_config);
expect(res3.status).toEqual(200);
expect(res3.headers['content-type']).toContain("application/json")
});
}); });

148
src/tests/donors/donor_update.spec.ts
View File

@ -1,75 +1,75 @@
import axios from 'axios'; import axios from 'axios';
import { config } from '../../config'; import { config } from '../../config';
const base = "http://localhost:" + config.internal_port const base = "http://localhost:" + config.internal_port
let access_token; let access_token;
let axios_config; let axios_config;
beforeAll(async () => { beforeAll(async () => {
const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" }); const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
access_token = res.data["access_token"]; access_token = res.data["access_token"];
axios_config = { axios_config = {
headers: { "authorization": "Bearer " + access_token }, headers: { "authorization": "Bearer " + access_token },
validateStatus: undefined validateStatus: undefined
}; };
}); });
describe('Update donor name after adding', () => { describe('Update donor name after adding', () => {
let added_donor; let added_donor;
it('creating a new runner with only needed params should return 200', async () => { it('creating a new runner with only needed params should return 200', async () => {
const res2 = await axios.post(base + '/api/donors', { const res2 = await axios.post(base + '/api/donors', {
"firstname": "first", "firstname": "first",
"lastname": "last" "lastname": "last"
}, axios_config); }, axios_config);
added_donor = res2.data; added_donor = res2.data;
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('valid update should return 200', async () => { it('valid update should return 200', async () => {
let donor_copy = added_donor let donor_copy = added_donor
donor_copy.firstname = "second" donor_copy.firstname = "second"
const res3 = await axios.put(base + '/api/donors/' + added_donor.id, donor_copy, axios_config); const res3 = await axios.put(base + '/api/donors/' + added_donor.id, donor_copy, axios_config);
expect(res3.status).toEqual(200); expect(res3.status).toEqual(200);
expect(res3.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
let updated_donor = res3.data let updated_donor = res3.data
expect(updated_donor).toEqual(donor_copy); expect(updated_donor).toEqual(donor_copy);
}); });
}); });
// --------------- // ---------------
describe('Update donor id after adding(should fail)', () => { describe('Update donor id after adding(should fail)', () => {
let added_donor; let added_donor;
it('creating a new donor with only needed params should return 200', async () => { it('creating a new donor with only needed params should return 200', async () => {
const res2 = await axios.post(base + '/api/donors', { const res2 = await axios.post(base + '/api/donors', {
"firstname": "first", "firstname": "first",
"lastname": "last" "lastname": "last"
}, axios_config); }, axios_config);
added_donor = res2.data; added_donor = res2.data;
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('invalid update should return 406', async () => { it('invalid update should return 406', async () => {
added_donor.id++; added_donor.id++;
const res3 = await axios.put(base + '/api/donors/' + (added_donor.id - 1), added_donor, axios_config); const res3 = await axios.put(base + '/api/donors/' + (added_donor.id - 1), added_donor, axios_config);
expect(res3.status).toEqual(406); expect(res3.status).toEqual(406);
expect(res3.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
}); });
}); });
// --------------- // ---------------
describe('Update donor without address but receiptNeeded=true should fail', () => { describe('Update donor without address but receiptNeeded=true should fail', () => {
let added_donor; let added_donor;
it('creating a new donor with only needed params should return 200', async () => { it('creating a new donor with only needed params should return 200', async () => {
const res2 = await axios.post(base + '/api/donors', { const res2 = await axios.post(base + '/api/donors', {
"firstname": "first", "firstname": "first",
"lastname": "last", "lastname": "testtest",
}, axios_config); }, axios_config);
added_donor = res2.data; added_donor = res2.data;
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('invalid update should return 406', async () => { it('invalid update should return 406', async () => {
added_donor.receiptNeeded = true; added_donor.receiptNeeded = true;
const res3 = await axios.put(base + '/api/donors/' + added_donor.id, added_donor, axios_config); const res3 = await axios.put(base + '/api/donors/' + added_donor.id, added_donor, axios_config);
expect(res3.status).toEqual(406); expect(res3.status).toEqual(406);
expect(res3.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
}); });
}); });

190
src/tests/runnerOrgs/org_add.spec.ts
View File

@ -1,90 +1,102 @@
import axios from 'axios'; import axios from 'axios';
import { config } from '../../config'; import { config } from '../../config';
const base = "http://localhost:" + config.internal_port const base = "http://localhost:" + config.internal_port
let access_token; let access_token;
let axios_config; let axios_config;
beforeAll(async () => { beforeAll(async () => {
const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" }); const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
access_token = res.data["access_token"]; access_token = res.data["access_token"];
axios_config = { axios_config = {
headers: { "authorization": "Bearer " + access_token }, headers: { "authorization": "Bearer " + access_token },
validateStatus: undefined validateStatus: undefined
}; };
}); });
describe('GET /api/organisations', () => { describe('GET /api/organisations', () => {
it('basic get should return 200', async () => { it('basic get should return 200', async () => {
const res = await axios.get(base + '/api/organisations', axios_config); const res = await axios.get(base + '/api/organisations', axios_config);
expect(res.status).toEqual(200); expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json") expect(res.headers['content-type']).toContain("application/json")
}); });
}); });
// --------------- // ---------------
describe('POST /api/organisations', () => { describe('POST /api/organisations', () => {
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res = await axios.post(base + '/api/organisations', { const res = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
expect(res.status).toEqual(200); expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json") expect(res.headers['content-type']).toContain("application/json")
}); });
it('creating a new org with without a name should return 400', async () => { it('creating a new org with without a name should return 400', async () => {
const res = await axios.post(base + '/api/organisations', { const res = await axios.post(base + '/api/organisations', {
"name": null "name": null
}, axios_config); }, axios_config);
expect(res.status).toEqual(400); expect(res.status).toEqual(400);
expect(res.headers['content-type']).toContain("application/json") expect(res.headers['content-type']).toContain("application/json")
}); });
}); });
// --------------- // ---------------
describe('adding + getting from all orgs', () => { describe('adding + getting from all orgs', () => {
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res = await axios.post(base + '/api/organisations', { const res = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
expect(res.status).toEqual(200); expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json") expect(res.headers['content-type']).toContain("application/json")
}); });
it('check if org was added', async () => { it('check if org was added', async () => {
const res = await axios.get(base + '/api/organisations', axios_config); const res = await axios.get(base + '/api/organisations', axios_config);
expect(res.status).toEqual(200); expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json") expect(res.headers['content-type']).toContain("application/json")
let added_org = res.data[res.data.length - 1] let added_org = res.data[res.data.length - 1]
delete added_org.id delete added_org.id
expect(added_org).toEqual({ expect(added_org).toEqual({
"name": "test123", "name": "test123",
"contact": null, "contact": null,
"address": null, "address": {
"teams": [] "address1": null,
}) "address2": null,
}); "city": null,
}); "country": null,
// --------------- "postalcode": null,
describe('adding + getting explicitly', () => { },
let added_org_id "teams": []
it('creating a new org with just a name should return 200', async () => { })
const res1 = await axios.post(base + '/api/organisations', { });
"name": "test123" });
}, axios_config); // ---------------
let added_org = res1.data describe('adding + getting explicitly', () => {
added_org_id = added_org.id; let added_org_id
expect(res1.status).toEqual(200); it('creating a new org with just a name should return 200', async () => {
expect(res1.headers['content-type']).toContain("application/json") const res1 = await axios.post(base + '/api/organisations', {
}); "name": "test123"
it('check if org was added', async () => { }, axios_config);
const res2 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config); let added_org = res1.data
expect(res2.status).toEqual(200); added_org_id = added_org.id;
expect(res2.headers['content-type']).toContain("application/json") expect(res1.status).toEqual(200);
let added_org2 = res2.data expect(res1.headers['content-type']).toContain("application/json")
added_org_id = added_org2.id; });
delete added_org2.id it('check if org was added', async () => {
expect(added_org2).toEqual({ const res2 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config);
"name": "test123", expect(res2.status).toEqual(200);
"contact": null, expect(res2.headers['content-type']).toContain("application/json")
"address": null, let added_org2 = res2.data
"teams": [] added_org_id = added_org2.id;
}) delete added_org2.id
}); expect(added_org2).toEqual({
"name": "test123",
"contact": null,
"address": {
"address1": null,
"address2": null,
"city": null,
"country": null,
"postalcode": null,
},
"teams": []
})
});
}); });

274
src/tests/runnerOrgs/org_delete.spec.ts
View File

@ -1,132 +1,144 @@
import axios from 'axios'; import axios from 'axios';
import { config } from '../../config'; import { config } from '../../config';
const base = "http://localhost:" + config.internal_port const base = "http://localhost:" + config.internal_port
let access_token; let access_token;
let axios_config; let axios_config;
beforeAll(async () => { beforeAll(async () => {
const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" }); const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
access_token = res.data["access_token"]; access_token = res.data["access_token"];
axios_config = { axios_config = {
headers: { "authorization": "Bearer " + access_token }, headers: { "authorization": "Bearer " + access_token },
validateStatus: undefined validateStatus: undefined
}; };
}); });
// --------------- // ---------------
describe('adding + deletion (non-existant)', () => { describe('adding + deletion (non-existant)', () => {
it('delete', async () => { it('delete', async () => {
const res2 = await axios.delete(base + '/api/organisations/0', axios_config); const res2 = await axios.delete(base + '/api/organisations/0', axios_config);
expect(res2.status).toEqual(204); expect(res2.status).toEqual(204);
}); });
}); });
// --------------- // ---------------
describe('adding + deletion (successfull)', () => { describe('adding + deletion (successfull)', () => {
let added_org_id let added_org_id
let added_org let added_org
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res1 = await axios.post(base + '/api/organisations', { const res1 = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
added_org = res1.data added_org = res1.data
added_org_id = added_org.id; added_org_id = added_org.id;
expect(res1.status).toEqual(200); expect(res1.status).toEqual(200);
expect(res1.headers['content-type']).toContain("application/json") expect(res1.headers['content-type']).toContain("application/json")
}); });
it('delete', async () => { it('delete', async () => {
const res2 = await axios.delete(base + '/api/organisations/' + added_org_id, axios_config); const res2 = await axios.delete(base + '/api/organisations/' + added_org_id, axios_config);
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
let added_org2 = res2.data let added_org2 = res2.data
added_org_id = added_org2.id; added_org_id = added_org2.id;
delete added_org2.id delete added_org2.id
expect(added_org2).toEqual({ expect(added_org2).toEqual({
"name": "test123", "name": "test123",
"contact": null, "contact": null,
"address": null, "address": {
"teams": [] "address1": null,
}); "address2": null,
}); "city": null,
it('check if org really was deleted', async () => { "country": null,
const res3 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config); "postalcode": null,
expect(res3.status).toEqual(404); },
expect(res3.headers['content-type']).toContain("application/json") "teams": []
}); });
}); });
// --------------- it('check if org really was deleted', async () => {
describe('adding + deletion with teams still existing (without force)', () => { const res3 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config);
let added_org; expect(res3.status).toEqual(404);
let added_org_id; expect(res3.headers['content-type']).toContain("application/json")
let added_team; });
let added_team_id });
it('creating a new org with just a name should return 200', async () => { // ---------------
const res1 = await axios.post(base + '/api/organisations', { describe('adding + deletion with teams still existing (without force)', () => {
"name": "test123" let added_org;
}, axios_config); let added_org_id;
added_org = res1.data; let added_team;
added_org_id = added_org.id; let added_team_id
expect(res1.status).toEqual(200); it('creating a new org with just a name should return 200', async () => {
expect(res1.headers['content-type']).toContain("application/json") const res1 = await axios.post(base + '/api/organisations', {
}); "name": "test123"
it('creating a new team with a valid org should return 200', async () => { }, axios_config);
const res2 = await axios.post(base + '/api/teams', { added_org = res1.data;
"name": "test123", added_org_id = added_org.id;
"parentGroup": added_org_id expect(res1.status).toEqual(200);
}, axios_config); expect(res1.headers['content-type']).toContain("application/json")
added_team = res2.data; });
added_team_id = added_team.id; it('creating a new team with a valid org should return 200', async () => {
expect(res2.status).toEqual(200); const res2 = await axios.post(base + '/api/teams', {
expect(res2.headers['content-type']).toContain("application/json") "name": "test123",
}); "parentGroup": added_org_id
it('delete org - this should fail with a 406', async () => { }, axios_config);
const res2 = await axios.delete(base + '/api/organisations/' + added_org_id, axios_config); added_team = res2.data;
expect(res2.status).toEqual(406); added_team_id = added_team.id;
expect(res2.headers['content-type']).toContain("application/json") expect(res2.status).toEqual(200);
}); expect(res2.headers['content-type']).toContain("application/json")
}); });
// --------------- it('delete org - this should fail with a 406', async () => {
describe('adding + deletion with teams still existing (with force)', () => { const res2 = await axios.delete(base + '/api/organisations/' + added_org_id, axios_config);
let added_org; expect(res2.status).toEqual(406);
let added_org_id; expect(res2.headers['content-type']).toContain("application/json")
let added_team; });
let added_team_id });
it('creating a new org with just a name should return 200', async () => { // ---------------
const res1 = await axios.post(base + '/api/organisations', { describe('adding + deletion with teams still existing (with force)', () => {
"name": "test123" let added_org;
}, axios_config); let added_org_id;
added_org = res1.data; let added_team;
added_org_id = added_org.id; let added_team_id
expect(res1.status).toEqual(200); it('creating a new org with just a name should return 200', async () => {
expect(res1.headers['content-type']).toContain("application/json") const res1 = await axios.post(base + '/api/organisations', {
}); "name": "test123"
it('creating a new team with a valid org should return 200', async () => { }, axios_config);
const res2 = await axios.post(base + '/api/teams', { added_org = res1.data;
"name": "test123", added_org_id = added_org.id;
"parentGroup": added_org_id expect(res1.status).toEqual(200);
}, axios_config); expect(res1.headers['content-type']).toContain("application/json")
added_team = res2.data; });
added_team_id = added_team.id; it('creating a new team with a valid org should return 200', async () => {
expect(res2.status).toEqual(200); const res2 = await axios.post(base + '/api/teams', {
expect(res2.headers['content-type']).toContain("application/json") "name": "test123",
}); "parentGroup": added_org_id
it('delete', async () => { }, axios_config);
const res2 = await axios.delete(base + '/api/organisations/' + added_org_id + '?force=true', axios_config); added_team = res2.data;
expect(res2.status).toEqual(200); added_team_id = added_team.id;
expect(res2.headers['content-type']).toContain("application/json") expect(res2.status).toEqual(200);
let added_org2 = res2.data expect(res2.headers['content-type']).toContain("application/json")
added_org_id = added_org2.id; });
delete added_org2.id; it('delete', async () => {
delete added_org2.teams; const res2 = await axios.delete(base + '/api/organisations/' + added_org_id + '?force=true', axios_config);
expect(added_org2).toEqual({ expect(res2.status).toEqual(200);
"name": "test123", expect(res2.headers['content-type']).toContain("application/json")
"contact": null, let added_org2 = res2.data
"address": null added_org_id = added_org2.id;
}); delete added_org2.id;
}); delete added_org2.teams;
it('check if org really was deleted', async () => { expect(added_org2).toEqual({
const res3 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config); "name": "test123",
expect(res3.status).toEqual(404); "contact": null,
expect(res3.headers['content-type']).toContain("application/json") "address": {
}); "address1": null,
"address2": null,
"city": null,
"country": null,
"postalcode": null,
},
});
});
it('check if org really was deleted', async () => {
const res3 = await axios.get(base + '/api/organisations/' + added_org_id, axios_config);
expect(res3.status).toEqual(404);
expect(res3.headers['content-type']).toContain("application/json")
});
}); });

454
src/tests/runnerOrgs/org_update.spec.ts
View File

@ -1,73 +1,383 @@
import axios from 'axios'; import axios from 'axios';
import { config } from '../../config'; import { config } from '../../config';
const base = "http://localhost:" + config.internal_port const base = "http://localhost:" + config.internal_port
let access_token; let access_token;
let axios_config; let axios_config;
beforeAll(async () => { beforeAll(async () => {
const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" }); const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
access_token = res.data["access_token"]; access_token = res.data["access_token"];
axios_config = { axios_config = {
headers: { "authorization": "Bearer " + access_token }, headers: { "authorization": "Bearer " + access_token },
validateStatus: undefined validateStatus: undefined
}; };
}); });
// --------------- // ---------------
describe('adding + updating name', () => { describe('adding + updating name', () => {
let added_org_id let added_org_id
let added_org let added_org
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res1 = await axios.post(base + '/api/organisations', { const res = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
added_org = res1.data added_org = res.data
added_org_id = added_org.id; added_org_id = added_org.id;
expect(res1.status).toEqual(200); expect(res.status).toEqual(200);
expect(res1.headers['content-type']).toContain("application/json") expect(res.headers['content-type']).toContain("application/json")
}); });
it('update org', async () => { it('update org', async () => {
const res2 = await axios.put(base + '/api/organisations/' + added_org_id, { const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id, "id": added_org_id,
"name": "testlelele", "name": "testlelele",
"contact": null, "contact": null,
"address": null, "address": null,
}, axios_config); }, axios_config);
expect(res2.status).toEqual(200); expect(res.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res.headers['content-type']).toContain("application/json")
let added_org2 = res2.data let added_org2 = res.data
added_org_id = added_org2.id; added_org_id = added_org2.id;
delete added_org2.id delete added_org2.id
expect(added_org2).toEqual({ expect(added_org2).toEqual({
"name": "testlelele", "name": "testlelele",
"contact": null, "contact": null,
"address": null, "address": {
"teams": [] "address1": null,
}) "address2": null,
}); "city": null,
}); "country": null,
// --------------- "postalcode": null,
describe('adding + try updating id (should return 406)', () => { },
let added_org_id "teams": []
let added_org })
it('creating a new org with just a name should return 200', async () => { });
const res1 = await axios.post(base + '/api/organisations', { });
"name": "test123" // ---------------
}, axios_config); describe('adding + try updating id (should return 406)', () => {
added_org = res1.data let added_org_id
added_org_id = added_org.id; let added_org
expect(res1.status).toEqual(200); it('creating a new org with just a name should return 200', async () => {
expect(res1.headers['content-type']).toContain("application/json") const res = await axios.post(base + '/api/organisations', {
}); "name": "test123"
it('update org', async () => { }, axios_config);
const res2 = await axios.put(base + '/api/organisations/' + added_org_id, { added_org = res.data
"id": added_org_id + 1, added_org_id = added_org.id;
"name": "testlelele", expect(res.status).toEqual(200);
"contact": null, expect(res.headers['content-type']).toContain("application/json")
"address": null, });
}, axios_config); it('update org', async () => {
expect(res2.status).toEqual(406); const res = await axios.put(base + '/api/organisations/' + added_org_id, {
expect(res2.headers['content-type']).toContain("application/json") "id": added_org_id + 1,
}); "name": "testlelele",
"contact": null,
"address": null,
}, axios_config);
expect(res.status).toEqual(406);
expect(res.headers['content-type']).toContain("application/json")
});
});
// ---------------
describe('adding + updateing address valid)', () => {
let added_org_id
let added_org
it('creating a new org with just a name should return 200', async () => {
const res = await axios.post(base + '/api/organisations', {
"name": "test123"
}, axios_config);
added_org = res.data
added_org_id = added_org.id;
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json")
});
it('adding address to org should return 200', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test1",
"address2": null,
"city": "Herzogenaurach",
"country": "Burkina Faso",
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json");
expect(res.data).toEqual({
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test1",
"address2": null,
"city": "Herzogenaurach",
"country": "Burkina Faso",
"postalcode": "90174"
},
"teams": []
});
});
it('updateing address\'s first line should return 200', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": null,
"city": "TestCity",
"country": "Burkina Faso",
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json");
expect(res.data).toEqual({
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": null,
"city": "TestCity",
"country": "Burkina Faso",
"postalcode": "90174"
},
"teams": []
});
});
it('updateing address\'s second line should return 200', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "TestCity",
"country": "Burkina Faso",
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json");
expect(res.data).toEqual({
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "TestCity",
"country": "Burkina Faso",
"postalcode": "90174"
},
"teams": []
});
});
it('updateing address\'s city should return 200', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "Kaya",
"country": "Burkina Faso",
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json");
expect(res.data).toEqual({
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "Kaya",
"country": "Burkina Faso",
"postalcode": "90174"
},
"teams": []
});
});
it('updateing address\'s country should return 200', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "Kaya",
"country": "Germany",
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json");
expect(res.data).toEqual({
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "Kaya",
"country": "Germany",
"postalcode": "90174"
},
"teams": []
});
});
it('updateing address\'s postal code should return 200', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "Kaya",
"country": "Germany",
"postalcode": "91065"
}
}, axios_config);
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json");
expect(res.data).toEqual({
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test2",
"address2": "Test3",
"city": "Kaya",
"country": "Germany",
"postalcode": "91065"
},
"teams": []
});
});
it('removing org\'s should return 200', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null
}, axios_config);
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json");
expect(res.data).toEqual({
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": null,
"address2": null,
"city": null,
"country": null,
"postalcode": null
},
"teams": []
});
});
});
// ---------------
describe('adding + updateing address invalid)', () => {
let added_org_id
let added_org
it('creating a new org with just a name should return 200', async () => {
const res = await axios.post(base + '/api/organisations', {
"name": "test123"
}, axios_config);
added_org = res.data
added_org_id = added_org.id;
expect(res.status).toEqual(200);
expect(res.headers['content-type']).toContain("application/json")
});
it('adding address to org w/o address1 should return 400', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": null,
"address2": null,
"city": "TestCity",
"country": "Burkina Faso",
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(400);
expect(res.headers['content-type']).toContain("application/json");
});
it('adding address to org w/o city should return 400', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test1",
"address2": null,
"city": null,
"country": "Burkina Faso",
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(400);
expect(res.headers['content-type']).toContain("application/json");
});
it('adding address to org w/o country should return 400', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test1",
"address2": null,
"city": "TestCity",
"country": null,
"postalcode": "90174"
}
}, axios_config);
expect(res.status).toEqual(400);
expect(res.headers['content-type']).toContain("application/json");
});
it('adding address to org w/o postal code should return 400', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test1",
"address2": null,
"city": "TestCity",
"country": "Burkina Faso",
"postalcode": null
}
}, axios_config);
expect(res.status).toEqual(400);
expect(res.headers['content-type']).toContain("application/json");
});
it('adding address to org w/ invalid postal code should return 400', async () => {
const res = await axios.put(base + '/api/organisations/' + added_org_id, {
"id": added_org_id,
"name": "testlelele",
"contact": null,
"address": {
"address1": "Test1",
"address2": null,
"city": "TestCity",
"country": "Burkina Faso",
"postalcode": "-1"
}
}, axios_config);
expect(res.status).toEqual(400);
expect(res.headers['content-type']).toContain("application/json");
});
}); });

259
src/tests/runnerTeams/team_update.spec.ts
View File

@ -1,131 +1,130 @@
import axios from 'axios'; import axios from 'axios';
import { config } from '../../config'; import { config } from '../../config';
const base = "http://localhost:" + config.internal_port const base = "http://localhost:" + config.internal_port
let access_token; let access_token;
let axios_config; let axios_config;
beforeAll(async () => { beforeAll(async () => {
const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" }); const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
access_token = res.data["access_token"]; access_token = res.data["access_token"];
axios_config = { axios_config = {
headers: { "authorization": "Bearer " + access_token }, headers: { "authorization": "Bearer " + access_token },
validateStatus: undefined validateStatus: undefined
}; };
}); });
// --------------- // ---------------
describe('adding + updating name', () => { describe('adding + updating name', () => {
let added_org; let added_org;
let added_org_id; let added_org_id;
let added_team; let added_team;
let added_team_id let added_team_id
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res1 = await axios.post(base + '/api/organisations', { const res1 = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
added_org = res1.data; added_org = res1.data;
added_org_id = added_org.id; added_org_id = added_org.id;
expect(res1.status).toEqual(200); expect(res1.status).toEqual(200);
expect(res1.headers['content-type']).toContain("application/json") expect(res1.headers['content-type']).toContain("application/json")
}); });
it('creating a new team with a valid org should return 200', async () => { it('creating a new team with a valid org should return 200', async () => {
const res2 = await axios.post(base + '/api/teams', { const res2 = await axios.post(base + '/api/teams', {
"name": "test123", "name": "test123",
"parentGroup": added_org_id "parentGroup": added_org_id
}, axios_config); }, axios_config);
added_team = res2.data; added_team = res2.data;
added_team_id = added_team.id; added_team_id = added_team.id;
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('update name', async () => { it('update name', async () => {
const res3 = await axios.put(base + '/api/teams/' + added_team_id, { const res3 = await axios.put(base + '/api/teams/' + added_team_id, {
"id": added_team_id, "id": added_team_id,
"name": "testlelele", "name": "testlelele",
"contact": null, "contact": null,
"parentGroup": added_org.id "parentGroup": added_org.id
}, axios_config); }, axios_config);
expect(res3.status).toEqual(200); expect(res3.status).toEqual(200);
expect(res3.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
let updated_team = res3.data; let updated_team = res3.data;
added_team.name = "testlelele"; added_team.name = "testlelele";
expect(updated_team).toEqual(added_team) expect(updated_team).toEqual(added_team)
}); });
}); });
// --------------- // ---------------
describe('adding + try updating id (should return 406)', () => { describe('adding + try updating id (should return 406)', () => {
let added_org; let added_org;
let added_org_id; let added_org_id;
let added_team; let added_team;
let added_team_id let added_team_id
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res1 = await axios.post(base + '/api/organisations', { const res1 = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
added_org = res1.data; added_org = res1.data;
added_org_id = added_org.id; added_org_id = added_org.id;
expect(res1.status).toEqual(200); expect(res1.status).toEqual(200);
expect(res1.headers['content-type']).toContain("application/json") expect(res1.headers['content-type']).toContain("application/json")
}); });
it('creating a new team with a valid org should return 200', async () => { it('creating a new team with a valid org should return 200', async () => {
const res2 = await axios.post(base + '/api/teams', { const res2 = await axios.post(base + '/api/teams', {
"name": "test123", "name": "test123",
"parentGroup": added_org_id "parentGroup": added_org_id
}, axios_config); }, axios_config);
added_team = res2.data; added_team = res2.data;
added_team_id = added_team.id; added_team_id = added_team.id;
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('update team', async () => { it('update team', async () => {
added_team.id = added_team.id + 1; added_team.id = added_team.id + 1;
added_team.parentGroup = added_team.parentGroup.id; added_team.parentGroup = added_team.parentGroup.id;
const res3 = await axios.put(base + '/api/teams/' + added_team_id, added_team, axios_config); const res3 = await axios.put(base + '/api/teams/' + added_team_id, added_team, axios_config);
expect(res3.status).toEqual(406); expect(res3.status).toEqual(406);
expect(res3.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
}); });
}); });
// --------------- // ---------------
describe('add+update parent org (valid)', () => { describe('add+update parent org (valid)', () => {
let added_org; let added_org;
let added_org2; let added_org2;
let added_team; let added_team;
let added_team_id let added_team_id
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res1 = await axios.post(base + '/api/organisations', { const res1 = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
added_org = res1.data; added_org = res1.data;
expect(res1.status).toEqual(200); expect(res1.status).toEqual(200);
expect(res1.headers['content-type']).toContain("application/json") expect(res1.headers['content-type']).toContain("application/json")
}); });
it('creating a new team with a valid org should return 200', async () => { it('creating a new team with a valid org should return 200', async () => {
const res2 = await axios.post(base + '/api/teams', { const res2 = await axios.post(base + '/api/teams', {
"name": "test123", "name": "test123",
"parentGroup": added_org.id "parentGroup": added_org.id
}, axios_config); }, axios_config);
added_team = res2.data; added_team = res2.data;
added_team_id = added_team.id; added_team_id = added_team.id;
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res3 = await axios.post(base + '/api/organisations', { const res3 = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
added_org2 = res3.data; added_org2 = res3.data;
expect(res3.status).toEqual(200); expect(res3.status).toEqual(200);
expect(res3.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
}); });
it('update team', async () => { it('update team', async () => {
added_team.parentGroup = added_org2.id; added_team.parentGroup = added_org2.id;
const res4 = await axios.put(base + '/api/teams/' + added_team_id, added_team, axios_config); const res4 = await axios.put(base + '/api/teams/' + added_team_id, added_team, axios_config);
let updated_team = res4.data; let updated_team = res4.data;
expect(res4.status).toEqual(200); expect(res4.status).toEqual(200);
expect(res4.headers['content-type']).toContain("application/json") expect(res4.headers['content-type']).toContain("application/json")
delete added_org2.address; delete added_org2.contact;
delete added_org2.contact; delete added_org2.teams;
delete added_org2.teams; expect(updated_team.parentGroup).toEqual(added_org2)
expect(updated_team.parentGroup).toEqual(added_org2) });
});
}); });

314
src/tests/runners/runner_update.spec.ts
View File

@ -1,160 +1,156 @@
import axios from 'axios'; import axios from 'axios';
import { config } from '../../config'; import { config } from '../../config';
const base = "http://localhost:" + config.internal_port const base = "http://localhost:" + config.internal_port
let access_token; let access_token;
let axios_config; let axios_config;
beforeAll(async () => { beforeAll(async () => {
const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" }); const res = await axios.post(base + '/api/auth/login', { username: "demo", password: "demo" });
access_token = res.data["access_token"]; access_token = res.data["access_token"];
axios_config = { axios_config = {
headers: { "authorization": "Bearer " + access_token }, headers: { "authorization": "Bearer " + access_token },
validateStatus: undefined validateStatus: undefined
}; };
}); });
describe('Update runner name after adding', () => { describe('Update runner name after adding', () => {
let added_org; let added_org;
let added_runner; let added_runner;
let updated_runner; let updated_runner;
it('creating a new org with just a name should return 200', async () => { it('creating a new org with just a name should return 200', async () => {
const res1 = await axios.post(base + '/api/organisations', { const res1 = await axios.post(base + '/api/organisations', {
"name": "test123" "name": "test123"
}, axios_config); }, axios_config);
added_org = res1.data added_org = res1.data
expect(res1.status).toEqual(200); expect(res1.status).toEqual(200);
expect(res1.headers['content-type']).toContain("application/json") expect(res1.headers['content-type']).toContain("application/json")
}); });
it('creating a new runner with only needed params should return 200', async () => { it('creating a new runner with only needed params should return 200', async () => {
const res2 = await axios.post(base + '/api/runners', { const res2 = await axios.post(base + '/api/runners', {
"firstname": "first", "firstname": "first",
"lastname": "last", "lastname": "last",
"group": added_org.id "group": added_org.id
}, axios_config); }, axios_config);
added_runner = res2.data; added_runner = res2.data;
expect(res2.status).toEqual(200); expect(res2.status).toEqual(200);
expect(res2.headers['content-type']).toContain("application/json") expect(res2.headers['content-type']).toContain("application/json")
}); });
it('valid update should return 200', async () => { it('valid update should return 200', async () => {
let runnercopy = added_runner let runnercopy = added_runner
runnercopy.firstname = "second" runnercopy.firstname = "second"
runnercopy.group = added_runner.group.id; runnercopy.group = added_runner.group.id;
const res3 = await axios.put(base + '/api/runners/' + added_runner.id, runnercopy, axios_config); const res3 = await axios.put(base + '/api/runners/' + added_runner.id, runnercopy, axios_config);
expect(res3.status).toEqual(200); expect(res3.status).toEqual(200);
expect(res3.headers['content-type']).toContain("application/json") expect(res3.headers['content-type']).toContain("application/json")
updated_runner = res3.data; updated_runner = res3.data;
delete added_org.address; delete added_org.contact;
delete added_org.contact; delete added_org.teams;
delete added_org.teams; runnercopy.group = added_org;
runnercopy.group = added_org; expect(updated_runner).toEqual(runnercopy);
expect(updated_runner).toEqual(runnercopy); });
}); });
}); // ---------------
// --------------- describe('Update runner group after adding', () => {
describe('Update runner group after adding', () => { let added_org_id;
let added_org_id; let added_org_2;
let added_org_2; let added_runner;
let added_runner; it('creating a new org with just a name should return 200', async () => {
let updated_runner; const res1 = await axios.post(base + '/api/organisations', {
it('creating a new org with just a name should return 200', async () => { "name": "test123"
const res1 = await axios.post(base + '/api/organisations', { }, axios_config);
"name": "test123" let added_org = res1.data
}, axios_config); added_org_id = added_org.id;
let added_org = res1.data expect(res1.status).toEqual(200);
added_org_id = added_org.id; expect(res1.headers['content-type']).toContain("application/json")
expect(res1.status).toEqual(200); });
expect(res1.headers['content-type']).toContain("application/json") it('creating a new runner with only needed params should return 200', async () => {
}); const res2 = await axios.post(base + '/api/runners', {
it('creating a new runner with only needed params should return 200', async () => { "firstname": "first",
const res2 = await axios.post(base + '/api/runners', { "lastname": "last",
"firstname": "first", "group": added_org_id
"lastname": "last", }, axios_config);
"group": added_org_id added_runner = res2.data;
}, axios_config); expect(res2.status).toEqual(200);
added_runner = res2.data; expect(res2.headers['content-type']).toContain("application/json")
expect(res2.status).toEqual(200); });
expect(res2.headers['content-type']).toContain("application/json") it('creating a new org with just a name should return 200', async () => {
}); const res3 = await axios.post(base + '/api/organisations', {
it('creating a new org with just a name should return 200', async () => { "name": "test123"
const res3 = await axios.post(base + '/api/organisations', { }, axios_config);
"name": "test123" added_org_2 = res3.data
}, axios_config); delete added_org_2.contact;
added_org_2 = res3.data delete added_org_2.teams;
delete added_org_2.address; expect(res3.status).toEqual(200);
delete added_org_2.contact; expect(res3.headers['content-type']).toContain("application/json")
delete added_org_2.teams; });
expect(res3.status).toEqual(200); it('valid group update should return 200', async () => {
expect(res3.headers['content-type']).toContain("application/json") added_runner.group = added_org_2.id;
}); const res3 = await axios.put(base + '/api/runners/' + added_runner.id, added_runner, axios_config);
it('valid group update should return 200', async () => { expect(res3.status).toEqual(200);
added_runner.group = added_org_2.id; expect(res3.headers['content-type']).toContain("application/json")
const res3 = await axios.put(base + '/api/runners/' + added_runner.id, added_runner, axios_config); expect(res3.data.group).toEqual(added_org_2);
expect(res3.status).toEqual(200); });
expect(res3.headers['content-type']).toContain("application/json") });
updated_runner = res3.data // ---------------
expect(updated_runner.group).toEqual(added_org_2); describe('Update runner id after adding(should fail)', () => {
}); let added_org_id;
}); let added_runner;
// --------------- let added_runner_id;
describe('Update runner id after adding(should fail)', () => { it('creating a new org with just a name should return 200', async () => {
let added_org_id; const res1 = await axios.post(base + '/api/organisations', {
let added_runner; "name": "test123"
let added_runner_id; }, axios_config);
it('creating a new org with just a name should return 200', async () => { let added_org = res1.data
const res1 = await axios.post(base + '/api/organisations', { added_org_id = added_org.id;
"name": "test123" expect(res1.status).toEqual(200);
}, axios_config); expect(res1.headers['content-type']).toContain("application/json")
let added_org = res1.data });
added_org_id = added_org.id; it('creating a new runner with only needed params should return 200', async () => {
expect(res1.status).toEqual(200); const res2 = await axios.post(base + '/api/runners', {
expect(res1.headers['content-type']).toContain("application/json") "firstname": "first",
}); "lastname": "last",
it('creating a new runner with only needed params should return 200', async () => { "group": added_org_id
const res2 = await axios.post(base + '/api/runners', { }, axios_config);
"firstname": "first", added_runner = res2.data;
"lastname": "last", added_runner_id = added_runner.id;
"group": added_org_id expect(res2.status).toEqual(200);
}, axios_config); expect(res2.headers['content-type']).toContain("application/json")
added_runner = res2.data; });
added_runner_id = added_runner.id; it('invalid update should return 406', async () => {
expect(res2.status).toEqual(200); added_runner.id++;
expect(res2.headers['content-type']).toContain("application/json") added_runner.group = added_runner.group.id;
}); const res3 = await axios.put(base + '/api/runners/' + added_runner_id, added_runner, axios_config);
it('invalid update should return 406', async () => { expect(res3.status).toEqual(406);
added_runner.id++; expect(res3.headers['content-type']).toContain("application/json")
added_runner.group = added_runner.group.id; });
const res3 = await axios.put(base + '/api/runners/' + added_runner_id, added_runner, axios_config); });
expect(res3.status).toEqual(406); // ---------------
expect(res3.headers['content-type']).toContain("application/json") describe('Update runner group with invalid group after adding', () => {
}); let added_org;
}); let added_runner;
// --------------- it('creating a new org with just a name should return 200', async () => {
describe('Update runner group with invalid group after adding', () => { const res1 = await axios.post(base + '/api/organisations', {
let added_org; "name": "test123"
let added_runner; }, axios_config);
it('creating a new org with just a name should return 200', async () => { added_org = res1.data
const res1 = await axios.post(base + '/api/organisations', { expect(res1.status).toEqual(200);
"name": "test123" expect(res1.headers['content-type']).toContain("application/json")
}, axios_config); });
added_org = res1.data it('creating a new runner with only needed params should return 200', async () => {
expect(res1.status).toEqual(200); const res2 = await axios.post(base + '/api/runners', {
expect(res1.headers['content-type']).toContain("application/json") "firstname": "first",
}); "lastname": "last",
it('creating a new runner with only needed params should return 200', async () => { "group": added_org.id
const res2 = await axios.post(base + '/api/runners', { }, axios_config);
"firstname": "first", added_runner = res2.data;
"lastname": "last", expect(res2.status).toEqual(200);
"group": added_org.id expect(res2.headers['content-type']).toContain("application/json")
}, axios_config); });
added_runner = res2.data; it('invalid group update should return 404', async () => {
expect(res2.status).toEqual(200); added_runner.group = 99999999999999999;
expect(res2.headers['content-type']).toContain("application/json") const res3 = await axios.put(base + '/api/runners/' + added_runner.id, added_runner, axios_config);
}); expect(res3.status).toEqual(404);
it('invalid group update should return 404', async () => { expect(res3.headers['content-type']).toContain("application/json")
added_runner.group = 99999999999999999; });
const res3 = await axios.put(base + '/api/runners/' + added_runner.id, added_runner, axios_config);
expect(res3.status).toEqual(404);
expect(res3.headers['content-type']).toContain("application/json")
});
}); });