Modern Application Development I 18 Dec 25 - 21 Dec 2025

app.py
```python
from flask import Flask, render_template
app = Flask(__name__)

@app.route('/')
def home():
    return render_template("index.html", items=['DaShBoard', 'SETtings',
                                                 'HELP'])

app.run()
```

index.html
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Menu</title>
</head>
<body>
    {% macro nav_list(elements) %}
    <ol>
        {% for element in elements %}
        <li><a href="/{{ element|lower }}">{{ element|upper }}</a></li>
        {% endfor %}
    </ol>
    {% endmacro %}

    {{ nav_list(items) }}
</body>
</html>
```

```python
from flask import Flask, abort, redirect, url_for

app = Flask(__name__)

@app.route('/home/<path:directory>')
def home(directory):
    if "DBMS" in directory:
        return "Welcome to DBMS course!"
    else:
        abort(404)

@app.route('/home/course/<path:directory>')
def course(directory):
    if "DBMS" in directory:
        return redirect(url_for('home', directory=directory))
    else:
        abort(404)

@app.errorhandler(404)
def page_not_found(error):
    return "<h2>Sorry, No course found!!<h2>"

app.run(debug=True)
```

Invalid command!

```python
def generate_series(n):
    seq = []
    for i in range(1, n+1):
        seq.append(i * 3)
    return seq

def test_case1():
    assert 9 in generate_series(3)

def test_case2():
    assert 21 in generate_series(6)

def test_case3():
    assert 30 in generate_series(8)
```
What will be the summary of the output for the command `pytest file.py` on the terminal?

```sql
CREATE TABLE employee (
    emp_id INTEGER NOT NULL,
    emp_code VARCHAR() NOT NULL,
    name VARCHAR(),
    salary INTEGER NOT NULL,
    join_date DATE NOT NULL,
    PRIMARY KEY (emp_id),
    UNIQUE (emp_code),
    UNIQUE (name)
)
```

```python
from jinja2 import Template

products = [
    {"category": "Groceries", "price": 40, "name": "Rice"},
    {"category": "Electronics", "price": 300, "name": "Headphones"},
    {"category": "Groceries", "price": 10, "name": "Soap"},
]

t = """
<ul>
{% for group in products|groupby('category') %}
    <li>{{ group.grouper }}
        <ul>
        {% for item in group.list %}
            <li>{{ item.name }} costs {{ item.price }}</li>
        {% endfor %}
        </ul>
    </li>
{% endfor %}
</ul>
"""

temp = Template(t)
print(temp.render(products=products))
```

Match the type of update with the correct analogy/description:

| Update Type             | Analogy/Description                                                      |
| :---------------------- | :----------------------------------------------------------------------- |
| 1. Synchronous Updates  | A. Runs tasks one after another, without parallel execution              |
| 2. Asynchronous Updates | B. Freezes the UI until the operation is complete                        |
| 3. Blocking Execution   | C. Ordering food at a restaurant and waiting in line until it is ready   |
| 4. Non-blocking Execution | D. Ordering food, receiving a buzzer, and waiting at a table until it rings |
|                         | E. Allows other tasks to continue while waiting for a response           |

Given the following test code:

```python
def test_about(client):
    response = client.get('/about')
    assert response.status_code == 200
    assert b'This is the about page.' in response.data
```

Assume the client fixture works correctly and you are testing a Flask route `/about` that should return the text "This is the about page.". Which of the following options would cause this test to fail?

The goal is to print "Even" for even numbers and "Odd"
for odd numbers in the sequence. Which of the following
if-else blocks should replace <!-- Missing code goes
here --> so that the code works correctly?

What will be the output of the following code?
```html
<script>
  function greet(name = "Guest") {
    return "Hello, " + name;
  }
  console.log(greet());
  console.log(greet("Alice"));
</script>
```

You want to change the text of a `<p>` element with `id="msg"` to "Welcome to JavaScript!" when a button is clicked. Which code snippet correctly does this?

```html
<p id="msg">Old Message</p>
<button id="btn">Change</button>
<script>
    // Code goes here
</script>
```

Table: products

| pid | name  | price |
| :-- | :---- | :---- |
| 101 | Pen   | 10    |
| 102 | Bag   | 450   |
| 103 | Watch | 800   |
| 104 | Shoes | 1300  |

Which query lists all products sorted from expensive to cheap?

```python
def max_value(nums):
    if not nums:
        return None
    return max(nums)

def test_max_value():
    ##Assertions to test max_value function##
```

```
curl -X POST -d "username=student&password=1234" https://student/login
```

Consider the following HTML5 form:

```html
<form method="POST" action="/submit">
    <input type="email" name="email" required>
    <input type="password" name="password" required minlength="8">
    <input type="number" name="age" min="18" max="65" required>
    <button type="submit">Submit</button>
</form>
```

Which of the following attributes are HTML5 native validation features that work without JavaScript?

Consider the following Flask-RESTful code:

```python
class UserResource(Resource):
    def get(self, user_id=None):
        if user_id:
            return {"message": "User details", "id": user_id}, 200
        return {"message": "All users"}, 200

    def post(self):
        return {"message": "User created"}, 201

api.add_resource(UserResource, '/users', '/users/<int:user_id>')
```

Which of the following requests will execute successfully?

Consider this logging setup:

```python
import logging

logging.basicConfig(level=logging.INFO,
                    format='%(levelname)s:%(name)s:%(message)s')

logging.debug("Debug message")
logging.info("Info message")
logging.warning("Warning message")
```

What will be displayed in the output?

Given the following pytest test structure:

```python
@pytest.fixture
def sample_data():
    return {"name": "John", "age": 30}

def test_name(sample_data):
    assert sample_data["name"] == "John"

def test_age(sample_data):
    assert sample_data["age"] == 30
```

When running `pytest -v`, how many times will the sample_data fixture be executed?

Consider test file with markers:

```python
@pytest.mark.slow
def test_database():
    pass

@pytest.mark.unit
def test_calculation():
    pass

@pytest.mark.slow
@pytest.mark.unit
def test_complex():
    pass
```

Running `pytest -m "unit and not slow"` will execute which tests?

In a Flask-Login protected route below:

```python
@app.route('/dashboard')
@login_required
def dashboard():
    return f"Welcome {current_user.username}"
```

What happens when an unauthenticated user tries to access /dashboard?