express-serve-static-core#Express TypeScript Examples

describe('Budget Api provider verification', () => {

  const port = 8080;
  let app: Express;
  let server: Server;
  let givenRequest: (req: Request) => void;

  beforeAll((done) => {
    app = express();
    app.use(express.json());
    app.use((req: Request, _res: Response, next: NextFunction) => {
      givenRequest(req);
      next();
    });
    app.use(new DashboardController(new InMemoryBudgetRepository()).getRouter());

    server = app.listen(port, () => done());
  });

  afterAll(() => server.close());

  it('passes for the all interactions', async () => {

    givenRequest = (req) => {
      req.user = { accountId: '1' };
    }

    const options = {
      providerBaseUrl: 'http://localhost:8080',
      pactUrls: [path.resolve(__dirname, './../../pacts/budgetclient-budgetprovider.json')],
      // we can also point here to the Pact Broker to get the contracts
    }

    await new Verifier(options).verifyProvider();
  });

});

setupServer = (app: Express, rollbar: Rollbar, models: DB) => {
  const port = process.env.PORT || DEFAULT_PORT;
  app.set('port', port);
  const server = http.createServer(app);
  setupWebSocketServer(server, rollbar, models);

  const onError = (error) => {
    if (error.syscall !== 'listen') {
      throw error;
    }
    switch (error.code) {
      case 'EACCES':
        log.error('Port requires elevated privileges');
        process.exit(1);
        break;
      case 'EADDRINUSE':
        log.error(`Port ${port} is already in use`);
        process.exit(1);
        break;
      default:
        throw error;
    }
  };

  const onListen = () => {
    const addr = server.address();
    if (typeof addr === 'string') {
      log.info(`Listening on ${addr}`);
    } else {
      log.info(`Listening on port ${addr.port}`);
    }
  };

  server.listen(port);
  server.on('error', onError);
  server.on('listening', onListen);
}

server: Express

server: Express

server: Express

export async function createServer(): Promise<Express> {
  const yamlSpecFile = './config/openapi.yml'
  const apiDefinition = YAML.load(yamlSpecFile)
  const apiSummary = summarise(apiDefinition)
  logger.info(apiSummary)
 
  const server = express()
  
  server.use(bodyParser.json())
  
  /* istanbul ignore next */
  if (config.morganLogger) {
    server.use(morgan(':method :url :status :response-time ms - :res[content-length]'))
  }
  
  /* istanbul ignore next */
  if (config.morganBodyLogger) {
    morganBody(server)
  }

  /* istanbul ignore next */
  if (config.exmplDevLogger) {
    server.use(expressDevLogger)
  }
  
  // setup API validator
  const validatorOptions = {
    coerceTypes: true,
    apiSpec: yamlSpecFile,
    validateRequests: true,
    validateResponses: true
  }
  await new OpenApiValidator(validatorOptions).install(server)
  
  // error customization, if request is invalid
  server.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
    res.status(err.status).json({
      error: {
        type: 'request_validation',
        message: err.message,
        errors: err.errors
      }
    })
  })
 
  const connect = connector(api, apiDefinition, {
    onCreateRoute: (method: string, descriptor: any[]) => {
      descriptor.shift()
      logger.verbose(`${method}: ${descriptor.map((d: any) => d.name).join(', ')}`)
    },
    security: {
      bearerAuth: api.auth
    }
  })
  connect(server)
 
  return server
}

app : Express = express()

describe('ExpensesController', () => {
  
  const fakeExpense: Expense = {
    accountId: '1',
    value: 100,
    datetime: new Date(1, 1, 2021),
    period: new Period(10, 2021),
    categoryId: '1',
    counterparty: 'fake'
  }

  let expenseRepoStub: ExpensesRepository = {
    getExpense: jest.fn(() => Promise.resolve(fakeExpense)),
    getExpenses: jest.fn(() => Promise.resolve([fakeExpense])),
    getExpensesByCategory: jest.fn(() => Promise.resolve([fakeExpense])),
    createExpense: jest.fn(() => Promise.resolve()),
    updateExpense: jest.fn(() => Promise.resolve()),
    deleteExpense: jest.fn(() => Promise.resolve())
  }

  let app: Express;
  let server: Server;
  let givenRequest: (req: Request) => void;
  const port = 3000;

  beforeAll((done) => {
    app = express();
    app.use(express.json());
    app.use((req: Request, _res: Response, next: NextFunction) => {
      givenRequest(req);
      next();
    });
    app.use(new ExpensesController(expenseRepoStub).getRouter());
    
    server = app.listen(port, () => done());
  });

  afterAll(() => server.close());

  it('returns error 500 when the user role is missing', (done) => {
    // given
    givenRequest = (req) => {
      req.user = { role: undefined };
    }

    // when & then
    request(`http://localhost:${port}`)
      .get('/expenses')
      .expect('Content-Type', /json/)
      .expect(500)
      .then(() => done());
  });

  it('returns expenses for the READER role', (done) => {
    // given
    givenRequest = (req) => {
      req.user = { role: 'READER' };
    }

    // when & then
    request(`http://localhost:${port}`)
      .get('/expenses')
      .expect('Content-Type', /json/)
      .expect(200)
      .then((response) => {
        expect(response.body[0].id).toEqual(fakeExpense.id);
        expect(response.body[0].accountId).toEqual(fakeExpense.accountId);
        expect(response.body[0].value).toEqual(fakeExpense.value);
        done();
      });
  });

  it('returns 403 error when the READER tries to POST expense', (done) => {
    // given
    givenRequest = (req) => {
      req.user = { role: 'READER' };
    }

    // when & then
    request(`http://localhost:${port}`)
      .post('/expenses')
      .send(fakeExpense)
      .expect('Content-Type', /json/)
      .expect(403)
      .then((response) => {
        expect(response.body.msg).toContain('not authorized');
        done();
      });
  });

  it('returns 201 success code when the OWNER tries to POST expense', (done) => {
    // given
    givenRequest = (req) => {
      req.user = { role: 'OWNER' };
    }

    // when & then
    request(`http://localhost:${port}`)
      .post('/expenses')
      .send(fakeExpense)
      .set('Accept', 'application/json')
      .expect('Content-Type', /json/)
      .expect(201)
      .then((response) => {
        expect(response.body).toBeFalsy();
        done();
      });
  });

});