skuzzle / snapshot-tests / 1

Committed 12 Feb 2025 03:38PM UTC coverage: 86.61% (+0.03%) from 86.577%

Build # 1

Build Type

Pull #109

jenkins

Committed by

skuzzle

Commit Message

Remove old file after merge

Pull Request Pull Request #109: 2.0 dev

Run Details

1947 of 2248 relevant lines covered (86.61%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.15

/../snapshot-tests-core/src/main/java/de/skuzzle/test/snapshots/impl/SnapshotDslResult.java

package de.skuzzle.test.snapshots.impl;

import java.io.IOException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;

import de.skuzzle.difftool.DiffRenderer;
import de.skuzzle.difftool.SplitDiffRenderer;
import de.skuzzle.difftool.UnifiedDiffRenderer;
import de.skuzzle.test.snapshots.ContextFiles;
import de.skuzzle.test.snapshots.SnapshotFile;
import de.skuzzle.test.snapshots.SnapshotFile.SnapshotHeader;
import de.skuzzle.test.snapshots.SnapshotNaming;
import de.skuzzle.test.snapshots.SnapshotSerializer;
import de.skuzzle.test.snapshots.SnapshotTestOptions;
import de.skuzzle.test.snapshots.SnapshotTestOptions.NormalizeLineEndings;
import de.skuzzle.test.snapshots.impl.SnapshotAssertionInput.TerminalOperation;
import de.skuzzle.test.snapshots.validation.Arguments;

/**
 * Aggregates the outcome of a single full DSL invocation. Encapsulates all information
 * that are required to perform a single snapshot assertion and provides the logic to
 * create a {@link SnapshotAssertionInput} object.
 * <p>
 * Some state within this class maybe shared with other assertions within the same test
 * method.
 *
 * @author Simon Taddiken
 */
final class SnapshotDslResult {

    // backup snapshot text that will be used in special case when assertions are disabled
    // and null input is given as actual object to snapshot.assertThat(...)
    private static final String UNAVAILABLE_BECAUSE_ACTUAL_WAS_NULL = "<<unavailable because actual was null>>";

    private final SnapshotConfiguration configuration;
    private final ResultRecorder resultRecorder;
    private final Method testMethod;
    private final SnapshotNaming namingStrategy;
    private final SnapshotSerializer snapshotSerializer;
    private final TerminalOperation operation;

    // Will be null if user decided to use default directory
    private final Path directoryOverride;
    private final Object actual;

    SnapshotDslResult(
            SnapshotConfiguration configuration,
            ResultRecorder resultRecorder,
            Method testMethod,
            SnapshotNaming namingStrategy,
            Object actual,
            TerminalOperation operation,
            SnapshotSerializer snapshotSerializer,
            Path directoryOverride) {

        this.configuration = Arguments.requireNonNull(configuration, "configuration must not be null");
        this.resultRecorder = Arguments.requireNonNull(resultRecorder, "resultRecorder must not be null");
        this.testMethod = Arguments.requireNonNull(testMethod, "testMethod must not be null");
        this.namingStrategy = Arguments.requireNonNull(namingStrategy, "namingStrategy must not be null");

        this.operation = Arguments.requireNonNull(operation, "operation must not be null");
        this.snapshotSerializer = Arguments.requireNonNull(snapshotSerializer, "snapshotSerializer must not be null");

        // only things that gracefully accept null
        this.directoryOverride = directoryOverride;
        this.actual = actual;
    }

    private SnapshotHeader determineNextSnapshotHeader(String snapshotName, int snapshotNumber) {
        return SnapshotHeader.fromMap(Map.of(
                SnapshotHeader.SNAPSHOT_NUMBER, "" + snapshotNumber,
                SnapshotHeader.TEST_METHOD, testMethod.getName(),
                SnapshotHeader.TEST_CLASS, configuration.testClass().getName(),
                SnapshotHeader.SNAPSHOT_NAME, snapshotName,
                SnapshotHeader.DYNAMIC_DIRECTORY, "" + (this.directoryOverride != null)));
    }

    private Path determineSnapshotDirectory() throws IOException {
        return this.directoryOverride != null
                ? this.directoryOverride
                : this.configuration.determineSnapshotDirectory();
    }

    private ContextFiles determineContextFiles(Path snapshotDirectory, String snapshotName) {
        final String snapshotFileName = InternalSnapshotNaming.getSnapshotFileName(snapshotName);
        final String actualFileName = InternalSnapshotNaming.getSnapshotFileNameActual(snapshotName);
        final String rawFileName = InternalSnapshotNaming.getSnapshotFileNameRaw(snapshotName);

        return ContextFiles.of(
                snapshotDirectory.resolve(snapshotFileName),
                snapshotDirectory.resolve(actualFileName),
                snapshotDirectory.resolve(rawFileName));
    }

    private DiffRenderer determineDiffRenderer(SnapshotTestOptions.DiffFormat diffFormat) {
        switch (diffFormat) {
        case UNIFIED:
            return UnifiedDiffRenderer.INSTANCE;
        case SPLIT:
            return SplitDiffRenderer.INSTANCE;
        }
        throw new IllegalStateException("Unhandled DiffFormat constant: " + diffFormat);
    }

    SnapshotAssertionInput createAssertionInput() throws Exception {
        final int snapshotNumber = resultRecorder.size();
        final Path snapshotDirectory = determineSnapshotDirectory();
        final String snapshotName = namingStrategy.determineSnapshotName(testMethod, snapshotNumber);
        final ContextFiles contextFilePaths = determineContextFiles(snapshotDirectory, snapshotName);

        final boolean disableAssertion = operation == TerminalOperation.DISABLE;
        final boolean forceUpdateSnapshots = configuration.isForceUpdateSnapshots(testMethod)
                || operation == TerminalOperation.FORCE_UPDATE;

        final boolean snapshotFileAlreadyExists = Files.exists(contextFilePaths.snapshotFile());
        final boolean alwaysPersistActualResult = configuration.alwaysPersistActualResult(testMethod);
        final boolean alwaysPersistRawResult = configuration.alwaysPersistRawResult(testMethod);
        final boolean persistActualResultOnFailure = configuration.persistActualResultOnFailure(testMethod);
        final boolean persistRawResultOnFailure = configuration.persistRawResultOnFailure(testMethod);

        final SnapshotHeader snapshotHeader = determineNextSnapshotHeader(snapshotName, snapshotNumber);

        final String serializedActual;
        final boolean actualWasNull = actual == null;
        if (actualWasNull) {
            serializedActual = UNAVAILABLE_BECAUSE_ACTUAL_WAS_NULL;
        } else {
            final NormalizeLineEndings normalizeLineEndings = configuration.normalizeLineEndings(
                    testMethod);
            final SnapshotSerializer normalizingSerializer = NormalizeLineEndingsSnapshotSerializer.wrap(
                    snapshotSerializer,
                    normalizeLineEndings);
            serializedActual = normalizingSerializer.serialize(actual);
        }
        final SnapshotFile actualSnapshotFile = SnapshotFile.of(snapshotHeader, serializedActual);

        final int lineNumberOffset = configuration.addOffsetToReportedLinenumbers(testMethod)
                ? snapshotHeader.lineNumberOffset()
                : 0;
        final int contextLines = configuration.textDiffContextLines(testMethod);
        final DiffRenderer diffRenderer = determineDiffRenderer(configuration.diffFormat(testMethod));

        return new SnapshotAssertionInput(
                snapshotName,
                contextFilePaths,
                actualSnapshotFile,
                actualWasNull,
                disableAssertion,
                forceUpdateSnapshots,
                snapshotFileAlreadyExists,
                alwaysPersistActualResult,
                alwaysPersistRawResult,
                persistActualResultOnFailure,
                persistRawResultOnFailure,
                lineNumberOffset,
                contextLines,
                diffRenderer);
    }
}

1	package de.skuzzle.test.snapshots.impl;
2
3	import java.io.IOException;
4	import java.lang.reflect.Method;
5	import java.nio.file.Files;
6	import java.nio.file.Path;
7	import java.util.Map;
8
9	import de.skuzzle.difftool.DiffRenderer;
10	import de.skuzzle.difftool.SplitDiffRenderer;
11	import de.skuzzle.difftool.UnifiedDiffRenderer;
12	import de.skuzzle.test.snapshots.ContextFiles;
13	import de.skuzzle.test.snapshots.SnapshotFile;
14	import de.skuzzle.test.snapshots.SnapshotFile.SnapshotHeader;
15	import de.skuzzle.test.snapshots.SnapshotNaming;
16	import de.skuzzle.test.snapshots.SnapshotSerializer;
17	import de.skuzzle.test.snapshots.SnapshotTestOptions;
18	import de.skuzzle.test.snapshots.SnapshotTestOptions.NormalizeLineEndings;
19	import de.skuzzle.test.snapshots.impl.SnapshotAssertionInput.TerminalOperation;
20	import de.skuzzle.test.snapshots.validation.Arguments;
21
22	/**
23	* Aggregates the outcome of a single full DSL invocation. Encapsulates all information
24	* that are required to perform a single snapshot assertion and provides the logic to
25	* create a {@link SnapshotAssertionInput} object.
26	* <p>
27	* Some state within this class maybe shared with other assertions within the same test
28	* method.
29	*
30	* @author Simon Taddiken
31	*/
32	final class SnapshotDslResult {
33
34	// backup snapshot text that will be used in special case when assertions are disabled
35	// and null input is given as actual object to snapshot.assertThat(...)
36	private static final String UNAVAILABLE_BECAUSE_ACTUAL_WAS_NULL = "<<unavailable because actual was null>>";
37
38	private final SnapshotConfiguration configuration;
39	private final ResultRecorder resultRecorder;
40	private final Method testMethod;
41	private final SnapshotNaming namingStrategy;
42	private final SnapshotSerializer snapshotSerializer;
43	private final TerminalOperation operation;
44
45	// Will be null if user decided to use default directory
46	private final Path directoryOverride;
47	private final Object actual;
48
49	SnapshotDslResult(
50	SnapshotConfiguration configuration,
51	ResultRecorder resultRecorder,
52	Method testMethod,
53	SnapshotNaming namingStrategy,
54	Object actual,
55	TerminalOperation operation,
56	SnapshotSerializer snapshotSerializer,
57	Path directoryOverride) {	1✔
58
59	this.configuration = Arguments.requireNonNull(configuration, "configuration must not be null");	1✔
60	this.resultRecorder = Arguments.requireNonNull(resultRecorder, "resultRecorder must not be null");	1✔
61	this.testMethod = Arguments.requireNonNull(testMethod, "testMethod must not be null");	1✔
62	this.namingStrategy = Arguments.requireNonNull(namingStrategy, "namingStrategy must not be null");	1✔
63
64	this.operation = Arguments.requireNonNull(operation, "operation must not be null");	1✔
65	this.snapshotSerializer = Arguments.requireNonNull(snapshotSerializer, "snapshotSerializer must not be null");	1✔
66
67	// only things that gracefully accept null
68	this.directoryOverride = directoryOverride;	1✔
69	this.actual = actual;	1✔
70	}	1✔
71
72	private SnapshotHeader determineNextSnapshotHeader(String snapshotName, int snapshotNumber) {
73	return SnapshotHeader.fromMap(Map.of(	1✔
74	SnapshotHeader.SNAPSHOT_NUMBER, "" + snapshotNumber,
75	SnapshotHeader.TEST_METHOD, testMethod.getName(),	1✔
76	SnapshotHeader.TEST_CLASS, configuration.testClass().getName(),	1✔
77	SnapshotHeader.SNAPSHOT_NAME, snapshotName,
78	SnapshotHeader.DYNAMIC_DIRECTORY, "" + (this.directoryOverride != null)));
79	}
80
81	private Path determineSnapshotDirectory() throws IOException {
82	return this.directoryOverride != null	1✔
83	? this.directoryOverride	1✔
84	: this.configuration.determineSnapshotDirectory();	1✔
85	}
86
87	private ContextFiles determineContextFiles(Path snapshotDirectory, String snapshotName) {
88	final String snapshotFileName = InternalSnapshotNaming.getSnapshotFileName(snapshotName);	1✔
89	final String actualFileName = InternalSnapshotNaming.getSnapshotFileNameActual(snapshotName);	1✔
90	final String rawFileName = InternalSnapshotNaming.getSnapshotFileNameRaw(snapshotName);	1✔
91
92	return ContextFiles.of(	1✔
93	snapshotDirectory.resolve(snapshotFileName),	1✔
94	snapshotDirectory.resolve(actualFileName),	1✔
95	snapshotDirectory.resolve(rawFileName));	1✔
96	}
97
98	private DiffRenderer determineDiffRenderer(SnapshotTestOptions.DiffFormat diffFormat) {
99	switch (diffFormat) {	1✔
100	case UNIFIED:
101	return UnifiedDiffRenderer.INSTANCE;	1✔
102	case SPLIT:
103	return SplitDiffRenderer.INSTANCE;	×
104	}
105	throw new IllegalStateException("Unhandled DiffFormat constant: " + diffFormat);	×
106	}
107
108	SnapshotAssertionInput createAssertionInput() throws Exception {
109	final int snapshotNumber = resultRecorder.size();	1✔
110	final Path snapshotDirectory = determineSnapshotDirectory();	1✔
111	final String snapshotName = namingStrategy.determineSnapshotName(testMethod, snapshotNumber);	1✔
112	final ContextFiles contextFilePaths = determineContextFiles(snapshotDirectory, snapshotName);	1✔
113
114	final boolean disableAssertion = operation == TerminalOperation.DISABLE;	1✔
115	final boolean forceUpdateSnapshots = configuration.isForceUpdateSnapshots(testMethod)	1✔
116	\|\| operation == TerminalOperation.FORCE_UPDATE;
117
118	final boolean snapshotFileAlreadyExists = Files.exists(contextFilePaths.snapshotFile());	1✔
119	final boolean alwaysPersistActualResult = configuration.alwaysPersistActualResult(testMethod);	1✔
120	final boolean alwaysPersistRawResult = configuration.alwaysPersistRawResult(testMethod);	1✔
121	final boolean persistActualResultOnFailure = configuration.persistActualResultOnFailure(testMethod);	1✔
122	final boolean persistRawResultOnFailure = configuration.persistRawResultOnFailure(testMethod);	1✔
123
124	final SnapshotHeader snapshotHeader = determineNextSnapshotHeader(snapshotName, snapshotNumber);	1✔
125
126	final String serializedActual;
127	final boolean actualWasNull = actual == null;	1✔
128	if (actualWasNull) {	1✔
129	serializedActual = UNAVAILABLE_BECAUSE_ACTUAL_WAS_NULL;	1✔
130	} else {
131	final NormalizeLineEndings normalizeLineEndings = configuration.normalizeLineEndings(	1✔
132	testMethod);
133	final SnapshotSerializer normalizingSerializer = NormalizeLineEndingsSnapshotSerializer.wrap(	1✔
134	snapshotSerializer,
135	normalizeLineEndings);
136	serializedActual = normalizingSerializer.serialize(actual);	1✔
137	}
138	final SnapshotFile actualSnapshotFile = SnapshotFile.of(snapshotHeader, serializedActual);	1✔
139
140	final int lineNumberOffset = configuration.addOffsetToReportedLinenumbers(testMethod)	1✔
141	? snapshotHeader.lineNumberOffset()	1✔
142	: 0;	1✔
143	final int contextLines = configuration.textDiffContextLines(testMethod);	1✔
144	final DiffRenderer diffRenderer = determineDiffRenderer(configuration.diffFormat(testMethod));	1✔
145
146	return new SnapshotAssertionInput(	1✔
147	snapshotName,
148	contextFilePaths,
149	actualSnapshotFile,
150	actualWasNull,
151	disableAssertion,
152	forceUpdateSnapshots,
153	snapshotFileAlreadyExists,
154	alwaysPersistActualResult,
155	alwaysPersistRawResult,
156	persistActualResultOnFailure,
157	persistRawResultOnFailure,
158	lineNumberOffset,
159	contextLines,
160	diffRenderer);
161	}
162	}

skuzzle / snapshot-tests / 1

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous