Home

Software Requirements Specification for IE Bank Corp App

Table of Contents

1. Introduction
2. Constraints
3. General System Description
   • System
   • System Architecture Design
   • Release Strategy & Environments Design
4. Functional Requirements
5. Interface Requirements
6. Non-Functional Requirements
   • System Maintenance and Support
7. Software Modelling
   • Use Case and Sequential Model
   • Class Model
   • Database Modelling
8. Software Quality Assurance (SQA) Requirements
   • Test Plan

Introduction

Product Description

Why the Software is Being Developed

The software is being developed to enhance IE Bank Corp's existing bank account management system. The current system lacks certain features and capabilities that are essential for providing a more comprehensive and user-friendly banking experience. The development aims to address these gaps and also to prepare the system for future scalability.

Most Important Features and Capabilities

1. Home Page: A landing page that serves as the entry point for users, providing them with an overview of the services and features available.
2. Country Field in Bank Accounts: Allows users to specify the country associated with a bank account, enabling more personalized services.
3. User Acceptance Testing (UAT) Environment: A replica of the production environment for testing new features and updates before they go live.
4. Monitoring with Azure Application Insights: To keep track of application performance and user activities.
5. GitHub Flow for Version Control: Implementing a branch-based workflow strategy for more efficient code management.

Objectives

The primary objectives of this software project are:

• To improve the user experience by introducing a home page and additional fields in the bank account data.
• To address the existing technical debt by implementing best practices in software development, such as writing unit and functional tests.
• To set up a robust workflow and monitoring system that ensures the application's reliability and performance.
• To prepare the application for a seamless transition from the UAT environment to the production environment.

In summary, this software project aims to elevate IE Bank Corp's existing bank account management system by introducing new features, optimizing workflows, and implementing robust monitoring solutions. The overarching goal is to enhance user experience, improve system reliability, and prepare the platform for future growth and scalability.

Constraints

Standards Imposed on the Solution

The application is required to be deployed on Microsoft's Azure cloud platform. This imposes certain architectural constraints, such as adhering to Azure's best practices for cloud-native applications. Additionally, the project will utilize GitHub for version control, and GitHub Actions for continuous integration and continuous deployment, aligning the development process with GitHub's recommended workflow.

Schedule

The project has a deadline which is set for October 8th, 2023, at 11:59 pm. This imposes a time constraint on all phases of development, from initial planning to final deployment, including testing and documentation. However, this may be subject to be extension based on the status of when access to the Azure services will be made available to us developers (students).

Budget

The budget for this project is indirectly constrained by the Azure service tier that will be provided by the course instructor, Alvaro Guadamillas. This service tier is expected to have limitations on computational resources, storage, and data transfer capabilities, which will influence the design and scalability of the application.

Preferred Software Programming Languages and Frameworks

The project will be developed using a specific set of languages and frameworks that have been used and provided in the source code of the current system.

• Vue.js will be used for building the frontend, focusing on the user interface and user experience.
• Python, specifically the Flask framework, will be employed for backend development to handle API requests and business logic.
• PostgreSQL will serve as the relational database management system for storing persistent data.

Required Development Tools

Several development tools are mandated by the project requirements:

• Vue CLI will be the toolchain for frontend development, providing a development server and build tools.
• Flask will be used as the web framework for building the backend API.
• GitHub will serve as the version control system, facilitating code reviews and team collaboration.
• GitHub Actions will be used for automating testing and deployment tasks.
• Azure will be the cloud platform for hosting the application and database.

Handling of Security Requirements

Currently, there are no explicit security requirements. However, in a future real-world implementation, basic security best practices such as HTTPS encryption for data in transit and secure storage for sensitive information like passwords may be implemented.

Potential Risks

While specific risks have not been identified, there is a general risk of exceeding the resource limitations imposed by the Azure service tier, which could result in additional costs or reduced application performance.

Policy and Regulation

At present, there are no specific policies or regulations that the application needs to comply with. Nonetheless, the development process will aim to adhere to industry best practices for software development and cloud deployment.

General System Description

System

The IE Bank web application is designed to operate as a component within a broader infrastructure rather than a self-contained system. It interacts with external systems and services, such as the Azure cloud platform for hosting and a PostgreSQL database for data storage. The system's infrastructure is defined and managed using Bicep language, allowing for automated and version-controlled provisioning of Azure resources.

Components and Their Functions

• Frontend (Vue.js):

  • Function: Handles the user interface and user experience.
  • Interface: Communicates with the backend through RESTful API calls.

• Backend (Flask):

  • Function: Manages business logic, API endpoints, and data manipulation.
  • Interface: Exposes RESTful APIs for the frontend and interacts with the PostgreSQL database.

• Database (PostgreSQL):

  • Function: Stores all the persistent data related to users, transactions, and account information.
  • Interface: Accessed via SQL queries from the Flask backend.

• Azure Cloud Platform:

  • Function: Hosts the application and provides computational resources. Incorporates both Azure's web portal and Infrastructure as Code (IaC) for resource management.
  • Interface: Managed through Azure's web portal, CLI, and Bicep language for IaC.

• GitHub and GitHub Actions:

  • Function: Provides version control and automates testing and deployment.
  • Interface: Managed through GitHub's web interface and Git commands.

External Interfaces

• User Browser:

  • Users will interact with the system through web browsers, which will communicate with the frontend.

• Azure Services:

  • The application will be deployed on Azure, and it will use Azure's services for cloud storage and computational resources.

• PostgreSQL Database:

  • Hosted on Azure, this database will store all persistent data and will be accessed by the backend.

System Architecture Design

Provided below is a high-level overview of the system architecture, illustrating how the different components interact with each other. It shows the flow of data and control between the user's browser, frontend, backend, database, and other services.

Release Strategy & Environments Design

Release Strategy

The application will follow a Continuous Integration/Continuous Deployment (CI/CD) model facilitated by GitHub Actions. This ensures that any new changes pushed to the repository are automatically tested and deployed to the Azure cloud platform.

1. Development Phase: Developers work on feature branches and create pull requests when a feature is complete.
2. Code Review: Pull requests are reviewed before merged. Automated tests, including unit tests, are run to ensure code quality.
3. Merge and Deploy: Once approved, the changes are merged into the main branch, triggering an automated deployment to the Azure cloud platform.

Environments

The application will have three primary environments:

1. Local Environment:

   • Purpose: For individual developers to test features locally.
   • Tools: Local IDE, local instance of PostgreSQL database. Frontend and Backend Debuggers.

2. Development (Azure):

   • Purpose: To deploy code to the cloud at a smaller scale.
   • Tools: Azure cloud platform, GitHub Actions for CI/CD, Staging PostgreSQL database on Azure.

3. UAT:

   • Purpose: To test the application in a production-like setting but without affecting the actual users. Will be utilizing higher speeds of Azure services
   • Tools: Azure cloud platform, GitHub Actions for CI/CD, Staging PostgreSQL database on Azure.

Versioning

Semantic versioning will be followed to keep track of the different releases of the application.

Functional Requirements

Core Business Functions

Current Features

• Account Listing: Users can view a list of all bank accounts.
• Individual Account View: Users can view details of individual bank accounts by their account ID.
• Account Deletion: Users can delete bank accounts.

New Features

• Home Page Display: When users enter the root URL, a home page should be displayed.
• Country Field Addition: Users should be able to add a 'country' field when creating a new account.

Sources of Inputs

• User Input: Through web forms on the frontend for account creation and management.
• API Calls: Backend API endpoints will be used to interact with the database.

Input Validation

• Account Fields: All fields must be filled out, and the 'country' field should only accept valid country names.
• HTTP Methods: Only GET, POST, PUT, and DELETE methods are allowed for respective functionalities.

Processing Requirements

• Database Operations: CRUD operations (db_read, db_add, db_update, db_delete) will be performed on the PostgreSQL database.
• Error Handling: Proper error messages should be displayed for invalid inputs or failed operations.

Outputs

• Account Information: Upon successful CRUD operations, relevant account information will be displayed.
• Error Messages: In case of an error, appropriate error messages will be shown.

Requirements Traceability Matrix (RTM)

Requirement ID	Description	Source	Test Case ID
FR1	Account Listing	User Story #1	TC1
FR2	Individual Account View	User Story #2	TC2
FR3	Account Deletion	User Story #3	TC3
FR4	Display Home Page	User Story #4	TC4
FR5	Add 'Country' Field in Account Creation	User Story #5	TC5

Interface Requirements

Major Interfaces Between the System and Users

1. Web User Interface (UI)

   • Description: The primary interface for users to interact with the IE Bank application. Built using React and styled with CSS, it provides various functionalities like account management, transaction history, and more.
   • Technology: React, Redux, CSS

2. RESTful API

   • Description: The backend API serves as the interface for the frontend to interact with the backend system. It handles requests and responses for account management, transactions, etc.
   • Technology: Flask, SQLAlchemy

3. Database Interface

   • Description: The backend interacts with the PostgreSQL database to perform CRUD (Create, Read, Update, Delete) operations.
   • Technology: SQLAlchemy, PostgreSQL

4. Azure Cloud Interface

   • Description: The application is hosted on Azure, and the interface for managing cloud resources is through Azure's web portal and CLI.
   • Technology: Azure Web Portal, Azure CLI

5. GitHub Interface

   • Description: Developers interact with the codebase through GitHub for version control, code reviews, and automated testing via GitHub Actions.
   • Technology: GitHub, GitHub Actions

Interfaces to External Hardware Devices

• None: The application does not directly interact with any external hardware devices.

Interfaces to Other Application Systems

1. Azure Services

   • Description: The application is deployed on Azure and uses Azure's services for cloud storage and computational resources.
   • Technology: Azure App Service, Azure Database for PostgreSQL

2. GitHub Actions

   • Description: Automates the CI/CD pipeline, including testing and deployment to Azure.
   • Technology: GitHub Actions

Non-Functional Requirements

System Maintenance and Support

Maintenance Requirements

1. Regular Updates: Throughout the project, system should undergo regular updates and feature enhancements are applied.

2. Monitoring: Azure Application Insights will be used for real-time monitoring of the application. Any anomalies or issues should trigger alerts to the development team.

Support Requirements

1. Peak Load: The system should be capable of supporting up to 100,000 users during peak load times.

2. Documentation: Comprehensive documentation (such as this one) should be maintained to assist both users and the development team in understanding the system's functionalities and troubleshooting issues.

Software Modelling

Use Case and Sequential Model

Use Case 1: Access Home Page

Attribute	Description
Use Case Name	Access Home Page
Summary	The user accesses the home page of the IE Bank web application to view account information.
Basic Flow	1. The user opens the web application. 2. The frontend requests account data from the backend. 3. The backend reads account data from the database. 4. The database returns the account data to the backend. 5. The backend sends the account data to the frontend. 6. The frontend displays the home page with account information to the user.
Postconditions	The user can view account information on the home page.

Use Case 2: Add New Account

Attribute	Description
Use Case Name	Add New Account
Summary	The user adds a new bank account with country information.
Basic Flow	1. The user clicks on the "Add New Account" button. 2. The frontend sends new account data to the backend. 3. The backend adds new account data to the database. 4. The database confirms the addition of the new account. 5. The backend confirms the addition to the frontend. 6. The frontend displays a confirmation message to the user.
Postconditions	A new account is added to the user's account list.

Class Model

The Class Model diagram provides an overview of the main classes involved in the IE Bank web application. It outlines the attributes and relationships for the Account classe. The Account class holds information about individual bank accounts, including a unique identifier (account_id), the current balance (balance), and the associated country (country).

Database Modeling

The database model consists of main entity: Account. The Account entity contains details like account_name, account_number, account_balance, account_currency, account_country, and account status. Due to the simplicity of the system, there is only one table in the database and thus there is no need to present a entity-relationship diagram

Software Quality Assurance (SQA) Requirements

Test Plan

Description

The Test Plan for this project is aligned with the requirements set forth by the assignment description. It aims to ensure the quality and reliability of both new features and existing functionalities. The plan outlines the testing approach, activities, techniques, and tools to be used.

Testing Approach

The testing approach for this project will be a combination of Unit Tests and Functional Tests. Unit tests will be written for the backend API code to test individual components, while functional tests will be used to test the system as a whole, including the interaction between the frontend and backend.

• Unit Tests: Will be written in Python using the unittest framework.
• Functional Tests: Will be written to test the frontend-backend interaction and will simulate user behavior.

Testing tools to be used include GitHub Actions for automated testing and Azure Application Insights for monitoring.

Testing Tasks to be Performed

1. Write Unit Tests for Backend API: To test individual components and ensure they work as expected.
   • Responsible: Developer
2. Write Functional Tests for System Interaction: To test the system as a whole and ensure that new features integrate well with existing functionalities.
   • Responsible: Developer
3. Automate Testing with GitHub Actions: To ensure that tests are run automatically upon code pushes and pull requests.
   • Responsible: Developer
4. Monitor Application with Azure Application Insights: To track performance and catch issues early.
   • Responsible: Developer

New Tests Added

Functional Tests:

1. Update Account Test:

   • Description: This test checks the functionality of updating an account.
   • Test Steps:
     • Given a Flask application.
     • When the '/accounts/int:id' page is posted to with a PUT request.
     • Then the response should be valid and return a status code of 200.
   • Responsible: Developer

2. Delete Account Test:

   • Description: This test checks the functionality of deleting an account.
   • Test Steps:
     • Given a Flask application.
     • When the '/accounts/int:id' page is posted to with a DELETE request.
     • Then the response should be valid and return a status code of 200.
   • Responsible: Developer

Unit Tests:

1. Account Model Initialization Test:

   • Description: This test checks the initialization of an account object with specific values and verifies if the fields are set correctly.
   • Test Steps:
     • Initialize an account object with specific values.
     • Check if the fields of the account object are set correctly.
   • Responsible: Developer

2. Account Model String Representation Test:

   • Description: This test checks the string representation of an account object. The string representation of an object is often used for debugging and logging purposes.
   • Test Steps:
     • Initialize an account object with specific values.
     • Check if the string representation of the account object is as expected.
   • Responsible: Developer