DongHyeonkaandClaude Opus 5
b2963105a8
The keycloak project ended with four open questions that design could not
settle. A two-VM lab was built to answer them by measurement, and this is
that material: 26 experiments, 125 raw command outputs, 22 browser captures.
Follows the import procedure in README.md.
source/ the originating repository verbatim — 78 documents, 28 SVGs,
8 manifests, plus .source-revision recording the commit
final/ the SSOT
document.md 729 lines written from the 29 experiment documents, not
concatenated: what was predicted, what was measured, and
where the measurement itself was wrong
evidence/raw 125 outputs, flattened to <experiment>__<file> because
the originals collided (01-baseline.txt appeared three
times) and the audit only globs the top level
evidence/meta one per raw file; command and exitCode are null and the
README says why rather than inventing them
evidence/browser 22 captures
assets/ three diagrams through techviz
.techviz/ their VizSpecs
A separate project rather than an addition to keycloak: the B-layer answers
that project's four questions, but the A, C and D layers are about cluster
failure, SSO and operations, and one document.md should hold one subject.
The four question records there can point here through 관계.
Recorded rather than papered over: only three of the 28 diagrams were
remade. The repository forbids hand-drawn SVG and forbids titles inside the
canvas; all 28 originals carry both, so converting them is redrawing, not
reformatting. They stay in source/ and the gap is written into the document.
verify-pipeline.py passes. audit-records.py reports no issues.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
289 lines
23 KiB
Plaintext
289 lines
23 KiB
Plaintext
# 이 실패를 위한 어휘
|
|
MongoFailureCategory.java:3 /**
|
|
MongoFailureCategory.java:4 * Stable parent category of a failure (design §15).
|
|
MongoFailureCategory.java:5 *
|
|
MongoFailureCategory.java:6 * <p>Server codes and driver error labels change between releases; this category does not. It is
|
|
MongoFailureCategory.java:7 * the value that appears in metrics and dashboards, which is why an unrecognised server code maps
|
|
MongoFailureCategory.java:8 * to {@link #UNCLASSIFIED} rather than inventing a new category at runtime and blowing up metric
|
|
MongoFailureCategory.java:9 * cardinality.
|
|
MongoFailureCategory.java:10 */
|
|
MongoFailureCategory.java:63
|
|
MongoFailureCategory.java:64 /** The platform refused the operation locally before contacting a server. */
|
|
MongoFailureCategory.java:65 OPERATION_REJECTED,
|
|
MongoFailureCategory.java:66
|
|
MongoFailureCategory.java:67 /** The stored document's schema version is outside the supported range. */
|
|
MongoFailureCategory.java:68 SCHEMA_VERSION_UNSUPPORTED,
|
|
MongoFailureCategory.java:69
|
|
MongoFailureCategory.java:70 /** A recognised failure with no more specific stable category. */
|
|
MongoFailureCategory.java:71 UNCLASSIFIED
|
|
MongoFailureCategory.java:72 }
|
|
|
|
MongoDataSchemaUnsupportedException.java:5 /**
|
|
MongoDataSchemaUnsupportedException.java:6 * A stored document's schema version is outside the supported range (design §12.2).
|
|
MongoDataSchemaUnsupportedException.java:7 *
|
|
MongoDataSchemaUnsupportedException.java:8 * <p>Raised before domain deserialization, which is the whole value: a document written by a newer
|
|
MongoDataSchemaUnsupportedException.java:9 * release, or one left behind by a retired version, must not be silently coerced into the current
|
|
MongoDataSchemaUnsupportedException.java:10 * shape. Versions are integers and carry no data, so both are safe to name in the message.
|
|
MongoDataSchemaUnsupportedException.java:11 */
|
|
MongoDataSchemaUnsupportedException.java:12 public final class MongoDataSchemaUnsupportedException extends MongoPersistenceException {
|
|
MongoDataSchemaUnsupportedException.java:13
|
|
MongoDataSchemaUnsupportedException.java:14 @Serial private static final long serialVersionUID = 1L;
|
|
MongoDataSchemaUnsupportedException.java:15
|
|
MongoDataSchemaUnsupportedException.java:16 private final int documentVersion;
|
|
MongoDataSchemaUnsupportedException.java:17
|
|
MongoDataSchemaUnsupportedException.java:18 private final int minimumSupported;
|
|
MongoDataSchemaUnsupportedException.java:19
|
|
MongoDataSchemaUnsupportedException.java:20 private final int currentVersion;
|
|
MongoDataSchemaUnsupportedException.java:21
|
|
MongoDataSchemaUnsupportedException.java:22 public MongoDataSchemaUnsupportedException(
|
|
MongoDataSchemaUnsupportedException.java:23 MongoFailureContext failureContext,
|
|
MongoDataSchemaUnsupportedException.java:24 int documentVersion,
|
|
MongoDataSchemaUnsupportedException.java:25 int minimumSupported,
|
|
MongoDataSchemaUnsupportedException.java:26 int currentVersion) {
|
|
MongoDataSchemaUnsupportedException.java:27 super(
|
|
MongoDataSchemaUnsupportedException.java:28 "stored schema version "
|
|
MongoDataSchemaUnsupportedException.java:29 + documentVersion
|
|
MongoDataSchemaUnsupportedException.java:30 + " is outside the supported range ["
|
|
MongoDataSchemaUnsupportedException.java:31 + minimumSupported
|
|
MongoDataSchemaUnsupportedException.java:32 + ", "
|
|
MongoDataSchemaUnsupportedException.java:33 + currentVersion
|
|
MongoDataSchemaUnsupportedException.java:34 + "]",
|
|
MongoDataSchemaUnsupportedException.java:35 failureContext);
|
|
MongoDataSchemaUnsupportedException.java:36 this.documentVersion = documentVersion;
|
|
MongoDataSchemaUnsupportedException.java:37 this.minimumSupported = minimumSupported;
|
|
MongoDataSchemaUnsupportedException.java:38 this.currentVersion = currentVersion;
|
|
MongoDataSchemaUnsupportedException.java:39 }
|
|
MongoDataSchemaUnsupportedException.java:40
|
|
MongoDataSchemaUnsupportedException.java:41 /** The version found on the stored document. */
|
|
MongoDataSchemaUnsupportedException.java:42 public int documentVersion() {
|
|
MongoDataSchemaUnsupportedException.java:43 return documentVersion;
|
|
MongoDataSchemaUnsupportedException.java:44 }
|
|
MongoDataSchemaUnsupportedException.java:45
|
|
MongoDataSchemaUnsupportedException.java:46 /** The oldest version this release can still read. */
|
|
MongoDataSchemaUnsupportedException.java:47 public int minimumSupported() {
|
|
MongoDataSchemaUnsupportedException.java:48 return minimumSupported;
|
|
MongoDataSchemaUnsupportedException.java:49 }
|
|
MongoDataSchemaUnsupportedException.java:50
|
|
MongoDataSchemaUnsupportedException.java:51 /** The version this release writes. */
|
|
MongoDataSchemaUnsupportedException.java:52 public int currentVersion() {
|
|
MongoDataSchemaUnsupportedException.java:53 return currentVersion;
|
|
MongoDataSchemaUnsupportedException.java:54 }
|
|
|
|
# 프로덕션 생성 지점 전수
|
|
MongoSchemaVersionPolicy.java:85 return new MongoDataSchemaUnsupportedException(
|
|
DefaultMongoFailureTranslator.java:111 new MongoDataSchemaUnsupportedException(failureContext, -1, -1, -1);
|
|
|
|
# 버전을 아는 쪽
|
|
MongoSchemaVersionPolicy.java:82 private MongoDataSchemaUnsupportedException unsupported(DocumentSchemaVersion version) {
|
|
MongoSchemaVersionPolicy.java:83 MongoFailureContext context =
|
|
MongoSchemaVersionPolicy.java:84 MongoFailureContext.rejected(new MongoOperationName("schema.version-check"));
|
|
MongoSchemaVersionPolicy.java:85 return new MongoDataSchemaUnsupportedException(
|
|
MongoSchemaVersionPolicy.java:86 context, version.value(), range.minimumSupported().value(), range.current().value());
|
|
MongoSchemaVersionPolicy.java:87 }
|
|
그 context 가 무엇을 담는가 :
|
|
MongoFailureContext.java:135 public static MongoFailureContext rejected(MongoOperationName operationName) {
|
|
MongoFailureContext.java:136 return new MongoFailureContext(
|
|
MongoFailureContext.java:137 MongoOperationScope.ofOperation(operationName),
|
|
MongoFailureContext.java:138 MongoOperationType.UNKNOWN,
|
|
MongoFailureContext.java:139 MongoConsistencyProfile.PRIMARY_LOCAL,
|
|
MongoFailureContext.java:140 MongoFailureCategory.OPERATION_REJECTED,
|
|
MongoFailureContext.java:141 MongoExecutionOutcome.NOT_SENT,
|
|
MongoFailureContext.java:142 false,
|
|
MongoFailureContext.java:143 false,
|
|
MongoFailureContext.java:144 Set.of(),
|
|
MongoFailureContext.java:145 "",
|
|
MongoFailureContext.java:146 1,
|
|
MongoFailureContext.java:147 Duration.ZERO,
|
|
MongoFailureContext.java:148 "");
|
|
MongoFailureContext.java:149 }
|
|
|
|
# 전용 category 를 붙이는 쪽
|
|
DefaultMongoFailureTranslator.java:88 elapsed,
|
|
DefaultMongoFailureTranslator.java:89 "");
|
|
DefaultMongoFailureTranslator.java:90
|
|
DefaultMongoFailureTranslator.java:91 return switch (classification.category()) {
|
|
DefaultMongoFailureTranslator.java:92 case DUPLICATE_KEY -> new MongoDuplicateKeyException(failureContext);
|
|
DefaultMongoFailureTranslator.java:93 case SCHEMA_VALIDATION -> new MongoSchemaValidationException(failureContext);
|
|
DefaultMongoFailureTranslator.java:94 case OPTIMISTIC_CONFLICT -> new MongoOptimisticConflictException(failureContext);
|
|
DefaultMongoFailureTranslator.java:95 case WRITE_CONFLICT -> new MongoWriteConflictException(failureContext);
|
|
DefaultMongoFailureTranslator.java:96 case TRANSACTION_TRANSIENT -> new MongoTransactionTransientException(failureContext);
|
|
DefaultMongoFailureTranslator.java:97 case TRANSACTION_COMMIT_UNKNOWN ->
|
|
DefaultMongoFailureTranslator.java:98 new MongoTransactionCommitUnknownException(
|
|
DefaultMongoFailureTranslator.java:99 failureContext, "read the transaction record, version or idempotency key");
|
|
DefaultMongoFailureTranslator.java:100 case WRITE_CONCERN -> new MongoWriteConcernException(failureContext);
|
|
DefaultMongoFailureTranslator.java:101 case READ_CONCERN -> new MongoReadConcernException(failureContext);
|
|
DefaultMongoFailureTranslator.java:102 case SERVER_SELECTION -> new MongoServerSelectionException(failureContext);
|
|
DefaultMongoFailureTranslator.java:103 case CONNECTION -> new MongoConnectionException(failureContext);
|
|
DefaultMongoFailureTranslator.java:104 case TIMEOUT -> new MongoTimeoutException(failureContext);
|
|
DefaultMongoFailureTranslator.java:105 case CURSOR -> new MongoCursorException(failureContext);
|
|
DefaultMongoFailureTranslator.java:106 case DOCUMENT_TOO_LARGE -> new MongoDocumentTooLargeException(failureContext, -1L, -1L);
|
|
DefaultMongoFailureTranslator.java:107 case SHARD_ROUTING -> new MongoShardRoutingException(failureContext);
|
|
DefaultMongoFailureTranslator.java:108 case RESUME -> new MongoResumeException(failureContext);
|
|
DefaultMongoFailureTranslator.java:109 case ENCRYPTION -> new MongoEncryptionException(failureContext);
|
|
DefaultMongoFailureTranslator.java:110 case SCHEMA_VERSION_UNSUPPORTED ->
|
|
DefaultMongoFailureTranslator.java:111 new MongoDataSchemaUnsupportedException(failureContext, -1, -1, -1);
|
|
DefaultMongoFailureTranslator.java:112 // Bulk partial failure and local rejection are raised by the layers that own their detail —
|
|
DefaultMongoFailureTranslator.java:113 // per-item results and the guardrail that refused — so a failure that reaches translation
|
|
DefaultMongoFailureTranslator.java:114 // carrying either category is one this release does not recognise.
|
|
DefaultMongoFailureTranslator.java:115 case BULK_PARTIAL_FAILURE, OPERATION_REJECTED, UNCLASSIFIED ->
|
|
DefaultMongoFailureTranslator.java:116 new MongoUnclassifiedFailureException(failureContext);
|
|
DefaultMongoFailureTranslator.java:117 };
|
|
DefaultMongoFailureTranslator.java:118 }
|
|
|
|
# 그 case 에 도달할 수 있는가
|
|
SCHEMA_VERSION_UNSUPPORTED 가 저장소 전체에 나오는 줄 : 2 개
|
|
MongoFailureCategory.java:68 SCHEMA_VERSION_UNSUPPORTED,
|
|
DefaultMongoFailureTranslator.java:110 case SCHEMA_VERSION_UNSUPPORTED ->
|
|
[대조] OPERATION_REJECTED 는 : 4 개
|
|
분류기가 category 를 정하는 자리 전부 :
|
|
DefaultMongoFailureClassifier.java:24 /** Server codes whose meaning the platform maps to a stable category. */
|
|
DefaultMongoFailureClassifier.java:25 private static final Map<Integer, MongoFailureCategory> CATEGORY_BY_CODE =
|
|
DefaultMongoFailureClassifier.java:26 Map.ofEntries(
|
|
DefaultMongoFailureClassifier.java:27 Map.entry(11000, MongoFailureCategory.DUPLICATE_KEY),
|
|
DefaultMongoFailureClassifier.java:28 Map.entry(11001, MongoFailureCategory.DUPLICATE_KEY),
|
|
DefaultMongoFailureClassifier.java:29 Map.entry(12582, MongoFailureCategory.DUPLICATE_KEY),
|
|
DefaultMongoFailureClassifier.java:30 Map.entry(121, MongoFailureCategory.SCHEMA_VALIDATION),
|
|
DefaultMongoFailureClassifier.java:31 Map.entry(112, MongoFailureCategory.WRITE_CONFLICT),
|
|
DefaultMongoFailureClassifier.java:32 Map.entry(64, MongoFailureCategory.WRITE_CONCERN),
|
|
DefaultMongoFailureClassifier.java:33 Map.entry(79, MongoFailureCategory.WRITE_CONCERN),
|
|
DefaultMongoFailureClassifier.java:34 Map.entry(100, MongoFailureCategory.WRITE_CONCERN),
|
|
DefaultMongoFailureClassifier.java:35 Map.entry(148, MongoFailureCategory.READ_CONCERN),
|
|
DefaultMongoFailureClassifier.java:36 Map.entry(246, MongoFailureCategory.READ_CONCERN),
|
|
DefaultMongoFailureClassifier.java:37 Map.entry(133, MongoFailureCategory.SERVER_SELECTION),
|
|
DefaultMongoFailureClassifier.java:38 Map.entry(6, MongoFailureCategory.CONNECTION),
|
|
DefaultMongoFailureClassifier.java:39 Map.entry(7, MongoFailureCategory.CONNECTION),
|
|
DefaultMongoFailureClassifier.java:40 Map.entry(9001, MongoFailureCategory.CONNECTION),
|
|
DefaultMongoFailureClassifier.java:41 Map.entry(89, MongoFailureCategory.TIMEOUT),
|
|
DefaultMongoFailureClassifier.java:42 Map.entry(50, MongoFailureCategory.TIMEOUT),
|
|
DefaultMongoFailureClassifier.java:43 Map.entry(262, MongoFailureCategory.TIMEOUT),
|
|
DefaultMongoFailureClassifier.java:44 Map.entry(43, MongoFailureCategory.CURSOR),
|
|
DefaultMongoFailureClassifier.java:45 Map.entry(237, MongoFailureCategory.CURSOR),
|
|
DefaultMongoFailureClassifier.java:46 Map.entry(10334, MongoFailureCategory.DOCUMENT_TOO_LARGE),
|
|
DefaultMongoFailureClassifier.java:47 Map.entry(17420, MongoFailureCategory.DOCUMENT_TOO_LARGE),
|
|
DefaultMongoFailureClassifier.java:48 Map.entry(63, MongoFailureCategory.SHARD_ROUTING),
|
|
DefaultMongoFailureClassifier.java:49 Map.entry(13388, MongoFailureCategory.SHARD_ROUTING),
|
|
DefaultMongoFailureClassifier.java:50 Map.entry(286, MongoFailureCategory.RESUME),
|
|
DefaultMongoFailureClassifier.java:51 Map.entry(280, MongoFailureCategory.RESUME),
|
|
DefaultMongoFailureClassifier.java:52 Map.entry(31, MongoFailureCategory.ENCRYPTION));
|
|
|
|
DefaultMongoFailureClassifier.java:86 // Labels first: the server's own recoverability statement outranks any code table, and these
|
|
DefaultMongoFailureClassifier.java:87 // two labels are the ones whose correct responses are opposite.
|
|
DefaultMongoFailureClassifier.java:88 if (failure.hasLabel(MongoDriverFailureView.UNKNOWN_TRANSACTION_COMMIT_RESULT)) {
|
|
DefaultMongoFailureClassifier.java:89 return MongoFailureClassification.commitUnknown();
|
|
DefaultMongoFailureClassifier.java:90 }
|
|
DefaultMongoFailureClassifier.java:91 if (failure.hasLabel(MongoDriverFailureView.TRANSIENT_TRANSACTION_ERROR)) {
|
|
DefaultMongoFailureClassifier.java:92 return MongoFailureClassification.transientTransaction();
|
|
DefaultMongoFailureClassifier.java:93 }
|
|
DefaultMongoFailureClassifier.java:94 if (failure.hasLabel(MongoDriverFailureView.NO_WRITES_PERFORMED)) {
|
|
DefaultMongoFailureClassifier.java:95 return new MongoFailureClassification(
|
|
DefaultMongoFailureClassifier.java:96 categoryOf(failure), MongoExecutionOutcome.NO_WRITE_PERFORMED, MongoRetryScope.NONE);
|
|
DefaultMongoFailureClassifier.java:97 }
|
|
DefaultMongoFailureClassifier.java:98
|
|
DefaultMongoFailureClassifier.java:99 MongoFailureCategory category = categoryOf(failure);
|
|
DefaultMongoFailureClassifier.java:100
|
|
DefaultMongoFailureClassifier.java:101 if (phase != null) {
|
|
DefaultMongoFailureClassifier.java:102 if (phase.nothingWasSent()) {
|
|
DefaultMongoFailureClassifier.java:103 // Nothing reached a server, so nothing was applied. A server-selection timeout carries no
|
|
DefaultMongoFailureClassifier.java:104 // label and often no code, and used to land in UNCLASSIFIED and be treated as terminal —
|
|
DefaultMongoFailureClassifier.java:105 // the one case where retrying is unambiguously safe.
|
|
DefaultMongoFailureClassifier.java:106 return MongoFailureClassification.retryableOperation(
|
|
DefaultMongoFailureClassifier.java:107 category == MongoFailureCategory.UNCLASSIFIED
|
|
DefaultMongoFailureClassifier.java:108 ? MongoFailureCategory.SERVER_SELECTION
|
|
DefaultMongoFailureClassifier.java:109 : category);
|
|
DefaultMongoFailureClassifier.java:110 }
|
|
DefaultMongoFailureClassifier.java:111 if (phase == MongoFailurePhase.TRANSACTION_COMMIT && failure.outcomeIsUnknown()) {
|
|
DefaultMongoFailureClassifier.java:112 return MongoFailureClassification.commitUnknown();
|
|
DefaultMongoFailureClassifier.java:113 }
|
|
DefaultMongoFailureClassifier.java:114 if (phase == MongoFailurePhase.TRANSACTION_BODY && failure.outcomeIsUnknown()) {
|
|
DefaultMongoFailureClassifier.java:115 // The body has not committed, so replaying the whole transaction is the correct scope —
|
|
DefaultMongoFailureClassifier.java:116 // and the correct scope is exactly what an ambiguous-write verdict would have denied.
|
|
DefaultMongoFailureClassifier.java:117 return MongoFailureClassification.transientTransaction();
|
|
DefaultMongoFailureClassifier.java:118 }
|
|
DefaultMongoFailureClassifier.java:119 if (operationType != null && isRead(operationType) && !isDefinitelyUnapplied(failure)) {
|
|
DefaultMongoFailureClassifier.java:120 // A read that failed changed nothing whatever phase it was in. Reporting it as an
|
|
|
|
DefaultMongoFailureClassifier.java:150 private static MongoFailureCategory categoryOf(MongoDriverFailureView failure) {
|
|
DefaultMongoFailureClassifier.java:151 if (!failure.hasServerCode()) {
|
|
DefaultMongoFailureClassifier.java:152 return failure.hasLabel(MongoDriverFailureView.RETRYABLE_WRITE_ERROR)
|
|
DefaultMongoFailureClassifier.java:153 ? MongoFailureCategory.CONNECTION
|
|
DefaultMongoFailureClassifier.java:154 : MongoFailureCategory.UNCLASSIFIED;
|
|
DefaultMongoFailureClassifier.java:155 }
|
|
DefaultMongoFailureClassifier.java:156 return CATEGORY_BY_CODE.getOrDefault(failure.serverCode(), MongoFailureCategory.UNCLASSIFIED);
|
|
DefaultMongoFailureClassifier.java:157 }
|
|
[대조] 같은 정규식을 MongoFailureContextTest 에 걸면 : 1 개
|
|
|
|
# 이 모듈에서 살아 있는 다른 스키마 실패 경로
|
|
MongoFailureContext.java:151 /**
|
|
MongoFailureContext.java:152 * A stored document that does not match the schema this release expects.
|
|
MongoFailureContext.java:153 *
|
|
MongoFailureContext.java:154 * <p>Nothing was written, so the outcome is {@code NO_WRITE_PERFORMED} rather than {@code
|
|
MongoFailureContext.java:155 * NOT_SENT}: the read did reach the server, and what came back is unusable.
|
|
MongoFailureContext.java:156 */
|
|
MongoFailureContext.java:157 public static MongoFailureContext schemaMismatch(MongoOperationName operationName) {
|
|
MongoFailureContext.java:158 return new MongoFailureContext(
|
|
MongoFailureContext.java:159 MongoOperationScope.ofOperation(operationName),
|
|
MongoFailureContext.java:160 MongoOperationType.FIND,
|
|
MongoFailureContext.java:161 MongoConsistencyProfile.PRIMARY_LOCAL,
|
|
MongoFailureContext.java:162 MongoFailureCategory.SCHEMA_VALIDATION,
|
|
MongoFailureContext.java:163 MongoExecutionOutcome.NO_WRITE_PERFORMED,
|
|
MongoFailureContext.java:164 false,
|
|
MongoFailureContext.java:165 false,
|
|
MongoFailureContext.java:166 Set.of(),
|
|
MongoFailureContext.java:167 "",
|
|
MongoFailureContext.java:168 1,
|
|
MongoFailureContext.java:169 Duration.ZERO,
|
|
MongoFailureContext.java:170 "");
|
|
MongoFailureContext.java:171 }
|
|
MongoFailureContext.java:172
|
|
그 팩터리를 부르는 자리 :
|
|
MongoFailureContext.java:157 public static MongoFailureContext schemaMismatch(MongoOperationName operationName) {
|
|
PolicyAwareMongoTypeMapper.java:112 dev.caskeleton.adapter.outbound.mongo.api.error.MongoFailureContext.schemaMismatch(
|
|
PolicyAwareMongoTypeMapper.java:185 MongoFailureContext.schemaMismatch(READ_OPERATION)));
|
|
PolicyAwareMongoTypeMapper.java:192 throw new MongoSchemaValidationException(MongoFailureContext.schemaMismatch(READ_OPERATION));
|
|
|
|
# 두 생성 지점이 조립되는가
|
|
new MongoSchemaVersionPolicy 를 부르는 main 줄 : 0 개
|
|
그 타입이 main 에 나오는 자리 전부 :
|
|
MongoSchemaVersionPolicy.java:17 public final class MongoSchemaVersionPolicy {
|
|
MongoSchemaVersionPolicy.java:22 public MongoSchemaVersionPolicy(
|
|
MongoSchemaVersionPolicy.java:29 public MongoSchemaVersionPolicy(MongoSchemaVersionRange range, boolean legacyReadsEnabled) {
|
|
[대조] new MongoSchemaVersionPolicy 를 부르는 시험 줄 : 6 개
|
|
DefaultMongoFailureTranslator 를 빈으로 만드는 main 줄 : 2 개
|
|
MongoPlatformAutoConfiguration.java:93 return new DefaultMongoFailureTranslator(classifier);
|
|
DefaultMongoFailureTranslator.java:47 return new DefaultMongoFailureTranslator(new DefaultMongoFailureClassifier());
|
|
|
|
# 같은 모양이 하나 더
|
|
MongoDocumentTooLargeException.java:26 }
|
|
MongoDocumentTooLargeException.java:27
|
|
MongoDocumentTooLargeException.java:28 /** Estimated serialized size. A size, not content: safe to log. */
|
|
MongoDocumentTooLargeException.java:29 public long estimatedBytes() {
|
|
MongoDocumentTooLargeException.java:30 return estimatedBytes;
|
|
MongoDocumentTooLargeException.java:31 }
|
|
MongoDocumentTooLargeException.java:32
|
|
MongoDocumentTooLargeException.java:33 /** The configured ceiling that was exceeded. */
|
|
MongoDocumentTooLargeException.java:34 public long budgetBytes() {
|
|
MongoDocumentTooLargeException.java:35 return budgetBytes;
|
|
MongoDocumentTooLargeException.java:36 }
|
|
|
|
# 그 정책을 검사하는 시험이 무엇을 단언하는가
|
|
MongoSchemaVersionPolicyTest.java:4 import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|
MongoSchemaVersionPolicyTest.java:15 void rejectsFutureVersion() {
|
|
MongoSchemaVersionPolicyTest.java:20 assertThatThrownBy(() -> policy.requireReadable(new DocumentSchemaVersion(5)))
|
|
MongoSchemaVersionPolicyTest.java:21 .isInstanceOf(MongoDataSchemaUnsupportedException.class);
|
|
MongoSchemaVersionPolicyTest.java:25 void rejectsRetiredVersion() {
|
|
MongoSchemaVersionPolicyTest.java:30 assertThatThrownBy(() -> policy.requireReadable(new DocumentSchemaVersion(1)))
|
|
MongoSchemaVersionPolicyTest.java:31 .isInstanceOf(MongoDataSchemaUnsupportedException.class);
|
|
MongoSchemaVersionPolicyTest.java:35 void missingVersionIsLegacyOnlyWhenTheCollectionAllowsIt() {
|
|
MongoSchemaVersionPolicyTest.java:43 assertThat(permissive.resolveMissingVersion()).isEqualTo(DocumentSchemaVersion.LEGACY_V0);
|
|
MongoSchemaVersionPolicyTest.java:44 assertThatThrownBy(strict::resolveMissingVersion)
|
|
MongoSchemaVersionPolicyTest.java:45 .isInstanceOf(MongoDataSchemaUnsupportedException.class);
|
|
MongoSchemaVersionPolicyTest.java:49 void newWritesAlwaysUseTheCurrentVersion() {
|
|
MongoSchemaVersionPolicyTest.java:54 assertThat(policy.writeVersion()).isEqualTo(new DocumentSchemaVersion(4));
|
|
MongoSchemaVersionPolicyTest.java:58 void readingAnOlderSupportedVersionIsAMeteredConversion() {
|
|
MongoSchemaVersionPolicyTest.java:63 assertThat(policy.requiresReadTimeConversion(new DocumentSchemaVersion(3))).isTrue();
|
|
MongoSchemaVersionPolicyTest.java:64 assertThat(policy.requiresReadTimeConversion(new DocumentSchemaVersion(4))).isFalse();
|
|
MongoSchemaVersionPolicyTest.java:68 void aNegativeVersionIsNotAVersion() {
|
|
MongoSchemaVersionPolicyTest.java:69 assertThatThrownBy(() -> new DocumentSchemaVersion(-1))
|
|
MongoSchemaVersionPolicyTest.java:70 .isInstanceOf(IllegalArgumentException.class);
|
|
그 시험이 category 나 세 버전 값을 단언하는 줄 : 0 개
|