chore: drop test dep on mrunit and use mockito instead (#4257)

mrunit is EOL

Change-Id: Icb9abbd5c6e50f511e79f106ae9a99ed519f588f

Author: igorbernstein2

bigtable-hbase-1.x-parent/bigtable-hbase-1.x-mapreduce/pom.xml

@@ -34,10 +34,6 @@ limitations under the License.
     in order to work with Bigtable.
   </description>
 
-  <properties>
-    <mrunit.version>1.1.0</mrunit.version>
-  </properties>
-
   <!-- NOTE: this artifact is designed to be used alongside hbase-server via
   the bin/hbase script. Its primary intention is to produce a single jar that can
   be added to hbase's classpath to kick off mapreduce jobs targeted at bigtable.
@@ -91,10 +87,15 @@ limitations under the License.
       <scope>test</scope>
     </dependency>
     <dependency>
-      <groupId>org.apache.mrunit</groupId>
-      <artifactId>mrunit</artifactId>
-      <version>${mrunit.version}</version>
-      <classifier>hadoop2</classifier>
+      <groupId>com.google.truth</groupId>
+      <artifactId>truth</artifactId>
+      <version>${truth.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>${mockito.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>

bigtable-hbase-1.x-parent/bigtable-hbase-1.x-mapreduce/src/test/java/com/google/cloud/bigtable/mapreduce/hbasesnapshots/TestSnapshotMapper.java

@@ -15,50 +15,65 @@
  */
 package com.google.cloud.bigtable.mapreduce.hbasesnapshots;
 
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.when;
+
 import com.google.cloud.bigtable.mapreduce.hbasesnapshots.ImportHBaseSnapshotJob.ScanCounter;
 import com.google.cloud.bigtable.mapreduce.hbasesnapshots.ImportHBaseSnapshotJob.SnapshotMapper;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.hbase.Cell;
 import org.apache.hadoop.hbase.CellScanner;
 import org.apache.hadoop.hbase.CellUtil;
 import org.apache.hadoop.hbase.KeyValue;
 import org.apache.hadoop.hbase.client.Put;
 import org.apache.hadoop.hbase.client.Result;
 import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
-import org.apache.hadoop.hbase.mapreduce.MutationSerialization;
-import org.apache.hadoop.hbase.mapreduce.ResultSerialization;
 import org.apache.hadoop.hbase.util.Bytes;
-import org.apache.hadoop.mapreduce.Counters;
-import org.apache.hadoop.mrunit.mapreduce.MapDriver;
-import org.apache.hadoop.mrunit.types.Pair;
+import org.apache.hadoop.hbase.util.Pair;
+import org.apache.hadoop.mapreduce.Counter;
+import org.apache.hadoop.mapreduce.Mapper;
 import org.junit.Assert;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /** test mapper for snapshot import */
 public class TestSnapshotMapper {
+  @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule();
+  private SnapshotMapper mappUnderTest;
 
-  private MapDriver<ImmutableBytesWritable, Result, ImmutableBytesWritable, Put> mapDriver;
+  @Mock private Mapper<ImmutableBytesWritable, Result, ImmutableBytesWritable, Put>.Context mockCtx;
+  @Mock private Counter rowCounter;
+  @Mock private Counter cellCounter;
+  private List<Pair<ImmutableBytesWritable, Put>> resultList;
 
   @Before
-  public void setup() {
-    SnapshotMapper snapshotMapper = new SnapshotMapper();
-    mapDriver = MapDriver.newMapDriver(snapshotMapper);
-    Configuration conf = new Configuration();
-    mapDriver
-        .getConfiguration()
-        .setStrings(
-            "io.serializations",
-            conf.get("io.serializations"),
-            MutationSerialization.class.getName(),
-            ResultSerialization.class.getName());
+  public void setup() throws Exception {
+    mappUnderTest = new SnapshotMapper();
+
+    when(mockCtx.getCounter(Mockito.eq(ScanCounter.NUM_ROWS))).thenReturn(rowCounter);
+    when(mockCtx.getCounter(Mockito.eq(ScanCounter.NUM_CELLS))).thenReturn(cellCounter);
+
+    resultList = new ArrayList<>();
+    doAnswer(
+            invocationOnMock -> {
+              resultList.add(
+                  Pair.newPair(
+                      (ImmutableBytesWritable) invocationOnMock.getArguments()[0],
+                      (Put) invocationOnMock.getArguments()[1]));
+              return null;
+            })
+        .when(mockCtx)
+        .write(Mockito.any(), Mockito.any());
   }
 
   @Test
-  public void testSnapshotMapper() throws IOException {
+  public void testSnapshotMapper() throws Exception {
     int rowCount = 20;
     int cellCount = 10;
     byte[] row = Bytes.toBytes("row");
@@ -68,7 +83,6 @@ public void testSnapshotMapper() throws IOException {
     long ts = 123L;
 
     ImmutableBytesWritable key = new ImmutableBytesWritable(row);
-
     for (int h = 0; h < rowCount; h++) {
       List<Cell> cellList = new ArrayList<>();
       for (int i = 0; i < cellCount; i++) {
@@ -77,11 +91,10 @@ public void testSnapshotMapper() throws IOException {
       }
 
       Result res = Result.create(cellList);
-      mapDriver.addInput(new Pair<>(key, res));
+      mappUnderTest.map(key, res, mockCtx);
     }
 
-    List<Pair<ImmutableBytesWritable, Put>> resultList = mapDriver.run();
-    Assert.assertEquals(rowCount, resultList.size());
+    Mockito.verify(mockCtx, Mockito.times(rowCount)).write(Mockito.any(), Mockito.any());
 
     int cellResCount = 0;
     for (Pair<ImmutableBytesWritable, Put> r : resultList) {
@@ -100,15 +113,12 @@ public void testSnapshotMapper() throws IOException {
     Assert.assertEquals((rowCount * cellCount), cellResCount);
 
     // verify counters
-    Counters counters = mapDriver.getCounters();
-    long numRows = counters.findCounter(ScanCounter.NUM_ROWS).getValue();
-    long numCells = counters.findCounter(ScanCounter.NUM_CELLS).getValue();
-    Assert.assertEquals(rowCount, numRows);
-    Assert.assertEquals((rowCount * cellCount), numCells);
+    Mockito.verify(rowCounter, Mockito.times(rowCount)).increment(Mockito.eq(1L));
+    Mockito.verify(cellCounter, Mockito.times(rowCount)).increment(Mockito.eq((long) cellCount));
   }
 
   @Test
-  public void testRowExceedingMaxCells() throws IOException {
+  public void testRowExceedingMaxCells() throws Exception {
     int cellCount = SnapshotMapper.MAX_CELLS + 100;
     byte[] row = Bytes.toBytes("row");
     ImmutableBytesWritable key = new ImmutableBytesWritable(row);
@@ -121,10 +131,9 @@ public void testRowExceedingMaxCells() throws IOException {
     }
 
     Result res = Result.create(cellList);
-    Pair<ImmutableBytesWritable, Result> input = new Pair<>(key, res);
-    mapDriver.addInput(input);
 
-    List<Pair<ImmutableBytesWritable, Put>> resultList = mapDriver.run();
+    mappUnderTest.map(key, res, mockCtx);
+
     Assert.assertEquals(2, resultList.size());
 
     int cellResCount = 0;
@@ -137,10 +146,7 @@ public void testRowExceedingMaxCells() throws IOException {
     Assert.assertEquals(cellCount, cellResCount);
 
     // verify counters
-    Counters counters = mapDriver.getCounters();
-    long numRows = counters.findCounter(ScanCounter.NUM_ROWS).getValue();
-    long numCells = counters.findCounter(ScanCounter.NUM_CELLS).getValue();
-    Assert.assertEquals(1, numRows);
-    Assert.assertEquals(cellCount, numCells);
+    Mockito.verify(rowCounter, Mockito.times(1)).increment(Mockito.eq(1L));
+    Mockito.verify(cellCounter, Mockito.times(1)).increment(Mockito.eq((long) cellCount));
   }
 }