deps: partial upgrade to hbase 2.5 (#4328)

Unfortunately mirroring-client still has to depend on hbase < 2.4 due to unresolved binary compatibility issues with mutateRow

Author: igorbernstein2

bigtable-client-core-parent/bigtable-hbase-integration-tests-common/src/test/java/com/google/cloud/bigtable/hbase/AbstractTestBatch.java

@@ -21,6 +21,8 @@
 import static org.junit.Assert.assertTrue;
 
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -268,7 +270,7 @@ public void testRowMutations() throws IOException {
     RowMutations rm = new RowMutations(rowKey);
     rm.add(put0);
     rm.add(put1);
-    table.mutateRow(rm);
+    invokeMutateRow(table, rm);
 
     // Check
     Result result = table.get(new Get(rowKey));
@@ -288,7 +290,7 @@ public void testRowMutations() throws IOException {
     rm = new RowMutations(rowKey);
     rm.add(delete);
     rm.add(put2);
-    table.mutateRow(rm);
+    invokeMutateRow(table, rm);
 
     // Check
     result = table.get(new Get(rowKey));
@@ -419,7 +421,7 @@ public void testBatchAppend() throws IOException, InterruptedException {
   @Test
   public void testBatchWithNullAndEmptyElements() throws IOException {
     Table table = getDefaultTable();
-    Exception actualError = null;
+    Throwable actualError = null;
     try {
       table.batch(null, new Object[1]);
     } catch (Exception ex) {
@@ -437,7 +439,7 @@ public void testBatchWithNullAndEmptyElements() throws IOException {
 
     try {
       table.batch(Collections.singletonList(null), new Object[0]);
-    } catch (Exception ex) {
+    } catch (Throwable ex) {
       actualError = ex;
     }
     assertNotNull(actualError);
@@ -448,35 +450,27 @@ public void testMutateRowWithEmptyElements() throws Exception {
     Table table = getDefaultTable();
     Exception actualError = null;
     try {
-      table.mutateRow(null);
+      invokeMutateRow(table, null);
     } catch (Exception ex) {
       actualError = ex;
     }
     assertNotNull(actualError);
     actualError = null;
 
     try {
-      table.mutateRow(new RowMutations(new byte[0]));
+      invokeMutateRow(table, new RowMutations(new byte[0]));
     } catch (Exception ex) {
       actualError = ex;
     }
     assertNotNull(actualError);
     actualError = null;
 
-    try {
-      // Table#mutateRow ignores requests without Mutations.
-      table.mutateRow(new RowMutations(new byte[1]));
-    } catch (Exception ex) {
-      actualError = ex;
-    }
-    assertNull(actualError);
-
     try {
       byte[] rowKeyForPut = dataHelper.randomData("test-rowKey");
       RowMutations rowMutations = new RowMutations(rowKeyForPut);
       rowMutations.add(new Put(rowKeyForPut));
 
-      table.mutateRow(rowMutations);
+      invokeMutateRow(table, rowMutations);
     } catch (Exception ex) {
       actualError = ex;
     }
@@ -489,7 +483,7 @@ public void testMutateRowWithEmptyElements() throws Exception {
       rowMutations.add(new Put(rowKeyWithNullQual).addColumn(COLUMN_FAMILY, null, null));
 
       // Table#mutateRow should add a row with null qualifier.
-      table.mutateRow(rowMutations);
+      invokeMutateRow(table, rowMutations);
 
       assertTrue(table.exists(new Get(rowKeyWithNullQual)));
     } catch (Exception ex) {
@@ -503,7 +497,7 @@ public void testMutateRowWithEmptyElements() throws Exception {
       rowMutations.add(new Put(rowKeyWithEmptyQual).addColumn(COLUMN_FAMILY, new byte[0], null));
 
       // Table#mutateRow should add a row with an empty qualifier.
-      table.mutateRow(rowMutations);
+      invokeMutateRow(table, rowMutations);
 
       assertTrue(table.exists(new Get(rowKeyWithEmptyQual)));
     } catch (Exception ex) {
@@ -517,7 +511,7 @@ public void testMutateRowWithEmptyElements() throws Exception {
       rowMutations.add(new Put(rowKeyWithNullValue).addColumn(COLUMN_FAMILY, "q".getBytes(), null));
 
       // Table#mutateRow should add a row with null values.
-      table.mutateRow(rowMutations);
+      invokeMutateRow(table, rowMutations);
 
       assertTrue(table.exists(new Get(rowKeyWithNullValue)));
     } catch (Exception ex) {
@@ -526,6 +520,17 @@ public void testMutateRowWithEmptyElements() throws Exception {
     assertNull(actualError);
   }
 
+  // workaround binary incompatible change in HBase 2.4 that changed the return type of mutateRow
+  // This is necessary because this test is shared by bigtable-hbase 1x & 2x
+  private void invokeMutateRow(Table table, RowMutations rm) {
+    try {
+      Method mutateRow = Table.class.getMethod("mutateRow", RowMutations.class);
+      mutateRow.invoke(table, rm);
+    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   protected abstract void appendAdd(
       Append append, byte[] columnFamily, byte[] qualifier, byte[] value);
 }

bigtable-client-core-parent/bigtable-hbase-integration-tests-common/src/test/java/com/google/cloud/bigtable/hbase/AbstractTestCheckAndMutate.java

@@ -127,9 +127,17 @@ public void testCheckAndDeleteSameQual() throws Exception {
     Assert.assertFalse(
         "Wrong value. Should fail.",
         checkAndDelete(rowKey, SharedTestEnvRule.COLUMN_FAMILY, qual, value2, delete));
-    Assert.assertFalse(
-        "Zero bytes value. Should fail.",
-        checkAndDelete(rowKey, SharedTestEnvRule.COLUMN_FAMILY, qual, ZERO_BYTES, delete));
+
+    // Newer versions of HBase throw an error instead of returning false
+    Exception actualError = null;
+    Boolean result = null;
+    try {
+      result = checkAndDelete(rowKey, SharedTestEnvRule.COLUMN_FAMILY, qual, ZERO_BYTES, delete);
+    } catch (Exception e) {
+      actualError = e;
+    }
+
+    Assert.assertTrue("Zero bytes value. Should fail.", actualError != null || !result);
     Assert.assertTrue(
         checkAndDelete(rowKey, SharedTestEnvRule.COLUMN_FAMILY, qual, value1, delete));
     Assert.assertFalse("Row should be gone", table.exists(new Get(rowKey)));
@@ -245,18 +253,9 @@ public void testCheckAndPutDiffRow() throws Exception {
 
     // Put then again
     Put put = new Put(rowKey1).addColumn(SharedTestEnvRule.COLUMN_FAMILY, qual, value);
-    try {
-      checkAndPut(rowKey2, SharedTestEnvRule.COLUMN_FAMILY, qual, null, put);
-      Assert.fail("IOException expected");
-    } catch (IOException e) {
-      assertGetRowException(e);
-    } finally {
-      table.close();
-    }
-  }
-
-  private static void assertGetRowException(IOException e) {
-    Assert.assertTrue(e.getMessage(), e.getMessage().contains("Action's getRow must match"));
+    Assert.assertThrows(
+        IOException.class,
+        () -> checkAndPut(rowKey2, SharedTestEnvRule.COLUMN_FAMILY, qual, null, put));
   }
 
   @Test
@@ -269,10 +268,9 @@ public void testCheckAndDeleteDiffRow() throws Exception {
 
       // Put then again
       Delete delete = new Delete(rowKey1).addColumns(SharedTestEnvRule.COLUMN_FAMILY, qual);
-      checkAndDelete(rowKey2, SharedTestEnvRule.COLUMN_FAMILY, qual, null, delete);
-      Assert.fail("IOException expected");
-    } catch (IOException e) {
-      assertGetRowException(e);
+      Assert.assertThrows(
+          IOException.class,
+          () -> checkAndDelete(rowKey2, SharedTestEnvRule.COLUMN_FAMILY, qual, null, delete));
     }
   }
 

bigtable-client-core-parent/bigtable-hbase-integration-tests-common/src/test/java/com/google/cloud/bigtable/hbase/test_helpers/ResultSubject.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed 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 com.google.cloud.bigtable.hbase.test_helpers;
+
+import static com.google.common.truth.Fact.simpleFact;
+import static com.google.common.truth.Truth.assertAbout;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import java.util.List;
+import org.apache.hadoop.hbase.Cell;
+import org.apache.hadoop.hbase.CellUtil;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+public class ResultSubject extends Subject {
+  // User-defined entry point
+  public static ResultSubject assertThat(org.apache.hadoop.hbase.client.Result result) {
+    return assertAbout(results()).that(result);
+  }
+
+  // Static method for getting the subject factory (for use with assertAbout())
+  public static Subject.Factory<ResultSubject, Result> results() {
+    return ResultSubject::new;
+  }
+
+  private final Result actual;
+
+  public ResultSubject(FailureMetadata metadata, @Nullable Result actual) {
+    super(metadata, actual);
+    this.actual = actual;
+  }
+
+  public void latestCellHasValue(byte[] family, byte[] qualifier, byte[] value) {
+    Cell cell = actual.getColumnLatestCell(family, qualifier);
+    byte[] actualValue = CellUtil.cloneValue(cell);
+    check("getColumnLatestCell(%s, %s).value()", family, Bytes.toStringBinary(qualifier))
+        .that(Bytes.toStringBinary(actualValue))
+        .isEqualTo(Bytes.toStringBinary(value));
+  }
+
+  public void doesNotHaveCell(byte[] family, byte[] qualifier) {
+    List<Cell> columnCells = actual.getColumnCells(family, qualifier);
+
+    check("doesNotHaveCell(%s,%s)", Bytes.toStringBinary(family), Bytes.toStringBinary(qualifier))
+        .that(columnCells)
+        .isEmpty();
+  }
+
+  @Override
+  public void isEqualTo(@Nullable Object expected) {
+    if (actual == expected) {
+      return;
+    }
+    if (actual == null) {
+      failWithoutActual(simpleFact("got null when expecting a value"));
+      return;
+    }
+    if (expected == null) {
+      failWithoutActual(simpleFact("expected null but got: " + actual));
+      return;
+    }
+
+    try {
+      Result.compareResults(actual, (Result) expected);
+    } catch (Exception e) {
+      failWithoutActual(simpleFact(e.getMessage()));
+    }
+  }
+
+  @Override
+  public void isNotEqualTo(@Nullable Object unexpected) {
+    if (actual == unexpected) {
+      failWithoutActual(simpleFact("Expected different values, but got same instance"));
+      return;
+    }
+    if (actual == null || unexpected == null) {
+      return;
+    }
+
+    try {
+      Result.compareResults(actual, (Result) unexpected);
+      failWithoutActual(simpleFact("Results were equal to each other"));
+    } catch (Exception e) {
+      // noop
+    }
+  }
+}