making more complicated.

package.json

@@ -6,7 +6,19 @@
   "scripts": {
     "demo": "ts-node ./src/demo-data/run.ts",
     "test": "jest --env=node --colors test --verbose=true",
-    "prettier": "prettier --write './{src,test}/**/*.ts'"
+    "prettier": "prettier --write './{src,test}/**/*.ts'",
+    "test-pattern": "jest --env=node --colors --verbose=true",
+    "test-00": "npm run test-pattern 00-*",
+    "test-01": "npm run test-pattern 01-*",
+    "test-02": "npm run test-pattern 02-*",
+    "test-03": "npm run test-pattern 03-*",
+    "test-04": "npm run test-pattern 04-*",
+    "test-05": "npm run test-pattern 05-*",
+    "test-06": "npm run test-pattern 06-*",
+    "test-07": "npm run test-pattern 07-*",
+    "test-08": "npm run test-pattern 08-*",
+    "test-09": "npm run test-pattern 09-*",
+    "test-10": "npm run test-pattern 10-*"
   },
   "author": "",
   "license": "ISC",

src/AdminFlightApi.ts

@@ -1,19 +1,47 @@
 import { AxiosResponse } from "axios";
 import { adminClient } from "./axios";
-import { AddFlightRequest, Flight } from "./api";
+import { AddFlightRequest, Airport, Flight } from "./api";
+import { AddAirportRequest } from "./api/AddAirportRequest";
 
 export class AdminFlightApi {
   static async addFlight(
     req: AddFlightRequest
+  ): Promise<AxiosResponse<Flight>> {
+    return adminClient.post("/flights", req);
+  }
+
+  static async updateFlight(
+    req: AddFlightRequest
   ): Promise<AxiosResponse<Flight>> {
     return adminClient.put("/flights", req);
   }
 
-  static async fetchFlight(id: number): Promise<AxiosResponse<Flight>> {
+  static async fetchFlight(id: string): Promise<AxiosResponse<Flight>> {
     return adminClient.get(`/flights/${id}`);
   }
 
-  static deleteFlight(id: number): Promise<AxiosResponse<void>> {
+  static deleteFlight(id: string): Promise<AxiosResponse<void>> {
     return adminClient.delete(`/flights/${id}`);
   }
+
+  static async addAirport(
+    req: AddAirportRequest
+  ): Promise<AxiosResponse<Airport>> {
+    return adminClient.post("/airports", req);
+  }
+
+  static async updateAirport(
+    id: string,
+    req: AddAirportRequest
+  ): Promise<AxiosResponse<Airport>> {
+    return adminClient.put(`/airports/${id}`, req);
+  }
+
+  static async fetchAirport(id: string): Promise<AxiosResponse<Airport>> {
+    return adminClient.get(`/airports/${id}`);
+  }
+
+  static deleteAirport(id: string): Promise<AxiosResponse<void>> {
+    return adminClient.delete(`/airports/${id}`);
+  }
 }

src/CustomerFlightApi.ts

@@ -3,15 +3,19 @@ import { customerClient } from "./axios";
 import { Airport, SearchFlightsRequest, PageResult, Flight } from "./api";
 
 export class CustomerFlightApi {
-    static async searchAirports(search: string): Promise<AxiosResponse<Airport[]>> {
-        return customerClient.get('/airports', { params: { search } })
-    }
+  static async searchAirports(
+    search: string
+  ): Promise<AxiosResponse<Airport[]>> {
+    return customerClient.get("/airports", { params: { search } });
+  }
 
-    static async searchFlights(req: SearchFlightsRequest): Promise<AxiosResponse<PageResult<Flight>>> {
-        return customerClient.post('/flights/search', req)
-    }
+  static async searchFlights(
+    req: SearchFlightsRequest
+  ): Promise<AxiosResponse<PageResult<Flight>>> {
+    return customerClient.post("/flights/search", req);
+  }
 
-    static async findFlightById(id: number): Promise<AxiosResponse<Flight>> {
-        return customerClient.get(`/flights/${id}`)
-    }
-}
+  static async findFlightById(id: string): Promise<AxiosResponse<Flight>> {
+    return customerClient.get(`/flights/${id}`);
+  }
+}

src/TestApi.ts

@@ -2,7 +2,11 @@ import { AxiosResponse } from "axios";
 import { testingClient } from "./axios";
 
 export class TestApi {
-  static async clear(): Promise<AxiosResponse<void>> {
-    return testingClient.post("/clear");
+  static async clearFlights(): Promise<AxiosResponse<void>> {
+    return testingClient.post("/flights/clear");
+  }
+
+  static async clearAirports(): Promise<AxiosResponse<void>> {
+    return testingClient.post("/airports/clear");
   }
 }

src/api/AddAirportRequest.ts

@@ -0,0 +1,11 @@
+export class AddAirportRequest {
+  country: string;
+  city: string;
+  airport: string;
+
+  constructor(country: string, city: string, airport: string) {
+    this.country = country;
+    this.city = city;
+    this.airport = airport;
+  }
+}

src/api/AddFlightRequest.ts

@@ -1,17 +1,17 @@
-import { Airport } from "./Airport";
 import { Moment } from "moment";
 import { formatDateTime } from "../formatting";
+import { AddAirportRequest } from "./AddAirportRequest";
 
 export class AddFlightRequest {
-  from: Airport;
-  to: Airport;
+  from: AddAirportRequest;
+  to: AddAirportRequest;
   carrier: string;
   departureTime: string;
   arrivalTime: string;
 
   constructor(
-    from: Airport,
-    to: Airport,
+    from: AddAirportRequest,
+    to: AddAirportRequest,
     carrier: string,
     departureTime: Moment,
     arrivalTime: Moment

src/api/Airport.ts

@@ -1,9 +1,11 @@
 export class Airport {
+  id: string;
   country: string;
   city: string;
   airport: string;
 
-  constructor(country: string, city: string, airport: string) {
+  constructor(id: string, country: string, city: string, airport: string) {
+    this.id = id;
     this.country = country;
     this.city = city;
     this.airport = airport;

src/api/Flight.ts

@@ -1,7 +1,7 @@
 import { Airport } from "./Airport";
 
 export interface Flight {
-  id: number;
+  id: string;
   from: Airport;
   to: Airport;
   carrier: string;

src/api/SearchFlightsRequest.ts

@@ -5,10 +5,12 @@ export class SearchFlightsRequest {
   from: string;
   to: string;
   departureDate: string;
+  page: number;
 
-  constructor(from: string, to: string, departureDate: Moment) {
+  constructor(from: string, to: string, departureDate: Moment, page: number) {
     this.from = from;
     this.to = to;
-    this.departureDate = formatDate(departureDate)
+    this.departureDate = formatDate(departureDate);
+    this.page = page;
   }
 }

src/axios.ts

@@ -2,18 +2,18 @@ import axios, { AxiosBasicCredentials } from "axios";
 
 const credentials: AxiosBasicCredentials = {
   username: "codelex-admin",
-  password: "Password123"
+  password: "Password123",
 };
 
 export const adminClient = axios.create({
-  baseURL: "http://localhost:8080/admin-api/",
-  auth: credentials
+  baseURL: "http://localhost:8080/api/admin/",
+  auth: credentials,
 });
 
 export const testingClient = axios.create({
-  baseURL: "http://localhost:8080/testing-api/"
+  baseURL: "http://localhost:8080/api/testing/",
 });
 
 export const customerClient = axios.create({
-  baseURL: "http://localhost:8080/api/"
+  baseURL: "http://localhost:8080/api/customer/",
 });

src/demo-data/generator.ts

@@ -2,43 +2,46 @@ import csv from "csvtojson";
 import _ from "lodash";
 import moment from "moment";
 import path from "path";
-import { Airport, AddFlightRequest } from "../api";
+import { AddFlightRequest } from "../api";
+import { AddAirportRequest } from "../api/AddAirportRequest";
 
 const AIRLINES_CSV = path.resolve(__dirname + "/airlines.csv");
 const AIRPORTS_CSV = path.resolve(__dirname + "/airports.csv");
 
-let airlines: string[]
-let airports: Airport[]
+let airlines: string[];
+let airports: AddAirportRequest[];
 
 const readAirlines = async (): Promise<string[]> => {
   const tranform = (lines: any[]) => {
-    return lines.map(it => it.description).filter(it => it);
+    return lines.map((it) => it.description).filter((it) => it);
   };
   return csv()
     .fromFile(AIRLINES_CSV)
     .then(tranform);
 };
 
-const readAirports = async (): Promise<Airport[]> => {
+const readAirports = async (): Promise<AddAirportRequest[]> => {
   const tranform = (lines: any[]) => {
     return lines
-      .map(it => new Airport(it.iso_country, it.municipality, it.ident))
-      .filter(it => it.country && it.city && it.airport)
-      .filter(it => it.airport !== "0");
+      .map(
+        (it) => new AddAirportRequest(it.iso_country, it.municipality, it.ident)
+      )
+      .filter((it) => it.country && it.city && it.airport)
+      .filter((it) => it.airport !== "0");
   };
   return csv()
     .fromFile(AIRPORTS_CSV)
     .then(tranform);
 };
 
 export const init = async () => {
-  await readAirlines().then(it => airlines = it)
-  await readAirports().then(it => airports = it)
-}
+  await readAirlines().then((it) => (airlines = it));
+  await readAirports().then((it) => (airports = it));
+};
 
 export const randomAddFlightRequest = (): AddFlightRequest => {
   const departureDate = moment()
-    .year(2019 + _.random(0, 10))
+    .year(2024 + _.random(0, 10))
     .month(1 + _.random(0, 11))
     .day(1 + _.random(0, 27))
     .hour(0 + _.random(0, 24))
@@ -64,8 +67,22 @@ export const randomAddFlightRequest = (): AddFlightRequest => {
   );
 };
 
+export const randomAddAirportRequest = (): AddAirportRequest => {
+  return airports[_.random(0, airports.length)];
+};
+
 export const generateAddFlightRequests = async (
   n: number
 ): Promise<AddFlightRequest[]> => {
-  return _.range(n).map(it => randomAddFlightRequest());
+  return _.range(n).map((it) => randomAddFlightRequest());
+};
+
+export const generateAddAirportRequests = async (
+  n: number
+): Promise<AddAirportRequest[]> => {
+  return _.range(n).map((it) => randomAddAirportRequest());
+};
+
+export const getAllAirportRequests = (): AddAirportRequest[] => {
+  return airports;
 };

test/00-admin-auth.test.ts

@@ -2,10 +2,10 @@ import { AxiosBasicCredentials } from "axios";
 import { AdminFlightApi, adminClient } from "../src";
 
 describe("Admin Auth", () => {
-  it("should not be able to access flights with wrong password", async done => {
+  it("should not be able to access flights with wrong password", async (done) => {
     const wrongAuth: AxiosBasicCredentials = {
       username: "admin",
-      password: "00000000"
+      password: "00000000",
     };
 
     try {
@@ -16,9 +16,9 @@ describe("Admin Auth", () => {
     }
   });
 
-  it("should be able to access flights with correct password", async done => {
+  it("should be able to access flights with correct password", async (done) => {
     try {
-      await AdminFlightApi.fetchFlight(123);
+      await AdminFlightApi.fetchFlight("123");
     } catch (e) {
       expect(e.response.status).toBe(404);
       done();

test/01-testing.test.ts

@@ -1,8 +1,15 @@
 import { TestApi } from "../src";
 
 describe("Testing", () => {
-  it("should clear flights", async done => {
-    const response = await TestApi.clear();
+  it("should clear flights", async (done) => {
+    const response = await TestApi.clearFlights();
+    expect(response.status).toBe(200);
+
+    done();
+  });
+
+  it("should clear airports", async (done) => {
+    const response = await TestApi.clearAirports();
     expect(response.status).toBe(200);
 
     done();