52 plugins in category «Unit testing»

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.

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.

Drupal Test Runner With Drupal Test Runner, a new run configuration is added to PhpStorm specifically for Drupal's test running script
run-tests.sh. This allows you to run Simpletest, Unit, Kernel, Functional, and FunctionalJavascript tests with one single runner.

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.

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.

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.

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.

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.

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.

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.

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.

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".

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.

Features:
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.

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.

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.