Gatling VS Spock

Gatling: An open-source load and performance testing tool primarily designed for web applications, Gatling utilizes a simple domain-specific language (DSL) for creating and maintaining test scripts. It supports HTTP/2 and allows recording and generation of scenarios directly from a browser. The tool also provides detailed performance reports that are easy to analyze.

Performance and load testing are essential parts of GraphQL API testing. It ensures APIs can handle expected traffic volumes and respond within acceptable timeframes. You can use tools like Apache JMeter or Gatling to generate realistic loads and evaluate the API's performance under different scenarios. Techniques like batched queries and caching can help mitigate this issue.

New to the .NET community and trying to learn! I have used tools such as Apache JMeter (Java), gatling.io (Java) and Locust (Python) that are decent full featured web perf frameworks. Typically these integrate well with your code, and can be run as part of your unit/integration tests and produce offline reports

Gatling , this is what we tested concurrency with. Setting up might take a while depending on your exp. but the tool is solid.

I used SpringBoot 3.0.2, GraalVM 22 (JVM mode), a MacOS 2,6 GHz 6-Core Intel Core i7, running 1000 users for 5 minutes. The idea was to test how memory consumption and CPU usage evolve. Below, I compared the footprint of these three solutions. I collected the total count of requests, throughput, memory consumption, and CPU usage using VisualVM and Gatling.

Load test your code to simulate a production load (you can use tools like k6 or Gatling)

k6 is our preferred javascript based cloud tester for light webservices. gattling if you have (a monolith with) workflows and need more formalized code to prove/audit your testing.

It's read as "Ochikisu" and origin is the machine gun manufacturer Hotchkiss because this tool does not have as much firepower as the Gatling.

Well I care a lot that it exists. And many other people I know do as well. Just because you don't seem to like it, you shouldn't imagine everyone else is like you.

Maybe Grails is no longer used as much (like Rails itself), but Groovy found other usages since then, like https://spockframework.org/ and Jenkins pipelines (https://www.jenkins.io/doc/book/pipeline/syntax/). It's not going anywhere, and I see no reason for anyone to be upset about it.

In my opinion it is Spock for Java/Groovy [1]. The amount of functionality and readability you can squeeze from Groovy's DSLesque is absurd. Is basically a full fledged new test language with Java sprinkled as the test contents code

[1]: https://spockframework.org/

Groovy allows you to perform transforms on it's AST. If you look at the Spock framework, they used AST transforms to pull off a lot of the DSL.

Spock and Cucumber exemplify the philosophy of behavior-driven development (BDD). The principle behind BDD is that you must first define the desired result of the added feature in a subject-oriented language before writing any tests. The developers are then given the final documentation.

As a quick demonstration, the following (Spock) test asserts that the client JVM code fails to create an SSL connection with the service. Note that I chose to use Vert.x Web Client to handle interacting with the service, but don't let this decision distract from the core content of this post. Nevertheless, if you haven't used Vert.x, I encourage you to try it out -- especially for building server-side network applications.

I maintain a batterie of libraries for my company. Managing dependencies is one of the hardest part even with internal only libraries. Our major pain-point is the dependency towards 3rd party software and dealing with semver. Semver is not really hard to understand it’s just hard to execute as the developer is executing the rules. So for instance if I create a library/plugin etc which wraps around the a tool, would it be a breaking change when the software stops supporting a specific version of the wrapped tool even though the internal API stayed the same (this happens a lot for me with gradle plugins which suddenly decide to not being compatible with the version of gradle I use). I would say yes but for larger dependency trees this becomes a nightmare. For our internal unity3d libraries we decided to not count the supported Unity versions as part of the semver version. The other option would be to have special library packages for each version of unity similar to how the Spock testing framework[1] deals with groovy. For this option we don’t have enough engineers at my company.

[1] https://github.com/spockframework/spock