Test Node js ( API Creating and Test in Postman )
BACKEND MACHINE TEST
F.M: 50 TIME: 1 HR 30 MIN
Question: 1
You have a develop API with CRUD OPERATION and test that API using POSTMAN
TOOL:
NOTE: CREATE A NEW APP FOR THE API CREATION AND INSTALL THE DEPENDENCY REQUIRED
FOR API CREATION.
NOTE THE BELOW POINTS:
CREATE A MODAL SCHEMA FOR RAILINFO :
Fields :
{ _id:’’ , train_no:’’ , train_name:’’ ,
src_station:’’,dest_station:’’,platform_no:’’,dep_time:’’,arr_time:’’}
CREATE THE CONTROLLER FOR THE BELOW OPERATIONS ON API :
FETCH ALL TRAIN INFO
FIND SPECIFIC TRAIN INFO based on src_station , dest_station
INSERT TRAIN INFO
UPDATE TRAIN INFO based on train_no
DELETE TRAIN INFO based on train _id
CREATE THE PROPER ROUTING FOR API.
TEST EACH ENDPOINTS USING POSTMAN and provide the screenshots
Attached.
Task Overview:
You need to develop an API that supports CRUD operations (Create, Read, Update, Delete) for train information. The API will be tested using the Postman tool. The steps below will guide you through creating a new application, defining the data schema, implementing the API, setting up routes, and testing with Postman.
Step 1: Set Up a New Project
a) Initialize a New Project
Depending on the language and framework you prefer, initialize a new project. Here, I'll guide you through the process using Node.js with Express.js and MongoDB as the database.
```bash
mkdir railinfo-api
cd railinfo-api
npm init -y
npm install express mongoose body-parser
```
b) Create Project Structure
Create folders and files for the model, controller, and routes.
```bash
mkdir models controllers routes
touch app.js
```
Step 2: Create a Model Schema for `RailInfo`
Define a schema that outlines the structure of your train information.
```javascript
// models/RailInfo.js
const mongoose = require('mongoose');
const railInfoSchema = new mongoose.Schema({
train_no: { type: String, required: true },
train_name: { type: String, required: true },
src_station: { type: String, required: true },
dest_station: { type: String, required: true },
platform_no: { type: String, required: true },
dep_time: { type: String, required: true },
arr_time: { type: String, required: true }
});
const RailInfo = mongoose.model('RailInfo', railInfoSchema);
module.exports = RailInfo;
```
Step 3: Create Controllers for CRUD Operations
Implement the logic for handling CRUD operations.
```javascript
// controllers/railController.js
const RailInfo = require('../models/RailInfo');
// Fetch All Train Info
exports.getAllTrainInfo = async (req, res) => {
const trains = await RailInfo.find();
res.json(trains);
};
// Find Specific Train Info based on src_station and dest_station
exports.getTrainByRoute = async (req, res) => {
const { src_station, dest_station } = req.query;
const trains = await RailInfo.find({ src_station, dest_station });
res.json(trains);
};
// Insert Train Info
exports.createTrainInfo = async (req, res) => {
const newTrain = new RailInfo(req.body);
await newTrain.save();
res.json(newTrain);
};
// Update Train Info based on train_no
exports.updateTrainInfo = async (req, res) => {
const { train_no } = req.params;
const updatedTrain = await RailInfo.findOneAndUpdate({ train_no }, req.body, { new: true });
res.json(updatedTrain);
};
// Delete Train Info based on train_id
exports.deleteTrainInfo = async (req, res) => {
const { id } = req.params;
await RailInfo.findByIdAndDelete(id);
res.json({ message: 'Train info deleted' });
};
```
Step 4: Set Up Routing
Define the routes that connect the HTTP requests to the appropriate controller functions.
```javascript
// routes/railRoutes.js
const express = require('express');
const router = express.Router();
const railController = require('../controllers/railController');
router.get('/trains', railController.getAllTrainInfo);
router.get('/trains/search', railController.getTrainByRoute);
router.post('/trains', railController.createTrainInfo);
router.put('/trains/:train_no', railController.updateTrainInfo);
router.delete('/trains/:id', railController.deleteTrainInfo);
module.exports = router;
```
Step 5: Set Up the Application
Integrate everything in your main application file.
```javascript
// app.js
const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');
const railRoutes = require('./routes/railRoutes');
const app = express();
app.use(bodyParser.json());
mongoose.connect('mongodb://localhost/railinfo', {
useNewUrlParser: true,
useUnifiedTopology: true,
useFindAndModify: false
});
app.use('/api', railRoutes);
app.listen(3000, () => {
console.log('Server is running on port 3000');
});
```
Step 6: Test the API Using Postman
1. Fetch All Train Info
- Method: `GET`
- URL: `http://localhost:3000/api/trains`
- Response: Should return all train records.
2. Find Specific Train Info
- Method: `GET`
- URL: `http://localhost:3000/api/trains/search?src_station=XYZ&dest_station=ABC`
- Response: Should return trains matching the specified source and destination stations.
3. Insert Train Info
- Method: `POST`
- URL: `http://localhost:3000/api/trains`
- Body (JSON):
```json
{
"train_no": "12345",
"train_name": "Express Train",
"src_station": "Station A",
"dest_station": "Station B",
"platform_no": "1",
"dep_time": "10:00",
"arr_time": "14:00"
}
```
- Response: Should return the newly created train record.
4. Update Train Info
- Method: `PUT`
- URL: `http://localhost:3000/api/trains/12345`
- Body (JSON):
```json
{
"train_name": "Super Express",
"platform_no": "2"
}
```
- Response: Should return the updated train record.
5. Delete Train Info
- Method: `DELETE`
- URL: `http://localhost:3000/api/trains/60f0c2e5a47e6c1a88e00000`
- Response: Should confirm the deletion.
Step 7: Provide Screenshots
Capture screenshots of each Postman request and response, and compile them into a document. Annotate the screenshots if needed, to explain the output of each API request.
This completes the setup and testing of the CRUD API for the `RailInfo` system.
Comments
Post a Comment
Please do not enter any spam link in the comment box.