embulk-output-kintone 1.0.0 → 1.2.0

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

@@ -1,62 +1,74 @@
 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;
 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.SubtableFieldValue;
 import com.kintone.client.model.record.UpdateKey;
 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;
 
+  public KintonePageOutputVerifier(
+      String domain,
+      String field,
+      List<String> values,
+      List<String> addValues,
+      List<Record> addRecords,
+      List<RecordForUpdate> updateRecords) {
+    this(null, domain, field, values, addValues, addRecords, updateRecords);
+  }
+
   public KintonePageOutputVerifier(
       TransactionalPageOutput 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;
   }
@@ -73,6 +85,9 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
 
   @Override
   public void close() {
+    if (transactionalPageOutput == null) {
+      return;
+    }
     transactionalPageOutput.close();
   }
 
@@ -86,45 +101,27 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
     return transactionalPageOutput.commit();
   }
 
-  public void runWithMock(Runnable runnable) {
+  public void runWithMock(MockClient.Runnable runnable) {
     try {
-      runWithMockClient(runnable);
+      runWithMockExec(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();
+  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);
+      runWithMockClient(runnable);
     }
+  }
+
+  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());
@@ -147,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()
@@ -167,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
@@ -181,16 +222,32 @@ public class KintonePageOutputVerifier implements TransactionalPageOutput {
     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)));
+    actual.getFieldCodes(true).forEach(fieldCode -> assertSubtableFieldValue(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) {
+    if (actual.getType() == FieldType.SUBTABLE) {
+      return;
+    }
     String reason = String.format("%s:%d:%s", domain, index, fieldCode);
     assertThat(reason, actual.getType(), is(expected.getType()));
     assertThat(reason, actual, is(expected));
   }
 
+  private static void assertSubtableFieldValue(
+      String domain, int index, String fieldCode, FieldValue actual, FieldValue expected) {
+    if (actual.getType() != FieldType.SUBTABLE) {
+      return;
+    }
+    String reason = String.format("%s:%d:%s", domain, index, fieldCode);
+    assertThat(reason, actual.getType(), is(expected.getType()));
+    // spotless:off
+    assertTableRows(reason, ((SubtableFieldValue) actual).getRows(), ((SubtableFieldValue) expected).getRows());
+    // spotless:on
+  }
+
   private static void assertRecordForUpdates(
       String domain, List<RecordForUpdate> actual, List<RecordForUpdate> expected) {
     assertThat(domain, actual.size(), is(expected.size()));
@@ -202,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;
+  }
+}

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

@@ -1,5 +1,10 @@
 package org.embulk.output.kintone;
 
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
 import com.google.common.io.Resources;
 import com.kintone.client.Json;
 import com.kintone.client.model.record.Record;
@@ -14,10 +19,17 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import org.embulk.config.ConfigDiff;
 import org.embulk.config.ConfigSource;
 import org.embulk.config.TaskSource;
+import org.embulk.output.kintone.record.Id;
+import org.embulk.output.kintone.record.Skip;
+import org.embulk.spi.Column;
+import org.embulk.spi.Exec;
 import org.embulk.spi.OutputPlugin;
 import org.embulk.spi.Schema;
 import org.embulk.spi.TransactionalPageOutput;
@@ -25,6 +37,7 @@ import org.embulk.spi.json.JsonParser;
 import org.embulk.test.EmbulkTests;
 import org.embulk.test.TestingEmbulk;
 import org.junit.Rule;
+import org.mockito.InOrder;
 import org.msgpack.value.Value;
 
 public class TestKintoneOutputPlugin extends KintoneOutputPlugin {
@@ -36,20 +49,19 @@ public class TestKintoneOutputPlugin extends KintoneOutputPlugin {
           .registerPlugin(OutputPlugin.class, "kintone", TestKintoneOutputPlugin.class)
           .build();
 
+  @Override
+  public ConfigDiff transaction(
+      ConfigSource config, Schema schema, int taskCount, Control control) {
+    return config.get(String.class, "reduce_key", null) == null
+        ? super.transaction(config, schema, taskCount, control)
+        : transactionWithVerifier(config, schema, taskCount, control);
+  }
+
   @Override
   public TransactionalPageOutput open(TaskSource taskSource, Schema schema, int taskIndex) {
-    String test = taskSource.get(String.class, "Domain");
-    String mode = taskSource.get(String.class, "Mode");
-    String field = taskSource.get(String.class, "UpdateKeyName");
-    boolean preferNulls = taskSource.get(boolean.class, "PreferNulls");
-    boolean ignoreNulls = taskSource.get(boolean.class, "IgnoreNulls");
-    return new KintonePageOutputVerifier(
-        super.open(taskSource, schema, taskIndex),
-        test,
-        field,
-        getValues(test, preferNulls, ignoreNulls),
-        getAddRecords(test, mode, preferNulls, ignoreNulls),
-        getUpdateRecords(test, mode, preferNulls, ignoreNulls, field));
+    return taskSource.get(String.class, "ReduceKeyName") == null
+        ? openWithVerifier(taskSource, schema, taskIndex)
+        : super.open(taskSource, schema, taskIndex);
   }
 
   protected void runOutput(String configName, String inputName) throws Exception {
@@ -91,11 +103,105 @@ public class TestKintoneOutputPlugin extends KintoneOutputPlugin {
     return embulk.configLoader().fromYamlString(string);
   }
 
-  private static List<String> getValues(String test, boolean preferNulls, boolean ignoreNulls) {
+  private ConfigDiff transactionWithVerifier(
+      ConfigSource config, Schema schema, int taskCount, Control control) {
+    try (KintonePageOutputVerifier verifier = verifier(config)) {
+      return runWithMock(verifier, config, schema, taskCount, control);
+    }
+  }
+
+  private ConfigDiff runWithMock(
+      KintonePageOutputVerifier verifier,
+      ConfigSource config,
+      Schema schema,
+      int taskCount,
+      OutputPlugin.Control control) {
+    String test = config.get(String.class, "domain");
+    PluginTask spyTask = spy(config.loadConfig(PluginTask.class));
+    ConfigSource spyConfig = spy(config);
+    when(spyConfig.loadConfig(PluginTask.class)).thenReturn(spyTask);
+    AtomicReference<ConfigDiff> configDiff = new AtomicReference<>();
+    verifier.runWithMock(
+        () -> configDiff.set(super.transaction(spyConfig, schema, taskCount, control)));
+    verify(spyConfig).loadConfig(PluginTask.class);
+    InOrder inOrderTask = inOrder(spyTask);
+    inOrderTask.verify(spyTask).setDerivedColumns(Collections.emptySet());
+    inOrderTask.verify(spyTask).setDerivedColumns(getDerivedColumns(test));
+    return configDiff.get();
+  }
+
+  private KintonePageOutputVerifier verifier(ConfigSource config) {
+    String test = config.get(String.class, "domain");
+    String mode = config.get(String.class, "mode");
+    String field = config.get(String.class, "update_key", null);
+    Skip skip = config.get(Skip.class, "skip_if_non_existing_id_or_update_key");
+    boolean preferNulls = config.get(boolean.class, "prefer_nulls", false);
+    boolean ignoreNulls = config.get(boolean.class, "ignore_nulls", false);
+    return new KintonePageOutputVerifier(
+        test,
+        field,
+        getValues(test, mode, skip, preferNulls, ignoreNulls, field),
+        getAddValues(test, mode, skip, preferNulls, ignoreNulls, field),
+        getAddRecords(test, mode, skip, preferNulls, ignoreNulls),
+        getUpdateRecords(test, mode, skip, preferNulls, ignoreNulls, field));
+  }
+
+  private TransactionalPageOutput openWithVerifier(
+      TaskSource taskSource, Schema schema, int taskIndex) {
+    String test = taskSource.get(String.class, "Domain");
+    String mode = taskSource.get(String.class, "Mode");
+    String field = taskSource.get(String.class, "UpdateKeyName");
+    Skip skip = taskSource.get(Skip.class, "SkipIfNonExistingIdOrUpdateKey");
+    boolean preferNulls = taskSource.get(boolean.class, "PreferNulls");
+    boolean ignoreNulls = taskSource.get(boolean.class, "IgnoreNulls");
+    return new KintonePageOutputVerifier(
+        super.open(taskSource, schema, taskIndex),
+        test,
+        field,
+        getValues(test, mode, skip, preferNulls, ignoreNulls, field),
+        getAddValues(test, mode, skip, preferNulls, ignoreNulls, field),
+        getAddRecords(test, mode, skip, preferNulls, ignoreNulls),
+        getUpdateRecords(test, mode, skip, preferNulls, ignoreNulls, field));
+  }
+
+  private static Set<Column> getDerivedColumns(String test) {
+    String name = String.format("%s/derived_columns.json", test);
+    String json = existsResource(name) ? readResource(name) : null;
+    return json == null || json.isEmpty()
+        ? Collections.emptySet()
+        : PARSER.parse(json).asArrayValue().list().stream()
+            .map(value -> Exec.getModelManager().readObject(Column.class, value.toJson()))
+            .collect(Collectors.toSet());
+  }
+
+  private static List<String> getValues(
+      String test, String mode, Skip skip, boolean preferNulls, boolean ignoreNulls, String field) {
+    String name =
+        String.format(
+            "%s/%s%s%s%s_values.json",
+            test,
+            mode,
+            format(skip),
+            ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "",
+            format(field));
+    String json = existsResource(name) ? readResource(name) : null;
+    return json == null || json.isEmpty()
+        ? Collections.emptyList()
+        : PARSER.parse(json).asArrayValue().list().stream()
+            .map(Value::toJson)
+            .collect(Collectors.toList());
+  }
+
+  private static List<String> getAddValues(
+      String test, String mode, Skip skip, boolean preferNulls, boolean ignoreNulls, String field) {
     String name =
         String.format(
-            "%s/values%s.json",
-            test, ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "");
+            "%s/%s%s%s%s_add_values.json",
+            test,
+            mode,
+            format(skip),
+            ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "",
+            format(field));
     String json = existsResource(name) ? readResource(name) : null;
     return json == null || json.isEmpty()
         ? Collections.emptyList()
@@ -105,11 +211,14 @@ public class TestKintoneOutputPlugin extends KintoneOutputPlugin {
   }
 
   private static List<Record> getAddRecords(
-      String test, String mode, boolean preferNulls, boolean ignoreNulls) {
+      String test, String mode, Skip skip, boolean preferNulls, boolean ignoreNulls) {
     String name =
         String.format(
-            "%s/%s_add%s_records.jsonl",
-            test, mode, ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "");
+            "%s/%s%s%s_add_records.jsonl",
+            test,
+            mode,
+            format(skip),
+            ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "");
     String jsonl = existsResource(name) ? readResource(name) : null;
     return jsonl == null || jsonl.isEmpty()
         ? Collections.emptyList()
@@ -119,21 +228,37 @@ public class TestKintoneOutputPlugin extends KintoneOutputPlugin {
   }
 
   private static List<RecordForUpdate> getUpdateRecords(
-      String test, String mode, boolean preferNulls, boolean ignoreNulls, String field) {
+      String test, String mode, Skip skip, boolean preferNulls, boolean ignoreNulls, String field) {
     Function<Record, UpdateKey> key = getKey(field);
+    Function<Record, RecordForUpdate> forUpdate =
+        record ->
+            Id.FIELD.equals(field)
+                ? new RecordForUpdate(record.getId(), Record.newFrom(record))
+                : new RecordForUpdate(key.apply(record), record.removeField(field));
     String name =
         String.format(
-            "%s/%s_update%s_records.jsonl",
-            test, mode, ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "");
+            "%s/%s%s%s_update_records.jsonl",
+            test,
+            mode,
+            format(skip),
+            ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "");
     String jsonl = existsResource(name) ? readResource(name) : null;
     return jsonl == null || jsonl.isEmpty()
         ? Collections.emptyList()
         : Arrays.stream(jsonl.split("\\r?\\n|\\r"))
             .map(s -> Json.parse(s, Record.class))
-            .map(record -> new RecordForUpdate(key.apply(record), record.removeField(field)))
+            .map(forUpdate)
             .collect(Collectors.toList());
   }
 
+  private static String format(Skip skip) {
+    return skip == Skip.AUTO ? "" : String.format("_%s_skip", skip.name().toLowerCase());
+  }
+
+  private static String format(String string) {
+    return string == null ? "" : String.format("_%s", string.replace('$', '_'));
+  }
+
   private static Function<Record, UpdateKey> getKey(String field) {
     return field == null
         ? record -> null

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

@@ -34,6 +34,7 @@ public class TestTaskMode extends TestTask {
   @Test
   public void testUpsert() throws Exception {
     merge(config("mode: upsert", "update_key: double_single_line_text"));
+    merge(config("skip_if_non_existing_id_or_update_key: never"));
     runOutput();
     merge(config("prefer_nulls: true"));
     runOutput();