How do you track versions in Bugzilla?

Question

We are in the process of migrating our bug tracking to Bugzilla from a really old version of the track, and I am running out of Advil.

We have an outdated application that has existed for a long time. Mix in the fact that our version control was through several iterations, it spawned many different versions in the wild. Worse, due to contractual limitations, it’s not always possible to upgrade clients to the latest and greatest, so we must deploy, fix, test and publish the version that they currently have, giving another version number.

The end result is that the version list box is ridiculously long. Finally, for various reasons, we want to track three different versions of information: the version in which the error was detected (version), the version in which we plan to fix the error (error) and the version in which it was ultimately corrected (open to suggestions). here is my problem actually ... actually it could be some numbers where we made a retroactive fix for some of these clients (this happens VERY often).

Here I need your common wisdom:

How do you track these versions (found, planned and multiple fixed) in Bugzilla?

What are the best methods for versioning and bug tracking?

---

The answers

It seems that cloning bugs for each version is a good way to track, so the target version is always tracked both in the milestone and in the fixed version, and the buggy version is always the native version.

Also, so that every clone block of the source bug makes it a good way to track the history to the original view.

Although I accepted the answer, I still welcome your input.

Answer 1

Often, if we need to fix something in several released versions (usually these are branches in the source code repository), an error will be cloned for each branch so that we can track all the fixes and release status separately. I think that the only time we do not do this is that the change is not directly related to the code base itself and cannot be fixed simply by updating our libraries.

As for version tracking in general, it showed me a reasonable way to do something, given that at any time we should only support 2-3 major versions (plus the torso). If you have several disjoint versions that need support, for example. client-specific deployments, then everything will be more difficult to track. (Perhaps this will cause a headache in general, and it would be better to combine things with a more central theme of the version).

Answer 2

I use Bugzilla to track not only bugs, but also new features, improvements, and vague ideas. For every planned and released version, I have a tracking error (something that I saw in the original Mozilla bugzilla was considered useful).

So, if you have a bug report, you enter the bug with the version number that was reported. Create additional errors (one for each version that you plan to fix) that all depend on (block) the original error and block version tracking errors.

If all errors blocking the original error are closed / acknowledged (regardless of your QA), you can also close the original error.

Answer 3

I searched for a similar function in TFS, and after doing some investigation, I found that there is an extended query for managing "observations" in Bugzilla: "Error 55970 - (bz-branch) Bugzilla needs to deal with branches better (make observations)": https : //bugzilla.mozilla.org/show_bug.cgi? id = 55970

There is also a suggested design: https://bug55970.bugzilla.mozilla.org/attachment.cgi?id=546912

For information, we are going to implement something similar in TFS 2010, with "Bug Parent" or "Bug Master", to store information about the error itself (playback steps, severity, technical information, affecting components ...), which may have a child type "Bug Child" or "Sighting", which will contain information specific to this branch (target milestone, priority, specific information for this branch ...).

Answer 4

We are using jira and still have this problem. I think this is a question of requirements and how versions are used, not some kind of tool.

Who uses versions and how do they use them?
How do versions relate to milestones in a project plan?

We are using the four dectet version (major.minor.patch.buildNO). buildNo is a version of the SVN # chapter at build time. Each version is stored in JIRA, and problems have a fix version and a fixed version selected by several.

After a while, we have many versions. Jira allows us to control the list in two ways: 1. Archived versions (grayed out from the selection list) 2. Merge versions (collapses several versions together into a new version - does not cancel)

We used Archive, but avoided merging due to the lack of cancellation. Therefore, we have a list of many versions.

I’m sure that you could probably perform the merge action in Bugzilla with some scenarios and time, the question is: when is it ok to combine several older versions together?

If I released, do I need to know that I have 17 collections between launch and release? Should I keep information about the error found in assembly 1, fixed in 2, found again in 7, fixed again 9? Or is it in version 1.0.0, fixed in version 1.0.1, good enough?

I'm going to ask a big question on this topic later today, but I already know the basic answer: - Depends on how your team wants to track things.

Implementation is fun, but it all comes down to the requirements, goals and work of a solution for users. Which is rude when people don’t necessarily know how they want to use something that doesn’t quite exist in the form that they would like to use.