logo

Bugzilla Interview Questions and Answers

Bugzilla is an open-source bug tracking system that helps developers and teams manage software defects and track issues throughout a project's lifecycle. It was originally developed by Mozilla and is widely used by software development teams to log, categorize, assign, and resolve bugs.
Key Features of Bugzilla :
  • Bug Tracking: Allows users to report, update, and resolve bugs.
  • Advanced Search: Provides powerful filtering and search capabilities.
  • Email Notifications: Sends updates to relevant team members when bug statuses change.
  • Custom Fields & Workflows: Can be customized to fit different development processes.
  • Security & Access Control: Allows setting permissions and access levels for different users.
  • Integration: Can be integrated with version control systems like Git and other tools.

Bugzilla is written in Perl and typically runs on Linux/Unix servers, though it can also work on Windows.

Bugzilla supports the following databases :

  • MariaDB
  • MySQL
  • PostgreSQL
  • Oracle
  • SQLite

It's recommended to use MariaDB, MySQL, or PostgreSQL for production environments. Oracle is supported, but it's not as extensively tested. SQLite is suitable only for testing or very small installations due to its limitations.

* Log in to Bugzilla.

* Click on "New" or "Report a Bug".

* Select the product and component where the bug was found.

* Enter details like summary, description, severity, priority, steps to reproduce, and attachments (if any).

* Click "Submit" to log the bug.
Aspect Priority Severity
Definition Defines how quickly the bug should be fixed. Defines how serious the impact of the bug is.
Levels P1 (Highest) to P5 (Lowest) Blocker, Critical, Major, Minor, Trivial
Who Sets It? Project Manager, Team Lead Tester or Developer
Example A minor UI issue in a high-profile release = High Priority A crash causing data loss = Critical Severity
* NEW – Newly reported bug.

* ASSIGNED – Bug assigned to a developer.

* RESOLVED – Bug fixed and marked as :

* FIXED – Successfully resolved.
* WONTFIX – Will not be fixed.
* DUPLICATE – Already reported.
* INVALID – Not a valid bug.
* WORKSFORME – Cannot be reproduced.

* VERIFIED – Tester confirms the fix.

* CLOSED – Bug is fully resolved.

Yes, you can customize fields in Bugzilla. Bugzilla has a feature that allows administrators to add custom fields to bugs, which can be used to capture additional information specific to your project or organization.

To add a custom field, you need to log in to Bugzilla as an administrator and go to the "Custom Fields" link in the footer of the page. From there, you can add a new field, specifying its name, description, type, and other attributes.

There are several types of custom fields available, including:

  • Free text : A single line box for entering free text.
  • Large text box : A multiple line box for entering free text.
  • Drop down : A list box where only one option can be selected.
  • Multiple-selection box : A list box where multiple options can be selected.
  • Date/Time : A date field.
  • Bug ID : A field where you can enter the ID of another bug from the same Bugzilla installation.

Once you have created a custom field, it can be used like any other field in Bugzilla. You can set its value when creating or editing a bug, and you can use it to search for bugs.

In addition to custom fields, Bugzilla also allows you to customize other aspects of the bug tracking system, such as the workflow, email notifications, and user permissions.

Bugzilla offers several ways to search for bugs, catering to different levels of information you have about the bug:

1. Quick Search:

  • This is the simplest way to search. Just type a word or series of words in the search box. Bugzilla will search the Product, Component, Keywords, Alias, Summary, Whiteboard, and Comment fields for your word(s).
    Typing a number will take you directly to the bug with that ID.
  • Adding more terms narrows down the search (AND search).
  • Searching is case-insensitive.

2. Simple Search:

  • Similar to Quick Search, but with a dedicated page.
  • Good for finding a particular bug when you have some keywords.

3. Advanced Search:

  • This is the most powerful search method.
  • You can specify criteria for various fields like Product, Component, Status, Resolution, Summary, Comments, URL, Whiteboard, Deadline, Bug Numbers, Version, Severity, Priority, Hardware, OS, and even custom fields.
  • You can combine multiple criteria to narrow down your search.
  • Allows searching by people (assignee, reporter, cc member, commenter) and change history.

4. Custom Search:

  • Lets you create complex queries with specific fields, operators, and values.
  • You can combine terms using "Match ANY" or "Match ALL" and use parentheses for grouping.


Tips for Effective Searching :

  • Be specific: The more specific your search criteria, the more accurate your results will be.
  • Use keywords: Think about the words that might be used to describe the bug.
  • Use wildcards: You can use the asterisk (*) as a wildcard to match any string of characters.
  • Search in specific fields: If you know which field the information you're looking for is likely to be in, you can specify that field in your search.
  • Combine search methods: You can use a combination of Quick Search, Simple Search, and Advanced Search to find the bug you're looking for.

Remember that Bugzilla's search functionality might have some specific syntax or features depending on the version and configuration. You can usually find more detailed information about searching in the Bugzilla documentation or help resources.

In Bugzilla, a Watchlist is a feature that allows you to track the emails another Bugzilla user receives. This can be useful in situations like:

  • Teamwork: If a team member goes on vacation, you can watch their Bug Mail to stay updated on any important bug-related communication.
  • Monitoring: You can keep an eye on the bug-related activity of specific users, such as developers or testers.
  • Knowledge Sharing: If you want to stay informed about the bugs a particular user is working on, you can add them to your watchlist.

How it works:

  • When you add a user to your watchlist, you will receive a copy of all the emails that Bugzilla sends to that user.
  • This includes emails triggered by any event related to bugs they are involved in, such as new comments, status changes, or attachments.
  • The user you are watching will be aware that you are watching them.

How to use it:

  1. Go to your Bugzilla preferences (usually a link in the footer).
  2. Find the "User Watching" section.
  3. Enter the email address of the user you want to watch.
  4. Submit the changes.

Important Notes:

  • The availability of the "User Watching" feature might depend on your Bugzilla installation's configuration.
  • Be mindful of privacy and only watch users when necessary and with their awareness.

By using the Watchlist feature, you can effectively monitor bug-related activity and ensure that you stay informed about important updates and discussions.

Bugzilla can be integrated with other tools in a variety of ways, allowing you to streamline workflows, improve communication, and enhance your overall development process. Here are some common integration methods:

1. API Integration:

  • Bugzilla offers a RESTful API that allows other applications to interact with it programmatically.
  • This enables you to create custom integrations, automate tasks, and exchange data between Bugzilla and other systems.
  • For example, you could integrate Bugzilla with your code repository (like Git) to automatically link commits to bug reports or update bug status based on code changes.

2. Email Integration:

  • Bugzilla can send email notifications for various events, such as new bug reports, comments, or status changes.
  • You can configure Bugzilla to send emails to specific users or groups, ensuring that everyone stays informed about relevant bug activity.
  • This can be useful for integrating Bugzilla with email-based workflows or notification systems.

3. Third-Party Integrations:

  • Many third-party tools offer pre-built integrations with Bugzilla.
  • These integrations can simplify the process of connecting Bugzilla with other systems, such as:
    • Test Management Tools: Integrate with tools like TestRail or PractiTest to link test cases and results to Bugzilla bugs.
    • Project Management Tools: Connect with tools like Jira or Asana to synchronize tasks and issues between Bugzilla and your project management system.
    • CRM Systems: Integrate with CRM systems like Salesforce to track customer-reported bugs and provide updates to customers.
    • Service Desk Platforms: Connect with service desk platforms like ServiceNow to automatically create bug reports from customer support tickets.

4. Webhooks:

  • Bugzilla supports webhooks, which allow it to send real-time notifications to other applications when specific events occur.
  • This can be used to trigger actions in other systems based on Bugzilla events, such as updating a project status or sending a notification to a communication channel.

5. Custom Integrations:

  • If you have specific integration needs that are not covered by existing tools or APIs, you can develop custom integrations using programming languages like Perl (Bugzilla's original language) or other languages that can interact with the Bugzilla API.


Benefits of Integration:

  • Improved Efficiency: Automate tasks and reduce manual data entry.
  • Enhanced Communication: Ensure that everyone is informed about bug activity.
  • Streamlined Workflows: Connect different tools to create a seamless development process.
  • Better Data Visibility: Gain insights into bug trends and track progress across multiple systems.

Bugzilla has a robust system for managing email notifications, allowing you to fine-tune what events trigger emails and who receives them. Here's a breakdown of how to set up email notifications:

1. Accessing Email Preferences:

  • Log in to Bugzilla.
  • Go to your user preferences. This is usually found in a link in the footer or under your profile.
  • Look for an "Email Preferences" tab or section.

2. Global Options:

  • Bugzilla often provides global options to control the overall flow of emails. These might include:
    • "Enable All Mail" or "Disable All Mail" buttons: These provide quick ways to turn on or off all email notifications.
    • Options to control emails related to flags (requests for flag settings, etc.).
    • Options to control emails related to the "User Watching" feature (more on this below).

3. Specific Event Notifications:

  • This is where you can get granular. Bugzilla will typically present a table or list of events, and you can choose which events trigger emails. Common events include:
    • New bug reports: When a new bug is filed.
    • Comments added: When someone adds a comment to a bug.
    • Status changes: When the status of a bug changes (e.g., from "New" to "Assigned").
    • Attachments added: When a file is attached to a bug.
    • Priority changes: When the priority of a bug is modified.
    • Assigned to changes: When a bug is assigned to a different person.
  • For each event, you can usually specify who receives the email:
    • The bug reporter: The person who originally submitted the bug.
    • The assignee: The person currently responsible for the bug.
    • CC list: Users added to the CC list of the bug.
    • Other users: You might be able to specify other email addresses or groups to notify.

4. "User Watching" Feature:

  • This feature allows you to "watch" another user's Bugzilla activity.
  • When you add a user to your watchlist, you receive copies of all the emails that Bugzilla sends to that user.
  • This can be useful for monitoring team members' activity or staying informed about bugs they are involved in.

5. Ignoring Specific Bugs:

  • Bugzilla might allow you to specify a list of bug IDs for which you never want to receive email notifications, regardless of other settings.

6. Saving Changes:

  • After configuring your email preferences, be sure to save or submit the changes.

Important Considerations :

  • Bugzilla Version: The exact layout and options for email notifications might vary slightly depending on the version of Bugzilla you are using.
  • Administrator Settings: Some email settings might be controlled by the Bugzilla administrator and not directly changeable by individual users.
  • Email Overload: Be mindful of the number of email notifications you enable. Too many emails can become overwhelming and make it difficult to focus on important updates.

By carefully configuring your email preferences in Bugzilla, you can ensure that you stay informed about the bugs that are most relevant to you without being overwhelmed by unnecessary notifications.

In Bugzilla, a Component is a subcategory within a Product that helps to further organize and classify bugs. Think of it as a way to divide a product into its different parts or modules.

Here's a breakdown of what Components are and why they're useful:

Purpose of Components:

  • Granular Organization: Products can be complex with many features and functionalities. Components allow you to break down these products into smaller, more manageable units.
  • Specialized Handling: Different components might be handled by different teams or individuals with specific expertise. Components help route bugs to the right people.
  • Efficient Searching and Reporting: When searching for bugs or generating reports, you can filter by component to focus on specific areas of the product.
  • Clearer Responsibilities: Each component can have an "owner" and a "QA contact" assigned, making it clear who is responsible for fixing bugs and ensuring their quality in that specific area.

Example:

Imagine you have a "Web Application" product in Bugzilla. You might divide it into components like:

  • Frontend: For bugs related to the user interface, design, and user experience.
  • Backend: For bugs related to the server-side logic, database, and APIs.
  • Security: For bugs related to security vulnerabilities and exploits.
  • Documentation: For bugs related to inaccurate or missing documentation.

How Components are Used:

  • Bug Filing: When submitting a bug report, users select the appropriate component to indicate which part of the product the bug affects.
  • Assignment: Bugs are often assigned to the owner of the relevant component.
  • Filtering and Searching: You can filter bug lists and search results by component to find specific bugs.
  • Reporting: Bugzilla can generate reports that show the number of bugs per component, helping to identify areas with more issues.

Key Features of Components:

  • Hierarchy: Components can have sub-components, creating a hierarchical structure for even finer organization.
  • Ownership: Each component can have an assigned owner who is responsible for addressing bugs in that area.
  • QA Contact: A QA contact can also be assigned to a component to ensure the quality of bug fixes.

Bugzilla has different user roles and permissions, such as :

  • Admin – Full control over Bugzilla.
  • Developer – Can modify bugs.
  • Reporter – Can only file new bugs.
  • QA – Can verify and close bugs.
* Install Perl, MySQL/PostgreSQL, Apache, and Bugzilla.

* Configure the Bugzilla database.

* Set up web server (Apache/NGINX).

* Access Bugzilla through the browser.

Bugzilla has built-in mechanisms to detect and handle duplicate bugs efficiently. Here’s how it works :

1. Duplicate Detection During Bug Entry
  • When a user starts typing a new bug report, Bugzilla suggests similar existing bugs based on the title and description.
  • This helps users find and link to existing reports before creating a new one.
2. Manually Marking a Bug as a Duplicate
  • If a duplicate is reported, a team member can mark it as a duplicate of an existing bug.
  • This is done by selecting the "Mark as Duplicate" option and entering the bug ID of the original report.
  • The duplicate bug is automatically closed with a status like “RESOLVED DUPLICATE” and linked to the original.
3. Tracking Duplicates
  • Even after marking a bug as a duplicate, it remains in the database for reference.
  • Bugzilla maintains a link between the duplicate and the original bug, so users can see a history of related reports.
  • If necessary, the bug can be reopened if it turns out to be a different issue.
4. Searching for Duplicates
  • Users can perform advanced searches in Bugzilla to look for similar reports.
  • Developers and QA teams often use specific filters to find and merge duplicate bug reports.
During software testing, bugs are discovered. This is made manifest when the actual results are compared with the expected results. When you take into account the testing types classification, every bug discovered at this stage is broken down into various kinds based on the origin of the type. However, bugs are generally broken down into functional bugs and non-functional bugs. It is very important to know the differences between the two and others.

A functional bug as the name implies is an error that has a functional relationship to software. A functional bug plays a part in the malfunctioning of a software or application.
A bug bounty program is a program deal given by various websites, developers of software and organizations. Through bug bounty programs, an individual can gets compensation or recognition just for reporting bugs. These bounty bugs are usually related to vulnerability, harm or exploits. The bug bounty programs make it possible for software developers to discover the bugs.

When the bugs are discovered, they are resolved immediately before it gets put to the public. When a bug goes out to the public it can lead to widespread abuse. Some of the organizations that implement bug bounty programs include Facebook, Microsoft, Google, Yahoo, Mozilla, Square, and Reddit.