embulk-output-kintone 0.4.0 → 1.0.0

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

@@ -0,0 +1,73 @@
+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 javax.validation.UnexpectedTypeException;
+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> options;
+  private final PageReader reader;
+  private final KintoneColumnVisitor visitor;
+
+  public KintoneColumnVisitorVerifier(
+      Schema schema, Map<String, KintoneColumnOption> options, String updateKeyName, Page page) {
+    this(schema, options, false, false, updateKeyName, page);
+  }
+
+  public KintoneColumnVisitorVerifier(
+      Schema schema,
+      Map<String, KintoneColumnOption> options,
+      boolean preferNulls,
+      boolean ignoreNulls,
+      String updateKeyName,
+      Page page) {
+    this.schema = schema;
+    this.options = options;
+    reader = new PageReader(schema);
+    reader.setPage(page);
+    visitor = new KintoneColumnVisitor(reader, options, preferNulls, ignoreNulls, updateKeyName);
+  }
+
+  public void verify() {
+    verify((record, updateKey) -> {});
+  }
+
+  public void verify(BiConsumer<Record, UpdateKey> consumer) {
+    verify(consumer, false);
+  }
+
+  public void verify(BiConsumer<Record, UpdateKey> consumer, boolean nullable) {
+    if (!reader.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, nullable));
+    consumer.accept(record, updateKey);
+  }
+
+  private void verify(Record record, Column column, boolean nullable) {
+    FieldType expected = FieldType.valueOf(options.get(column.getName()).getType());
+    FieldType actual = record.getFieldType(column.getName());
+    if (actual == null && nullable) {
+      return;
+    }
+    if (expected != actual) {
+      throw new UnexpectedTypeException(
+          String.format(
+              "%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,221 @@
+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.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.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()));
+    assertThat(reason, actual, is(expected));
+  }
+
+  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()));
+  }
+
+  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() {}
+}

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

@@ -1,3 +1,178 @@
 package org.embulk.output.kintone;
 
-public class TestKintoneOutputPlugin {}
+import com.google.common.io.Resources;
+import com.kintone.client.Json;
+import com.kintone.client.model.record.Record;
+import com.kintone.client.model.record.RecordForUpdate;
+import com.kintone.client.model.record.UpdateKey;
+import java.io.File;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.TaskSource;
+import org.embulk.spi.OutputPlugin;
+import org.embulk.spi.Schema;
+import org.embulk.spi.TransactionalPageOutput;
+import org.embulk.spi.json.JsonParser;
+import org.embulk.test.EmbulkTests;
+import org.embulk.test.TestingEmbulk;
+import org.junit.Rule;
+import org.msgpack.value.Value;
+
+public class TestKintoneOutputPlugin extends KintoneOutputPlugin {
+  private static final JsonParser PARSER = new JsonParser();
+
+  @Rule
+  public final TestingEmbulk embulk =
+      TestingEmbulk.builder()
+          .registerPlugin(OutputPlugin.class, "kintone", TestKintoneOutputPlugin.class)
+          .build();
+
+  @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));
+  }
+
+  protected void runOutput(String configName, String inputName) throws Exception {
+    System.gc();
+    ConfigSource outConfig = loadConfigYaml(configName);
+    Path inputPath = getResourceFile(inputName).toPath();
+    embulk.runOutput(outConfig, inputPath);
+  }
+
+  protected String getConfigName() {
+    return getName("config.yml");
+  }
+
+  protected String getInputName() {
+    return getName("input.csv");
+  }
+
+  protected String getName(String name) {
+    return name;
+  }
+
+  protected ConfigSource config(String... strings) {
+    return Arrays.stream(strings)
+        .map(this::fromYamlString)
+        .reduce(ConfigSource::merge)
+        .orElseGet(() -> fromYamlString("{}"));
+  }
+
+  protected ConfigSource loadConfigYaml(String name) {
+    ConfigSource config = loadYamlResource("config.yml");
+    return config.merge(loadYamlResource(name));
+  }
+
+  protected ConfigSource loadYamlResource(String name) {
+    return embulk.loadYamlResource(getResourceName(name));
+  }
+
+  protected ConfigSource fromYamlString(String string) {
+    return embulk.configLoader().fromYamlString(string);
+  }
+
+  private static List<String> getValues(String test, boolean preferNulls, boolean ignoreNulls) {
+    String name =
+        String.format(
+            "%s/values%s.json",
+            test, ignoreNulls ? "_ignore_nulls" : preferNulls ? "_prefer_nulls" : "");
+    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<Record> getAddRecords(
+      String test, String mode, boolean preferNulls, boolean ignoreNulls) {
+    String name =
+        String.format(
+            "%s/%s_add%s_records.jsonl",
+            test, mode, 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))
+            .collect(Collectors.toList());
+  }
+
+  private static List<RecordForUpdate> getUpdateRecords(
+      String test, String mode, boolean preferNulls, boolean ignoreNulls, String field) {
+    Function<Record, UpdateKey> key = getKey(field);
+    String name =
+        String.format(
+            "%s/%s_update%s_records.jsonl",
+            test, mode, 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)))
+            .collect(Collectors.toList());
+  }
+
+  private static Function<Record, UpdateKey> getKey(String field) {
+    return field == null
+        ? record -> null
+        : record ->
+            field.matches("^.*_number$")
+                ? new UpdateKey(field, record.getNumberFieldValue(field))
+                : new UpdateKey(field, record.getSingleLineTextFieldValue(field));
+  }
+
+  private static File getResourceFile(String name) {
+    return toPath(Objects.requireNonNull(getResource(getResourceName(name)))).toFile();
+  }
+
+  private static String readResource(String name) {
+    return EmbulkTests.readResource(getResourceName(name));
+  }
+
+  private static boolean existsResource(String name) {
+    return getResource(getResourceName(name)) != null;
+  }
+
+  private static String getResourceName(String name) {
+    return String.format("org/embulk/output/kintone/%s", name);
+  }
+
+  private static Path toPath(URL url) {
+    try {
+      return Paths.get(url.toURI());
+    } catch (URISyntaxException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @SuppressWarnings("UnstableApiUsage")
+  private static URL getResource(String resourceName) {
+    try {
+      return Resources.getResource(resourceName);
+    } catch (IllegalArgumentException e) {
+      return null;
+    }
+  }
+}

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

@@ -0,0 +1,40 @@
+package org.embulk.output.kintone;
+
+import org.embulk.config.ConfigSource;
+import org.junit.Before;
+
+public class TestTask extends TestKintoneOutputPlugin {
+  private ConfigSource config;
+
+  @Before
+  public void before() {
+    config = fromYamlString("{}");
+  }
+
+  @Override
+  protected ConfigSource loadConfigYaml(String name) {
+    ConfigSource config = super.loadConfigYaml("task/config.yml");
+    return config.merge(loadYamlResource(name)).merge(this.config);
+  }
+
+  protected void merge(ConfigSource config) {
+    this.config.merge(config);
+  }
+
+  protected void runOutput() throws Exception {
+    String test = config.get(String.class, "domain");
+    runOutput(getConfigName(test), getInputName(test));
+  }
+
+  private String getConfigName(String test) {
+    return getName(test, getConfigName());
+  }
+
+  private String getInputName(String test) {
+    return getName(test, getInputName());
+  }
+
+  private static String getName(String test, String name) {
+    return String.format("%s/%s", test, name);
+  }
+}

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

@@ -0,0 +1,43 @@
+package org.embulk.output.kintone;
+
+import net.jcip.annotations.NotThreadSafe;
+import org.junit.Test;
+
+@NotThreadSafe
+public class TestTaskMode extends TestTask {
+  @Override
+  public void before() {
+    super.before();
+    merge(config("domain: task/mode"));
+  }
+
+  @Test
+  public void testInsert() throws Exception {
+    merge(config("mode: insert"));
+    runOutput();
+    merge(config("prefer_nulls: true"));
+    runOutput();
+    merge(config("ignore_nulls: true"));
+    runOutput();
+  }
+
+  @Test
+  public void testUpdate() throws Exception {
+    merge(config("mode: update", "update_key: string_number"));
+    runOutput();
+    merge(config("prefer_nulls: true"));
+    runOutput();
+    merge(config("ignore_nulls: true"));
+    runOutput();
+  }
+
+  @Test
+  public void testUpsert() throws Exception {
+    merge(config("mode: upsert", "update_key: double_single_line_text"));
+    runOutput();
+    merge(config("prefer_nulls: true"));
+    runOutput();
+    merge(config("ignore_nulls: true"));
+    runOutput();
+  }
+}

data/src/test/resources/logback-test.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE configuration>
+<configuration>
+  <import class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"/>
+  <import class="ch.qos.logback.core.ConsoleAppender"/>
+  <appender name="STDOUT" class="ConsoleAppender">
+    <encoder class="PatternLayoutEncoder">
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} -%kvp- %msg%n</pattern>
+    </encoder>
+  </appender>
+  <root level="debug">
+    <appender-ref ref="STDOUT"/>
+  </root>
+</configuration>

data/src/test/resources/org/embulk/output/kintone/config.yml

@@ -0,0 +1,4 @@
+type: kintone
+domain: domain
+app_id: 0
+token: token

data/src/test/resources/org/embulk/output/kintone/task/config.yml

@@ -0,0 +1 @@
+{}