I have some ideas about a tool to assist and support Red Green refactor cycles as you follow a TDD loop, and my first iteration towards that is now available. This is incredibly basic right now from where I intend to take it.
This is the basic process to use RedGreenRefactor right now.
You need to select a Visual Studio solution to monitor. You can change to another at any time on the Settings page. RedGreenRefactor will parse the projects (*.csproj) and find all those that use a test framework (only nBehave supported in this release)
Define the intent of one or many test cycles
Now go to the test cycles list and add what you think you intend to change, and if you want to group them by release. Start to work on your first cycles.
Working on an Intention
Start your TDD cycle, so in VS add a new test. Every time you recompile, RedGreenRefactor will run the tests automatically and record the results. Over time you build up a history of your changes.
Right now the Home Page tries to give you everything you need and is starting to show a small fragment of the reporting capabilities planned.
What is the tool for?
Right now, RedGreenRefactor will automatically run your tests every time you re-compile or click Run Now. My original idea was to simply capture these and provide reports back on how you are doing.
I use RedGreenRefactor to help ensure I’ve followed my cycle through failing tests (including having Pending specification steps) and then into Green, and refactor. My plan is to get RedGreenRefactor to help with that and marking the difference between test development (i.e. Red stage) and functional development (i.e. Green and Refactor). However by collecting these test runs, I think many more useful reports can be made available, ranging from estimation assistance (length of time that changes were made including a set of keywords), productivity (number of tests), and personal contribution to coverage are just a few.
In addition I also think that simple things like better check in comments in your VCS of choice can be easily achieved if a tool knows what you have changed. In addition I recognise that there is a relationship between test cycles and bug fixes so integrate with tools such as JIRA may also be relevant.
- Support more test frameworks e.g. nUnit, mbUnit
- Detect refactorings and code transformations
- Detect change to coverage levels
- Support workflows (e.g. UI only changes may not generate a Red phase)
- Generate reports
- Integrate with version control (so we simplify the commit cycle)
- Integrate with VS
- Integrate with Bug Trackers