56 plugins in category «Unit testing»
This plugin will mark test directories and resolve testCompile dependencies. It also sets up the correct system properties for Robolectric.
- Go to the test class from the tested class (shortcut : alt+shift+K)
- Go to the tested class from the test class (shortcut : alt+shift+K)
- Execute tests inside PhpStorm (shortcut : alt+shift+M)
- Easily identify test files by a custom icon
For running puppet labs Beaker tests from RubyMine
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)
For more info visit https://github.com/SokolovMS/easymock-expect-builder
- Support run/debug ef-common tests via context menu.
- Show run button in the line of test case.
- Run and debug ef-common tests with standard run configuration.
- It will update run.py in your project to support this plugin.
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
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.
- 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.
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
- 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.
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.
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.
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
- 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
- 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.
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
- static imports for useful mockito functions like
To generate the Mockito code with the plugin hit
ctrl shift M or use a choose the action from "Generate Action" context menu.
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:
- Custom icons for phpspac files
- Generate spec file for php class
- go to spec from php class / go to clas from spec class
PhpStorm plugin to provide smart autocomplete, code navigation and refactoring features for mocked class methods.Feature list
method autocomplete for class, abstract class and trait mock objects;
- type providers: getMock, getMockForAbstractClass, etc. will return mock object with methods of mocking class and PHPUnit_Framework_MockObject_MockObject;
supported PHPUnit methods:
- code navigation (go to declaration, find usages, etc.) and refactoring (rename methods);
- highlighting of incorrect method usages;
- Prophecy support.
This plugin is used for loading files with the logs of Pytest or Python failures/tracebacks and then visualizing them in the editor. This plugin also provides a Dependency Graph
Here are listed the actions, which will appear in the tools menu in IDE:
- Load and Visualize log .txt: A windows will appear where if the file containing the logs is selected and then the Editor of the IDE is used for visualizing/highlighting the lines.
- Clear current View: Clears the view for the current opened tab, after refreshing the visualization will be redrawn.
- Stop visualization: Stops the visualization for all the files, keeping the settings, but not the so far visualized data.
- Visualize console logs:Visualizes the logs from the internal IntelliJ console log. Logs are visualized, if any errors happened and are drawn when the editor tabs are opened/reopened.
- Listen for external jars:Listens for external logs, which can be send through a UDP protocol on port 9876 as 1024 bit words. These are then visualized.
Here are listed the actions which can be used on the Dependency Graph window.
- Visualize coverage: Creates a dependency Graph visualizing the actual coverage for all the modules (python files) of the project. The nodes are differently colorized according to their code coverage.
- Reset view: Resets the view of the visualized graph - changes the focus.
- Clean canvas: Cleans the canvas and reoves the entire visualization
- 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
Auto Generate Unit Test Class from code.
No more boilerplate!Features:
- Auto generate Java or Groovy test class with JUnit 4,5
- 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.
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.For more information on Xcordion/Concordion see: