{
12 | /**
13 | * The abstract method of the {@link FunctionalInterface}.
14 | *
15 | * @param p the parameter
16 | */
17 | void invoke(P p);
18 | }
19 |
--------------------------------------------------------------------------------
/License.txt:
--------------------------------------------------------------------------------
1 | Copyright 2016 Adam Ruka
2 |
3 | Licensed under the Apache License, Version 2.0 (the "License");
4 | you may not use this file except in compliance with the License.
5 | You may obtain a copy of the License at
6 |
7 | http://www.apache.org/licenses/LICENSE-2.0
8 |
9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | rootProject.name = 'specnaz-all'
2 |
3 | include 'src:main:specnaz',
4 | 'src:main:specnaz-junit',
5 | 'src:main:specnaz-kotlin',
6 | 'src:main:specnaz-kotlin-junit',
7 | 'src:main:specnaz-testng',
8 | 'src:main:specnaz-kotlin-testng',
9 | 'src:examples:specnaz-java-examples',
10 | 'src:examples:specnaz-junit-rules-examples',
11 | 'src:examples:specnaz-kotlin-examples',
12 | 'src:examples:specnaz-groovy-examples',
13 | 'src:examples:specnaz-testng-examples',
14 | 'src:examples:specnaz-custom-dsl-example'
15 |
--------------------------------------------------------------------------------
/src/main/specnaz-junit/src/main/java/org/specnaz/junit/SpecnazJUnit.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.junit;
2 |
3 | import org.junit.runner.RunWith;
4 | import org.junit.runner.Runner;
5 | import org.specnaz.Specnaz;
6 |
7 | /**
8 | * A utility class that implements the {@link Specnaz} interface
9 | * and declares {@link SpecnazJUnitRunner} as the JUnit test {@link Runner}
10 | * with the {@link RunWith} annotation.
11 | * Useful in cases where your test class doesn't have to extend any particular class.
12 | */
13 | @RunWith(SpecnazJUnitRunner.class)
14 | public abstract class SpecnazJUnit implements Specnaz {
15 | }
16 |
--------------------------------------------------------------------------------
/src/examples/specnaz-custom-dsl-example/src/main/java/org/specnaz/examples/custom_dsl/given_when_then/GivenBuilder.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.examples.custom_dsl.given_when_then;
2 |
3 | import org.specnaz.utils.TestClosure;
4 |
5 | import java.util.function.Consumer;
6 |
7 | public interface GivenBuilder {
8 | default void given(String description, Runnable closure) {
9 | given(description, () -> {}, closure);
10 | }
11 |
12 | void given(String description, TestClosure action, Runnable closure);
13 |
14 | void when(String description, TestClosure action, Consumer {
14 | /**
15 | * The abstract method of the {@link FunctionalInterface}.
16 | *
17 | * @param p the parameter
18 | * @throws Exception can safely throw any Exception
19 | */
20 | void invoke(P p) throws Exception;
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/specnaz/src/main/java/org/specnaz/params/impl/ParametrizedSubgroup1.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.params.impl;
2 |
3 | import org.specnaz.impl.TestCaseType;
4 | import org.specnaz.params.RunnableParams1;
5 |
6 | import java.util.List;
7 |
8 | public final class ParametrizedSubgroup1 extends AbstractParametrizedSubgroup {
9 | private final RunnableParams1 specClosure;
10 |
11 | public ParametrizedSubgroup1(String description, RunnableParams1 specClosure, TestCaseType testCaseType) {
12 | super(description, testCaseType);
13 | this.specClosure = specClosure;
14 | }
15 |
16 | @Override
17 | protected Runnable toSpecClosure(List paramsSet) {
18 | return () -> specClosure.invoke((P) paramsSet.get(0));
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/src/main/specnaz/src/main/java/org/specnaz/params/RunnableParams5.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.params;
2 |
3 | /**
4 | * The equivalent of {@link Runnable} for parametrized
5 | * sub-specifications taking 5 parameters.
6 | *
7 | * @see #invoke(P1, P2, P3, P4, P5)
8 | * @see ParamsSpecBuilder#describes(String, RunnableParams5)
9 | */
10 | @FunctionalInterface
11 | public interface RunnableParams5 extends
11 | AbstractParametrizedPositiveTest {
12 | private final TestClosureParams1 testBody;
13 |
14 | public ParametrizedPositiveTest1(TestSettings testSettings,
15 | String description, TestClosureParams1 testBody, TestCaseType testCaseType) {
16 | super(testSettings, description, testCaseType);
17 | this.testBody = testBody;
18 | }
19 |
20 | @Override
21 | protected TestClosure toTestClosure(List params) {
22 | return Conversions.toTestClosure1(testBody, params);
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/specnaz/src/main/java/org/specnaz/params/impl/AbstractParametrizedPositiveTest.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.params.impl;
2 |
3 | import org.specnaz.TestSettings;
4 | import org.specnaz.impl.SinglePositiveTestCase;
5 | import org.specnaz.impl.SingleTestCase;
6 | import org.specnaz.impl.TestCaseType;
7 |
8 | import java.util.List;
9 |
10 | public abstract class AbstractParametrizedPositiveTest extends AbstractParametrizedTest {
11 | public final TestSettings testSettings;
12 |
13 | AbstractParametrizedPositiveTest(TestSettings testSettings, String description, TestCaseType testCaseType) {
14 | super(description, testCaseType);
15 | this.testSettings = testSettings;
16 | }
17 |
18 | @Override
19 | protected SingleTestCase testCase(List params) {
20 | return new SinglePositiveTestCase(testSettings,
21 | formatDesc(params), toTestClosure(params), testCaseType);
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/specnaz/src/main/java/org/specnaz/params/impl/ParametrizedPositiveTest2.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.params.impl;
2 |
3 | import org.specnaz.TestSettings;
4 | import org.specnaz.impl.TestCaseType;
5 | import org.specnaz.params.TestClosureParams2;
6 | import org.specnaz.utils.TestClosure;
7 |
8 | import java.util.List;
9 |
10 | public final class ParametrizedPositiveTest2 testBody;
13 |
14 | public ParametrizedExceptionTest1(ThrowableExpectations testBody, TestCaseType testCaseType) {
16 | super(throwableExpectations, description, testCaseType);
17 | this.testBody = testBody;
18 | }
19 |
20 | @Override
21 | protected TestClosure toTestClosure(List params) {
22 | return Conversions.toTestClosure1(testBody, params);
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/src/examples/specnaz-custom-dsl-example/src/main/java/org/specnaz/examples/custom_dsl/given_when_then/SpecnazGivenWhenThen.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.examples.custom_dsl.given_when_then;
2 |
3 | import org.specnaz.core.CoreDslBuilder;
4 | import org.specnaz.core.SpecnazCoreDsl;
5 |
6 | import java.util.function.Consumer;
7 |
8 | public interface SpecnazGivenWhenThen extends SpecnazCoreDsl {
9 | default void given(String description, Consumer {
17 | private final ParametrizedSubgroup1 parametrizedSubgroup;
18 |
19 | public ParamsExpectedSubgroup1(ParametrizedSubgroup1 parametrizedSubgroup) {
20 | this.parametrizedSubgroup = parametrizedSubgroup;
21 | }
22 |
23 | /**
24 | * Complete the parametrized sub-specification by providing the parameters
25 | * it will run with.
26 | *
27 | * @param params
28 | * the parameters to create the sub-specifications with
29 | */
30 | @SafeVarargs
31 | public final void provided(P... params) {
32 | Conversions.complete1d(parametrizedSubgroup, Stream.of(params));
33 | }
34 |
35 | /**
36 | * Complete the parametrized sub-specification by providing the parameters
37 | * it will run with.
38 | *
39 | * @param params
40 | * the parameters to create the sub-specifications with
41 | */
42 | public void provided(Iterable params) {
43 | Conversions.complete1d(parametrizedSubgroup, Conversions.iterable2stream(params));
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/src/examples/specnaz-java-examples/src/test/java/ParametrizedSpec.java:
--------------------------------------------------------------------------------
1 | import org.specnaz.params.junit.SpecnazParamsJUnit;
2 |
3 | import static java.lang.String.format;
4 | import static org.assertj.core.api.Assertions.assertThat;
5 | import static org.specnaz.params.Params2.p2;
6 | import static org.specnaz.params.Params3.p3;
7 |
8 | /**
9 | * An example of a parametrized Specnaz spec.
10 | */
11 | public class ParametrizedSpec extends SpecnazParamsJUnit {
12 | {
13 | describes("A parametrized spec", it -> {
14 | it.should("confirm that %1 + %2 = %3", (Integer a, Integer b, Integer c) -> {
15 | assertThat(a + b).isEqualTo(c);
16 | }).provided(
17 | p3(1, 2, 3),
18 | p3(4, 4, 8),
19 | p3(-3, 3, 0),
20 | p3(Integer.MAX_VALUE, 1, Integer.MIN_VALUE)
21 | );
22 |
23 | it.should("correctly parse '%1' as an Int with radix %2", (String str, Integer radix) -> {
24 | assertThat(Integer.parseInt(str, radix)).isPositive();
25 | }).provided(
26 | p2("cafe", 16),
27 | p2("G", 17)
28 | );
29 |
30 | it.describes("with '%1' as the argument", (String str) -> {
31 | it.shouldThrow(NumberFormatException.class,
32 | format("when trying to parse '%s' as an Int with radix %%1", str), (Integer radix) -> {
33 | Integer.parseInt(str, radix);
34 | }).provided(8, 10)
35 | .withMessageContaining(str);
36 | }).provided("cafe", "G");
37 | });
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/src/main/specnaz/src/main/java/org/specnaz/params/impl/AbstractParametrizedSubgroup.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.params.impl;
2 |
3 | import org.specnaz.impl.TestCaseType;
4 |
5 | import java.util.Collection;
6 | import java.util.LinkedList;
7 | import java.util.List;
8 |
9 | import static java.lang.String.format;
10 |
11 | public abstract class AbstractParametrizedSubgroup {
12 | private final String description;
13 | private final TestCaseType testCaseType;
14 | private List
21 | * There's a helper included with Specnaz that tries to make finding the parameter
22 | * to pass to this method easier, {@link org.specnaz.utils.Utils#findMethod}.
23 | *
24 | * @param method the {@link Method} to use
25 | * @return {@code this}
26 | * @see org.specnaz.utils.Utils#findMethod
27 | */
28 | public TestSettings usingMethod(Method method) {
29 | this.method = method;
30 | return this;
31 | }
32 |
33 | /**
34 | * This is a wrapper class used in the implementation of Specnaz.
35 | * You never need it when writing tests,
36 | * it's just an implementation detail.
37 | */
38 | public static final class Wrapper {
39 | private final TestSettings inner;
40 |
41 | public Wrapper(TestSettings inner) {
42 | this.inner = inner;
43 | }
44 |
45 | public Method method() {
46 | return inner.method;
47 | }
48 |
49 | public Annotation[] annotations() {
50 | Method method = method();
51 | return method == null
52 | ? new Annotation[]{}
53 | : method.getAnnotations();
54 | }
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/src/main/specnaz-testng/src/test/java/org/specnaz/testng/SpecnazTestNgSpecWithBefores.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.testng;
2 |
3 | import org.testng.Assert;
4 | import org.testng.annotations.Test;
5 |
6 | @Test
7 | public class SpecnazTestNgSpecWithBefores implements SpecnazFactoryTestNG {
8 | int counter = 0;
9 |
10 | {
11 | describes("A spec with befores", it -> {
12 | it.beginsAll(() -> {
13 | counter++;
14 | });
15 |
16 | it.beginsEach(() -> {
17 | counter++;
18 | });
19 |
20 | it.should("run the beginsEach to increment the counter by 1", () -> {
21 | Assert.assertEquals(counter, 2);
22 | });
23 |
24 | it.should("also run the endsEach to decrement the counter by 1 ", () -> {
25 | Assert.assertEquals(counter, 2);
26 | });
27 |
28 | it.shouldThrow(ArithmeticException.class, "when dividing by counter - 2", () -> {
29 | int unused = 1 / (counter - 2);
30 | });
31 |
32 | it.endsEach(() -> {
33 | counter--;
34 | });
35 |
36 | it.endsAll(() -> {
37 | counter--;
38 | });
39 |
40 | it.describes("with a sub-specification", () -> {
41 | it.beginsAll(() -> {
42 | counter++;
43 | });
44 |
45 | it.beginsEach(() -> {
46 | counter++;
47 | });
48 |
49 | it.should("run the parent fixtures in the child test", () -> {
50 | Assert.assertEquals(counter, 4);
51 | });
52 |
53 | it.endsEach(() -> {
54 | counter--;
55 | });
56 |
57 | it.endsAll(() -> {
58 | counter--;
59 | });
60 | });
61 | });
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/src/main/specnaz/src/main/java/org/specnaz/params/ParamsExpected1.java:
--------------------------------------------------------------------------------
1 | package org.specnaz.params;
2 |
3 | import org.specnaz.TestSettings;
4 | import org.specnaz.params.impl.Conversions;
5 | import org.specnaz.params.impl.ParametrizedPositiveTest1;
6 |
7 | import java.util.stream.Stream;
8 |
9 | /**
10 | * The class returned from {@link ParamsSpecBuilder#should(String, TestClosureParams1)}.
11 | * You need to call one of the {@code provided} methods on it,
12 | * passing the parameters for the test to run with.
13 | *
14 | * @see #provided(P...)
15 | * @see #provided(Iterable)
16 | */
17 | public final class ParamsExpected1 {
18 | private final ParametrizedPositiveTest1 parametrizedTest;
19 |
20 | public ParamsExpected1(ParametrizedPositiveTest1 parametrizedTest) {
21 | this.parametrizedTest = parametrizedTest;
22 | }
23 |
24 | /**
25 | * Complete the parametrized test by providing the parameters
26 | * it will run with.
27 | *
28 | * @param params
29 | * the parameters to run the test with
30 | * @return
31 | * an instance of the {@link TestSettings} class, like a regular
32 | * {@link org.specnaz.SpecBuilder#should} method would
33 | */
34 | @SafeVarargs
35 | public final TestSettings provided(P... params) {
36 | return Conversions.complete1p(parametrizedTest, Stream.of(params));
37 | }
38 |
39 | /**
40 | * Complete the parametrized test by providing the parameters
41 | * it will run with.
42 | *
43 | * @param params
44 | * the parameters to run the test with
45 | * @return
46 | * an instance of the {@link TestSettings} class, like a regular
47 | * {@link org.specnaz.SpecBuilder#should} method would
48 | */
49 | public final TestSettings provided(Iterable params) {
50 | return Conversions.complete1p(parametrizedTest, Conversions.iterable2stream(params));
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/examples/specnaz-custom-dsl-example/src/test/java/standalone/GivenWhenThenStandaloneStackSpec.java:
--------------------------------------------------------------------------------
1 | package standalone;
2 |
3 | import org.junit.runner.RunWith;
4 | import org.specnaz.examples.custom_dsl.given_when_then.standalone.GivenWhenThenStandaloneJUnitRunner;
5 | import org.specnaz.examples.custom_dsl.given_when_then.standalone.SpecnazGivenWhenThenStandalone;
6 | import org.specnaz.utils.IntBox;
7 |
8 | import java.util.Stack;
9 |
10 | import static org.assertj.core.api.Assertions.assertThat;
11 | import static org.specnaz.utils.IntBox.boxWith;
12 |
13 | @RunWith(GivenWhenThenStandaloneJUnitRunner.class)
14 | public class GivenWhenThenStandaloneStackSpec implements SpecnazGivenWhenThenStandalone {
15 | {
16 | given("a Stack", that -> {
17 | Stack
14 | * {@code
15 | * public interface MyCustomDsl extends SpecnazCoreDsl {
16 | * default void myEntryMethod(String description, Consumer
24 | *
25 | * If you're not writing a custom DSL, use the {@link Specnaz} interface instead.
26 | *
27 | * @see SpecnazCoreDsl#specification
28 | */
29 | public interface SpecnazCoreDsl {
30 | /**
31 | * The analog of {@link Specnaz#describes} - defines the specification.
32 | *
33 | * @param description
34 | * the top-level description of the spec
35 | * @param specClosure
36 | * the callback that creates the specification
37 | */
38 | default void specification(String description, Consumer