What's New in TeamCity 6.0

Last modified: 20 April 2023

Multiple build steps



When creating a build configuration, you can now configure a sequence of build steps to be executed. Each build step is represented by a build runner and provides integration with specific build or test tool. You can add as many build steps to your build configuration as needed. For example, call a NAnt script before compiling VS solutions, run inspections and duplicates finder after your ANT build, and so on. The build will get merged status and the output will go into the same build log.

Configuring Build Steps.

Sequential build steps crop

Improved upgrade procedure



TeamCity upgrade is usually performed in two steps:

  • upgrade TeamCity software

  • convert TeamCity data to new format

In previous versions of TeamCity the last step was performed implicitly on server startup. Our users might not even know that such conversion was performed.

With this release we introduce the new upgrade process which we tried to make as clear as possible. If newly installed TeamCity detects that data conversion is required, it brings on an Upgrade page, where system administrator can review the details of data conversion and confirm it.

Upgrade

Upgrade wizard small

New build runners



NUnit & MSTest



Support for NUnit and MSTest testing frameworks is extracted into separate build runners, which allows you to add them as build steps to any configuration. For example, this makes it easier to add NUnit tests to your Rake builds.

In addition code coverage can now be collected for MSTest runner too.

NUnit.

IntelliJ IDEA Project



With TeamCity 6.0 IPR runner has become deprecated. We did not remove it, but we plan to do so in the future versions. Instead of it, new IntelliJ IDEA project runner should be used. It supports more IntelliJ IDEA Project of IntelliJ IDEA and has some unique capabilities.

New runner is able to produce IntelliJ IDEA artifacts (artifacts feature was added in IDEA 9), including J2EE artifacts (war, ear), GWT artifacts and so on.

With help of this runner you can run tests using IntelliJ IDEA shared run configurations. In other words, this runner can start your tests almost in the same way as this is done by IntelliJ IDEA.

And finally, instead of compiling the whole project and only after that starting your tests, or artifacts building, you can configure runner to make necessary modules only. Runner will take into account dependencies information and will only make modules required to start tests or build artifacts.

IntelliJ IDEA Project.

Jps runner

Gradle



Gradle is a promising new build tool with some very nice features. It is compatible with Ant and Maven and is very CI-friendly. TeamCity 6.0 includes full-fledged support for Gradle by means of the dedicated build runner.

Some of the most interesting features of this runner:

  • On the fly build progress reporting

  • Passed / failed tests reporting

  • Gradle wrapper support

  • Ability to use build and agent properties inside your Gradle build.

  • IntelliJ IDEA code coverage

Gradle.

Maven integration



Maven3 support



TeamCity 6.0 dedicated Maven support is now fully compatible with Maven 3.0. IntelliJ IDEA Inspections and Duplicates runners support Maven 3 projects too. Note that we still bundle Maven 2.2.1 with TeamCity.

Maven build information tab



For each Maven build TeamCity agent gathers Maven specific build details, which are available on the dedicated Maven Build Info tab after the build is finished. From this information you can find what versions of libraries were used to build Maven projects, what versions of plugins, what artifacts were produced and so on.

Maven build info small

JetBrains dotCover integration



JetBrains released a brand new .NET coverage tool: dotCover. It has lots of neat features, like reporting statement-level coverage in .NET Framework and Silverlight applications, highlighting for covered and uncovered code inside Visual Studio, back-tracing tests which cover a particular location in code, and much much more.

Starting with TeamCity 6.0, coverage engine of dotCover is bundled with TeamCity and available as a choice for coverage, next to NCover and PartCover. You don't need to install dotCover on agents to run coverage on your tests and to view the reports in TeamCity (and you also do not need a dotCover license for this). However to run coverage on your tests locally and to view the highlighted code coverage results in Visual Studio, you will need to have dotCover installed in Visual Studio.

JetBrains dotCover

Rake runner



Rake runner has got support for Bundler and RVM. Moreover with help of "Ruby environment build feature" it is now much easier to prepare necessary environment for your Rake build.

Rake

Web interface improvements



New "My Changes" page



For TeamCity 6.0 release we have carefully re-thought a concept of the My Changes page, and did some radical changes in order to improve usability and navigability. The current state is still work-in-progress, and we'll be more than happy to hear your feedback and impressions.

New "My Changes" page provides visual representation of how your commit has affected different builds. At a glance you can see if your commit has caused new problems: failing tests and other build problems.

The list of changes is keyboard navigable, which allows you to locate problems faster and in more comfortable way. You can also monitor status of your changes in all projects or in specific project. We also worked hard to improve performance of this page.

Viewing Changes

My changes

"Tree View" on the build log

Starting from version 6.0, you can browse the build log of a finished build as a hierarchy of messages. This makes it much easier to identify long stages in your build and analyze them. Note that this feature is available for builds created by TeamCity 6.0; builds created by previous versions won't have this view.

Build log

Small improvements over TeamCity web interface



Bulk responsibility management It is now possible to assign / take responsibility for several tests at once from the web interface.

Keyboard navigation in the "Projects" popup You can open projects popup by pressing 'P' key on any page in TeamCity. In addition to that, projects popup now supports keyboard navigation, which makes it very easy and fast to navigate from project to project.

Artifact chooser in the dependencies configuration Artifact dependencies configuration has become slightly easier thanks to possibility to browse artifacts of the source build right in the configuration dialog.

Autocompletion in the Agent requirements dialog Agent requirements dialog has got autocompletion, which allows to preview parameters available on the agents and find how many agents have them.

Manual selection of build configurations for an agent User interface for the manual selection of build configurations for an agent has become more user friendly.

Drop-downs with filters We've added a lot of drop-down elements with dynamic filters across the entire TeamCity web interface.

Build priorities



From now on, system administrators have better control over the Build Queue by means of so-called Priority Classes. In two words, a priority class is a set of build configurations with a specified priority. When adding a build to the Build Queue, TeamCity would take into account which priority class this configuration belongs to, and place the build higher or lower in the queue accordingly.

There is also a reserved priority class for the personal builds. This can help your system administrator setup personal builds as having greater or smaller priority than the regular builds.

Ordering Build Queue

Priorities small

Better handling of "failed to start" builds



Sometimes a build would not start at all due to a configuration error. For example, VCS repository can be down when the build is about to start, or artifact dependencies can't be resolved, and so on. We have improved the way TeamCity handles these situations.

In brief, "failed to start build" is treated as a Cancelled build. However, they are shown differently in the web UI. Such builds are marked with Failed to start icon. It is also possible to receive notifications for "failed to start" builds.

Build State.

Build directory cleanup plugin bundled (Swabra)



Builds often produce a lot of garbage which should be cleaned before next build starts in the same directory. In some cases it's not easy to handle this in the build script (you may not have a script at all). In such situations Swabra plugin can be very handy.

Right after source checkout, Swabra remembers the state of the build checkout directory, and when next build starts in this directory, Swabra finds all of the files added by the previous build and removes them.

Swabra can also detect processes with "lock files" in the checkout directory. If such processes detected, Swabra will dump them in the build log after the build is finished. If one of such processes doesn't allow to remove its files from the checkout directory, Swabra fails the build.

Adding Swabra as a Build Feature.

Improvements in IDE plugins



IDE plugins for TeamCity have got a lot of improvements in 6.0. The most notable updates are:

  • Re-run of the tests failed on the server locally (IDEA Platform*, Eclipse, Visual Studio w/Resharper)

  • My responsibilities tab which shows all responsibilities assigned to current user, and allows to manage them (IDEA Platform*, Eclipse)

  • Ability to open patch in IDE from web in one click (IDEA Platform* X, Eclipse)

  • Coverage results from TeamCity builds can be presented in code highlighting in IDE Editor (Eclipse)

  • Ability to shelve changes (Eclipse)

  • Separate tab for build compilation errors when build information is loaded in IDE (IDEA Platform*, Eclipse)

  • Visual Studio addin performance greatly improved

* Supported in all IDEA Platform - based products: IntelliJ IDEA, RubyMine, PhpStorm, WebStorm, PyCharm.

VCS integration improvements



Agent-side checkout for Perforce and Clearcase



Checkout on agent is now available for Perforce and Clearcase. For this feature to work:

  • Perforce client must be installed on the agents and path to p4 executable must be added to the PATH environment variable.

  • ClearCase client (cleartool) has to be installed on agents and properly configured. It means that the tool must be in system paths and should have access to the ClearCase Registry.

TeamCity usage statistics



We added one more tab in the Administration -> Server configuration space. The tab is called "Usage statistics" and lists several values describing what features are used in your TeamCity installation. We tried hard to avoid gathering of any sensitive data, and as such we would appreciate if you could share this information with us. The statistics is sent anonymously, we do not gather anything except what is shown on the page. If you want to share this information with us all you need to do is to turn on checkbox on this page.

Other improvements



  • System administrators can view agent logs right from the web interface

  • Ability to filter by file path added on change log page

  • VCS trigger rules now can be configured on commit message

  • VCS trigger rules for pending changes can be added in build schedule trigger

  • Snapshot dependencies have an option to run dependent build on the same agent

  • Custom build started from the custom run dialog can be marked as personal

  • Command line runner allows to specify script content

  • Detection of Mono framework on MacOS is supported

  • REST API now allows to create new user accounts, retrieve running builds and pin/unpin finished builds

  • PMD CPD reports are supported

  • Agent reports found .NET frameworks as configuration parameters