RABIA ATTACH

2025 Interview Questions

2025-09-17T11:30:00.004+05:30

2025 Interview Questions

Programming Languages Cover: PHP (Laravel, Codeignitor, CakePHP), JS, Python, Dot Net,

Database Cover: MongoDB, Postgres Sql, MySQL,

Stack Cover: MERN Stack, MEAN Stack, PHP Full Stack

Architechture: MVC

Testing: Playwright,

Tools: Npm, Wget, Nikto, Burp Suite etc.

Short Ques and Ans for Interview Ques:
1. What is MongoDB?
2. Difference between MongoDB and PostgresSQL
3. Difference between Node.js and Next.js
4. What is nodemon
5. Which one is better angular or react, why?
6. React and React.JS what's the difference
7. Difference between NPM and NPX?
8. EXPRESS.JS what is it?
9.

Test Node js ( API Creating and Test in Postman )

2024-08-25T09:44:00.001+05:30

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.

Laravel Test Running

2024-08-09T10:35:00.004+05:30

Running tests in Laravel is done using the `php artisan test` command. Laravel provides a robust testing suite that allows you to write and run tests for your application. Here's how to do it:

### 1. Creating a Test

To create a new test, you can use the `make:test` command:

```bash

php artisan make:test BookTest

```

This will create a test file in the `tests/Feature` directory by default. If you want to create a unit test instead, you can use:

```bash

php artisan make:test BookTest --unit

```

### 2. Writing a Test

Let's say you want to write a test for creating a book. Open the test file (e.g., `tests/Feature/BookTest.php`) and write your test methods.

Here’s an example of what a simple test might look like:

```php

<?php

namespace Tests\Feature;

use App\Models\Book;

use App\Models\User;

use Illuminate\Foundation\Testing\RefreshDatabase;

use Tests\TestCase;

class BookTest extends TestCase

{

use RefreshDatabase;

public function test_user_can_create_a_book()

{

// Create a user and act as that user

$user = User::factory()->create();

$this->actingAs($user);

// Data to create a new book

$bookData = [

'title' => 'Test Book',

'author' => 'Author Name',

'isbn' => '1234567890',

'published_date' => '2024-01-01',

'status' => 'available',

];

// Post request to store the book

$response = $this->post('/books', $bookData);

// Assert that the book was created successfully

$response->assertStatus(302);

$this->assertDatabaseHas('books', ['title' => 'Test Book']);

}

```

### 3. Running the Test

After writing your tests, you can run them using the following command:

```bash

php artisan test

```

This will run all the tests in your `tests` directory and output the results in the terminal. If you only want to run a specific test file, you can do:

```bash

php artisan test --filter=BookTest

```

Or even a specific test method within that file:

```bash

php artisan test --filter=BookTest::test_user_can_create_a_book

```

### 4. Checking Test Results

The output will show how many tests passed and how many failed. If any tests fail, you’ll see details about the failures, including the file and line number where the test failed, and an explanation of why it failed.

### 5. Cleaning Up After Tests

Laravel’s `RefreshDatabase` trait, as used in the example, will automatically reset the database to a clean state after each test. This ensures that each test starts with a fresh database.

### 6. Debugging Failed Tests

If a test fails, you can add `dd()` or `dump()` within the test method to inspect the values and see what went wrong:

```php

dd($response->getContent());

```

This can help you identify issues in your code or test logic.

### Example Output:

When you run `php artisan test`, you should see something like this if everything passes:

```

PASS Tests\Feature\BookTest

✓ user can create a book

Tests: 1 passed

Time: 0.45s

```

---

Running tests is an essential part of the development process, especially during a machine test or interview, as it demonstrates your ability to ensure your code works correctly.