test/unit/org/apache/cassandra/service/reads/thresholds/WarningsSnapshotTest.java

/*
 * 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.service.reads.thresholds;

import java.net.InetAddress;
import java.net.UnknownHostException;

import com.google.common.collect.ImmutableSet;
import org.junit.Test;

import org.apache.cassandra.locator.InetAddressAndPort;
import org.quicktheories.core.Gen;
import org.quicktheories.generators.SourceDSL;
import org.quicktheories.impl.Constraint;

import static org.apache.cassandra.service.reads.thresholds.WarningsSnapshot.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.quicktheories.QuickTheory.qt;

public class WarningsSnapshotTest
{
    private static final InetAddressAndPort HOME = address(127, 0, 0, 1);
    private static final InetAddressAndPort VACATION_HOME = address(127, 0, 0, 2);

    @Test
    public void staticMergeEmtpy()
    {
        WarningsSnapshot result = merge(null, empty(), null, empty());
        assertThat(result).isNull();
    }

    @Test
    public void staticMergeNonEmtpy()
    {
        qt().forAll(nonEmpty(), nonEmpty()).check((a, b) -> {
            WarningsSnapshot result = merge(a, b, null, empty());
            return result != null && !result.isEmpty();
        });
    }

    @Test
    public void mergeEmtpy()
    {
        WarningsSnapshot result = empty().merge(empty());
        assertThat(result).isEqualTo(empty());
    }

    @Test
    public void mergeSelf()
    {
        qt().forAll(all()).check(self -> self.merge(self).equals(self));
    }

    @Test
    public void mergeSelfWithEmpty()
    {
        qt().forAll(all()).check(self -> self.merge(empty()).equals(self) && empty().merge(self).equals(self));
    }

    @Test
    public void mergeNonEmpty()
    {
        WarningsSnapshot expected = builder()
                                    .tombstonesAbort(ImmutableSet.of(HOME), 42)
                                    .localReadSizeWarning(ImmutableSet.of(VACATION_HOME), 12)
                                    .build();
        // validate builder to protect against empty = empty passing this test
        assertThat(expected.tombstones.aborts.instances).isEqualTo(ImmutableSet.of(HOME));
        assertThat(expected.tombstones.aborts.maxValue).isEqualTo(42);
        assertThat(expected.localReadSize.warnings.instances).isEqualTo(ImmutableSet.of(VACATION_HOME));
        assertThat(expected.localReadSize.warnings.maxValue).isEqualTo(12);

        WarningsSnapshot output = empty().merge(expected);
        assertThat(output).isEqualTo(expected).isEqualTo(expected.merge(empty()));
        assertThat(output.merge(expected)).isEqualTo(expected);
    }

    @Test
    public void mergeNonEmpty2()
    {
        WarningsSnapshot a = builder()
                             .tombstonesAbort(ImmutableSet.of(HOME), 42)
                             .build();
        WarningsSnapshot b = builder()
                             .localReadSizeWarning(ImmutableSet.of(VACATION_HOME), 12)
                             .build();
        WarningsSnapshot expected = builder()
                                    .tombstonesAbort(ImmutableSet.of(HOME), 42)
                                    .localReadSizeWarning(ImmutableSet.of(VACATION_HOME), 12)
                                    .build();

        // validate builder to protect against empty = empty passing this test
        assertThat(a.tombstones.aborts.instances).isEqualTo(expected.tombstones.aborts.instances).isEqualTo(ImmutableSet.of(HOME));
        assertThat(a.tombstones.aborts.maxValue).isEqualTo(expected.tombstones.aborts.maxValue).isEqualTo(42);
        assertThat(b.localReadSize.warnings.instances).isEqualTo(expected.localReadSize.warnings.instances).isEqualTo(ImmutableSet.of(VACATION_HOME));
        assertThat(b.localReadSize.warnings.maxValue).isEqualTo(expected.localReadSize.warnings.maxValue).isEqualTo(12);

        WarningsSnapshot output = a.merge(b);
        assertThat(output).isEqualTo(expected).isEqualTo(expected.merge(empty()));
        assertThat(output.merge(expected)).isEqualTo(expected);
    }

    @Test
    public void mergeConflict()
    {
        WarningsSnapshot a          = builder().tombstonesAbort(ImmutableSet.of(HOME), 42).build();
        WarningsSnapshot b          = builder().tombstonesAbort(ImmutableSet.of(VACATION_HOME), 12).build();
        WarningsSnapshot expected   = builder().tombstonesAbort(ImmutableSet.of(HOME, VACATION_HOME), 42).build();

        // validate builder to protect against empty = empty passing this test
        assertThat(a.tombstones.aborts.instances).isEqualTo(ImmutableSet.of(HOME));
        assertThat(a.tombstones.aborts.maxValue).isEqualTo(42);
        assertThat(b.tombstones.aborts.instances).isEqualTo(ImmutableSet.of(VACATION_HOME));
        assertThat(b.tombstones.aborts.maxValue).isEqualTo(12);
        assertThat(expected.tombstones.aborts.instances).isEqualTo(ImmutableSet.of(HOME, VACATION_HOME));
        assertThat(expected.tombstones.aborts.maxValue).isEqualTo(42);

        WarningsSnapshot output = a.merge(b);
        assertThat(output).isEqualTo(expected).isEqualTo(expected.merge(empty()));
        assertThat(output.merge(expected)).isEqualTo(expected);
    }

    private static InetAddressAndPort address(int a, int b, int c, int d)
    {
        try
        {
            InetAddress address = InetAddress.getByAddress(new byte[]{ (byte) a, (byte) b, (byte) c, (byte) d });
            return InetAddressAndPort.getByAddress(address);
        }
        catch (UnknownHostException e)
        {
            throw new AssertionError(e);
        }
    }

    private static Gen<WarningsSnapshot> all()
    {
        Gen<Boolean> empty = SourceDSL.booleans().all();
        Gen<WarningsSnapshot> nonEmpty = nonEmpty();
        Gen<WarningsSnapshot> gen = rs ->
            empty.generate(rs) ? empty() : nonEmpty.generate(rs);
        return gen.describedAs(WarningsSnapshot::toString);
    }

    private static Gen<WarningsSnapshot> nonEmpty()
    {
        Gen<Counter> counter = counter();
        Gen<WarningsSnapshot> gen = rs -> {
            Builder builder = builder();
            builder.tombstonesWarning(counter.generate(rs));
            builder.tombstonesAbort(counter.generate(rs));
            builder.localReadSizeWarning(counter.generate(rs));
            builder.localReadSizeAbort(counter.generate(rs));
            builder.rowIndexSizeWarning(counter.generate(rs));
            builder.rowIndexSizeAbort(counter.generate(rs));
            return builder.build();
        };
        return gen.assuming(WarningsSnapshot::isDefined).describedAs(WarningsSnapshot::toString);
    }

    private static Gen<Counter> counter()
    {
        Gen<Boolean> empty = SourceDSL.booleans().all();
        Constraint maxValue = Constraint.between(1, Long.MAX_VALUE);
        Gen<ImmutableSet<InetAddressAndPort>> instances = SourceDSL.arbitrary()
                                                                   .pick(ImmutableSet.of(HOME), ImmutableSet.of(VACATION_HOME), ImmutableSet.of(HOME, VACATION_HOME));
        Gen<Counter> gen = rs ->
                           empty.generate(rs) ? Counter.empty()
                                              : new Counter(instances.generate(rs), rs.next(maxValue));
        return gen.describedAs(Counter::toString);
    }
}