From 229c7d09221031ac6327e150ec4444da701f7a72 Mon Sep 17 00:00:00 2001 From: Alan Wang Date: Fri, 16 Jan 2026 14:31:16 -0800 Subject: [PATCH 1/3] added guardrail for when no serial consistency level is specified by user --- conf/cassandra.yaml | 4 + .../org/apache/cassandra/config/Config.java | 2 + .../cassandra/config/GuardrailsOptions.java | 28 ++++ .../cassandra/cql3/BatchQueryOptions.java | 5 + .../apache/cassandra/cql3/QueryOptions.java | 26 +++- .../cql3/statements/BatchStatement.java | 2 + .../statements/ModificationStatement.java | 2 + .../cassandra/db/guardrails/Guardrails.java | 34 +++++ .../db/guardrails/GuardrailsConfig.java | 12 ++ .../db/guardrails/GuardrailsMBean.java | 22 +++ ...lWhenSerialConsistencyNotProvidedTest.java | 138 ++++++++++++++++++ 11 files changed, 267 insertions(+), 8 deletions(-) create mode 100644 test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java diff --git a/conf/cassandra.yaml b/conf/cassandra.yaml index b207ff289b9b..32cbc5fa25c5 100644 --- a/conf/cassandra.yaml +++ b/conf/cassandra.yaml @@ -2348,6 +2348,10 @@ drop_compact_storage_enabled: false # write_consistency_levels_warned: [] # write_consistency_levels_disallowed: [] # +# Guardrail to warn or fail if no serial consistency level is provided for CAS operations. By default, this is turned off. +# warn_if_no_serial_consistency_level_provided_for_cas_enabled: false +# fail_if_no_serial_consistency_level_provided_for_cas_enabled: false +# # Guardrail to warn or fail when writing partitions larger than threshold, expressed as 100MiB, 1GiB, etc. # The guardrail is only checked when writing sstables (flush and compaction), and exceeding the fail threshold on that # moment will only log an error message, without interrupting the operation. diff --git a/src/java/org/apache/cassandra/config/Config.java b/src/java/org/apache/cassandra/config/Config.java index 193c77c8f4cb..c3c09e19caa4 100644 --- a/src/java/org/apache/cassandra/config/Config.java +++ b/src/java/org/apache/cassandra/config/Config.java @@ -934,6 +934,8 @@ public static void setClientMode(boolean clientMode) public volatile Set read_consistency_levels_disallowed = Collections.emptySet(); public volatile Set write_consistency_levels_warned = Collections.emptySet(); public volatile Set write_consistency_levels_disallowed = Collections.emptySet(); + public volatile boolean warn_if_no_serial_consistency_level_provided_for_cas_enabled = false; + public volatile boolean fail_if_no_serial_consistency_level_provided_for_cas_enabled = false; public volatile boolean user_timestamps_enabled = true; public volatile boolean alter_table_enabled = true; public volatile boolean group_by_enabled = true; diff --git a/src/java/org/apache/cassandra/config/GuardrailsOptions.java b/src/java/org/apache/cassandra/config/GuardrailsOptions.java index d10a2490ef8a..529e634f7e66 100644 --- a/src/java/org/apache/cassandra/config/GuardrailsOptions.java +++ b/src/java/org/apache/cassandra/config/GuardrailsOptions.java @@ -622,6 +622,34 @@ public void setWriteConsistencyLevelsDisallowed(Set consistenc x -> config.write_consistency_levels_disallowed = x); } + @Override + public boolean getWarnIfNoSerialConsistencyLevelProvidedForCASEnabled() + { + return config.warn_if_no_serial_consistency_level_provided_for_cas_enabled; + } + + public void setWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(boolean enabled) + { + updatePropertyWithLogging("warn_if_no_serial_consistency_level_provided_for_cas_enabled", + enabled, + () -> config.warn_if_no_serial_consistency_level_provided_for_cas_enabled, + x -> config.warn_if_no_serial_consistency_level_provided_for_cas_enabled = x); + } + + @Override + public boolean getFailIfNoSerialConsistencyLevelProvidedForCASEnabled() + { + return config.fail_if_no_serial_consistency_level_provided_for_cas_enabled; + } + + public void setFailIfNoSerialConsistencyLevelProvidedForCASEnabled(boolean enabled) + { + updatePropertyWithLogging("fail_if_no_serial_consistency_level_provided_for_cas_enabled", + enabled, + () -> config.fail_if_no_serial_consistency_level_provided_for_cas_enabled, + x -> config.fail_if_no_serial_consistency_level_provided_for_cas_enabled = x); + } + @Override @Nullable public DataStorageSpec.LongBytesBound getPartitionSizeWarnThreshold() diff --git a/src/java/org/apache/cassandra/cql3/BatchQueryOptions.java b/src/java/org/apache/cassandra/cql3/BatchQueryOptions.java index 13143453bb31..9ca7d883184a 100644 --- a/src/java/org/apache/cassandra/cql3/BatchQueryOptions.java +++ b/src/java/org/apache/cassandra/cql3/BatchQueryOptions.java @@ -78,6 +78,11 @@ public ConsistencyLevel getSerialConsistency() return wrapped.getSerialConsistency(); } + public boolean serialConsistencyNotProvided() + { + return wrapped.serialConsistencyNotProvided(); + } + public List getQueryOrIdList() { return queryOrIdList; diff --git a/src/java/org/apache/cassandra/cql3/QueryOptions.java b/src/java/org/apache/cassandra/cql3/QueryOptions.java index b7003388af7a..1f394e39a120 100644 --- a/src/java/org/apache/cassandra/cql3/QueryOptions.java +++ b/src/java/org/apache/cassandra/cql3/QueryOptions.java @@ -24,6 +24,8 @@ import java.util.List; import java.util.Map; +import javax.annotation.Nullable; + import com.google.common.collect.ImmutableList; import org.apache.commons.lang3.builder.ToStringBuilder; @@ -71,17 +73,20 @@ public abstract class QueryOptions public static QueryOptions forInternalCalls(ConsistencyLevel consistency, List values) { - return new DefaultQueryOptions(consistency, values, ByteArrayUtil.EMPTY_ARRAY_OF_BYTE_ARRAYS, false, SpecificOptions.DEFAULT, ProtocolVersion.V3); + SpecificOptions specificOptions = new SpecificOptions(-1, null, ConsistencyLevel.SERIAL, Long.MIN_VALUE, null, UNSET_NOWINSEC); + return new DefaultQueryOptions(consistency, values, ByteArrayUtil.EMPTY_ARRAY_OF_BYTE_ARRAYS, false, specificOptions, ProtocolVersion.V3); } public static QueryOptions forInternalCallsWithNowInSec(long nowInSec, ConsistencyLevel consistency, List values) { - return new DefaultQueryOptions(consistency, values, ByteArrayUtil.EMPTY_ARRAY_OF_BYTE_ARRAYS, false, SpecificOptions.DEFAULT.withNowInSec(nowInSec), ProtocolVersion.CURRENT); + SpecificOptions specificOptions = new SpecificOptions(-1, null, ConsistencyLevel.SERIAL, Long.MIN_VALUE, null, nowInSec); + return new DefaultQueryOptions(consistency, values, ByteArrayUtil.EMPTY_ARRAY_OF_BYTE_ARRAYS, false, specificOptions, ProtocolVersion.CURRENT); } public static QueryOptions forInternalCalls(List values) { - return new DefaultQueryOptions(ConsistencyLevel.ONE, values, ByteArrayUtil.EMPTY_ARRAY_OF_BYTE_ARRAYS, false, SpecificOptions.DEFAULT, ProtocolVersion.V3); + SpecificOptions specificOptions = new SpecificOptions(-1, null, ConsistencyLevel.SERIAL, Long.MIN_VALUE, null, UNSET_NOWINSEC); + return new DefaultQueryOptions(ConsistencyLevel.ONE, values, ByteArrayUtil.EMPTY_ARRAY_OF_BYTE_ARRAYS, false, specificOptions, ProtocolVersion.V3); } public static QueryOptions forProtocolVersion(ProtocolVersion protocolVersion) @@ -249,7 +254,12 @@ public PagingState getPagingState() /** Serial consistency for conditional updates. */ public ConsistencyLevel getSerialConsistency() { - return getSpecificOptions().serialConsistency; + return getSpecificOptions().serialConsistency == null ? ConsistencyLevel.SERIAL : getSpecificOptions().serialConsistency; + } + + public boolean serialConsistencyNotProvided() + { + return getSpecificOptions().serialConsistency == null; } public long getTimestamp(QueryState state) @@ -642,14 +652,14 @@ static class SpecificOptions private SpecificOptions(int pageSize, PagingState state, - ConsistencyLevel serialConsistency, + @Nullable ConsistencyLevel serialConsistency, long timestamp, String keyspace, long nowInSeconds) { this.pageSize = pageSize; this.state = state; - this.serialConsistency = serialConsistency == null ? ConsistencyLevel.SERIAL : serialConsistency; + this.serialConsistency = serialConsistency; this.timestamp = timestamp; this.keyspace = keyspace; this.nowInSeconds = nowInSeconds; @@ -743,7 +753,7 @@ public QueryOptions decode(ByteBuf body, ProtocolVersion version) { int pageSize = Flag.contains(flags, Flag.PAGE_SIZE) ? body.readInt() : -1; PagingState pagingState = Flag.contains(flags, Flag.PAGING_STATE) ? PagingState.deserialize(CBUtil.readValueNoCopy(body), version) : null; - ConsistencyLevel serialConsistency = Flag.contains(flags, Flag.SERIAL_CONSISTENCY) ? CBUtil.readConsistencyLevel(body) : ConsistencyLevel.SERIAL; + ConsistencyLevel serialConsistency = Flag.contains(flags, Flag.SERIAL_CONSISTENCY) ? CBUtil.readConsistencyLevel(body) : null; long timestamp = Long.MIN_VALUE; if (Flag.contains(flags, Flag.TIMESTAMP)) { @@ -830,7 +840,7 @@ private int gatherFlags(QueryOptions options, ProtocolVersion version) flags = Flag.add(flags, Flag.PAGE_SIZE); if (options.getPagingState() != null) flags = Flag.add(flags, Flag.PAGING_STATE); - if (options.getSerialConsistency() != ConsistencyLevel.SERIAL) + if (options.getSpecificOptions().serialConsistency != null) flags = Flag.add(flags, Flag.SERIAL_CONSISTENCY); if (options.getSpecificOptions().timestamp != Long.MIN_VALUE) flags = Flag.add(flags, Flag.TIMESTAMP); diff --git a/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java b/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java index 39d36aa4a52b..90c9a26d63c5 100644 --- a/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java @@ -524,6 +524,8 @@ private void updatePartitionsPerBatchMetrics(int updatedPartitions) private ResultMessage executeWithConditions(BatchQueryOptions options, QueryState state, Dispatcher.RequestTime requestTime) { + Guardrails.serialConsistency.guard(options.serialConsistencyNotProvided(), state.getClientState()); + Pair> p = makeCasRequest(options, state, requestTime); CQL3CasRequest casRequest = p.left; Set columnsWithConditions = p.right; diff --git a/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java b/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java index 6f37effc5c4b..0fa3dd6e9e27 100644 --- a/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java @@ -667,6 +667,8 @@ private ResultMessage executeWithoutCondition(QueryState queryState, QueryOption private ResultMessage executeWithCondition(QueryState queryState, QueryOptions options, Dispatcher.RequestTime requestTime) { + Guardrails.serialConsistency.guard(options.serialConsistencyNotProvided(), queryState.getClientState()); + CQL3CasRequest request = makeCasRequest(queryState, options, requestTime); try (RowIterator result = StorageProxy.cas(keyspace(), diff --git a/src/java/org/apache/cassandra/db/guardrails/Guardrails.java b/src/java/org/apache/cassandra/db/guardrails/Guardrails.java index 7de915190ff2..3b4bf008ea43 100644 --- a/src/java/org/apache/cassandra/db/guardrails/Guardrails.java +++ b/src/java/org/apache/cassandra/db/guardrails/Guardrails.java @@ -350,6 +350,16 @@ public final class Guardrails implements GuardrailsMBean state -> CONFIG_PROVIDER.getOrCreate(state).getWriteConsistencyLevelsDisallowed(), "write consistency levels"); + /** + * Guardrail on if a client specifies a serial consistency level for CAS operations. + */ + public static final Predicates serialConsistency = + new Predicates<>("warn_when_using_default_serial_consistency_on_cas", + null, + state -> x -> x && CONFIG_PROVIDER.getOrCreate(state).getWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(), + state -> x -> x && CONFIG_PROVIDER.getOrCreate(state).getFailIfNoSerialConsistencyLevelProvidedForCASEnabled(), + (isWarning, value) -> "Query did not provide a serial consistency level."); + /** * Guardrail on the size of a partition. */ @@ -1448,6 +1458,30 @@ public void setWriteConsistencyLevelsDisallowedCSV(String consistencyLevels) DEFAULT_CONFIG.setWriteConsistencyLevelsDisallowed(fromCSV(consistencyLevels, ConsistencyLevel::fromString)); } + @Override + public boolean getWarnIfNoSerialConsistencyLevelProvidedForCASEnabled() + { + return DEFAULT_CONFIG.getWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(); + } + + @Override + public void setWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(boolean enabled) + { + DEFAULT_CONFIG.setWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(enabled); + } + + @Override + public boolean getFailIfNoSerialConsistencyLevelProvidedForCASEnabled() + { + return DEFAULT_CONFIG.getFailIfNoSerialConsistencyLevelProvidedForCASEnabled(); + } + + @Override + public void setFailIfNoSerialConsistencyLevelProvidedForCASEnabled(boolean enabled) + { + DEFAULT_CONFIG.setFailIfNoSerialConsistencyLevelProvidedForCASEnabled(enabled); + } + @Override public int getFieldsPerUDTWarnThreshold() { diff --git a/src/java/org/apache/cassandra/db/guardrails/GuardrailsConfig.java b/src/java/org/apache/cassandra/db/guardrails/GuardrailsConfig.java index 8e0d02025975..680639d9c593 100644 --- a/src/java/org/apache/cassandra/db/guardrails/GuardrailsConfig.java +++ b/src/java/org/apache/cassandra/db/guardrails/GuardrailsConfig.java @@ -260,6 +260,18 @@ public interface GuardrailsConfig */ Set getWriteConsistencyLevelsDisallowed(); + /** + * @return {@code true} warn if no serial consistency level is provided for CAS operations. + * {@code false} does not warn when no serial consistency is used on CAS operations. + */ + boolean getWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(); + + /** + * @return {@code true} fail if no serial consistency level is provided for CAS operations. + * {@code false} does not fail when no serial consistency is used on CAS operations. + */ + boolean getFailIfNoSerialConsistencyLevelProvidedForCASEnabled(); + /** * @return The threshold to warn when writing partitions larger than threshold. */ diff --git a/src/java/org/apache/cassandra/db/guardrails/GuardrailsMBean.java b/src/java/org/apache/cassandra/db/guardrails/GuardrailsMBean.java index 108b721fa223..37043ac266a3 100644 --- a/src/java/org/apache/cassandra/db/guardrails/GuardrailsMBean.java +++ b/src/java/org/apache/cassandra/db/guardrails/GuardrailsMBean.java @@ -541,6 +541,28 @@ public interface GuardrailsMBean */ void setWriteConsistencyLevelsDisallowedCSV(String consistencyLevels); + /** + * @return {@code true} warn if no serial consistency level is provided for CAS operations. + * {@code false} does not warn when no serial consistency is used on CAS operations. + */ + boolean getWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(); + + /** + * @param enabled {@code true} if when no serial consistency is provided a client warning is produced. + */ + void setWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(boolean enabled); + + /** + * @return {@code true} fail if no serial consistency level is provided for CAS operations. + * {@code false} does not fail when no serial consistency is used on CAS operations. + */ + boolean getFailIfNoSerialConsistencyLevelProvidedForCASEnabled(); + + /** + * @param enabled {@code true} if when no serial consistency is provided the query fails. + */ + void setFailIfNoSerialConsistencyLevelProvidedForCASEnabled(boolean enabled); + /** * @return The threshold to warn when encountering partitions larger than threshold, as a string formatted as in, * for example, {@code 10GiB}, {@code 20MiB}, {@code 30KiB} or {@code 40B}. A {@code null} value means disabled. diff --git a/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java b/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java new file mode 100644 index 000000000000..d57e2b6dedde --- /dev/null +++ b/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java @@ -0,0 +1,138 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.db.guardrails; + +import org.junit.Before; + +import org.junit.Test; + +import org.apache.cassandra.db.ConsistencyLevel; + +import static org.apache.cassandra.db.ConsistencyLevel.ALL; +import static org.apache.cassandra.db.ConsistencyLevel.LOCAL_ONE; +import static org.apache.cassandra.db.ConsistencyLevel.LOCAL_QUORUM; +import static org.apache.cassandra.db.ConsistencyLevel.LOCAL_SERIAL; +import static org.apache.cassandra.db.ConsistencyLevel.ONE; +import static org.apache.cassandra.db.ConsistencyLevel.QUORUM; +import static org.apache.cassandra.db.ConsistencyLevel.SERIAL; + +public class GuardrailWhenSerialConsistencyNotProvidedTest extends GuardrailTester +{ + public GuardrailWhenSerialConsistencyNotProvidedTest() + { + super(Guardrails.serialConsistency); + } + + @Before + public void before() + { + createTable("CREATE TABLE %s (k int PRIMARY KEY, v int)"); + } + + @Test + public void testWarnsWhenNoSerialConsistencyLevelProvided() throws Throwable + { + guardrails().setWarnIfNoSerialConsistencyLevelProvidedForCASEnabled(true); + testLWTQuery(String.format("INSERT INTO %s.%s (k, v) VALUES (1, 1) IF NOT EXISTS;", + KEYSPACE, + currentTable()), true); + testLWTQuery(String.format("BEGIN BATCH \n" + + "INSERT INTO %s.%s \n" + + "(k, v) VALUES (1, 1) IF NOT EXISTS\n;" + + "INSERT INTO cql_test_keyspace.%s \n" + + "(k, v) VALUES (1, 2) \n;" + + "APPLY BATCH;", + KEYSPACE, + currentTable(), currentTable()), true); + testNotUsingLWT(String.format("INSERT INTO %s.%s (k, v) VALUES (1, 1);", + KEYSPACE, + currentTable())); + } + + @Test + public void testFailWhenNoSerialConsistencyLevelProvided() throws Throwable + { + guardrails().setFailIfNoSerialConsistencyLevelProvidedForCASEnabled(true); + testLWTQuery(String.format("INSERT INTO %s.%s (k, v) VALUES (1, 1) IF NOT EXISTS;", + KEYSPACE, + currentTable()), false); + testLWTQuery(String.format("BEGIN BATCH \n" + + "INSERT INTO %s.%s \n" + + "(k, v) VALUES (1, 1) IF NOT EXISTS\n;" + + "INSERT INTO cql_test_keyspace.%s \n" + + "(k, v) VALUES (1, 2) \n;" + + "APPLY BATCH;", + KEYSPACE, + currentTable(), currentTable()), false); + testNotUsingLWT(String.format("INSERT INTO %s.%s (k, v) VALUES (1, 1);", + KEYSPACE, + currentTable())); + } + + private void testNotUsingLWT(String query) throws Throwable + { + testNotUsingLWT(query, ONE); + testNotUsingLWT(query, ALL); + testNotUsingLWT(query, QUORUM); + testNotUsingLWT(query, LOCAL_ONE); + testNotUsingLWT(query, LOCAL_QUORUM); + } + + private void testNotUsingLWT(String query, ConsistencyLevel cl) throws Throwable + { + assertValid(query, cl, SERIAL); + assertValid(query, cl, LOCAL_SERIAL); + assertValid(query, cl, null); + } + + private void testLWTQuery(String query, boolean shouldWarn) throws Throwable + { + testLWTQuery(query, ONE, shouldWarn); + testLWTQuery(query, ALL, shouldWarn); + testLWTQuery(query, QUORUM, shouldWarn); + testLWTQuery(query, LOCAL_ONE, shouldWarn); + testLWTQuery(query, LOCAL_QUORUM, shouldWarn); + } + + private void testLWTQuery(String query, ConsistencyLevel cl, boolean shouldWarn) throws Throwable + { + assertValid(query, cl, SERIAL); + assertValid(query, cl, LOCAL_SERIAL); + if (shouldWarn) { + assertWarns(query, cl, null); + } else { + assertFails(query, cl, null); + } + } + + private void assertValid(String query, ConsistencyLevel cl, ConsistencyLevel serialCl) throws Throwable + { + assertValid(() -> execute(userClientState, query, cl, serialCl)); + } + + private void assertWarns(String query, ConsistencyLevel cl, ConsistencyLevel serialCl) throws Throwable + { + assertWarns(() -> execute(userClientState, query, cl, serialCl), "Query did not provide a serial consistency level."); + } + + private void assertFails(String query, ConsistencyLevel cl, ConsistencyLevel serialCl) throws Throwable + { + assertFails(() -> execute(userClientState, query, cl, serialCl), "Query did not provide a serial consistency level."); + } +} From 7672857e5ec3d8fe48bdeaa600b25542d0fbc85c Mon Sep 17 00:00:00 2001 From: Alan Wang Date: Fri, 16 Jan 2026 14:41:23 -0800 Subject: [PATCH 2/3] formatting --- .../GuardrailWhenSerialConsistencyNotProvidedTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java b/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java index d57e2b6dedde..a770e3fe55f8 100644 --- a/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java +++ b/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java @@ -136,3 +136,4 @@ private void assertFails(String query, ConsistencyLevel cl, ConsistencyLevel ser assertFails(() -> execute(userClientState, query, cl, serialCl), "Query did not provide a serial consistency level."); } } + From eaa121932a5c774e4cf07b30558b63ea3f122c8b Mon Sep 17 00:00:00 2001 From: Alan Wang Date: Fri, 16 Jan 2026 14:42:32 -0800 Subject: [PATCH 3/3] formatting --- .../GuardrailWhenSerialConsistencyNotProvidedTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java b/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java index a770e3fe55f8..55ac0865b347 100644 --- a/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java +++ b/test/unit/org/apache/cassandra/db/guardrails/GuardrailWhenSerialConsistencyNotProvidedTest.java @@ -135,5 +135,4 @@ private void assertFails(String query, ConsistencyLevel cl, ConsistencyLevel ser { assertFails(() -> execute(userClientState, query, cl, serialCl), "Query did not provide a serial consistency level."); } -} - +} \ No newline at end of file