embulk-output-kintone 1.1.0 → 1.2.0

data/src/test/java/org/embulk/output/kintone/KintoneColumnVisitorTest.java

@@ -44,7 +44,7 @@ public class KintoneColumnVisitorTest {
   public void test() {
     KintoneColumnVisitorVerifier verifier = verifier(null, "STRING|SINGLE_LINE_TEXT");
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
           assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("0")));
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("0"));
@@ -104,11 +104,11 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
           assertThat(
               record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"\""));
-          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is(""));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is(""));
         });
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
           assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("0")));
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("0"));
@@ -168,11 +168,11 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
           assertThat(
               record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"\""));
-          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is(""));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is(""));
         });
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("true"));
           assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("1")));
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("123"));
@@ -233,11 +233,11 @@ public class KintoneColumnVisitorTest {
           assertTableRows(record.getSubtableFieldValue("JSON|SUBTABLE"), rows(0L, 1L, 2L));
           assertThat(
               record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"abc\""));
-          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is("abc"));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is("abc"));
         });
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
           assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("0")));
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("456"));
@@ -298,8 +298,8 @@ public class KintoneColumnVisitorTest {
           assertTableRows(record.getSubtableFieldValue("JSON|SUBTABLE"), rows(3L, 4L, 5L));
           assertThat(
               record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"def\""));
-          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is("def"));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is("def"));
         });
   }
 
@@ -307,7 +307,7 @@ public class KintoneColumnVisitorTest {
   public void testPreferNulls() {
     KintoneColumnVisitorVerifier verifier = verifier(null, "LONG", true, false);
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(
               record.getFieldType("BOOLEAN|SINGLE_LINE_TEXT"), is(FieldType.SINGLE_LINE_TEXT));
           assertThat(record.getFieldType("BOOLEAN"), is(FieldType.NUMBER));
@@ -415,8 +415,8 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
           assertThat(
               record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
-          assertThat(updateKey.getField(), is("LONG"));
-          assertThat(updateKey.getValue(), nullValue());
+          assertThat(idOrUpdateKey.getField(), is("LONG"));
+          assertThat(idOrUpdateKey.getValue(), nullValue());
         });
   }
 
@@ -424,7 +424,7 @@ public class KintoneColumnVisitorTest {
   public void testIgnoreNulls() {
     KintoneColumnVisitorVerifier verifier = verifier("JSON", "JSON", false, true);
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getFieldValue("BOOLEAN"), nullValue());
           assertThat(record.getFieldValue("LONG|SINGLE_LINE_TEXT"), nullValue());
@@ -475,8 +475,8 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getFieldValue("JSON"), nullValue());
           assertThat(record.getFieldValue("JSON|SUBTABLE"), nullValue());
           assertThat(record.getFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
-          assertThat(updateKey.getField(), nullValue());
-          assertThat(updateKey.getValue(), nullValue());
+          assertThat(idOrUpdateKey.getField(), nullValue());
+          assertThat(idOrUpdateKey.getValue(), nullValue());
         },
         true);
   }
@@ -485,7 +485,7 @@ public class KintoneColumnVisitorTest {
   public void testReduceKey() {
     KintoneColumnVisitorVerifier verifier = verifier("JSON|SUBTABLE", null);
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
           assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("0")));
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("0"));
@@ -544,8 +544,8 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getMultiLineTextFieldValue("JSON"), is("\"\""));
           assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
           assertThat(record.getFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
-          assertThat(updateKey.getField(), nullValue());
-          assertThat(updateKey.getValue(), nullValue());
+          assertThat(idOrUpdateKey.getField(), nullValue());
+          assertThat(idOrUpdateKey.getValue(), nullValue());
         },
         true);
   }
@@ -555,24 +555,24 @@ public class KintoneColumnVisitorTest {
     assertThrows(UnsupportedOperationException.class, () -> verifier(null, "TIMESTAMP").verify());
     KintoneColumnVisitorVerifier verifier = verifier(null, "TIMESTAMP|NUMBER");
     verifier.verify(
-        (record, updateKey) -> {
-          assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
-          assertThat(updateKey.getValue(), is(number("0")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("0")));
         });
     verifier.verify(
-        (record, updateKey) -> {
-          assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
-          assertThat(updateKey.getValue(), is(number("0")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("0")));
         });
     verifier.verify(
-        (record, updateKey) -> {
-          assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
-          assertThat(updateKey.getValue(), is(number("946684799")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("946684799")));
         });
     verifier.verify(
-        (record, updateKey) -> {
-          assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
-          assertThat(updateKey.getValue(), is(number("946684800")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("946684800")));
         });
   }
 

data/src/test/java/org/embulk/output/kintone/KintoneColumnVisitorVerifier.java

@@ -2,11 +2,11 @@ package org.embulk.output.kintone;
 
 import com.kintone.client.model.record.FieldType;
 import com.kintone.client.model.record.Record;
-import com.kintone.client.model.record.UpdateKey;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiConsumer;
 import javax.validation.UnexpectedTypeException;
+import org.embulk.output.kintone.record.IdOrUpdateKey;
 import org.embulk.spi.Column;
 import org.embulk.spi.Page;
 import org.embulk.spi.PageReader;
@@ -50,21 +50,21 @@ public class KintoneColumnVisitorVerifier {
     verify((record, updateKey) -> {});
   }
 
-  public void verify(BiConsumer<Record, UpdateKey> consumer) {
+  public void verify(BiConsumer<Record, IdOrUpdateKey> consumer) {
     verify(consumer, false);
   }
 
-  public void verify(BiConsumer<Record, UpdateKey> consumer, boolean nullable) {
+  public void verify(BiConsumer<Record, IdOrUpdateKey> consumer, boolean nullable) {
     if (!reader.nextRecord()) {
       throw new IllegalStateException();
     }
     Record record = new Record();
     visitor.setRecord(record);
-    UpdateKey updateKey = new UpdateKey();
-    visitor.setUpdateKey(updateKey);
+    IdOrUpdateKey idOrUpdateKey = new IdOrUpdateKey();
+    visitor.setIdOrUpdateKey(idOrUpdateKey);
     schema.visitColumns(visitor);
     schema.getColumns().forEach(column -> verify(record, column, nullable));
-    consumer.accept(record, updateKey);
+    consumer.accept(record, idOrUpdateKey);
   }
 
   private void verify(Record record, Column column, boolean nullable) {

data/src/test/java/org/embulk/output/kintone/KintonePageOutputVerifier.java

@@ -3,24 +3,13 @@ package org.embulk.output.kintone;
 import static org.embulk.output.kintone.deserializer.DeserializerTest.assertTableRows;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
-import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.matches;
 import static org.mockito.Mockito.CALLS_REAL_METHODS;
 import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
-import com.kintone.client.AppClient;
-import com.kintone.client.KintoneClient;
-import com.kintone.client.KintoneClientBuilder;
 import com.kintone.client.RecordClient;
-import com.kintone.client.api.record.GetRecordsByCursorResponseBody;
-import com.kintone.client.model.app.field.FieldProperty;
-import com.kintone.client.model.app.field.NumberFieldProperty;
-import com.kintone.client.model.app.field.SingleLineTextFieldProperty;
 import com.kintone.client.model.record.FieldType;
 import com.kintone.client.model.record.FieldValue;
 import com.kintone.client.model.record.NumberFieldValue;
@@ -33,23 +22,27 @@ import java.math.BigDecimal;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.embulk.config.TaskReport;
 import org.embulk.deps.buffer.PooledBufferAllocator;
+import org.embulk.output.kintone.record.Id;
 import org.embulk.spi.BufferAllocator;
 import org.embulk.spi.Exec;
 import org.embulk.spi.Page;
 import org.embulk.spi.TransactionalPageOutput;
 import org.mockito.ArgumentCaptor;
 import org.mockito.MockedStatic;
+import org.msgpack.value.StringValue;
+import org.msgpack.value.ValueFactory;
 
 public class KintonePageOutputVerifier implements TransactionalPageOutput {
   private final TransactionalPageOutput transactionalPageOutput;
   private final String domain;
   private final String field;
   private final List<String> values;
+  private final List<String> addValues;
   private final List<Record> addRecords;
   private final List<RecordForUpdate> updateRecords;
 
@@ -57,9 +50,10 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
       String domain,
       String field,
       List<String> values,
+      List<String> addValues,
       List<Record> addRecords,
       List<RecordForUpdate> updateRecords) {
-    this(null, domain, field, values, addRecords, updateRecords);
+    this(null, domain, field, values, addValues, addRecords, updateRecords);
   }
 
   public KintonePageOutputVerifier(
@@ -67,12 +61,14 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
       String domain,
       String field,
       List<String> values,
+      List<String> addValues,
       List<Record> addRecords,
       List<RecordForUpdate> updateRecords) {
     this.transactionalPageOutput = transactionalPageOutput;
     this.domain = domain;
     this.field = field;
     this.values = values;
+    this.addValues = addValues;
     this.addRecords = addRecords;
     this.updateRecords = updateRecords;
   }
@@ -105,7 +101,7 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
     return transactionalPageOutput.commit();
   }
 
-  public void runWithMock(Runnable runnable) {
+  public void runWithMock(MockClient.Runnable runnable) {
     try {
       runWithMockExec(runnable);
     } catch (Exception e) {
@@ -113,7 +109,7 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
     }
   }
 
-  private void runWithMockExec(Runnable runnable) throws Exception {
+  private void runWithMockExec(MockClient.Runnable runnable) throws Exception {
     BufferAllocator bufferAllocator = PooledBufferAllocator.create(1024 * 1024);
     try (MockedStatic<Exec> mocked = mockStatic(Exec.class, CALLS_REAL_METHODS)) {
       mocked.when(Exec::getBufferAllocator).thenReturn(bufferAllocator);
@@ -121,37 +117,11 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
     }
   }
 
-  private void runWithMockClient(Runnable runnable) throws Exception {
-    @SuppressWarnings("unchecked")
-    Map<String, FieldProperty> mockFormFields = mock(Map.class);
-    when(mockFormFields.get(matches("^.*_single_line_text$")))
-        .thenReturn(new SingleLineTextFieldProperty());
-    when(mockFormFields.get(matches("^.*_number$"))).thenReturn(new NumberFieldProperty());
-    AppClient mockAppClient = mock(AppClient.class);
-    when(mockAppClient.getFormFields(eq(0L))).thenReturn(mockFormFields);
-    GetRecordsByCursorResponseBody mockGetRecordsByCursorResponseBody =
-        mock(GetRecordsByCursorResponseBody.class);
-    when(mockGetRecordsByCursorResponseBody.getRecords())
-        .thenReturn(updateRecords.stream().map(this::getRecord).collect(Collectors.toList()));
-    when(mockGetRecordsByCursorResponseBody.hasNext()).thenReturn(false);
-    RecordClient mockRecordClient = mock(RecordClient.class);
-    when(mockRecordClient.createCursor(eq(0L), eq(getFields()), eq(getQuery()))).thenReturn("id");
-    when(mockRecordClient.getRecordsByCursor(eq("id")))
-        .thenReturn(mockGetRecordsByCursorResponseBody);
-    when(mockRecordClient.addRecords(eq(0L), anyList())).thenReturn(Collections.emptyList());
-    when(mockRecordClient.updateRecords(eq(0L), anyList())).thenReturn(Collections.emptyList());
-    KintoneClient mockKintoneClient = mock(KintoneClient.class);
-    when(mockKintoneClient.app()).thenReturn(mockAppClient);
-    when(mockKintoneClient.record()).thenReturn(mockRecordClient);
-    KintoneClientBuilder mockKintoneClientBuilder = mock(KintoneClientBuilder.class);
-    when(mockKintoneClientBuilder.authByApiToken(eq("token"))).thenReturn(mockKintoneClientBuilder);
-    when(mockKintoneClientBuilder.build()).thenReturn(mockKintoneClient);
-    try (MockedStatic<KintoneClientBuilder> mocked = mockStatic(KintoneClientBuilder.class)) {
-      mocked
-          .when(() -> KintoneClientBuilder.create(String.format("https://%s", domain)))
-          .thenReturn(mockKintoneClientBuilder);
-      runnable.run();
-    }
+  private void runWithMockClient(MockClient.Runnable runnable) throws Exception {
+    assertValues(domain, getValues(), sorted(values));
+    MockClient mockClient = new MockClient(domain, getRecords(), getFields(), getQuery());
+    RecordClient mockRecordClient = mockClient.getMockRecordClient();
+    mockClient.run(runnable);
     @SuppressWarnings("unchecked")
     ArgumentCaptor<List<Record>> addRecordsArgumentCaptor = ArgumentCaptor.forClass(List.class);
     verify(mockRecordClient, atLeast(0)).addRecords(eq(0L), addRecordsArgumentCaptor.capture());
@@ -174,8 +144,40 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
         updateRecords);
   }
 
+  private List<String> getValues() {
+    if (values.isEmpty() || updateRecords.isEmpty()) {
+      return values;
+    }
+    Function<FieldValue, StringValue> toValue =
+        value ->
+            field.matches("^.*_number$")
+                ? ValueFactory.newString(((NumberFieldValue) value).getValue().toPlainString())
+                : ValueFactory.newString(((SingleLineTextFieldValue) value).getValue());
+    Function<Record, String> toJson =
+        record ->
+            Id.FIELD.equals(field)
+                ? ValueFactory.newString(record.getId().toString()).toJson()
+                : toValue.apply(record.getFieldValue(field)).toJson();
+    List<String> values = getRecords().stream().map(toJson).collect(Collectors.toList());
+    values.addAll(addValues);
+    return sorted(values);
+  }
+
+  private List<Record> getRecords() {
+    return updateRecords.stream().map(this::getRecord).collect(Collectors.toList());
+  }
+
   private Record getRecord(RecordForUpdate updateRecord) {
+    Long id = updateRecord.getId();
     UpdateKey key = updateRecord.getUpdateKey();
+    return id != null ? getRecord(id) : getRecord(key);
+  }
+
+  private Record getRecord(Long id) {
+    return new Record(id, null);
+  }
+
+  private Record getRecord(UpdateKey key) {
     String field = key.getField();
     Object value = key.getValue();
     return new Record()
@@ -194,6 +196,18 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
     return String.format("%s in (%s)", field, String.join(",", values));
   }
 
+  private static void assertValues(String domain, List<String> actual, List<String> expected) {
+    assertThat(domain, actual.size(), is(expected.size()));
+    // spotless:off
+    IntStream.range(0, actual.size()).forEach(index -> assertValue(domain, index, actual.get(index), expected.get(index)));
+    // spotless:on
+  }
+
+  private static void assertValue(String domain, int index, String actual, String expected) {
+    String reason = String.format("%s:%d", domain, index);
+    assertThat(reason, actual, is(expected));
+  }
+
   private static void assertRecords(String domain, List<Record> actual, List<Record> expected) {
     assertThat(domain, actual.size(), is(expected.size()));
     // spotless:off
@@ -245,20 +259,32 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
   private static void assertRecordForUpdate(
       String domain, int index, RecordForUpdate actual, RecordForUpdate expected) {
     String reason = String.format("%s:%d", domain, index);
-    assertThat(reason, actual.getId(), is(expected.getId()));
-    assertUpdateKey(domain, index, actual.getUpdateKey(), expected.getUpdateKey());
+    assertId(domain, index, actual, expected);
+    assertUpdateKey(domain, index, actual, expected);
     assertRecord(domain, index, actual.getRecord(), expected.getRecord());
     assertThat(reason, actual.getRevision(), is(expected.getRevision()));
   }
 
+  private static void assertId(
+      String domain, int index, RecordForUpdate actual, RecordForUpdate expected) {
+    if (actual.getUpdateKey() != null && expected.getUpdateKey() != null) {
+      return;
+    }
+    String reason = String.format("%s:%d", domain, index);
+    assertThat(reason, actual.getId(), is(expected.getId()));
+  }
+
   private static void assertUpdateKey(
-      String domain, int index, UpdateKey actual, UpdateKey expected) {
+      String domain, int index, RecordForUpdate actual, RecordForUpdate expected) {
+    if (actual.getId() != null && expected.getId() != null) {
+      return;
+    }
     String reason = String.format("%s:%d", domain, index);
-    assertThat(reason, actual.getField(), is(expected.getField()));
-    assertThat(reason, actual.getValue(), is(expected.getValue()));
+    assertThat(reason, actual.getUpdateKey().getField(), is(expected.getUpdateKey().getField()));
+    assertThat(reason, actual.getUpdateKey().getValue(), is(expected.getUpdateKey().getValue()));
   }
 
-  public interface Runnable {
-    void run() throws Exception;
+  private static <T> List<T> sorted(List<T> list) {
+    return list.stream().sorted().collect(Collectors.toList());
   }
 }

data/src/test/java/org/embulk/output/kintone/MockClient.java

@@ -0,0 +1,112 @@
+package org.embulk.output.kintone;
+
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.matches;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+import com.kintone.client.AppClient;
+import com.kintone.client.KintoneClient;
+import com.kintone.client.KintoneClientBuilder;
+import com.kintone.client.RecordClient;
+import com.kintone.client.api.record.GetRecordsByCursorResponseBody;
+import com.kintone.client.model.app.field.CheckBoxFieldProperty;
+import com.kintone.client.model.app.field.DateFieldProperty;
+import com.kintone.client.model.app.field.DateTimeFieldProperty;
+import com.kintone.client.model.app.field.DropDownFieldProperty;
+import com.kintone.client.model.app.field.FieldProperty;
+import com.kintone.client.model.app.field.FileFieldProperty;
+import com.kintone.client.model.app.field.GroupSelectFieldProperty;
+import com.kintone.client.model.app.field.LinkFieldProperty;
+import com.kintone.client.model.app.field.MultiLineTextFieldProperty;
+import com.kintone.client.model.app.field.MultiSelectFieldProperty;
+import com.kintone.client.model.app.field.NumberFieldProperty;
+import com.kintone.client.model.app.field.OrganizationSelectFieldProperty;
+import com.kintone.client.model.app.field.RadioButtonFieldProperty;
+import com.kintone.client.model.app.field.RichTextFieldProperty;
+import com.kintone.client.model.app.field.SingleLineTextFieldProperty;
+import com.kintone.client.model.app.field.SubtableFieldProperty;
+import com.kintone.client.model.app.field.TimeFieldProperty;
+import com.kintone.client.model.app.field.UserSelectFieldProperty;
+import com.kintone.client.model.record.Record;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.mockito.MockedStatic;
+
+public class MockClient {
+  private final String domain;
+  private final List<Record> records;
+  private final List<String> fields;
+  private final String query;
+  private final RecordClient mockRecordClient;
+
+  public MockClient(String domain, List<Record> records, List<String> fields, String query) {
+    this.domain = domain;
+    this.records = records;
+    this.fields = fields;
+    this.query = query;
+    mockRecordClient = mock(RecordClient.class);
+  }
+
+  public RecordClient getMockRecordClient() {
+    return mockRecordClient;
+  }
+
+  public void run(Runnable runnable) throws Exception {
+    @SuppressWarnings("unchecked")
+    Map<String, FieldProperty> mockFormFields = mock(Map.class);
+    when(mockFormFields.get(matches("^.*_single_line_text$")))
+        .thenReturn(new SingleLineTextFieldProperty());
+    when(mockFormFields.get(matches("^.*_multi_line_text$")))
+        .thenReturn(new MultiLineTextFieldProperty());
+    when(mockFormFields.get(matches("^.*_rich_text$"))).thenReturn(new RichTextFieldProperty());
+    when(mockFormFields.get(matches("^.*_number$"))).thenReturn(new NumberFieldProperty());
+    when(mockFormFields.get(matches("^.*_check_box$"))).thenReturn(new CheckBoxFieldProperty());
+    when(mockFormFields.get(matches("^.*_radio_button$")))
+        .thenReturn(new RadioButtonFieldProperty());
+    when(mockFormFields.get(matches("^.*_multi_select$")))
+        .thenReturn(new MultiSelectFieldProperty());
+    when(mockFormFields.get(matches("^.*_drop_down$"))).thenReturn(new DropDownFieldProperty());
+    when(mockFormFields.get(matches("^.*_user_select$"))).thenReturn(new UserSelectFieldProperty());
+    when(mockFormFields.get(matches("^.*_organization_select$")))
+        .thenReturn(new OrganizationSelectFieldProperty());
+    when(mockFormFields.get(matches("^.*_group_select$")))
+        .thenReturn(new GroupSelectFieldProperty());
+    when(mockFormFields.get(matches("^.*_date$"))).thenReturn(new DateFieldProperty());
+    when(mockFormFields.get(matches("^.*_time$"))).thenReturn(new TimeFieldProperty());
+    when(mockFormFields.get(matches("^.*_datetime$"))).thenReturn(new DateTimeFieldProperty());
+    when(mockFormFields.get(matches("^.*_link$"))).thenReturn(new LinkFieldProperty());
+    when(mockFormFields.get(matches("^.*_file$"))).thenReturn(new FileFieldProperty());
+    when(mockFormFields.get(matches("^.*_subtable$"))).thenReturn(new SubtableFieldProperty());
+    AppClient mockAppClient = mock(AppClient.class);
+    when(mockAppClient.getFormFields(eq(0L))).thenReturn(mockFormFields);
+    GetRecordsByCursorResponseBody mockGetRecordsByCursorResponseBody =
+        mock(GetRecordsByCursorResponseBody.class);
+    when(mockGetRecordsByCursorResponseBody.getRecords()).thenReturn(records);
+    when(mockGetRecordsByCursorResponseBody.hasNext()).thenReturn(false);
+    when(mockRecordClient.createCursor(eq(0L), eq(fields), eq(query))).thenReturn("id");
+    when(mockRecordClient.getRecordsByCursor(eq("id")))
+        .thenReturn(mockGetRecordsByCursorResponseBody);
+    when(mockRecordClient.addRecords(eq(0L), anyList())).thenReturn(Collections.emptyList());
+    when(mockRecordClient.updateRecords(eq(0L), anyList())).thenReturn(Collections.emptyList());
+    com.kintone.client.KintoneClient mockKintoneClient = mock(KintoneClient.class);
+    when(mockKintoneClient.app()).thenReturn(mockAppClient);
+    when(mockKintoneClient.record()).thenReturn(mockRecordClient);
+    KintoneClientBuilder mockKintoneClientBuilder = mock(KintoneClientBuilder.class);
+    when(mockKintoneClientBuilder.authByApiToken(eq("token"))).thenReturn(mockKintoneClientBuilder);
+    when(mockKintoneClientBuilder.build()).thenReturn(mockKintoneClient);
+    try (MockedStatic<KintoneClientBuilder> mocked = mockStatic(KintoneClientBuilder.class)) {
+      mocked
+          .when(() -> KintoneClientBuilder.create(String.format("https://%s", domain)))
+          .thenReturn(mockKintoneClientBuilder);
+      runnable.run();
+    }
+  }
+
+  public interface Runnable {
+    void run() throws Exception;
+  }
+}