embulk-output-kintone 0.4.0 → 0.4.1

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

@@ -0,0 +1,297 @@
+package org.embulk.output.kintone;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+
+import com.google.common.collect.ImmutableMap;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import org.embulk.spi.Page;
+import org.embulk.spi.Schema;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.type.Types;
+import org.junit.Test;
+import org.msgpack.value.ValueFactory;
+
+public class KintoneColumnVisitorTest {
+  @Test
+  public void test() {
+    Schema schema = build(Schema.builder());
+    KintoneColumnVisitorVerifier verifier =
+        new KintoneColumnVisitorVerifier(
+            schema,
+            build(ImmutableMap.builder()),
+            "STRING|SINGLE_LINE_TEXT",
+            OutputPageBuilder.build(schema, KintoneColumnVisitorTest::build));
+    verifier.verify(
+        (record, updateKey) -> {
+          assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
+          assertThat(record.getNumberFieldValue("BOOLEAN"), nullValue());
+          assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is(""));
+          assertThat(record.getNumberFieldValue("LONG"), nullValue());
+          assertThat(record.getSingleLineTextFieldValue("DOUBLE|SINGLE_LINE_TEXT"), is("0.0"));
+          assertThat(record.getNumberFieldValue("DOUBLE"), is(number("0.0")));
+          assertThat(record.getSingleLineTextFieldValue("STRING|SINGLE_LINE_TEXT"), is(""));
+          assertThat(record.getMultiLineTextFieldValue("STRING"), is(""));
+          assertThat(record.getNumberFieldValue("STRING|NUMBER"), nullValue());
+          assertThat(record.getCheckBoxFieldValue("STRING|CHECK_BOX"), is(list("null")));
+          assertThat(record.getDropDownFieldValue("STRING|DROP_DOWN"), is(""));
+          assertThat(record.getLinkFieldValue("STRING|LINK"), is(""));
+          assertThat(record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"), nullValue());
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE"), nullValue());
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|JST"), nullValue());
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|PST"), nullValue());
+          assertThat(record.getDateTimeFieldValue("TIMESTAMP"), nullValue());
+          assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is(""));
+          assertThat(record.getMultiLineTextFieldValue("JSON"), is(""));
+          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(updateKey.getValue(), is(""));
+        });
+    verifier.verify(
+        (record, updateKey) -> {
+          assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
+          assertThat(record.getNumberFieldValue("BOOLEAN"), nullValue());
+          assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("0"));
+          assertThat(record.getNumberFieldValue("LONG"), is(number("0")));
+          assertThat(record.getSingleLineTextFieldValue("DOUBLE|SINGLE_LINE_TEXT"), is("0.0"));
+          assertThat(record.getNumberFieldValue("DOUBLE"), is(number("0.0")));
+          assertThat(record.getSingleLineTextFieldValue("STRING|SINGLE_LINE_TEXT"), is(""));
+          assertThat(record.getMultiLineTextFieldValue("STRING"), is(""));
+          assertThat(record.getNumberFieldValue("STRING|NUMBER"), nullValue());
+          assertThat(record.getCheckBoxFieldValue("STRING|CHECK_BOX"), is(list()));
+          assertThat(record.getDropDownFieldValue("STRING|DROP_DOWN"), is(""));
+          assertThat(record.getLinkFieldValue("STRING|LINK"), is(""));
+          assertThat(record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"), nullValue());
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|JST"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|PST"), is(date("1969-12-31")));
+          assertThat(
+              record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("1970-01-01T00:00:00Z")));
+          assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is(""));
+          assertThat(record.getMultiLineTextFieldValue("JSON"), is(""));
+          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(updateKey.getValue(), is(""));
+        });
+    verifier.verify(
+        (record, updateKey) -> {
+          assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("true"));
+          assertThat(record.getNumberFieldValue("BOOLEAN"), nullValue());
+          assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("123"));
+          assertThat(record.getNumberFieldValue("LONG"), is(number("123")));
+          assertThat(record.getSingleLineTextFieldValue("DOUBLE|SINGLE_LINE_TEXT"), is("123.0"));
+          assertThat(record.getNumberFieldValue("DOUBLE"), is(number("123.0")));
+          assertThat(record.getSingleLineTextFieldValue("STRING|SINGLE_LINE_TEXT"), is("abc"));
+          assertThat(record.getMultiLineTextFieldValue("STRING"), is("abc"));
+          assertThat(record.getNumberFieldValue("STRING|NUMBER"), is(number("123")));
+          assertThat(record.getCheckBoxFieldValue("STRING|CHECK_BOX"), is(list("123", "abc")));
+          assertThat(record.getDropDownFieldValue("STRING|DROP_DOWN"), is("abc"));
+          assertThat(record.getLinkFieldValue("STRING|LINK"), is("abc"));
+          assertThat(record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"), nullValue());
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE"), is(date("1999-12-31")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|JST"), is(date("2000-01-01")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|PST"), is(date("1999-12-31")));
+          assertThat(
+              record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("1999-12-31T23:59:59Z")));
+          assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is("abc"));
+          assertThat(record.getMultiLineTextFieldValue("JSON"), is("abc"));
+          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(updateKey.getValue(), is("abc"));
+        });
+    verifier.verify(
+        (record, updateKey) -> {
+          assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
+          assertThat(record.getNumberFieldValue("BOOLEAN"), nullValue());
+          assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("456"));
+          assertThat(record.getNumberFieldValue("LONG"), is(number("456")));
+          assertThat(record.getSingleLineTextFieldValue("DOUBLE|SINGLE_LINE_TEXT"), is("456.0"));
+          assertThat(record.getNumberFieldValue("DOUBLE"), is(number("456.0")));
+          assertThat(record.getSingleLineTextFieldValue("STRING|SINGLE_LINE_TEXT"), is("def"));
+          assertThat(record.getMultiLineTextFieldValue("STRING"), is("def"));
+          assertThat(record.getNumberFieldValue("STRING|NUMBER"), is(number("456")));
+          assertThat(record.getCheckBoxFieldValue("STRING|CHECK_BOX"), is(list("456", "def")));
+          assertThat(record.getDropDownFieldValue("STRING|DROP_DOWN"), is("def"));
+          assertThat(record.getLinkFieldValue("STRING|LINK"), is("def"));
+          assertThat(record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"), nullValue());
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE"), is(date("2000-01-01")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|JST"), is(date("2000-01-01")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|PST"), is(date("1999-12-31")));
+          assertThat(
+              record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("2000-01-01T00:00:00Z")));
+          assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is("def"));
+          assertThat(record.getMultiLineTextFieldValue("JSON"), is("def"));
+          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(updateKey.getValue(), is("def"));
+        });
+  }
+
+  private static Schema build(Schema.Builder builder) {
+    return builder
+        .add("BOOLEAN|SINGLE_LINE_TEXT", Types.BOOLEAN)
+        // java.lang.NumberFormatException at java.math.BigDecimal.<init>
+        // .add("BOOLEAN", Types.BOOLEAN)
+        .add("LONG|SINGLE_LINE_TEXT", Types.LONG)
+        .add("LONG", Types.LONG)
+        .add("DOUBLE|SINGLE_LINE_TEXT", Types.DOUBLE)
+        .add("DOUBLE", Types.DOUBLE)
+        .add("STRING|SINGLE_LINE_TEXT", Types.STRING)
+        .add("STRING", Types.STRING)
+        .add("STRING|NUMBER", Types.STRING)
+        .add("STRING|CHECK_BOX", Types.STRING)
+        .add("STRING|DROP_DOWN", Types.STRING)
+        .add("STRING|LINK", Types.STRING)
+        .add("TIMESTAMP|SINGLE_LINE_TEXT", Types.TIMESTAMP)
+        .add("TIMESTAMP|DATE", Types.TIMESTAMP)
+        .add("TIMESTAMP|DATE|JST", Types.TIMESTAMP)
+        .add("TIMESTAMP|DATE|PST", Types.TIMESTAMP)
+        .add("TIMESTAMP", Types.TIMESTAMP)
+        .add("JSON|SINGLE_LINE_TEXT", Types.JSON)
+        .add("JSON", Types.JSON)
+        .build();
+  }
+
+  private static Map<String, KintoneColumnOption> build(
+      ImmutableMap.Builder<String, KintoneColumnOption> builder) {
+    return builder
+        .put(build("BOOLEAN|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
+        .put(build("BOOLEAN", it -> it.setType("NUMBER")))
+        .put(build("LONG|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
+        .put(build("LONG", it -> it.setType("NUMBER")))
+        .put(build("DOUBLE|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
+        .put(build("DOUBLE", it -> it.setType("NUMBER")))
+        .put(build("STRING|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
+        .put(build("STRING", it -> it.setType("MULTI_LINE_TEXT")))
+        .put(build("STRING|NUMBER", it -> it.setType("NUMBER")))
+        .put(build("STRING|CHECK_BOX", it -> it.setType("CHECK_BOX").setValueSeparator(",")))
+        .put(build("STRING|DROP_DOWN", it -> it.setType("DROP_DOWN")))
+        .put(build("STRING|LINK", it -> it.setType("LINK")))
+        .put(build("TIMESTAMP|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
+        .put(build("TIMESTAMP|DATE", it -> it.setType("DATE").setTimezone("UTC")))
+        .put(build("TIMESTAMP|DATE|JST", it -> it.setType("DATE").setTimezone("Asia/Tokyo")))
+        .put(build("TIMESTAMP|DATE|PST", it -> it.setType("DATE").setTimezone("US/Pacific")))
+        .put(build("TIMESTAMP", it -> it.setType("DATETIME")))
+        .put(build("JSON|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
+        .put(build("JSON", it -> it.setType("MULTI_LINE_TEXT")))
+        .build();
+  }
+
+  private static Map.Entry<String, KintoneColumnOption> build(
+      String name, Function<KintoneColumnOptionBuilder, KintoneColumnOptionBuilder> function) {
+    return new AbstractMap.SimpleImmutableEntry<>(
+        name, function.apply(new KintoneColumnOptionBuilder().setFieldCode(name)).build());
+  }
+
+  private static Page build(OutputPageBuilder builder) {
+    return builder
+        .setNull("BOOLEAN|SINGLE_LINE_TEXT")
+        // .setNull("BOOLEAN")
+        .setNull("LONG|SINGLE_LINE_TEXT")
+        .setNull("LONG")
+        .setNull("DOUBLE|SINGLE_LINE_TEXT")
+        .setNull("DOUBLE")
+        .setNull("STRING|SINGLE_LINE_TEXT")
+        .setNull("STRING")
+        .setNull("STRING|NUMBER")
+        .setNull("STRING|CHECK_BOX")
+        .setNull("STRING|DROP_DOWN")
+        .setNull("STRING|LINK")
+        .setNull("TIMESTAMP|SINGLE_LINE_TEXT")
+        .setNull("TIMESTAMP|DATE")
+        .setNull("TIMESTAMP|DATE|JST")
+        .setNull("TIMESTAMP|DATE|PST")
+        .setNull("TIMESTAMP")
+        .setNull("JSON|SINGLE_LINE_TEXT")
+        .setNull("JSON")
+        .addRecord()
+        .setBoolean("BOOLEAN|SINGLE_LINE_TEXT", false)
+        // .setBoolean("BOOLEAN", false)
+        .setLong("LONG|SINGLE_LINE_TEXT", 0)
+        .setLong("LONG", 0)
+        .setDouble("DOUBLE|SINGLE_LINE_TEXT", 0)
+        .setDouble("DOUBLE", 0)
+        .setString("STRING|SINGLE_LINE_TEXT", "")
+        .setString("STRING", "")
+        .setString("STRING|NUMBER", "")
+        .setString("STRING|CHECK_BOX", "")
+        .setString("STRING|DROP_DOWN", "")
+        .setString("STRING|LINK", "")
+        .setTimestamp("TIMESTAMP|SINGLE_LINE_TEXT", Timestamp.ofInstant(Instant.EPOCH))
+        .setTimestamp("TIMESTAMP|DATE", Timestamp.ofInstant(Instant.EPOCH))
+        .setTimestamp("TIMESTAMP|DATE|JST", Timestamp.ofInstant(Instant.EPOCH))
+        .setTimestamp("TIMESTAMP|DATE|PST", Timestamp.ofInstant(Instant.EPOCH))
+        .setTimestamp("TIMESTAMP", Timestamp.ofInstant(Instant.EPOCH))
+        .setJson("JSON|SINGLE_LINE_TEXT", ValueFactory.newString(""))
+        .setJson("JSON", ValueFactory.newString(""))
+        .addRecord()
+        .setBoolean("BOOLEAN|SINGLE_LINE_TEXT", true)
+        // .setBoolean("BOOLEAN", true)
+        .setLong("LONG|SINGLE_LINE_TEXT", 123)
+        .setLong("LONG", 123)
+        .setDouble("DOUBLE|SINGLE_LINE_TEXT", 123)
+        .setDouble("DOUBLE", 123)
+        .setString("STRING|SINGLE_LINE_TEXT", "abc")
+        .setString("STRING", "abc")
+        .setString("STRING|NUMBER", "123")
+        .setString("STRING|CHECK_BOX", "123,abc")
+        .setString("STRING|DROP_DOWN", "abc")
+        .setString("STRING|LINK", "abc")
+        .setTimestamp("TIMESTAMP|SINGLE_LINE_TEXT", timestamp("1999-12-31T23:59:59Z"))
+        .setTimestamp("TIMESTAMP|DATE", timestamp("1999-12-31T23:59:59Z"))
+        .setTimestamp("TIMESTAMP|DATE|JST", timestamp("1999-12-31T23:59:59Z"))
+        .setTimestamp("TIMESTAMP|DATE|PST", timestamp("1999-12-31T23:59:59Z"))
+        .setTimestamp("TIMESTAMP", timestamp("1999-12-31T23:59:59Z"))
+        .setJson("JSON|SINGLE_LINE_TEXT", ValueFactory.newString("abc"))
+        .setJson("JSON", ValueFactory.newString("abc"))
+        .addRecord()
+        .setBoolean("BOOLEAN|SINGLE_LINE_TEXT", false)
+        // .setBoolean("BOOLEAN", false)
+        .setLong("LONG|SINGLE_LINE_TEXT", 456)
+        .setLong("LONG", 456)
+        .setDouble("DOUBLE|SINGLE_LINE_TEXT", 456)
+        .setDouble("DOUBLE", 456)
+        .setString("STRING|SINGLE_LINE_TEXT", "def")
+        .setString("STRING", "def")
+        .setString("STRING|NUMBER", "456")
+        .setString("STRING|CHECK_BOX", "456,def")
+        .setString("STRING|DROP_DOWN", "def")
+        .setString("STRING|LINK", "def")
+        .setTimestamp("TIMESTAMP|SINGLE_LINE_TEXT", timestamp("2000-01-01T00:00:00Z"))
+        .setTimestamp("TIMESTAMP|DATE", timestamp("2000-01-01T00:00:00Z"))
+        .setTimestamp("TIMESTAMP|DATE|JST", timestamp("2000-01-01T00:00:00Z"))
+        .setTimestamp("TIMESTAMP|DATE|PST", timestamp("2000-01-01T00:00:00Z"))
+        .setTimestamp("TIMESTAMP", timestamp("2000-01-01T00:00:00Z"))
+        .setJson("JSON|SINGLE_LINE_TEXT", ValueFactory.newString("def"))
+        .setJson("JSON", ValueFactory.newString("def"))
+        .addRecord()
+        .build();
+  }
+
+  private static BigDecimal number(String value) {
+    return new BigDecimal(value);
+  }
+
+  @SafeVarargs
+  private static <T> List<T> list(T... a) {
+    return Arrays.asList(a);
+  }
+
+  private static LocalDate date(CharSequence text) {
+    return LocalDate.parse(text);
+  }
+
+  private static ZonedDateTime dateTime(CharSequence text) {
+    return ZonedDateTime.parse(text).withZoneSameInstant(ZoneId.of("UTC"));
+  }
+
+  private static Timestamp timestamp(CharSequence text) {
+    return Timestamp.ofInstant(Instant.parse(text));
+  }
+}

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

@@ -0,0 +1,52 @@
+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.function.BiConsumer;
+import org.embulk.spi.Column;
+import org.embulk.spi.Page;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.Schema;
+
+public class KintoneColumnVisitorVerifier {
+  private final Schema schema;
+  private final Map<String, KintoneColumnOption> columnOptions;
+  private final PageReader pageReader;
+  private final KintoneColumnVisitor visitor;
+
+  public KintoneColumnVisitorVerifier(
+      Schema schema,
+      Map<String, KintoneColumnOption> columnOptions,
+      String updateKeyName,
+      Page page) {
+    this.schema = schema;
+    this.columnOptions = columnOptions;
+    pageReader = new PageReader(schema);
+    pageReader.setPage(page);
+    visitor = new KintoneColumnVisitor(pageReader, columnOptions, updateKeyName);
+  }
+
+  public void verify(BiConsumer<Record, UpdateKey> consumer) {
+    if (!pageReader.nextRecord()) {
+      throw new IllegalStateException();
+    }
+    Record record = new Record();
+    visitor.setRecord(record);
+    UpdateKey updateKey = new UpdateKey();
+    visitor.setUpdateKey(updateKey);
+    schema.visitColumns(visitor);
+    schema.getColumns().forEach(column -> verify(record, column));
+    consumer.accept(record, updateKey);
+  }
+
+  private void verify(Record record, Column column) {
+    FieldType expected = FieldType.valueOf(columnOptions.get(column.getName()).getType());
+    FieldType actual = record.getFieldType(column.getName());
+    if (!expected.equals(actual)) {
+      System.out.printf(
+          "%s: Expected type is %s, but actual type is %s%n", column.getName(), expected, actual);
+    }
+  }
+}

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

@@ -0,0 +1,226 @@
+package org.embulk.output.kintone;
+
+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.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.DateTimeFieldValue;
+import com.kintone.client.model.record.FieldType;
+import com.kintone.client.model.record.FieldValue;
+import com.kintone.client.model.record.NumberFieldValue;
+import com.kintone.client.model.record.Record;
+import com.kintone.client.model.record.RecordForUpdate;
+import com.kintone.client.model.record.SingleLineTextFieldValue;
+import com.kintone.client.model.record.UpdateKey;
+import java.math.BigDecimal;
+import java.time.ZoneId;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import org.embulk.config.TaskReport;
+import org.embulk.spi.Page;
+import org.embulk.spi.TransactionalPageOutput;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+
+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<Record> addRecords;
+  private final List<RecordForUpdate> updateRecords;
+
+  public KintonePageOutputVerifier(
+      TransactionalPageOutput transactionalPageOutput,
+      String domain,
+      String field,
+      List<String> values,
+      List<Record> addRecords,
+      List<RecordForUpdate> updateRecords) {
+    this.transactionalPageOutput = transactionalPageOutput;
+    this.domain = domain;
+    this.field = field;
+    this.values = values;
+    this.addRecords = addRecords;
+    this.updateRecords = updateRecords;
+  }
+
+  @Override
+  public void add(Page page) {
+    runWithMock(() -> transactionalPageOutput.add(page));
+  }
+
+  @Override
+  public void finish() {
+    transactionalPageOutput.finish();
+  }
+
+  @Override
+  public void close() {
+    transactionalPageOutput.close();
+  }
+
+  @Override
+  public void abort() {
+    transactionalPageOutput.abort();
+  }
+
+  @Override
+  public TaskReport commit() {
+    return transactionalPageOutput.commit();
+  }
+
+  public void runWithMock(Runnable runnable) {
+    try {
+      runWithMockClient(runnable);
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  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();
+    }
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<List<Record>> addRecordsArgumentCaptor = ArgumentCaptor.forClass(List.class);
+    verify(mockRecordClient, atLeast(0)).addRecords(eq(0L), addRecordsArgumentCaptor.capture());
+    assertRecords(
+        domain,
+        addRecordsArgumentCaptor.getAllValues().stream()
+            .flatMap(Collection::stream)
+            .collect(Collectors.toList()),
+        addRecords);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<List<RecordForUpdate>> updateRecordsArgumentCaptor =
+        ArgumentCaptor.forClass(List.class);
+    verify(mockRecordClient, atLeast(0))
+        .updateRecords(eq(0L), updateRecordsArgumentCaptor.capture());
+    assertRecordForUpdates(
+        domain,
+        updateRecordsArgumentCaptor.getAllValues().stream()
+            .flatMap(Collection::stream)
+            .collect(Collectors.toList()),
+        updateRecords);
+  }
+
+  private Record getRecord(RecordForUpdate updateRecord) {
+    UpdateKey key = updateRecord.getUpdateKey();
+    String field = key.getField();
+    Object value = key.getValue();
+    return new Record()
+        .putField(
+            field,
+            field.matches("^.*_number$")
+                ? new NumberFieldValue((BigDecimal) value)
+                : new SingleLineTextFieldValue((String) value));
+  }
+
+  private List<String> getFields() {
+    return Collections.singletonList(field);
+  }
+
+  private String getQuery() {
+    return String.format("%s in (%s)", field, String.join(",", values));
+  }
+
+  private static void assertRecords(String domain, List<Record> actual, List<Record> expected) {
+    assertThat(domain, actual.size(), is(expected.size()));
+    // spotless:off
+    IntStream.range(0, actual.size()).forEach(index -> assertRecord(domain, index, actual.get(index), expected.get(index)));
+    // spotless:on
+  }
+
+  private static void assertRecord(String domain, int index, Record actual, Record expected) {
+    String reason = String.format("%s:%d", domain, index);
+    assertThat(reason, actual.getId(), is(expected.getId()));
+    assertThat(reason, actual.getRevision(), is(expected.getRevision()));
+    assertThat(reason, actual.getFieldCodes(true), is(expected.getFieldCodes(true)));
+    // spotless:off
+    actual.getFieldCodes(true).forEach(fieldCode -> assertFieldValue(domain, index, fieldCode, actual.getFieldValue(fieldCode), expected.getFieldValue(fieldCode)));
+    // spotless:on
+  }
+
+  private static void assertFieldValue(
+      String domain, int index, String fieldCode, FieldValue actual, FieldValue expected) {
+    String reason = String.format("%s:%d:%s", domain, index, fieldCode);
+    assertThat(reason, actual.getType(), is(expected.getType()));
+    // spotless:off
+    assertThat(reason, actual, is(expected.getType().equals(FieldType.DATETIME) ? new DateTimeFieldValue(((DateTimeFieldValue) expected).getValue().withZoneSameInstant(ZoneId.of("UTC"))) : expected));
+    // spotless:on
+  }
+
+  private static void assertRecordForUpdates(
+      String domain, List<RecordForUpdate> actual, List<RecordForUpdate> expected) {
+    assertThat(domain, actual.size(), is(expected.size()));
+    // spotless:off
+    IntStream.range(0, actual.size()).forEach(index -> assertRecordForUpdate(domain, index, actual.get(index), expected.get(index)));
+    // spotless:on
+  }
+
+  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());
+    assertRecord(domain, index, actual.getRecord(), expected.getRecord());
+    assertThat(reason, actual.getRevision(), is(expected.getRevision()));
+  }
+
+  private static void assertUpdateKey(
+      String domain, int index, UpdateKey actual, UpdateKey expected) {
+    String reason = String.format("%s:%d", domain, index);
+    assertThat(reason, actual.getField(), is(expected.getField()));
+    assertThat(reason, actual.getValue(), is(expected.getValue().toString()));
+  }
+
+  public interface Runnable {
+    void run() throws Exception;
+  }
+}

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

@@ -0,0 +1,92 @@
+package org.embulk.output.kintone;
+
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.embulk.deps.buffer.PooledBufferAllocator;
+import org.embulk.spi.Column;
+import org.embulk.spi.Page;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.PageOutput;
+import org.embulk.spi.Schema;
+import org.embulk.spi.time.Timestamp;
+import org.msgpack.value.Value;
+
+public class OutputPageBuilder implements PageOutput {
+  private final List<String> names;
+  private final PageBuilder builder;
+  private Page page;
+
+  public static Page build(Schema schema, Function<OutputPageBuilder, Page> function) {
+    Page page;
+    try (OutputPageBuilder builder = new OutputPageBuilder(schema)) {
+      page = function.apply(builder);
+    }
+    return page;
+  }
+
+  public OutputPageBuilder(Schema schema) {
+    names = schema.getColumns().stream().map(Column::getName).collect(Collectors.toList());
+    builder = new PageBuilder(PooledBufferAllocator.create(), schema, this);
+  }
+
+  public OutputPageBuilder setNull(String name) {
+    builder.setNull(names.indexOf(name));
+    return this;
+  }
+
+  public OutputPageBuilder setBoolean(String name, boolean value) {
+    builder.setBoolean(names.indexOf(name), value);
+    return this;
+  }
+
+  public OutputPageBuilder setLong(String name, long value) {
+    builder.setLong(names.indexOf(name), value);
+    return this;
+  }
+
+  public OutputPageBuilder setDouble(String name, double value) {
+    builder.setDouble(names.indexOf(name), value);
+    return this;
+  }
+
+  public OutputPageBuilder setString(String name, String value) {
+    builder.setString(names.indexOf(name), value);
+    return this;
+  }
+
+  public OutputPageBuilder setJson(String name, Value value) {
+    builder.setJson(names.indexOf(name), value);
+    return this;
+  }
+
+  public OutputPageBuilder setTimestamp(String name, Timestamp value) {
+    builder.setTimestamp(names.indexOf(name), value);
+    return this;
+  }
+
+  public OutputPageBuilder addRecord() {
+    builder.addRecord();
+    return this;
+  }
+
+  public Page build() {
+    builder.flush();
+    builder.close();
+    return page;
+  }
+
+  @Override
+  public void add(Page page) {
+    if (this.page != null) {
+      throw new IllegalStateException();
+    }
+    this.page = page;
+  }
+
+  @Override
+  public void finish() {}
+
+  @Override
+  public void close() {}
+}