integrationtest typescript

1it(`GIVEN an id = "${id}", WHEN getDetailedVehicle() is executed, THEN the Promise will be resolved with ${expectedVehicleDto}.`, async () => {
2            (VehicleRepository.findOne as SinonStub).withArgs(id).resolves(vehicleEntity);
3            (ClassTransformer.plainToClass as SinonStub).withArgs(VehicleDto, vehicleEntity).returns(vehicleDto);
4            (DamageService.getDamageState as SinonStub).withArgs(vehicleDto.id).resolves(true);
5 
6            const result = VehicleService.getDetailedVehicle(id);
7 
8            await expect(result).to.be.eventually.deep.equal(expectedVehicleDto);
9});
10

1describe('Contract test for DamageService: getDamageState', () => {
2    const provider: Pact = new Pact({
3        consumer: 'vehicle-service',
4        provider: 'damage-service',
5        port: 8080,
6        host: 'localhost',
7        dir: resolve(__dirname, '../contract/pacts'),
8        log: resolve(__dirname, '../contract/logs/pact.log'),
9        spec: 2,
10    });
11    const BASIC_AUTH_MATCHER: string = '^Basic ';
12 
13    const damagedVehicleId = '1';
14    const notDamagedVehicleId = '2';
15    const nonExistingDamagedVehicleId = '17';
16 
17    const validInteractionForDamagedVehicle = new Interaction()
18        .given(`Valid vehicle ID = ${damagedVehicleId}`)
19        .uponReceiving('a valid vehicle ID from Vehicle Service')
20        .withRequest({
21            method: 'GET',
22            path: `/damage/vehicle/${damagedVehicleId}`,
23            headers: {
24                [AUTHORIZATION_HEADER]: Matchers.term({
25                    generate: `Basic ${BASIC_AUTH}`,
26                    matcher: BASIC_AUTH_MATCHER,
27                }),
28            },
29        })
30        .willRespondWith({
31            status: OK,
32            body: Matchers.somethingLike({ damaged: true }),
33        });
34  
35    before(async () => {
36        await provider.setup();
37    });
38 
39    after(async () => {
40        await provider.finalize();
41    });
42 
43    afterEach(async () => {
44        await provider.removeInteractions();
45    });
46 
47    it(`GIVEN vehicle id="${damagedVehicleId}", WHEN getDamageState() is executed, THEN the Promise will be resolved with true.`, async () => {
48        await provider.addInteraction(validInteractionForDamagedVehicle);
49 
50        const result = DamageService.getDamageState(damagedVehicleId);
51 
52        await expect(result).to.be.eventually.true;
53        await expect(provider.verify()).to.not.be.rejected;
54    });
55

1it(`GIVEN vehicle id="${healthyVehicle.id}", WHEN getDamageState() is executed THEN the Promise will be resolved with false.`, async () => {
2 
3            const result = DamageService.getDamageState(healthyVehicle.id);
4 
5            await expect(result).to.be.eventually.false;
6});
7

1    it('GIVEN a valid vehicle, WHEN posting to vehicles endpoint, THEN a Response with HTTP STATUS OK and the created vehicle will be sent.', async () => {
2        const vehicle = {
3            id: '1',
4            color: 1,
5        };
6 
7        const result = await chai.request(App)
8            .post(VEHICLE_ENDPOINT)
9            .send(vehicle);
10 
11        expect(result).to.have.status(OK);
12        expect(result.body).to.be.deep.equal(vehicle);
13    });
14