Hi. It seems like Maven Central now shows that the current version of JUnit that J8Spec is linking against has 1 CVE:

https://mvnrepository.com/artifact/io.github.j8spec/j8spec/3.0.0 https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-15250

The latest 4.x version doesn't seem to have it anymore.

group: 'junit', name: 'junit', version: '4.13.2'

I'll see if I can send in a PR when possible. Thanks!

One very useful form of keeping tests interdependent is to have execution randomized. This way it could cause test failures when one test setups some information and the other test expect that data to be there.

I would like to propose the following:

• [ ] Execute the test order randomly
• [ ] Have an option to provide a seed and have the same execution order

RSpec provides an interesting feature which allows an expression to have a different value depending on the context where it is being resolved: let and let!.

describe Subject do
  before do
    do_something_with(key)
  end

  context 'when key is value1' do
    let(:key) { 'value1' }

    it 'does something' do
      expect(...)
    end
  end

  context 'when key is value2' do
    let(:key) { 'value2' }

    it 'does something' do
      expect(...)
    end
  end
end

A possible Java way of doing that using injectors would be:

public class SubjectTest {{

    beforeEach(f -> {
        String key = f.get("key", String.class);
        doSomethingWith(key);
    });

    context("when key is value1", () -> {
        let("key", () -> "value1");

        it("does something", f -> {
            String key = f.get("key", String.class);
            assertThat(...);
        });
    });

    context("when key is value2", () -> {
        let("key", () -> "value2");

        it("does something", f -> {
            String key = f.get("key", String.class);
            assertThat(...);
        });
    });
}}

Another way would be:

public class SubjectTest {{

    Var<String> key = var();

    beforeEach(() -> {
        doSomethingWith(var(key));
    });

    context("when key is value1", () -> {
        let(key, () -> "value1");

        it("does something", () -> {
            String keyValue = var(key);
            assertThat(...);
        });
    });

    context("when key is value2", () -> {
        let(key, () -> "value2");

        it("does something", () -> {
            String keyValue = var(key);
            assertThat(...);
        });
    });
}}

Fails an example if it does not complete under the specified time limit.

it("completes the operation in time", c -> c.timeout(2, TimeoutUnit.SECONDS), () -> {
    doSomething();
});

Replaces Runnable with 2 new functional interfaces: UnsafeBlock and SafeBlock. Since UnsafeBlock is excepted to throw checked exceptions, it will allow the lambda expression to contain code that might throw checked exceptions.

Closes #40.

Sometimes the subject of a test can throw checked exceptions. In these cases the compiler will require the method invocation to be inside a try/catch block:

it("does something important", () -> {
    ...
    try {
        result = methodThatCouldThrowCheckedExceptions();
    } catch (Exception e) {
        ...
    }
    ...
});

In order to avoid this situation, the framework could provide a wrapper method to translate checked exceptions into unchecked exceptions:

it("does something important", () -> {
    ...
    result = unsafe(() -> methodThatCouldThrowCheckedExceptions());
    ...
});

Reference: Stack Overflow