TeamCity

What’s New in TeamCity V6.5?

• Muting of failed tests - TeamCity introduces new means to mute some of the failing tests so they wouldn't affect build status, allowing to significantly reduce cluttering of the build information flow.
• Tests grouping - Grouping tests by package is an essential feature for faster problem investigation. Tests can now be grouped in TeamCity on the build results page, current problems page, my changes page and so on.
• Remote Agent Installation - TeamCity 6.5 provides a new, experimental way to remotely install build agents on the machines in your network, or in the cloud.
• Restyled web interface - TeamCity 6.5 introduces new, restyled web interface - more lightweight, more modern looking and much more convenient.
• Personal Builds on branches for Git and Mercurial - TeamCity 6.5 provides a more natural way to start Personal Builds on server with distributed version controls.
• Parametrized Version Control System roots - VCS roots are collections of VSC settings used by TeamCity to obtain the source files for your builds. VCS roots do often get shared among different projects and build configurations.

What’s New in TeamCity V6.0?

• Build steps - When creating a build configuration, you can now configure the sequence of build steps to be executed. Each build step is represented by a build runner and provides integration with a specific build or test tool. You can add as many build steps to your build configuration as needed.
• New "My Changes" page - For TeamCity 6 release Jetbrains have carefully re-thought a concept of the My Changes page, and did some radical changes towards usability and navigability. The new "My Changes" gives you a nice overview of how well your commit integrates in different builds and build configurations. It also supports keyboard navigation, which allows you to locate problems faster and in more comfortable way.
• New IntelliJ IDEA projects build engine - TeamCity 6 uses a rewritten build engine for IntelliJ IDEA projects, similar to the one found in IDEA itself. You can now run IntelliJ IDEA shared "run configurations" in TeamCity, and also produce all kinds of IntelliJ IDEA artifacts, including wars, ears, GWT artifacts, etc. Last but not least, IDEA projects in TeamCity can now be configured to only compile modules, required to run tests or produce build artifact, instead of recompiling and testing the whole project.
• Support for Gradle and Maven 3 - Gradle is a build automation tool with lots of features. Jetbrains have created a full-fledged Gradle build runner, which supports all of the advanced TeamCity features. TeamCity 6 now includes dedicated Maven support and is now fully compatible with Maven 3.
• Bundled plugin for an authomatic build directory clean-up - Builds often produce a lot of garbage which should be cleaned before next build starts in the same directory. "Swabra" plugin 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.

What’s New in TeamCity V5.1.4?

• Now includes transparent support for maven-failsafe-plugin reports

What’s New in TeamCity V5.1.2?

• Supports Asia Pacific EC2 region
• Removed TEAMCITY_RAKE_RUNNER_MODE env variable requirement
• You can now temporarily disable sending notifications via email or Jabber

What’s New in TeamCity V5.1?

Greatly improved support for .NET 4.0

• NET 4.0, Visual Studio 2010 and TFS 2010 are now supported;
• All solution runners (except 2003) were merged into the one solution runner which includes support for Visual Studio 2010;
• MSBuild runner now supports MSBuild for .NET 4.0;
• .NET 4.0 is supported for tests runners. You can also choose the .NET framework version for NUnit runner;
• NUnit tests UI is available in MSBuild runner;
• NAnt 0.90 alpha 1 is supported;
• Support for NUnit 2.5.3 and 2.5.4 added;
• NUnit runner supports running each test assembly in its own process;
• Enabled .NET Coverage report generation with the dedicated service messages.

Code coverage support for Maven

• IDEA-based code coverage added for the Maven runner.
• Coverage results can be seen on the Coverage report tab of the build and in the Coverage statistics chart for the build configuration.
• In order for this feature to work properly, tests should run in the fork=true mode.
• For the more information, check Code Coverage documentation section.
• Maven artifact trigger now supports classifiers.

What’s New in TeamCity V5.0?

• Amazon EC2 and Virtual Agents - Take avdantage of cloud computing with TeamCity by putting Build Agents on Amazon EC2. After your Build Agents' AMIs (Amazon Machine Images) are registered, the TeamCity server will account for those virtual machines in its build scheduling and will automatically do a suspend/resume job on them, based on the load and build queue status.
• Better Support for Maven - Version 5.0 has many Maven support improvements under the hood. These include the creation of Maven-based build configurations (only the URL to the POM file is needed), the visualization of various project data gathered from POM, and a new type of dependency trigger - Maven artifact trigger. This type of trigger starts a build each time the specified Maven artifact changes.
• Build Configuration Templates - Templates can save a lot of manual work when you need to define a number of duplicate or very similar build configurations. Now you can create a template with the common (shared) settings, and then inherit any number of build configs from this template. You can also extract a template from any of your existing build configurations.
• Issue Tracker Integration - How often do you see comments like this: "TW-3431 fixed"? How about a little more detail on the issue at hand? The issue tracker integration provides an in-place bug title, direct navigation to the issue, and other productivity goodies. It is currently available for Jira, Bugzilla and JetBrains YouTrack out of the box, but can easily be extended to other systems via plugins.
• Command Line Tool for Personal Builds - Previously, if you weren't using Eclipse, IntelliJ IDEA or Visual Studio, you were out of luck for missing one of the most important TeamCity features - Remote Run and Pre-Tested Commits. But things have changed. As the name suggests, now you can initiate the building of your local changes remotely on the server - from the local command line. No IDEs required. Command Line Tool is an experimental feature and can be downloaded as a separate plugin. It currently supports Perforce, Subversion, CVS, and TFS.

Many Other Improvements

• Per-test responsibilities
• Build artifacts promotion
• Dedicated change details/status page
• Incremental update of the build log
• Project archiving
• Backup & Restore for easier TeamCity maintenance. Backup can be started from the UI or from the command line; Restore and Migration can be started from the command line only. Command line backup does not require stopping TeamCity if an external database is used.
• Audit of user actions
• Coverage support for .NET & Java. Based on IntelliJ IDEA coverage engine for Java and on NCover (ver 1, ver 3) or PartCover for .NET.
• Git & Mercurial support now bundled with TeamCity
• Remote Run for Git from IntelliJ IDEA & Eclipse
• Support for Cucumber, Shoulda, Test-Spec in Rake runner
• TeamCity IntelliJ IDEA plugin now works with IntelliJ IDEA Community Edition and RubyMine.

What’s New in TeamCity V4.5x?

User Groups
A new notion introduced in TeamCity is User Group. A user can be included into one or several User Groups from Administration Web UI. There is a predefined group: "All Users" that contains all registered users in the system and its members cannot be modified. A user group can be included into one or several other groups.
A group can have assigned roles and notification rules.

A user gets all the roles that are

• assigned to the user directly
• assigned to the groups the user belongs to. These includes the groups user is a direct and indirect member of (indirect means user belongs to a group that itself belongs to another group).

A user gets all the notification rules form the groups the user belongs to (both directly and indirectly) as defaul notification rules. All the user-configured notification rules have greater priority then groups-provided notification rules.

• Configuring user roles
• Assigning roles in specific projects
• Specifying groups and groups hierarchy and setting up notification rules for users groups

LDAP Integration

• Obtaining user's profile data
• Creating and removing user accounts automatically

User Interface Improvements

• Improvements of the Project page report tabs
• Test Details and Problematic Tests display on a project level
• Test List grouping
• Improved integration of external change browser
• Project-wide Change Log
• Possibility to move the build on the top of the Build Queue when running custom build.
• Possibility to rearrange the view of the Projects page: moving projects in the visible projects list.
• Assigning responsibility for broken build
• If a build failed because of failures in dependencies, actually failed dependent builds are shown on the Build Results page.
• Indirect dependencies are displayed on the build Dependencies tab.
• VCS roots page displays warnings on the VCS errors; the list of VCS roots is broken down into pages, and you can now find the desired root by typing its name and clicking the Filter button.
• User can now leave a comment when pausing a build configuration.
• Builds with "My changes" now have "Changes" block highlighted for better visibility.

Support of Mono framework
TeamCity .NET runners were made compatible with Mono Framework, so that it can now be used as a .NET platform for continuous builds. Also, Build Agents now attempt to automatically detect presence of Mono framework, and if it's installed, set system properties which you can use when specifying the build settings and Build Agent requirements.

IDE Integration Plugins Improvements

Eclipse

• CVS is now supported for remote run and pre-tested commit.
• Support for Perforce 2008.2 plugin.
• Browse failed tests output without leaving IDE.

Microsoft Visual Studio

• Perforce support.
• Subversion 1.6 support.

IntelliJ IDEA

• IntelliJ IDEA 8.1 is supported.

XML Reporter
Now TeamCity can process various XML reports and feed data to TeamCity. The following formats are supported:

• Ant's JUnit task
• NUnit
• Surefire
• PMD
• FindBugs

You can now import XML test reports using the bundled XML Test Reporting plugin.

VCS Improvements

• SVNKit library for Subversion support is updated.
• TFS sources labeling is now supported. TFS checkout on agent is improved.

Other Improvements

• Moving a build configuration to another project.
• Possibility to download all build artifacts in a .zip archive.
• Agents can be disabled with a timeout (useful when disabling an agent for current issue investigation).
• JVM crashes and Java OutOfMemory errors are now detected, and a build summary is changed accordingly.
• TeamCity server disk space watcher will notify if disk space available for artifacts and build logs is less than a threshold (10Mb).
• Rebooting a Build Agent.
• Build Agent checks for free space and ensures the old data is cleaned up before the build if the free space exceeds a particular amount.
• NAnt runner supports specification of the target. framework (-targetframework: option).
• MSTest 2005 is now supported (in addition to MSTest 2008).
• TFS performance improvements
• Taking thread dumps to build log on execution timeout.
• Bundled Ant is updated to 1.7.1
• Remote API is updated.

What's New in TeamCity V4.0?

Build Chains and Enhanced Build Dependencies - with the newly introduced Build Chains, you can break down a single build procedure into several parts that can be run on different build agents both in sequence and in parallel using the same set of sources snapshot in all of them. This provides opportunity to make sure you are using your build grid at full power, and also helps better align build procedure with the release engineering phases.

Tests Re-ordering for Risk Group Tests and Test Details - TeamCity now identifies a set of tests which are likely to fail, and can run those tests first on the next build, allowing you to confirm potential fixes sooner thus reducing the feedback time. You can choose to:

• run newly added and modified tests first (available with JUnit, TestNG using Ant/Ipr build runners)
• run recently failed tests first (available with JUnit, TestNG using Ant/Ipr build runners, and with NUnit using any .NET runner)

Custom and History Build - With history builds, you can choose a particular change from the change history, and run the build which will only include changes up to this one, quickly identifying the unsafe modification. History builds can also be helpful to restore your old build bits - you don't have to keep all your build artifacts anymore. You also have an option to pass custom properties to a build on the build start.

Build Agents Management Improvements

• Improved agents authentication mechanics
• Per-agent CPU-benchmarks for better load balancing

User Interface Improvements - TeamCity comes with lots of UI improvements. Among the most notable:

• New quick navigation items added for the most frequently used actions.
• New Build Parameters tab displays properties used for running custom builds.
• An improved My Changes page allowing to filter out successful build results.
• It's now possible to select a build range for showing in a Change log. You can also hide builds from the list if you're only interested in browsing changes.
• Improved cleanup rules editing and ability to configure dependent builds' artifacts cleanup.
• Greatly improved Lucene-based search, search results sorting, and more.
• Ability to browse statistics in the scope of an entire project, and view comparative statistics on a single chart.

What's New in TeamCity V3.1x?

• Build Agents' Workload Statistics - More visual metrics, namely, statistics of Build Agents' activity and their usage during a particular time period are now available.
• "Time to fix tests" Statistics - A new type of statistical data display: time it took to fix the build's tests.
• Publishing Build Artifacts while the Build is Still Running - Now you can notify TeamCity as soon as the build artifacts are created so they can be uploaded and available even before the build is finished. It increases your builds responsiveness and you don't need to wait until your builds are finished.
• Notifications Improvements - Receive notifications only when the build status changes
• Ability to watch all projects - When customizing the notification rules, besides the Watch builds of the selected build configurations you can now select All projects to monitor all builds of all the projects' build configurations.
• User Interface Enhancements - Viewing and navigating to any build configuration. From any place in TeamCity user interface you can now navigate to any build configuration by just pressing the arrow button in the Projects tab and selecting the desired build configuration.
• New Search Possibilities - Search for builds run on a Build Agent and filter history by Agent name. In addition to searching by build number, project or a build configuration name, you can now search by the Build Agent the build was run on, and it's also possible to search for the builds created on a particular Build Agent on the build configuration History page.
• Tests filtering - It is now possible to filter the build tests list by the test or package name.
• Improved Builds Clean-Up Policy - You now have a more fine-grained control on a data to be cleaned up. Choose between keeping only the statistical data and build history without artefacts
• .NET Testing Framework Support Enhancements - In addition to NAnt version 0.85 now TeamCity supports NAnt 0.86 Beta 1. Added ability to specify the mode (x86 or x64) to run the NUnit tests. In addition to NUnit version 2.2.x now TeamCity supports NUnit 2.4.x. Added support of NUnit tests categories for NAnt, MSBuild, solution 2005 and 2008 build runners, and NUnit Launcher
• Custom Tests Reporting - You can now benefit from TeamCity's tests reporting possibilities even when your testing framework is not directly supported by TeamCity. By printing the specially formatted messages to the build standard output, you send test events to TeamCity and get on-the-fly test reporting. This feature can be useful for custom frameworks support and doesn't require developing a fully-fledged TeamCity plugin.

What's New in TeamCity V3.0?

• Free Professional Edition - Get a freeware continuous integration server with lots of possibilities for delivering high-quality software
• Per-project Access Rights and Security Management - Long-awaited security support allows you to assign different roles - each with a set of permissions - to TeamCity users giving them access to various features. Now you control who monitors your projects' status, or manages the projects' and build agents', or performs standard software developer's tasks
• Build Statistics Charts - Get a visual representation of your projects' health: individual tests, code coverage, build success rates, build durations, and artefacts size trends
• .NET Duplicates Search - Search for duplicated blocks of C# and Visual Basic .NET code and navigation from the web-based UI to the Microsoft Visual Studio editor
• Numerous Enhancements in VCS Integration - StarTeam support, VCS labeling, sharable VCS roots, pre-tested commit from Visual Studio into Subversion and more
• Improved Performance and Usability - Greatly improved performance, combined with better UI usability results in an unprecedented user experience

What's new in V2.1?

Administration: Build management

• Version Control System enhancements
  • Subversion: svnkit library upgraded to the latest version; multiple bugfixes
  • ClearCase: added support for ClearCase Base and ClearCase load rules
• Ipr and Inspection runners, Duplicates finder
  • Possibility to specify pre-script and post-script for Ipr runner. Allows to use Ipr runner with TestNG tests
  • Possibility to specify pre-script for Inspections runner and for Duplicates finder. Allows to fetch necessary libraries before the build if they are not presented in your version control system
  • Possibility to specify artifact path for Ipr runner
  • Possibility to look for tests only in "test sources" paths defined in Ipr
• Ivy-related improvements
  • Ivy repository is protected by password authentication (TW-2393)
  • Do not provide generated ivy.xml if ivy.xml already exists in published artifacts (TW-2392)
  • View artifact dependency information
• Maven runner improvements
  • Maven runner has been totally reworked. Maven is now launched directly using 'mvn' executable, not using Maven embedder. It allows TeamCity not to be tied to a set of specific Maven versions anymore
• General enhancements
  • Match and does not match requirement types support
  • Configurable server URL used in notifications (to allow https)
  • Support wildcards in artifact paths (TW-1328) and possibility to specify target directory (TW-1220)
  • More predefined properties and environment variables available
  • Ability to access server from build scripts using basic authentication. For example, it is now possible to trigger a build from a script

User interface features

• Assign next build to specific agent
  • Now you can select an agent to run your build on. You can also select a disabled agent (for testing purposes)
• Possibility to enforce clean checkout for a project on all build agents
  • Clean all project sources on all agents to eliminate incorrect data
• Ability to Collapse Mini-Stack from Failed Tests
  • Click the "Show test names only" link to hide short stacktraces and view more failed tests on one screen
• Line numbers in Duplicates view on the web
  • Give you the exact location of the duplicate fragment in the source file
• Implicit requirements are shown on the requirements page
  • Get better understanding of build configuration and build agents compatibility

Key Features

• Continuous Integration & Testing - The delayed commit feature allows you to always keep builds working and the project code base clean. Developers' code modifications are submitted into version control only if all the tests pass. Failures are immediately reported and are visible online for the entire team
• Efficient, Effective Build Management - Define and run different build types with different build configurations for any project, customize build triggers, for flexible management of the build process. The innovative Build Grid utilizes multiple computing resources of your network for maximum efficiency
• Code Quality Maintenance - Highest code quality is maintained with server-side code analysis features (600+ Java code inspections, inherited from IntelliJ IDEA) and by searching for code duplicates and performing code coverage analysis. This also frees up developers' local computing resources
• IDE-friendly Solution - Eclipse, IntelliJ IDEA, and MS Visual Studio Integration. TeamCity comes with many plugins for Eclipse, Microsoft Visual Studio, and IntelliJ IDEA, which provide all the productivity features right in the IDE
• Web-based Interface & Project Dashboard - A late-model web browser is also enough to work with TeamCity, making you independent of IDEs or programming languages. The project dashboard helps all team members stay up-to-date on the status of current builds and provides effective and painless navigation through large amounts of test/build-related information