46 plugins in category «Unit testing»

Android Studio Unit Test

By evant
Android Studio IDE support for Android gradle unit tests. Prepared for Robolectric.
This plugin will mark test directories and resolve testCompile dependencies. It also sets up the correct system properties for Robolectric.

AssertJ Postfix Completion Plugin

This plugin adds postfix completion template for assertj.

Check Tests

Using the IntelliJ index this plugin will find usages on file(s) you have selected with right click or you are going to commit and try to find TestClasses that are being referenced. You will then be asked if you would like to run the tests.

Concordion support

This plugin provides support such as autocompletion, navigation between spec files, go to declaration and renaming for http://concordion.org/ testing framework.
Plugin homepage: https://github.com/concordion/idea-concordion-support
Require idea 14.1+ with JUnit plugin running on jdk 8 (project may use any jdk)


easyb behavior driven development framework


easyb behavior driven development framework. This is the version for IDEA 11 as considerable parts of the openapi have changed


easyb behavior driven development framework. This is the version for IDEA X

Easymock expect builder

Plugin for intellij idea to create builder for tests from source class.
For more info visit https://github.com/SokolovMS/easymock-expect-builder


TDD as if you meant it

Slide effortlessly between...

  • java tests (unit, integration, acceptance)
  • Concordion tests (HTML specification and fixture)
  • test subjects

Encourages expressive test method names by displaying the test names next to your production classes

Write and move between your tests quicker than ever and without breaking Red/Green/Refactor flow

Instructions for use: Alt-T

EvoSuite Plugin

IntelliJ plugin for the EvoSuite tool, which is used to automatically generate high coverage JUnit tests. To generate test cases, EvoSuite uses advanced evolutionary algorithms enhanced by static analysis of the bytecode of the tested classes.

Note: this plugin is just used to call EvoSuite from inside IntelliJ IDEA, and so you still need to configure and install EvoSuite separately. You can do it automatically via its Maven plugin, or add the executable jar directly into your project.

Main features:
  • Generation of JUnit 4 tests for the selected classes
  • Optimization of different coverage criteria, like lines, branches, outputs, mutation testing, etc.
  • Tests are minimized: only the ones contributing to achieve coverage are retained
  • Generation of JUnit asserts to capture the current behavior of the tested classes
  • Tests run in a sandbox to prevent potentially dangerous operations
  • Virtual file system
  • Virtual network

For more information, see the documentation on www.evosuite.org


  • Auto run tests
  • Track tests edited, and run them
  • Run all tests and track failure/error tests
  • Better UI for test failures/errors

Do you know about the following steps?

  • Quickly add a test.
  • Run all tests and see the new one fail.
  • Make a little change.
  • Run all tests and see them all succeed.
  • Refactor to remove duplication.
How about these?
  • Quickly add a test.
  • Take a break or review the code.
  • IDE tells me that there is new test fail.
  • Make a little change.
  • Take a break or review the code.
  • IDE tells me all tests succeed.
  • Refactor to remove duplication.
  • Take a drink of coffee and IDE tells me there is no broken test.

It's great that we have time to run all tests continuously. But more tests we wrote, more time costs. It was too much cost for me to run all tests in almost every real project before. So it's better that I just run tests about which are cared recently continuously and run all tests when I finish a task or need to commit code.

Fireworks is such a plugin for helping TDDers to have more pleasure in process of test-driven development by spending more time on writing code. The configuration of "Delay time" is key of when to schedule task of running tests about which are cared after document changed and no error. It's a normal way to trigger a task after a delay time when there is no action performed by keyboard or mouse and all documents have no error marked during period of delay time. Yes, it's not good enough. I am still working on powup it. Yuo can read the changes of version to find what have been improved.

There is a "recent test list" for collecting test about which are cared. JUnit TestCase will be added into "recent test list" when we open or edit it. And there is a regex of test class name for helping us to filter test we don't want to care recently. If there is a test failed after we run all tests by pressing hot key, it will be added into "recent test list" too.

Generate Tests

Helper plugin for working with generated tests.
Needs a run configuration named "Generate Tests" which updates source files with generated tests.
The plugin adds a toolbar button to run this run configuration (also available with Control-Shift-G) and when the tests are generated it analyzes changes made to the source files and detects tests that have been added. It shows a popup with suggestion to run them.
Currently only JUnit tests are supported.


Plugin to generate unit test methods with meaningful names based in described behaviours with @should tags in interface methods javadoc

To see how to use it: http://elespaciodejaime.wordpress.com/2011/05/29/generate-test-cases-intellij-plugin/ or http://plugins.intellij.net/plugin/?idea&id=5847 or for a usage video http://www.youtube.com/watch?v=WYET6PECxuc

Credits for the @should style testing should go to OpenMRS team


Infinitest plugin for Intellij


By iTest
iTest makes your JUnit tests talk to you in editor.


  • iTest Tool Window icon shows status of tests
  • Effective reports in editor, no need to switch between windows or leave hands from keyboard anymore
  • Quick fixes for assertion failure.
  • Run test you need feedback first.
  • Easy to organize your tests run in iTest by class name pattern filter and test exclusion.


By Kuffi
JsChilicat is a javascript test framework integration for intellij idea. JsChilicat is based on Rhino and EnvJs for headless JavaScript testing. As testframework is QUnit in use. The plugin will add a new Run configuration JsChilicat which let you configure a source and a test directory. It will present the test results in a JUnit style. Added local server for Ajax tests. JsChilicate supports now to write a server interface completely in java script. It allows the user to write a mock server for AJAX api tests in a easy way. Currently is it possible to receive Forms and JSON objects ans to send JSON objects back. Please download the latest jsChilicat release bundle form the project page. Feedback is welcome.

JSUnitTest plugin

By kaneg
Invoke jsUnitTest from idea

JUnit 4 Synchronizer

Creates JUnit 4 test classes/methods for source methods annotated with the @Testable annotation. The test classes are created in a 'test' package, inside which the application package structure is duplicated. The 'test' package will be created if it does not already exist. The @Testable annotation is created automatically in the 'test' package the first time the synchronizer is run. @Testable currently has a single attribute whereby you can override the name of the test method to be created. For example, @Testable("testIntegerAddition") would create a test method named 'testIntegerAddition'. If no name attribute is specified a default name will be created that consists of the name of the annotated method prefixed with 'test'. Test classes will only be created for those source classes with at least one method annotated with @Testable. This plugin is available from the 'Tools' menu or from the project view popup menu as 'Synchronize JUnit Tests'. Instructions: #1 - RunSynchronize JUnit Tests once to create the @Testable annotation. #2 - Annotate desired source methods with @Testable annotation. #3 - Run Synchronize JUnit Tests to create test methods. #4 - Repeat steps 2 and 3 as often as desired to create new unit tests. Note 1: If you have a multi-module project simply copy the @Testable annotation from the first module (as created during step 1 above) into 'test' packages in the additional modules and proceed with steps 2 thru 4 to create the unit tests for these modules. Note 2: An enhancement request has been submitted to JUnit.org (via SourceForge.net) to include the @Testable annotation in the JUnit 4 framework.

JUnit, Mockito and Hamcrest refactorings

Intentions to convert Mockito "when-then" stubbing to "do-when" stubbing and vice versa, and to convert JUnit 3 assertions to JUnit 4 assertions with Hamcrest matchers.


Allows user to generate JUnit test-case skeleton.
The output is produced using Velocity template, that could be modified to meet user needs.
If test-case already exists, then the user will be prompted to either overwrite or compare the test-case using diff panels.

JUnitGenerator V2.0

This plugin generates JUnit tests from right click 'Generate...' menu while focused on a java class. The unit test output code can be customized using a provided velocity template to format the code based on the origin class.

If a unit test is created where one already exists, the user is prompted for overwrite or merge operation. The merge operation allows the user to selectively create the target file content.

A future revision will allow the user to generate their own test case macros.


Сontext-config generation for class/test dependencies.
Useful for quick dependencies resolution in JUnit-tests with Spring-beans.

Detects class dependencies that must be resolved with spring-beans.
There are fields annotated with @Autowired or class's setters(set-methods)
Searchs bean definitions through all project *.xml files, that can be assigned to them
For all beans it recursively detects their dependencies and doing another search
Finally, we have all beans that can be need for our initial class
They can be saved to some xml-file and used as context-configuration for our class

Main use-case: Quick context-config generation for JUnit-tests.
In big project it can be difficult(or boring) to resolve all class dependencies to run some local-tests

If more than one beans found by name and type, it will be resolved with some priority-rules that you can tune in plugin-propertis

Supported features:
  • Searching beans in production, test or libraries scope.
  • Searching beans with a check for assign by field-type (not only by name)
  • Bean-aliases supported. We can find bean-alias by name and another bean that can be referenced by alias
  • Spring-util beans supported: map, set, list
  • Some beans can be excludes from search by their name through the plugin-properties
  • Some beans can be described for use strongly-their
  • Bean's file-path can have priority, that used to resolve conflicts if more then one bean were found
  • Can be added custom headers in result-file, e.g. we can exclude some useful beans and add <import> with it file in header

Default shortcuts:
  • Ctrl+Shift+Alt+L
    • Generate context-configuration for current class(in editor)
    • Add missing dependencies for current context-configuration (xml-file in editor)
  • Tools Menu -> "Generate context config" - Same as above
  • Settings Menu (Ctrl+Alt+S) -> LazySpring - Plugin properties

Please note: This plugin is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

Mockito code generator

The plugin generates boilerplate Mockito code that usually needs to be added manually to unit tests.

Auto-generated are:

  • RunWith(MockitoJUnitRunner.class) annotation for the class
  • Mocked fields for each non-static object declared in the test subject
  • Field for the test subject with @InjectMocks annotation
  • static imports for useful mockito functions like when, verify

To generate the Mockito code with the plugin hit ctrl shift M or use a choose the action from "Generate Action" context menu.

Mockito Postfix Completion Plugin

This plugin adds postfix completion template for Mockito.


MoreUnit Logo

MoreUnit assists you in writing unit tests!


  • Works for all IntelliJ-based IDEs (AppCode, IDEA, PhpStorm, PyCharm, RubyMine, WebStorm, etc.)
  • Jump form your production code to you test code, and vice-versa. To access the command:
    • From the main menu: "Navigate" > "Jump to Test" or "Jump to Test Subject".
    • From the contextual menu: "Go To" > "Jump to Test" or "Jump to Test Subject".
    • From the "Find Action..." pop-up window: "Jump to Test / Test Subject".
  • Should several candidates be found, a list is displayed for selection.
  • Supported naming patterns:
    • lower/upper CamelCase or word separated with hyphens, underscores or even spaces
    • "test", "tests", "spec" or "should" suffixes (case insensitive, except for CamelCase style)
    • "test", "tests" or "spec" prefixes (case insensitive, except for CamelCase style)
  • Writing tests for your Java code in Scala? Your test code does not have to be written in the same
  • language as you production code!
  • Practicing TDD, having integration tests? You likely don't always have a one-to-one relationship between your test and production files...
    MoreUnit lets you simply jump to the last opened test file (respectively to the last opened production file). To access the command:
  • From the main menu: "Navigate" > "Jump to Last Opened Test" or "Jump to Last Opened Test Subject".
  • From the contextual menu: "Go To" > "Jump to Last Opened Test" or "Jump to Last Opened Test Subject".
  • From the "Find Action..." pop-up window: "Jump to Last Opened Test / Test Subject".
  • NUnitJS

    NUnitJS integration plugin, NUnitJS is a test framework for NodeJS


    IntelliJ version of PairHero plugin http://www.happyprog.com/pairhero/

    PHPUnit code coverage

    By oker1
    Displays PHPUnit code coverage of file in the editor.

    Robotium Recorder

    • Record professional Android UI test cases in minutes
    • Records from emulators and actual devices
    • Full support for native and hybrid Android apps
    • Supports binary APK:s and apps with source code
    • Automatically detects resource ID:s 
    • Click to Assert™ - Click any View to make an assert
    • Always in perfect sync with the latest Robotium features

    SeleniumRC Server

    The Selenium Remove Control Server embedded as a plugin.


    Official IntelliJ IDEA plugin for Spek.


    track test driven design activities and report on it

    Test Recorder

    Records behaviour of the developer about testing.

    Test/Production Class and Method Generator

    This plugin is used to generate test and production classes, as well as test and production methods from a single action. It is primarily intended for use in Test Driven Development, to speed up the implementation of test cases.


    Provides enhanced navigation and live documentation for unit tested code. Never write a badly named test again!


    Auto Generate Unit Tests for source class in Java or Groovy.

    No more boilerplate!

    • Auto generate Java or Groovy test code with JUnit 4/5, TestNG or Spock frameworks
    • Auto generate Mockito mocks
    • Generate test params and assertion statements
    • Integrate with IDEA menus: Code->TestMe, Code->Generate

    You're welcome to report issues and raise feature requests at TestMe project forum


    Ctrl + Alt + U, U

    Supports multiple cursors
    Can insert test methods based on the current cursor(s) lines contents. Will update method if shortcut is triggered from inside a docblock comment that's followed by a "public function test______" string
    Uses the project's indent settings; defaults on four spaces.
    Limitations / bugs:
    no PHP-only file filtering was set, will trigger and behave the same for any file

    Install: Open PhpStorm's File / Settings... menu, go to Plugins and click the "Install plugin from disk..." button. Search for the jar file (download from the Releases page), click OK and restart the editor.

    TestNG Generator

    By Skynx
    Automatically generates a TestNG test class skeleton for all of the current class methods.
    The output is produced using a Velocity template, which can be modified to meet your specific needs.
    If a test class already exists, your will be prompted to either overwrite or compare the test class using diff panels.


    TestNG Integration


    Toggles between the Code and a Test

    TypeScript spec file generator / navigator

    TypeScript test file generator / navigator.

    Unitils plugin

    To make Unitils using easy!


    Simplify creation and maintenance of junit tests


    This plugin does basic code completions for xcordion/concordion (html) specification files.

    You can switch between or create a backing class for a valid test specification file by using the shortcut alt + shift + X. There are project and module level configuration panels to allow you to specify an abstract class to use for the test.

    For more information on Xcordion/Concordion see:

    xielunyan for idea

    the plugin for unit testing


    Plugin for running mutation tests with a click of a button. It uses PIT under the hood.