Skip to content
Back to search

citrus-marketplace

MarketplaceWorks with Claude CodeGitHub

Citrus plugins for Claude Code, including the Citrus MCP server.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/citrusframework/citrus with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/citrusframework/citrus'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/citrusframework--citrus/badge.svg)](/listings/citrusframework--citrus)

HTML

<a href="/listings/citrusframework--citrus"><img src="/api/listings/citrusframework--citrus/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Learn how to create and run Citrus integration tests in just a few minutes. You can choose from a set of supported runtimes (JUnit, TestNG, Quarkus, SpringBoot, JBang) and domain specific languages (Java, XML, YAML, Groovy, Cucumber).

For a full guide how to get started with Citrus please visit the [quickstart section](https://citrusframework.org/quickstart/) on the official website.

The easiest way to create and run a Citrus test without a project setup is to use the Citrus JBang support.

You can just call this command to create a new test.

jbang citrus@citrusframework/citrus init MyTest.java

The `init` command creates a new file that represents a Citrus test. The file extension used defines the test source language. You can choose one of the supported test source languages `.java`, `.xml`, `.yaml`, `.groovy`, `.feature`.

The result looks like this:

import org.citrusframework.dsl.TestActionSupport;
import org.citrusframework.TestCaseRunner;
import org.citrusframework.annotations.CitrusResource;

public class MyTest implements Runnable, TestActionSupport {

    @CitrusResource
    TestCaseRunner t;

    @Override
    public void run() {
        t.given(
            createVariables().variable("message", "Citrus rocks!")
        );

        t.then(
            echo().message("${message}")
        );
    }
}

You can now just run the test without any project setup using the Citrus JBang run command:

jbang citrus@citrusframework/citrus run MyTest.java

You may also install the Citrus JBang app to simplify the command line tooling:

jbang trust add https://github.com/citrusframework/citrus/
jbang app install citrus@citrusframework/citrus

Now you can just call:

citrus init my.citrus.it.yaml
citrus run my.citrus.it.yaml

A more complex Citrus integration test typically uses messaging endpoints to send and receive messages with different messaging transports.

A typical Citrus Java JUnit Jupiter test may look like this:

import org.citrusframework.TestCaseRunner;
import org.citrusframework.dsl.TestActionSupport;
import org.citrusframework.annotations.CitrusResource;
import org.citrusframework.annotations.CitrusTest;
import org.citrusframework.junit.jupiter.CitrusSupport;
import org.junit.jupiter.api.Test;

@CitrusSupport
public class HelloServiceIT implements TestActionSupport {

    @CitrusResource
    private TestCaseRunner t;

    @Test
    @CitrusTest
    public void shouldSayHello() {
        t.when(
            http().client("http://localhost:8080/test")
                    .send()
                    .post()
                    .contentType("text/plain")
                    .body("Hello from Citrus!")
        );

        t.then(
            receive().endpoint("kafka:my-topic")
                    .message()
                    .body("Hello from Citrus!")
        );

        t.and(
            http().client("http://localhost:8080/test")
                    .receive()
                    .response(HttpStatus.OK));
    }
}

As you can see the test leverages several Citrus features like sending/receiving messages with different message transports. Receiving a message always comes with an expected message content, so Citrus performs a powerful message validation on body and header content. Citrus is able to handle different message types such as XML, Json, Plaintext, YAML, CSV and more.

You can easily integrate the test into your project with Maven, or you can just run the test without any project setup with JBang.

citrus run HelloServiceIT.java

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "citrus-marketplace",
  3. "description": "Citrus plugins for Claude Code, including the Citrus MCP server.",
  4. "owner": {
  5. "name": "Citrus Integration Test",
  6. "email": "citrus-dev@googlegroups.com",
  7. "url": "https://citrusframework.org"
  8. },
  9. "plugins": [
  10. {
  11. "name": "citrus-mcp",
  12. "source": "./plugins/citrus-mcp",
  13. "description": "Citrus MCP server: exposes the Citrus components in the form of a catalog plus specialized tools (catalog exploration, component schemas, DSL schemas for YAML and XML, detailed documentation material, and collected best practices) to AI coding assistants over the Model Context Protocol. Requires JBang on the PATH."
  14. }
  15. ]
  16. }
README.md · README · 213 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. Citrus Integration Testing ![Logo][1]
  2. ==============
  3. [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.citrusframework/citrus/badge.svg?style=flat-square)](https://central.sonatype.com/search?q=g%253Aorg.citrusframework)
  4. [![build](https://github.com/citrusframework/citrus/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/citrusframework/citrus/actions/workflows/build.yml)
  5. [![Javadocs](http://javadoc.io/badge/org.citrusframework/citrus-core.svg)](http://javadoc.io/doc/org.citrusframework/citrus-core)
  6. [![Licensed under Apache License version 2.0](https://img.shields.io/github/license/openshift/origin.svg?maxAge=2592000)](https://www.apache.org/licenses/LICENSE-2.0")
  7. [![Chat on Zulip](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://citrusframework.zulipchat.com)
  8. Welcome to Citrus
  9. ---------
  10. Citrus is a test framework written in Java that provides a complete test automation tool for integration testing of message-based enterprise applications.
  11. The framework supports a huge set of different message transports and protocols like Http REST, Kafka, JMS, TCP/IP, FTP, SOAP Web Services.
  12. In addition to that Citrus integrates with many technologies and libraries such as Apache Camel, Spring, Quarkus, Testcontainers, Kubernetes, Knative, Selenium and many more.
  13. For validation purpose Citrus is able to verify many different message data formats and protocols such as XML, Json, YAML, CSV, Plaintext, SQL ResultSet and more.
  14. Visit the official website at 'https://citrusframework.org'
  15. for more information and a detailed documentation.
  16. Quickstart
  17. ---------
  18. Learn how to create and run Citrus integration tests in just a few minutes. You can choose from a set of supported runtimes (JUnit, TestNG, Quarkus, SpringBoot, JBang) and domain specific languages (Java, XML, YAML, Groovy, Cucumber).
  19. For a full guide how to get started with Citrus please visit the [quickstart section](https://citrusframework.org/quickstart/) on the official website.
  20. The easiest way to create and run a Citrus test without a project setup is to use the Citrus JBang support.
  21. You can just call this command to create a new test.
  22. ```shell
  23. jbang citrus@citrusframework/citrus init MyTest.java
  24. ```
  25. The `init` command creates a new file that represents a Citrus test. The file extension used defines the test source language. You can choose one of the supported test source languages `.java`, `.xml`, `.yaml`, `.groovy`, `.feature`.
  26. The result looks like this:
  27. ```java
  28. import org.citrusframework.dsl.TestActionSupport;
  29. import org.citrusframework.TestCaseRunner;
  30. import org.citrusframework.annotations.CitrusResource;
  31. public class MyTest implements Runnable, TestActionSupport {
  32. @CitrusResource
  33. TestCaseRunner t;
  34. @Override
  35. public void run() {
  36. t.given(
  37. createVariables().variable("message", "Citrus rocks!")
  38. );
  39. t.then(
  40. echo().message("${message}")
  41. );
  42. }
  43. }
  44. ```
  45. You can now just run the test without any project setup using the Citrus JBang run command:
  46. ```shell
  47. jbang citrus@citrusframework/citrus run MyTest.java
  48. ```
  49. You may also install the Citrus JBang app to simplify the command line tooling:
  50. ```shell
  51. jbang trust add https://github.com/citrusframework/citrus/
  52. jbang app install citrus@citrusframework/citrus
  53. ```
  54. Now you can just call:
  55. ```shell
  56. citrus init my.citrus.it.yaml
  57. citrus run my.citrus.it.yaml
  58. ```
  59. A more complex Citrus integration test typically uses messaging endpoints to send and receive messages with different messaging transports.
  60. A typical Citrus Java JUnit Jupiter test may look like this:
  61. ```java
  62. import org.citrusframework.TestCaseRunner;
  63. import org.citrusframework.dsl.TestActionSupport;
  64. import org.citrusframework.annotations.CitrusResource;
  65. import org.citrusframework.annotations.CitrusTest;
  66. import org.citrusframework.junit.jupiter.CitrusSupport;
  67. import org.junit.jupiter.api.Test;
  68. @CitrusSupport
  69. public class HelloServiceIT implements TestActionSupport {
  70. @CitrusResource
  71. private TestCaseRunner t;
  72. @Test
  73. @CitrusTest
  74. public void shouldSayHello() {
  75. t.when(
  76. http().client("http://localhost:8080/test")
  77. .send()
  78. .post()
  79. .contentType("text/plain")
  80. .body("Hello from Citrus!")
  81. );
  82. t.then(
  83. receive().endpoint("kafka:my-topic")
  84. .message()
  85. .body("Hello from Citrus!")
  86. );
  87. t.and(
  88. http().client("http://localhost:8080/test")
  89. .receive()
  90. .response(HttpStatus.OK));
  91. }
  92. }
  93. ```
  94. As you can see the test leverages several Citrus features like sending/receiving messages with different message transports. Receiving a message always comes with an expected message content, so Citrus performs a powerful message validation on body and header content. Citrus is able to handle different message types such as XML, Json, Plaintext, YAML, CSV and more.
  95. You can easily integrate the test into your project with Maven, or you can just run the test without any project setup with JBang.
  96. ```shell
  97. citrus run HelloServiceIT.java
  98. ```
  99. Developing
  100. ---------
  101. The following software is recommended in order to code with the
  102. Citrus framework:
  103. * Java 21+
  104. Installed JDK plus JAVA_HOME environment variable set
  105. up and pointing to your Java installation directory. Used to compile and build the Citrus code.
  106. * Maven 3.9.8+
  107. Citrus projects will fit best with [Maven](https://maven.apache.org).
  108. However, it is not required to use Maven. You can also run tests using [Gradle](https://gradle.org/) for instance.
  109. * Java IDE (optional)
  110. A Java IDE will help you to manage your Citrus project (e.g. creating
  111. and executing test cases). You can use the Java IDE that you like best like Eclipse or IntelliJ IDEA.
  112. * [JBang](https://jbang.dev) (optional)
  113. For fast prototyping you can use the Citrus JBang app as a command line tooling. It allows you to create and run Citrus tests without a project setup. Dependencies and Java runtime setup is automatically managed by JBang.
  114. Samples
  115. ---------
  116. Our sample section is still growing.
  117. You can find several sample projects in the separate repository [citrusframework/citrus-samples](https://github.com/citrusframework/citrus-samples).
  118. Support
  119. ---------
  120. In case you need help and support for Citrus have a look at
  121. [https://citrusframework.org/help](https://citrusframework.org/help).
  122. Contact `citrus-dev@googlegroups.com` directly for any request or questions.
  123. Issues
  124. ---------
  125. Please report any bugs and/or feature requests directly to
  126. [citrusframework/citrus/issues](https://github.com/citrusframework/citrus/issues)
  127. Resources
  128. ---------
  129. * Clone the code repository [https://github.com/citrusframework/citrus.git](https://github.com/citrusframework/citrus.git) with Git to run the Maven build on your machine to get a fresh copy of the latest bits.
  130. * Find our [blog and news articles](https://citrusframework.org/news) about Citrus and checkout the various post categories for selecting a specific topic.
  131. * The official website [https://citrusframework.org](https://citrusframework.org) offers tutorials and more information about Citrus.
  132. * Review the individual [release notes](https://citrusframework.org/docs/history/) to learn about the changes for a release. For detailed description of changed packages and classes do also consult the GitHub commit history.
  133. License
  134. ---------
  135. Copyright 2006-2025 the original author or authors.
  136. Licensed under the Apache License, Version 2.0 (the "License");
  137. you may not use this file except in compliance with the License.
  138. You may obtain a copy of the License at
  139. http://www.apache.org/licenses/LICENSE-2.0
  140. Unless required by applicable law or agreed to in writing, software
  141. distributed under the License is distributed on an "AS IS" BASIS,
  142. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  143. See the License for the specific language governing permissions and
  144. limitations under the License.
  145. Information
  146. ---------
  147. For more information on Citrus see [citrusframework.org][2], including
  148. a complete [reference manual][3].
  149. [1]: https://citrusframework.org/img/brand-logo.png "Citrus"
  150. [2]: https://citrusframework.org
  151. [3]: https://citrusframework.org/citrus/reference/html/index.html

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.