BUG TRACKING Project

Software Requirements Specification

Version <3.0>

S.Vishnu Teja
K23HT
12304606
Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

Revision History
Date Version Description Author
<12/03/2024> <1.0> SRS 1.0 Vishnu
<24/03/2024> <2.0> SRS 2.0 Vishnu
<05/04/2024> <3.0> SRS 3.0 Vishnu

Confidential <Company Name>, 2024 Page 2

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

Table of Contents
Introduction
1. Purpose
2. Scope
3. Definitions, Acronyms, and Abbreviations
4. References
5. Overview

General Description
1. Product Perspective
2. Product Functions
3. User Characteristics
4. General Constraints
5. Assumptions and Dependencies

Specific Requirements
1. External Interface Requirements
1. User Interfaces
2. Hardware Interfaces
3. Software Interfaces
4. Communication Interfaces
2. Functional Requirements
3. Non-functional Requirements
1. Performance Requirements
2. Security Requirements
3. Reliability Requirements
4. Scalability Requirements

System Features
1. Feature 1
1. Description
2. Dependencies
3. Assumptions
4.2 Feature 2

External Interface Requirements

1. User Interfaces
2. Hardware Interfaces
3. Software Interfaces
4. Communication Interfaces

Confidential <Company Name>, 2024 Page 3

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

Supporting information
User Interface of Bug Tracking
Use case diagram
Class diagram
DFD’s
Test cases
References

Confidential <Company Name>, 2024 Page 4

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

Software Requirements Specification

1. Introduction
1. Purpose

The purpose of this Software Requirements Specification (SRS) document is to outline the
requirements for the development of a bug tracking system. This document will serve as a guide
for the development team and stakeholders to understand the objectives, scope, and
functionalities of the bug tracking software.

2. Scope

The bug tracking system will be designed to allow users to report, track, and manage software
defects or issues throughout the software development lifecycle. It will provide a centralized
platform for users to submit bug reports, assign tasks, track progress, and communicate
effectively to ensure timely resolution of issues.

3. Definitions, Acronyms, and Abbreviations

Bug: An error, flaw, or defect in the software that affects its functionality.

SRS: Software Requirements Specification - a document that outlines the requirements for a
software project.

UI: User Interface - the visual elements and controls through which users interact with the
software.

API: Application Programming Interface - a set of rules and protocols for building and interacting
with software applications.

4. References
The references are:

*IEEE Std 830-1998: IEEE Recommended Practice for Software Requirements Specifications
*Bugzilla Documentation: Official documentation for the Bugzilla bug tracking system
*Project Charter: Document outlining the project goals, scope, and stakeholders Overview

5. Overview:
The bug tracking system will be developed to streamline the process of identifying, reporting, and resolving
software defects. It will enhance collaboration among team members, improve transparency in issue management,
and ultimately contribute to delivering high-quality software products.

Confidential <Company Name>, 2024 Page 5

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

2. General Description

1. Product Perspective:
The bug tracking system will be a standalone application that integrates with existing software
development tools and systems, such as version control repositories and project management
platforms. It will provide a seamless interface for users to report and track bugs without
disrupting their existing workflows.

2. Product Functions:
The key functions of the bug tracking system will include:

Bug reporting
Bug assignment and prioritization
Bug tracking and status updates
Communication and collaboration tools
Reporting and analytics
3. User Characteristics:
The system will cater to various user roles, including developers, testers, project managers, and
system administrators. Each user role will have specific permissions and access levels based on
their responsibilities within the software development process.

4. General Constraints:
The bug tracking system must be developed within a specified budget and timeline. It should
also adhere to industry standards for data security and privacy to protect sensitive information
stored within the system.

5. Assumptions and Dependencies:

The successful implementation of the bug tracking system is dependent on the availability of
necessary hardware resources, software dependencies, and user training. It is assumed that users
will receive adequate training to effectively utilize the system.

3. Specific Requirements

The specific requirements are –

1. External Interface Requirements:

1. User Interfaces: The system will feature an intuitive web-based user interface with
functionalities for bug reporting, tracking, and collaboration.
2. Hardware Interfaces: The bug tracking system will be compatible with standard desktop and
mobile devices.
3. Software Interfaces: Integration with version control systems like Git and project
management tools like Jira will be supported.

Confidential <Company Name>, 2024 Page 6

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

3.1.4 Communication Interfaces: The system will support email notifications and in-app
messaging for effective communication.

3.2 Functional Requirements:

The functional requirements will detail the specific features and capabilities of the bug tracking
system, including user authentication, bug categorization, workflow management, and reporting
functionalities.

3. Non-functional Requirements:
1. Performance Requirements:

The bug tracking system should respond to user actions promptly, with a maximum response
time of 2 seconds for most operations.
The system should be able to handle concurrent user interactions without significant performance
degradation.
2. Security Requirements:

User data, bug reports, and system configurations must be securely stored and protected from
unauthorized access.
Access control mechanisms should be in place to ensure that users can only view and modify
data based on their assigned permissions.
3. Reliability Requirements:

The system should be available 24/7 with a minimum uptime of 99.9% to ensure continuous
access for users.
Regular backups of data should be performed to prevent data loss in case of system failures.
4. Scalability Requirements:

The bug tracking system should be designed to scale horizontally to accommodate an increasing
number of users and bug reports over time.
Performance testing should be conducted to ensure that the system can handle a growing
workload without significant performance degradation.

4. System Features
1. Feature 1: Bug Reporting

1. Description: Users can submit detailed bug reports, including steps to reproduce, screenshots, and other
relevant information.
2. Dependencies: This feature depends on user authentication and access control mechanisms.
3. Assumptions: Users will provide accurate and detailed information when submitting bug reports.

Confidential <Company Name>, 2024 Page 7

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

2. Feature 2: Bug Tracking

1. Description:

The bug tracking feature allows users to track the status and progress of reported bugs throughout the bug resolution
process.
Users can view the current status of each bug, including whether it is open, assigned, in progress, or resolved.
The feature provides a centralized dashboard where users can filter and search for specific bugs based on various
criteria.

2. Dependencies:

This feature depends on the bug reporting functionality to populate the list of reported bugs that need tracking.
It also relies on user authentication and access control mechanisms to ensure that only authorized users can view and
update bug status.

3. Assumptions:

It is assumed that users will regularly update the status of bugs they are assigned to, providing accurate information
on bug progress.
The system assumes that users will utilize the filtering and search functionalities to efficiently track and manage
bugs assigned to them.

5. User Interface for Bug Tracking System

1. Login Page:

* The login page should provide a secure authentication process for users to access the bug tracking system.
* Include fields for username and password, along with options for password recovery or account registration.

5.2 Dashboard:

* The dashboard should offer an overview of the user's assigned bugs, bug status updates, and important
notifications.
* Include widgets or summary views for quick access to critical information such as high-priority bugs or pending
tasks.
5.3 Bug Reporting Form:

* The bug reporting form should include fields for detailed bug descriptions, steps to reproduce, severity levels, and
attachments for screenshots or logs.
* Provide dropdown menus or checkboxes for bug categorization, priority levels, and assignment to specific team
members.
5.4 Bug List View:

* The bug list view should display a list of reported bugs with key information such as bug ID, title, status, severity,
and assignee.
* Include filtering and sorting options to allow users to search for specific bugs based on criteria like status, priority,
or creation date.

Confidential <Company Name>, 2024 Page 8

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

5.5 Bug Details Page:

* The bug details page should provide a comprehensive view of a specific bug, including its description, steps to
reproduce, current status, comments, and history.
* Allow users to add comments, update bug status, attach files, and view related discussions or resolutions.
5.6 User Profile Settings:

* User profile settings should allow users to update their personal information, change passwords, and configure
notification preferences.
* Include options for setting up email notifications, customizing dashboard layouts, and managing user roles and
permissions.
5.7 Reporting and Analytics:

 Include reporting and analytics features to generate bug reports, track trends in bug resolution times, and
monitor team performance.
 Provide visualizations such as charts or graphs to represent data on bug statuses, priorities, and resolutions.

Confidential <Company Name>, 2024 Page 9

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

6. Use case diagram :-

Confidential <Company Name>, 2024 Page 10

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

7.Class Diagram:-

Confidential <Company Name>, 2024 Page 11

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

8. DFD’S:-

Confidential <Company Name>, 2024 Page 12

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

9. TEST CASES :-

Security Testing of the Project

Testing is vital for the success of any software. no system design is ever perfect.
Testing is also carried in two phases. first phase is during the software engineering
that is during the module creation. second phase is after the completion of
software. this is system testing which verifies that the whole set of programs
hanged together.

White Box Testing:

In this technique, the close examination of the logical parts through the software
are tested by cases that exercise species sets of conditions or loops. all logical parts
of the software checked once. errors that can be corrected using this technique are
typographical errors, logical expressions which should be executed once may be
getting executed more than once and error resulting by using wrong controls and
loops. When the box testing tests all the independent part within a module a logical
decisions on their true and the false side are exercised , all loops and bounds within
their operational bounds were exercised and internal data structure to ensure their
validity were exercised once.

Black Box Testing:

This method enables the software engineer to device sets of input techniques that
fully exercise all functional requirements for a program. black box testing tests the
input, the output and the external data. it checks whether the input data is correct
and whether we are getting the desired output.

Alpha Testing:
Acceptance testing is also sometimes called alpha testing. Be spoke systems are
developed for a single customer. The alpha testing proceeds until the system
developer and the customer agree that the provided system is an acceptable
implementation of the system requirements.

Confidential <Company Name>, 2024 Page 13

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

Beta Testing:
On the other hand, when a system isto be marked as a software product, another
process called beta testing is often conducted. During beta testing, a system is
delivered among a number of potential users who agree to use it. The customers
then report problems to the developers. This provides the product for real use and
detects errors which may not have been anticipated by the system developers.

Unit Testing:
Each module is considered independently. it focuses on each unit of software as
implemented in the source code. it is white box testing.
Integration Testing:
Integration testing aims at constructing the program structure while at the same
constructing tests to uncover errors associated with interfacing the modules.
modules are integrated by using the top down approach.

Validation Testing:
Validation testing was performed to ensure that all the functional and performance
requirements are met.
System Testing:
It is executing programs to check logical changes made in it with intention of
finding errors. a system is tested for online response, volume of transaction,
recovery from failure etc. System testing is done to ensure that the system satisfies

all the user requirements.

Confidential <Company Name>, 2024 Page 14

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

FLOW CHAT:-

Confidential <Company Name>, 2024 Page 15

Bug Tracking Project Version: <2.0>
Software Requirements Specification Date: <24/03/2024>
<document identifier>

REFERANCE :-
● http://www.bluedart.com/
● http://www.wampserver.com/en/
● http://www.JSP.net/

Confidential <Company Name>, 2024 Page 16