Express.js Online Test

A blogging application is built using an Express.js backend. The backend serves the frontend code through the public directory and also serves a few static files for the website through the static directory. The code for Express.js application is:

const express = require("express");
const path = require("path");
const app = express();

app.use(express.static(path.join(__dirname, "public")));
app.use("/images", express.static(path.join(__dirname, "static", "images")));
app.use("/files", express.static(path.join(__dirname, "static", "manuals")));

app.listen(80, () => {
  console.log("Blogging app listening on port 80");
});

Below is the folder structure of the application:

Which endpoints will return a status code of 200 for the above application?

Consider the following package.json for a Node.js application:

{
  "name": "skill-measure-app",
  "private": true,
  "version": "1.0.0",
  "main": "lib/main.js",
  "scripts": {
    "build": "npm run cleanup & npm run test & npm run publish",
    "cleanup": "rm -fr ./lib",
    "test": "jest",
    "publish": "npm publish lib"
  },
  "dependencies": {
     "jest": "^23.0.1",
     "custom-package": "file:../custom-package"
  }
}

Select all the correct statements.

Omega Services is updating its pricing page and they are updating their Express.js application so that the requests for the old pricing endpoint are redirected to the new endpoint. They also have an endpoint which will serve the company's brochure file.

Below is the code for the Express.js app of the company:

const express = require("express");
const path = require("path");
const app = express();

app.get("/omega/pricing", (req, res) => {
  ____________("/omega/pricingnew");
});

app.get("/omega/brochure", (req, res) => {
  ____________(path.join(̲ ̲ dirname, "public", "brochure.pdf"));
});

app.get("/omega/pricingnew", (req, res) => {
  res.send("Omega has the best deals");
});

app.listen(80, () => {
  console.log("Omega app listening on port 80");
});

Fill in the blanks so that all endpoints of the application respond as expected.

A temperature converter service is built using an Express.js backend. The service is used to convert units from Fahrenheit to Celsius. The endpoint receives the request with the content type as application/json, and is authenticated by verifying the value of "X-Auth-Key" in the headers.

The code for the Express.js application is:

const express = require("express");
const app = express();

const authCheck = (req, res, next) => {
  const authKey = _______("X-Auth-Key");
  if (authKey == "secret") {
    next();
  } else {
    res.status(401).end();
  }
};

app.use(____________());

app.post("/tocelsius", authCheck, (req, res) => {
  const fahrenheit = req.body.fahrenheit;
  res.json({ celsius: ((fahrenheit - 32) * 5) / 9 });
});

app.listen(80, () => {
  console.log("Temperature converter app listening on port 80");
});

The following JSON is passed to the request body

{
  "fahrenheit" : 95
}

Considering the JSON above, fill in the blanks so that the service functions successfully.

A company hosts its website and a product API on same server using the code below:

let http = require("http");

let commonResponse = function(response){
  response.writeHead(200, { "Content-Type": "text/html" });
  response.write("Request Completed");
}

let handleApi = function(req, res){
  if(req.method == "POST"){
    commonResponse(res);
    res.end();
  }
}

let handleWeb = function(req, res){
  commonResponse(res)
  res.end();
}

http.createServer(handleApi).listen(4513);
http.createServer(handleWeb).listen(4514);

Select all the correct answers.

The createEmitter function should create a new EventEmitter and register "open" and "close" event listeners. The callbacks for those events should be onOpen and onClose arguments, respectively. The opened and closed methods should raise the "open" and "close" events on the EventEmitter they will receive as emitter arguments. The callbacks should only be invoked once per emitter.

For example, after executing the following code, it should print "Opened!" and then "Closed!":

let emitter = createEmitter(
  () => console.log("Opened!"), () => console.log("Closed!")
);
opened(emitter);
closed(emitter);

Implement the getInParallel function that should be used to invoke multiple API calls in parallel. The function accepts an array of functions that return a Promise. The function should return a Promise which should resolve to an array of results from the apiCalls argument.

For example, calling the following code should print "[ 'First API call!', 'Second API call!' ]":

let promise = getInParallel([() => Promise.resolve("First API call!"),
                             () => Promise.resolve("Second API call!")]);
if(promise) {
  promise.then((result) => console.log(result)).catch((err) => console.log(err));
}

A company uses a Node.js application that checks several data sources for requested information. Since each request to a data source is performance heavy, the application should try to check the next source only if the request failed at the current data source. That functionality was extracted into the firstSuccessfulPromise function.

The firstSuccessfulPromise function accepts an array of Promises as a promiseArray parameter. The function should return a Promise which should resolve to the first successful result from the promiseArray.

If no Promise from the promiseArray returns successfully, the function should return undefined.

For example, if the following code is executed:

firstSuccessfulPromise([new Promise((resolve, reject) => reject()), 
              new Promise((resolve, reject) => resolve("Success!"))])
  .then(result => console.log(result));

It should print "Success!".