IIT M DEGREE AN EXAM QDB3 31 Aug 2025 - 31 Aug 2025

You executed the following:

```python
student = Student.query.filter_by(id=2).first()
student.name = "Riya"
db.session.add(student)
print(student.name)
```

What will this print?

You define two routes in your Flask app as:

```python
@app.route('/home')
def home():
    return "Home No Slash"

@app.route('/about/')
def about():
    return "About With Slash"
```

A user visits /about (without the trailing slash). What will Flask do?

Consider the following git branches for a remote repository.

```
feature1
* feature2
main
```

Choose the correct git command sequence to merge *feature1* and *feature2* into the *main* branch.

Consider the following HTML code.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Home page</title>
    <style>
        /* Missing CSS code */
    </style>
</head>
<body>
    <div id="mybox">
        IITM Online Degree
    </div>
</body>
</html>
```

Which of the following /* Missing CSS code */ renders the below output?

A rectangular box with an orange background and a thin dark border, containing the text "IITM Online Degree" in a dark, bold font.

What will be displayed when running `python app.py 8080` for the following script?
app.py

```python
import sys

port = int(sys.argv[1]) if len(sys.argv) > 1 else 5000
print(f"Server running on port {port}")
```

Consider the following Flask code.

```python
from flask import Flask
import sys

app = Flask(__name__)

# Read multiplier from command-line
MULTIPLIER = int(sys.argv[1]) if len(sys.argv) > 1 else 1

@app.route('/multiply/<int:number>')
def multiply(number):
    return f"Result: {number % MULTIPLIER}"

if __name__ == '__main__':
    app.run()
```

What will be the output when you run the following code in the terminal
python app.py 5 and then access in the browser with the following link
http://localhost:5000/multiply/4 ?

Consider the following Python code

File name: main_test.py
```python
import pytest

class TestGroup:

    def do_something(self, x, y):
        return x % y

    def test_one(self):
        assert self.do_something(10, 5) == 0, " Is 5 factor of 10? "

    def test_two(self):
        assert self.do_something(32, 5) == 0, " Is 5 factor of 32 "
```
What will be the output of running the above python script using command line "pytest -v main_test.py"?

You created the following templates:

**base.html**

```html
<html>
<body>
    {% block content %}{% endblock %}
</body>
</html>
```

**home.html**

```html
{% extends "base.html" %}
<h1>Welcome!</h1>
```

But when rendered, "Welcome!" doesn't appear. Why?

Suppose you have these models in your Flask-SQLAlchemy app:

```python
class Author(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    books = db.relationship('Book', backref='author', cascade="all, delete")

class Book(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(80))
    author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
```

If you delete an Author instance from the database, what happens to their related Book instances?

Consider the following HTML code snippet (without any CSS styling).

```html
<div>
    <p>This is paragraph 1</p>
    <span>Span element 1</span>
    <span>Span element 2</span>
    <p>This is paragraph 2</p>
    <a href="#">Link 1</a>
    <a href="#">Link 2</a>
    <div>Nested div content</div>
    <strong>Bold text</strong>
    <em>Italic text</em>
</div>
```

Which of the following statements correctly describes how the elements will be displayed by default in a browser?

Consider the following Python code.

File name: main.py
```python
def funA(func):
    def inner_wrapper():
        print("Wrapper function of funA")
        res1 = func()
        res2 = func()
        return res1, res2
    return inner_wrapper

@funA
def funB():
    return "I am from funB"

print(funB())
```

What will be the output, when running the above code using the command "python main.py"?

Consider the table and match each type of software testing with its correct focus area.

| Test Type | Focus Area |
|---|---|
| 1. Unit Testing | a. Simulated end-user browser-based interaction |
| 2. Integration Testing | b. Whole app in full environment including server |
| 3. System Testing | c. Real-world verification by actual users before release |
| 4. System Testing Automation | d. Multiple components/modules working together |
| 5. User Acceptance Testing | e. Smallest logical units (functions/methods) |

You are working on a team project hosted on GitHub. After making changes to your local files, you run the following commands in this exact order:

```shell
git status
git add .
git commit -m "Fixed header bug"
git push
git pull
```

Assuming your teammate pushed a new change **just before** you did `git push`, what is the most likely outcome?

Consider the following Flask application structure and code.

```
my_project/
├── app.py
├── views/
│   └── dashboard.html
├── templates/
│   ├── base.html
│   └── home.html
└── custom_templates/
    ├── admin/
    │   └── login.html
    └── user/
        └── profile.html
```

**app.py:**

```python
from flask import Flask, render_template

app = Flask(__name__, template_folder='custom_templates')

@app.route('/')
def home():
    return render_template('home.html')

@app.route('/admin')
def admin_login():
    return render_template('admin/login.html')

@app.route('/profile')
def user_profile():
    return render_template('user/profile.html')

@app.route('/dashboard')
def dashboard():
    return render_template('dashboard.html')

if __name__ == '__main__':
    app.run(debug=True)
```

Which of the following statements about the template rendering behavior is correct?

Examine the following Python code snippet.

File: logger_test.py

```python
import logging
import sys

logging.basicConfig(level=logging.WARNING,
                    format='%(asctime)s - %(levelname)s - %(message)s')

def process_data(num):
    logging.debug("Starting data processing")
    logging.info("Processing number: %d", num)

    if num == 0:
        logging.warning("Zero value detected - potential division by zero")
        return None
    elif num < 0:
        logging.error("Negative number provided: %d", num)
        return None
    else:
        result = 100 / num
        logging.info("Calculation completed successfully")
        return result

try:
    input_num = int(sys.argv[1])
    result = process_data(input_num)
    if result:
        print(f"Result: {result}")
except IndexError:
    logging.critical("No command line argument provided")
except ValueError:
    logging.error("Invalid input - not a number")
```

What will be the output when running the command: python logger_test.py -5 ?

Consider the following Python code snippet:

**python: app.py**

```python
from string import Template
from jinja2 import Template as JinjaTemplate
import sys

mode = sys.argv[1]
data = {"user": "Bob", "language": "JavaScript", "project": "web app",
        "status": "completed"}

template_str = "Hello ${user}! Your {{project}} written in {{language}} is ${status}."

if mode == "hybrid":
    str_template = Template(template_str)
    intermediate = str_template.substitute(data)
    jinja_template = JinjaTemplate(intermediate)
    result = jinja_template.render(data)
    print(result)
else:
    jinja_template = JinjaTemplate(template_str)
    result = jinja_template.render(data)
    print(result)
```

What will be printed on the terminal for the command: `python app.py hybrid` ?

Consider the following Flask app code.

```python
from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

class MyApiResource(Resource):
    def get(self):
        return {"response": "GET"}, 200

    def post(self, value):
        return {"response": "POST", "value": value}, 200

api.add_resource(MyApiResource, "/", "/<int:value>")

if __name__ == "__main__":
    app.run(debug=True)
```

The above flask app is running on "http://127.0.0.1:5000". Which of the following commands will return a runtime error?

Which of these are true about unit tests in Flask using pytest?

Examine the following Python test file:

Filename: math_tests.py

```python
import pytest

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

@pytest.mark.unit
def test_multiply_positive():
    assert multiply(3, 4) == 12

@pytest.mark.integration
def test_divide_normal():
    assert divide(10, 2) == 5.0

@pytest.mark.slow
@pytest.mark.integration
def test_complex_calculation():
    result = divide(multiply(6, 7), 2)
    assert result == 21.0

@pytest.mark.unit
def test_multiply_negative():
    assert multiply(-2, 3) == -6
```

Consider the following pytest command output:

========= 1 passed, 3 deselected in 0.02s =========

Which of the following pytest commands would produce the output shown above?

Consider the following HTML code.

**File name: home.html**

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Home page</title>
    <script>
        //Missing JS code
    </script>
</head>
<body>
    <form>
        Your name : <input type="text" id="txt1" value="Welcome to IITM Online BS Degree" size="35">
        <br>
        <input type="button" onclick="doSomething()" value="Click me!">
    </form>
</body>
</html>
```

Assume the user clicks the “**Click me!**” button on the below-rendered output.

Your name : [text input field with value "Welcome to IITM Online BS Degree"]
[button with text "Click me!"]

Which of the following //Missing JS code will change the text box font style into **bold**?

If the application is running locally
on http://127.0.0.1:5000, which
of the following statements are TRUE?

The given Flask-RESTful app is running
on http://127.0.0.1:5000. Which of
the following HTTP requests will result in
a runtime error due to method signature
mismatch?

Consider the following HTTP requests
to the same Flask-RESTful application.

What will be the response status code
for each request?

Request 1: `curl http://127.0.0.1:5000/students -X POST -d "name=Ashish"`

Request 2: `curl http://127.0.0.1:5000/courses/CS101/enroll/456 -X POST`

Request 3: `curl http://127.0.0.1:5000/students/789 -X DELETE`

What will be the output of visiting the URL

http://localhost:5000/score?name=Alex&marks=eighty ?

What will be the output of visiting the URL

http://localhost:5000/score?marks=88 ?

What is the output of visiting the URL

http://localhost:5000/score?name=Anya&marks=59.5 ?