Our development team has been using the GitFlow branching strategy and it has been great !
Recently we recruited a couple testers to improve our software quality. The idea is that every feature should be tested/QA by a tester.
In the past, developers work on features on separate feature branches and merge them back to the develop
branch when done. The developer will test his work himself on that feature
branch. Now with testers, we start asking this Question
On which branch should the tester test new features ?
Obviously, there are two options:
develop
branchInitially, we believed this is the sure way to go because:
develop
branch since it's development started. develop
) at all time. He doesn't need to ask the developer about which branch is for which feature ( feature branches are personal branches managed exclusively and freely by relevant developers )The biggest problems with this is:
The develop
branch is polluted with bugs.
When the tester finds bugs or conflicts, he reports them back to the developer, who fixes the issue on the develop branch (the feature branch were abandoned once merged ), and there could be more fixes required afterward. Multiple subsequence commits or merges (if a branch is recreated off develop
branch again for fixing the bugs) makes rolling back the feature from the develop
branch very difficult if possible. There are multiple features merging to and being fixed on the develop
branch at different times. This creates a big issue when we want to create a release with just some of the features in the develop
branch
So we thought again and decided we should test features on the feature branches. Before we test, we merge the changes from the develop
branch to the feature branch ( catch up with the develop
branch ). This is good:
develop
branch;However, there are some drawbacks
develop
branch. These means you will have to test against the develop
branch again when both of the features are merged to the develop branch anyway. And you have to remember to test this in the future.Above is our story. With limited resource, I would like to avoid testing everything everywhere. We are still looking for a better way to cope with this. I would love to hear how other teams handle this kind of situations.
The way we do it is the following:
We test on the feature branches after we merge the latest develop branch code on them. The main reason is that we do not want to "pollute" the develop branch code before a feature is accepted. In case a feature would not be accepted after testing but we would like to release other features already merged on develop that would be hell. Develop is a branch from which a release is made and thus should better be in a releasable state. The long version is that we test in many phases. More analytically:
What do you think of this approach?