Download JAR files tagged by hooks with all dependencies
jexbox-jsf from group com.jexbox.connector (version 0.0.2)
Jexbox JSF connector hooks into ExceptionHandlerWrapper, so any uncaught exceptions in your JSF application will be sent to your Jexbox database. The connector extracts complete exception stack trace, including nested exceptions, error message and system properties and page/component traces
0 downloads
Artifact jexbox-jsf
Group com.jexbox.connector
Version 0.0.2
Last update 15. August 2014
Organization not specified
URL http://jexbox.com/connectors
License The Apache Software License, Version 2.0
Dependencies amount 4
Dependencies jexbox-http, commons-codec, jsf-api, jsf-impl,
There are maybe transitive dependencies!
Group com.jexbox.connector
Version 0.0.2
Last update 15. August 2014
Organization not specified
URL http://jexbox.com/connectors
License The Apache Software License, Version 2.0
Dependencies amount 4
Dependencies jexbox-http, commons-codec, jsf-api, jsf-impl,
There are maybe transitive dependencies!
jexbox-tapestry from group com.jexbox.connector (version 0.0.1)
Jexbox Tapestry connector hooks as RequestExceptionHandler, so any uncaught exceptions in your Tapestry application will be sent to your Jexbox database. The connector extracts complete exception stack trace, including nested exceptions, error message and system properties and page/component traces
Artifact jexbox-tapestry
Group com.jexbox.connector
Version 0.0.1
Last update 26. May 2014
Organization not specified
URL http://jexbox.com/connectors
License The Apache Software License, Version 2.0
Dependencies amount 2
Dependencies jexbox-http, tapestry-core,
There are maybe transitive dependencies!
Group com.jexbox.connector
Version 0.0.1
Last update 26. May 2014
Organization not specified
URL http://jexbox.com/connectors
License The Apache Software License, Version 2.0
Dependencies amount 2
Dependencies jexbox-http, tapestry-core,
There are maybe transitive dependencies!
jexbox-core from group com.jexbox.connector (version 0.0.1)
Core Java Jexbox connector hooks into Thread.UncaughtExceptionHandler, so any uncaught exceptions in your application will be sent to your Jexbox database. The connector extracts complete exception stack trace, including nested exceptions, error message and system properties
Artifact jexbox-core
Group com.jexbox.connector
Version 0.0.1
Last update 26. May 2014
Organization not specified
URL http://jexbox.com/connectors
License The Apache Software License, Version 2.0
Dependencies amount 1
Dependencies gson,
There are maybe transitive dependencies!
Group com.jexbox.connector
Version 0.0.1
Last update 26. May 2014
Organization not specified
URL http://jexbox.com/connectors
License The Apache Software License, Version 2.0
Dependencies amount 1
Dependencies gson,
There are maybe transitive dependencies!
fortuity-parent from group com.fortuityframework (version 1.0.7)
The Fortuity Framework is a simple framework for making event-driven web applications. It hooks into commonly used frameworks such as Hibernate or Spring and dispatches both user-generated and entity change events to designated beans.
Group: com.fortuityframework Artifact: fortuity-parent
Show all versions
Show all versions
There is no JAR file uploaded. A download is not possible! Please choose another version.
0 downloads
Artifact fortuity-parent
Group com.fortuityframework
Version 1.0.7
Last update 04. March 2011
Organization not specified
URL http://www.fortuityframework.com/
License Apache 2
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
Group com.fortuityframework
Version 1.0.7
Last update 04. March 2011
Organization not specified
URL http://www.fortuityframework.com/
License Apache 2
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
incrementalbuild-workspace from group io.takari (version 0.20.9)
Provides hooks to run incremental build inside m2e workspace. Other host applications
may also be able to use this API, but have not been tested.
Incremental build workspace API will be embedded in m2e, and therefore the same version
of this API should work with multiple versions of incrementalbuild library. This means
all changes to this API must be backwards compatible. This also means that changes to
this API will require update to io.takari.m2e.lifecycle.
Artifact incrementalbuild-workspace
Group io.takari
Version 0.20.9
Last update 12. March 2019
Organization not specified
URL Not specified
License not specified
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
Group io.takari
Version 0.20.9
Last update 12. March 2019
Organization not specified
URL Not specified
License not specified
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
spring-data-events from group org.labun (version 1.0.1)
An implementation of missing spring data repository hooks.
JPA @EventHandlers have following limitations, which
have been solved in this library:
1) It leads to circular dependency between your entity and
it's event handler which makes it impossible to split your
application into dedicated modules or extends an existing
one with own modules.
2) The inability to inject spring beans without using of
static context.
1 downloads
Artifact spring-data-events
Group org.labun
Version 1.0.1
Last update 25. July 2017
Organization not specified
URL https://labun.org
License Apache License, Version 2.0
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
Group org.labun
Version 1.0.1
Last update 25. July 2017
Organization not specified
URL https://labun.org
License Apache License, Version 2.0
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
drift from group org.vafer (version 0.1)
Drift can be used to serialize and deserialze objects in a cross
language manner. It will generate code based on a grammar and provide
hooks for data migrations across different grammar versions.
In many ways very similar to Thrift (original code base) and
protobuffers. It's focus is serialization and data migration rather
than RPC and service implementation though.
Artifact drift
Group org.vafer
Version 0.1
Last update 29. October 2008
Organization not specified
URL http://vafer.org/projects/drift
License Apache License 2
Dependencies amount 3
Dependencies ant, antlr, stringtemplate,
There are maybe transitive dependencies!
Group org.vafer
Version 0.1
Last update 29. October 2008
Organization not specified
URL http://vafer.org/projects/drift
License Apache License 2
Dependencies amount 3
Dependencies ant, antlr, stringtemplate,
There are maybe transitive dependencies!
xapi-template from group net.wetheinter (version 0.2)
A simple templating system for java codegen.
This library includes an object-oriented, fluent source writing api, for a chained, intuitive codegen api.
It also includes a template processor which can take java source files formatted with "magic comments",
to allow simple mapping of GeneratorClass#generatorMethod() to inject dynamic source content.
//@generateWith(GeneratorClass)//
-Sets the current generator. You may use as many as you please
//generatorMethod(arbitrary-string-data-you-may-want-to-parse)//
-invokes the named method on the current injector, with any text (between brackets) sent as a string
This allows you to markup default source with hooks where you may want to inject arbitrary code.
It is especially useful for generating super-source in gwt compiles; changes to the default class are propagated to overrides.
Artifact xapi-template
Group net.wetheinter
Version 0.2
Last update 20. February 2013
Organization The Internet Party
URL https://github.com/WeTheInternet/xapi-template
License The Apache Software License, Version 2.0
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
Group net.wetheinter
Version 0.2
Last update 20. February 2013
Organization The Internet Party
URL https://github.com/WeTheInternet/xapi-template
License The Apache Software License, Version 2.0
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
minitest from group rubygems (version 5.4.1)
minitest provides a complete suite of testing facilities supporting
TDD, BDD, mocking, and benchmarking.
"I had a class with Jim Weirich on testing last week and we were
allowed to choose our testing frameworks. Kirk Haines and I were
paired up and we cracked open the code for a few test
frameworks...
I MUST say that minitest is *very* readable / understandable
compared to the 'other two' options we looked at. Nicely done and
thank you for helping us keep our mental sanity."
-- Wayne E. Seguin
minitest/unit is a small and incredibly fast unit testing framework.
It provides a rich set of assertions to make your tests clean and
readable.
minitest/spec is a functionally complete spec engine. It hooks onto
minitest/unit and seamlessly bridges test assertions over to spec
expectations.
minitest/benchmark is an awesome way to assert the performance of your
algorithms in a repeatable manner. Now you can assert that your newb
co-worker doesn't replace your linear algorithm with an exponential
one!
minitest/mock by Steven Baker, is a beautifully tiny mock (and stub)
object framework.
minitest/pride shows pride in testing and adds coloring to your test
output. I guess it is an example of how to write IO pipes too. :P
minitest/unit is meant to have a clean implementation for language
implementors that need a minimal set of methods to bootstrap a working
test suite. For example, there is no magic involved for test-case
discovery.
"Again, I can't praise enough the idea of a testing/specing
framework that I can actually read in full in one sitting!"
-- Piotr Szotkowski
Comparing to rspec:
rspec is a testing DSL. minitest is ruby.
-- Adam Hawkins, "Bow Before MiniTest"
minitest doesn't reinvent anything that ruby already provides, like:
classes, modules, inheritance, methods. This means you only have to
learn ruby to use minitest and all of your regular OO practices like
extract-method refactorings still apply.
Group: rubygems Artifact: minitest
There is no JAR file uploaded. A download is not possible! Please choose another version.
0 downloads
Artifact minitest
Group rubygems
Version 5.4.1
Last update 28. March 2015
Organization not specified
URL https://github.com/seattlerb/minitest
License MIT
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
Group rubygems
Version 5.4.1
Last update 28. March 2015
Organization not specified
URL https://github.com/seattlerb/minitest
License MIT
Dependencies amount 0
Dependencies No dependencies
There are maybe transitive dependencies!
pact-jvm-consumer_2.10 from group au.com.dius (version 2.4.20)
Pact consumer
=============
Pact Consumer is used by projects that are consumers of an API.
Most projects will want to use pact-consumer via one of the test framework specific projects. If your favourite
framework is not implemented, this module should give you all the hooks you need.
Provides a DSL for use with Java to build consumer pacts.
## Dependency
The library is available on maven central using:
* group-id = `au.com.dius`
* artifact-id = `pact-jvm-consumer_2.11`
## DSL Usage
Example in a JUnit test:
```java
import au.com.dius.pact.model.MockProviderConfig;
import au.com.dius.pact.model.PactFragment;
import org.junit.Test;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertEquals;
public class PactTest {
@Test
public void testPact() {
PactFragment pactFragment = ConsumerPactBuilder
.consumer("Some Consumer")
.hasPactWith("Some Provider")
.uponReceiving("a request to say Hello")
.path("/hello")
.method("POST")
.body("{\"name\": \"harry\"}")
.willRespondWith()
.status(200)
.body("{\"hello\": \"harry\"}")
.toFragment();
MockProviderConfig config = MockProviderConfig.createDefault();
VerificationResult result = pactFragment.runConsumer(config, new TestRun() {
@Override
public void run(MockProviderConfig config) {
Map expectedResponse = new HashMap();
expectedResponse.put("hello", "harry");
try {
assertEquals(new ProviderClient(config.url()).hello("{\"name\": \"harry\"}"),
expectedResponse);
} catch (IOException e) {}
}
});
if (result instanceof PactError) {
throw new RuntimeException(((PactError)result).error());
}
assertEquals(ConsumerPactTest.PACT_VERIFIED, result);
}
}
```
The DSL has the following pattern:
```java
.consumer("Some Consumer")
.hasPactWith("Some Provider")
.given("a certain state on the provider")
.uponReceiving("a request for something")
.path("/hello")
.method("POST")
.body("{\"name\": \"harry\"}")
.willRespondWith()
.status(200)
.body("{\"hello\": \"harry\"}")
.uponReceiving("another request for something")
.path("/hello")
.method("POST")
.body("{\"name\": \"harry\"}")
.willRespondWith()
.status(200)
.body("{\"hello\": \"harry\"}")
.
.
.
.toFragment()
```
You can define as many interactions as required. Each interaction starts with `uponReceiving` followed by `willRespondWith`.
The test state setup with `given` is a mechanism to describe what the state of the provider should be in before the provider
is verified. It is only recorded in the consumer tests and used by the provider verification tasks.
### Building JSON bodies with PactDslJsonBody DSL
The body method of the ConsumerPactBuilder can accept a PactDslJsonBody, which can construct a JSON body as well as
define regex and type matchers.
For example:
```java
PactDslJsonBody body = new PactDslJsonBody()
.stringType("name")
.booleanType("happy")
.hexValue("hexCode")
.id()
.ipAddress("localAddress")
.numberValue("age", 100)
.timestamp();
```
#### DSL Matching methods
The following matching methods are provided with the DSL. In most cases, they take an optional value parameter which
will be used to generate example values (i.e. when returning a mock response). If no example value is given, a random
one will be generated.
| method | description |
|--------|-------------|
| string, stringValue | Match a string value (using string equality) |
| number, numberValue | Match a number value (using Number.equals)\* |
| booleanValue | Match a boolean value (using equality) |
| stringType | Will match all Strings |
| numberType | Will match all numbers\* |
| integerType | Will match all numbers that are integers (both ints and longs)\* |
| decimalType | Will match all real numbers (floating point and decimal)\* |
| booleanType | Will match all boolean values (true and false) |
| stringMatcher | Will match strings using the provided regular expression |
| timestamp | Will match string containing timestamps. If a timestamp format is not given, will match an ISO timestamp format |
| date | Will match string containing dates. If a date format is not given, will match an ISO date format |
| time | Will match string containing times. If a time format is not given, will match an ISO time format |
| ipAddress | Will match string containing IP4 formatted address. |
| id | Will match all numbers by type |
| hexValue | Will match all hexadecimal encoded strings |
| uuid | Will match strings containing UUIDs |
_\* Note:_ JSON only supports double precision floating point values. Depending on the language implementation, they
may parsed as integer, floating point or decimal numbers.
#### Ensuring all items in a list match an example (2.2.0+)
Lots of the time you might not know the number of items that will be in a list, but you want to ensure that the list
has a minimum or maximum size and that each item in the list matches a given example. You can do this with the `arrayLike`,
`minArrayLike` and `maxArrayLike` functions.
| function | description |
|----------|-------------|
| `eachLike` | Ensure that each item in the list matches the provided example |
| `maxArrayLike` | Ensure that each item in the list matches the provided example and the list is no bigger than the provided max |
| `minArrayLike` | Ensure that each item in the list matches the provided example and the list is no smaller than the provided min |
For example:
```java
DslPart body = new PactDslJsonBody()
.minArrayLike("users")
.id()
.stringType("name")
.closeObject()
.closeArray();
```
This will ensure that the users list is never empty and that each user has an identifier that is a number and a name that is a string.
#### Matching JSON values at the root (Version 3.2.2/2.4.3+)
For cases where you are expecting basic JSON values (strings, numbers, booleans and null) at the root level of the body
and need to use matchers, you can use the `PactDslJsonRootValue` class. It has all the DSL matching methods for basic
values that you can use.
For example:
```java
.consumer("Some Consumer")
.hasPactWith("Some Provider")
.uponReceiving("a request for a basic JSON value")
.path("/hello")
.willRespondWith()
.status(200)
.body(PactDslJsonRootValue.integerType())
```
#### Root level arrays that match all items (version 2.2.11+)
If the root of the body is an array, you can create PactDslJsonArray classes with the following methods:
| function | description |
|----------|-------------|
| `arrayEachLike` | Ensure that each item in the list matches the provided example |
| `arrayMinLike` | Ensure that each item in the list matches the provided example and the list is no bigger than the provided max |
| `arrayMaxLike` | Ensure that each item in the list matches the provided example and the list is no smaller than the provided min |
For example:
```java
PactDslJsonArray.arrayEachLike()
.date("clearedDate", "mm/dd/yyyy", date)
.stringType("status", "STATUS")
.decimalType("amount", 100.0)
.closeObject()
```
This will then match a body like:
```json
[ {
"clearedDate" : "07/22/2015",
"status" : "C",
"amount" : 15.0
}, {
"clearedDate" : "07/22/2015",
"status" : "C",
"amount" : 15.0
}, {
"clearedDate" : "07/22/2015",
"status" : "C",
"amount" : 15.0
} ]
```
#### Matching arrays of arrays (version 3.2.12/2.4.14+)
For the case where you have arrays of arrays (GeoJSON is an example), the following methods have been provided:
| function | description |
|----------|-------------|
| `eachArrayLike` | Ensure that each item in the array is an array that matches the provided example |
| `eachArrayWithMaxLike` | Ensure that each item in the array is an array that matches the provided example and the array is no bigger than the provided max |
| `eachArrayWithMinLike` | Ensure that each item in the array is an array that matches the provided example and the array is no smaller than the provided min |
For example (with GeoJSON structure):
```java
new PactDslJsonBody()
.stringType("type","FeatureCollection")
.eachLike("features")
.stringType("type","Feature")
.object("geometry")
.stringType("type","Point")
.eachArrayLike("coordinates") // coordinates is an array of arrays
.decimalType(-7.55717)
.decimalType(49.766896)
.closeArray()
.closeArray()
.closeObject()
.object("properties")
.stringType("prop0","value0")
.closeObject()
.closeObject()
.closeArray()
```
This generated the following JSON:
```json
{
"features": [
{
"geometry": {
"coordinates": [[-7.55717, 49.766896]],
"type": "Point"
},
"type": "Feature",
"properties": { "prop0": "value0" }
}
],
"type": "FeatureCollection"
}
```
and will be able to match all coordinates regardless of the number of coordinates.
#### Matching any key in a map (3.3.1/2.5.0+)
The DSL has been extended for cases where the keys in a map are IDs. For an example of this, see
[#313](https://github.com/DiUS/pact-jvm/issues/131). In this case you can use the `eachKeyLike` method, which takes an
example key as a parameter.
For example:
```java
DslPart body = new PactDslJsonBody()
.object("one")
.eachKeyLike("001", PactDslJsonRootValue.id(12345L)) // key like an id mapped to a matcher
.closeObject()
.object("two")
.eachKeyLike("001-A") // key like an id where the value is matched by the following example
.stringType("description", "Some Description")
.closeObject()
.closeObject()
.object("three")
.eachKeyMappedToAnArrayLike("001") // key like an id mapped to an array where each item is matched by the following example
.id("someId", 23456L)
.closeObject()
.closeArray()
.closeObject();
```
For an example, have a look at [WildcardKeysTest](src/test/java/au/com/dius/pact/consumer/WildcardKeysTest.java).
**NOTE:** The `eachKeyLike` method adds a `*` to the matching path, so the matching definition will be applied to all keys
of the map if there is not a more specific matcher defined for a particular key. Having more than one `eachKeyLike` condition
applied to a map will result in only one being applied when the pact is verified (probably the last).
### Matching on paths (version 2.1.5+)
You can use regular expressions to match incoming requests. The DSL has a `matchPath` method for this. You can provide
a real path as a second value to use when generating requests, and if you leave it out it will generate a random one
from the regular expression.
For example:
```java
.given("test state")
.uponReceiving("a test interaction")
.matchPath("/transaction/[0-9]+") // or .matchPath("/transaction/[0-9]+", "/transaction/1234567890")
.method("POST")
.body("{\"name\": \"harry\"}")
.willRespondWith()
.status(200)
.body("{\"hello\": \"harry\"}")
```
### Matching on headers (version 2.2.2+)
You can use regular expressions to match request and response headers. The DSL has a `matchHeader` method for this. You can provide
an example header value to use when generating requests and responses, and if you leave it out it will generate a random one
from the regular expression.
For example:
```java
.given("test state")
.uponReceiving("a test interaction")
.path("/hello")
.method("POST")
.matchHeader("testreqheader", "test.*value")
.body("{\"name\": \"harry\"}")
.willRespondWith()
.status(200)
.body("{\"hello\": \"harry\"}")
.matchHeader("Location", ".*/hello/[0-9]+", "/hello/1234")
```
### Matching on query parameters (version 3.3.7+)
You can use regular expressions to match request query parameters. The DSL has a `matchQuery` method for this. You can provide
an example value to use when generating requests, and if you leave it out it will generate a random one
from the regular expression.
For example:
```java
.given("test state")
.uponReceiving("a test interaction")
.path("/hello")
.method("POST")
.matchQuery("a", "\\d+", "100")
.matchQuery("b", "[A-Z]", "X")
.body("{\"name\": \"harry\"}")
.willRespondWith()
.status(200)
.body("{\"hello\": \"harry\"}")
```
6 downloads
Artifact pact-jvm-consumer_2.10
Group au.com.dius
Version 2.4.20
Last update 14. April 2018
Organization not specified
URL https://github.com/DiUS/pact-jvm
License Apache 2
Dependencies amount 12
Dependencies slf4j-api, scala-library, pact-jvm-model, pact-jvm-matchers_2.10, groovy-all, diffutils, automaton, httpclient, jackson-databind, generex, unfiltered-netty-server_2.10, dispatch-core_2.10,
There are maybe transitive dependencies!
Group au.com.dius
Version 2.4.20
Last update 14. April 2018
Organization not specified
URL https://github.com/DiUS/pact-jvm
License Apache 2
Dependencies amount 12
Dependencies slf4j-api, scala-library, pact-jvm-model, pact-jvm-matchers_2.10, groovy-all, diffutils, automaton, httpclient, jackson-databind, generex, unfiltered-netty-server_2.10, dispatch-core_2.10,
There are maybe transitive dependencies!
Page 9 from 10 (items total 93)