embulk-output-bigquery 0.2.3 → 0.3.0.pre1

data/test/test_transaction.rb

@@ -0,0 +1,129 @@
+require_relative './helper'
+require 'embulk/output/bigquery'
+
+Bigquery = Embulk::Output::Bigquery unless defined?(Bigquery)
+
+module Embulk
+  class Output::Bigquery
+    class TestTransaction < Test::Unit::TestCase
+      def least_config
+        DataSource.new({
+          'project' => 'your_project_name',
+          'dataset' => 'your_dataset_name',
+          'table'   => 'your_table_name',
+          'p12_keyfile' => __FILE__, # fake
+        })
+      end
+
+      def schema
+        Schema.new([
+          Column.new({index: 0, name: 'boolean', type: :boolean}),
+          Column.new({index: 1, name: 'long', type: :long}),
+          Column.new({index: 2, name: 'double', type: :double}),
+          Column.new({index: 3, name: 'string', type: :string}),
+          Column.new({index: 4, name: 'timestamp', type: :timestamp}),
+          Column.new({index: 5, name: 'json', type: :json}),
+        ])
+      end
+
+      def processor_count
+        1
+      end
+
+      def control
+        Proc.new {|task| task_reports = [] }
+      end
+
+      def test_append
+        config = least_config.merge('mode' => 'append', 'temp_table' => 'temp_table')
+        any_instance_of(BigqueryClient) do |obj|
+          mock(obj).get_dataset(config['dataset'])
+          mock(obj).create_table(config['temp_table'])
+          mock(obj).load_in_parallel(anything, config['temp_table']) { [] }
+          mock(obj).copy(config['temp_table'], config['table'], write_disposition: 'WRITE_APPEND')
+          mock(obj).delete_table(config['temp_table'])
+        end
+        Bigquery.transaction(config, schema, processor_count, &control)
+      end
+
+      sub_test_case "append_direct" do
+        def test_append_direct
+          config = least_config.merge('mode' => 'append_direct')
+          any_instance_of(BigqueryClient) do |obj|
+            mock(obj).get_dataset(config['dataset'])
+            mock(obj).get_table(config['table'])
+            mock(obj).load_in_parallel(anything, config['table']) { [] }
+          end
+          Bigquery.transaction(config, schema, processor_count, &control)
+        end
+
+        def test_append_direct_with_auto_create
+          config = least_config.merge('mode' => 'append_direct', 'auto_create_dataset' => true, 'auto_create_table' => true)
+          any_instance_of(BigqueryClient) do |obj|
+            mock(obj).create_dataset(config['dataset'])
+            mock(obj).create_table(config['table'])
+            mock(obj).load_in_parallel(anything, config['table']) { [] }
+          end
+          Bigquery.transaction(config, schema, processor_count, &control)
+        end
+      end
+
+      def test_delete_in_advance
+        config = least_config.merge('mode' => 'delete_in_advance')
+        any_instance_of(BigqueryClient) do |obj|
+          mock(obj).get_dataset(config['dataset'])
+          mock(obj).delete_table(config['table'])
+          mock(obj).create_table(config['table'])
+          mock(obj).load_in_parallel(anything, config['table']) { [] }
+        end
+        Bigquery.transaction(config, schema, processor_count, &control)
+      end
+
+      def test_replace
+        config = least_config.merge('mode' => 'replace', 'temp_table' => 'temp_table')
+        any_instance_of(BigqueryClient) do |obj|
+          mock(obj).get_dataset(config['dataset'])
+          mock(obj).create_table(config['temp_table'])
+          mock(obj).load_in_parallel(anything, config['temp_table']) { [] }
+          mock(obj).copy(config['temp_table'], config['table'], write_disposition: 'WRITE_TRUNCATE')
+          mock(obj).delete_table(config['temp_table'])
+        end
+        Bigquery.transaction(config, schema, processor_count, &control)
+      end
+
+      sub_test_case "replace_backup" do
+        def test_replace_backup
+          config = least_config.merge('mode' => 'replace_backup', 'dataset_old' => 'dataset_old', 'table_old' => 'table_old', 'temp_table' => 'temp_table')
+          any_instance_of(BigqueryClient) do |obj|
+            mock(obj).get_dataset(config['dataset'])
+            mock(obj).get_dataset(config['dataset_old'])
+            mock(obj).create_table(config['temp_table'])
+            mock(obj).load_in_parallel(anything, config['temp_table']) { [] }
+
+            mock(obj).copy(config['table'], config['table_old'], config['dataset_old'])
+
+            mock(obj).copy(config['temp_table'], config['table'], write_disposition: 'WRITE_TRUNCATE')
+            mock(obj).delete_table(config['temp_table'])
+          end
+          Bigquery.transaction(config, schema, processor_count, &control)
+        end
+
+        def test_replace_backup_auto_create_dataset
+          config = least_config.merge('mode' => 'replace_backup', 'dataset_old' => 'dataset_old', 'table_old' => 'table_old', 'temp_table' => 'temp_table', 'auto_create_dataset' => true)
+          any_instance_of(BigqueryClient) do |obj|
+            mock(obj).create_dataset(config['dataset'])
+            mock(obj).create_dataset(config['dataset_old'], reference: config['dataset'])
+            mock(obj).create_table(config['temp_table'])
+            mock(obj).load_in_parallel(anything, config['temp_table']) { [] }
+
+            mock(obj).copy(config['table'], config['table_old'], config['dataset_old'])
+
+            mock(obj).copy(config['temp_table'], config['table'], write_disposition: 'WRITE_TRUNCATE')
+            mock(obj).delete_table(config['temp_table'])
+          end
+          Bigquery.transaction(config, schema, processor_count, &control)
+        end
+      end
+    end
+  end
+end

data/test/test_value_converter_factory.rb

@@ -0,0 +1,316 @@
+require_relative './helper'
+require 'embulk/output/bigquery/value_converter_factory'
+
+module Embulk
+  class Output::Bigquery
+    class TestValueConverterFactory < Test::Unit::TestCase
+
+      class TestCreateConverters < Test::Unit::TestCase
+        def test_create_default_converter
+          schema = Schema.new([
+            Column.new({index: 0, name: 'boolean', type: :boolean}),
+            Column.new({index: 1, name: 'long', type: :long}),
+            Column.new({index: 2, name: 'double', type: :double}),
+            Column.new({index: 3, name: 'string', type: :string}),
+            Column.new({index: 4, name: 'timestamp', type: :timestamp}),
+            Column.new({index: 5, name: 'json', type: :json}),
+          ])
+          converters = ValueConverterFactory.create_converters({}, schema)
+          assert_equal schema.size, converters.size
+          # Check correct converters are created
+          # Proc can not have names, so we have to execute to check...
+          assert_equal true, converters[0].call(true)
+          assert_equal 1, converters[1].call(1)
+          assert_equal 1.1, converters[2].call(1.1)
+          assert_equal 'foo', converters[3].call('foo')
+          timestamp = Time.parse("2016-02-26 00:00:00.100000 UTC")
+          assert_equal 1456444800.1, converters[4].call(timestamp)
+          assert_equal %Q[{"foo":"foo"}], converters[5].call({'foo'=>'foo'})
+        end
+
+        def test_create_custom_converter
+          schema = Schema.new([
+            Column.new({index: 0, name: 'boolean', type: :boolean}),
+            Column.new({index: 1, name: 'long', type: :long}),
+            Column.new({index: 2, name: 'double', type: :double}),
+            Column.new({index: 3, name: 'string', type: :string}),
+            Column.new({index: 4, name: 'timestamp', type: :timestamp}),
+            Column.new({index: 5, name: 'json', type: :json}),
+          ])
+          task = {
+            'column_options' => [
+              {'name' => 'boolean',   'type' => 'STRING'},
+              {'name' => 'long',      'type' => 'STRING'},
+              {'name' => 'double',    'type' => 'STRING'},
+              {'name' => 'string',    'type' => 'INTEGER'},
+              {'name' => 'timestamp', 'type' => 'INTEGER'},
+              {'name' => 'json',      'type' => 'RECORD'},
+            ],
+          }
+          converters = ValueConverterFactory.create_converters(task, schema)
+          assert_equal schema.size, converters.size
+          # Check correct converters are created
+          # Proc can not have names, so we have to execute to check...
+          assert_equal 'true', converters[0].call(true)
+          assert_equal '1', converters[1].call(1)
+          assert_equal '1.1', converters[2].call(1.1)
+          assert_equal 1, converters[3].call('1')
+          timestamp = Time.parse("2016-02-26 00:00:00.100000 UTC")
+          assert_equal 1456444800, converters[4].call(timestamp)
+          assert_equal({'foo'=>'foo'}, converters[5].call({'foo'=>'foo'}))
+        end
+      end
+
+      class TestBooleanConverter < Test::Unit::TestCase
+        SCHEMA_TYPE = :boolean
+
+        def test_boolean
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'BOOLEAN').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal true, converter.call(true)
+          assert_equal false, converter.call(false)
+        end
+
+        def test_integer
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'INTEGER').create_converter }
+        end
+
+        def test_float
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'FLOAT').create_converter }
+        end
+
+        def test_string
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'STRING').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal "true", converter.call(true)
+          assert_equal "false", converter.call(false)
+        end
+
+        def test_timestamp
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'TIMESTAMP').create_converter }
+        end
+
+        def test_record
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'RECORD').create_converter }
+        end
+      end
+
+      class TestLongConverter < Test::Unit::TestCase
+        SCHEMA_TYPE = :long
+
+        def test_boolean
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'BOOLEAN').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal true, converter.call(1)
+          assert_equal false, converter.call(0)
+          assert_raise { converter.call(2) }
+        end
+
+        def test_integer
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'INTEGER').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1, converter.call(1)
+        end
+
+        def test_float
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'FLOAT').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1.0, converter.call(1)
+        end
+
+        def test_string
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'STRING').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal "1", converter.call(1)
+        end
+
+        def test_timestamp
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'TIMESTAMP').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1408452095, converter.call(1408452095)
+        end
+
+        def test_record
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'RECORD').create_converter }
+        end
+      end
+
+      class TestDoubleConverter < Test::Unit::TestCase
+        SCHEMA_TYPE = :double
+
+        def test_boolean
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'BOOLEAN').create_converter }
+        end
+
+        def test_integer
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'INTEGER').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1, converter.call(1.1)
+        end
+
+        def test_float
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'FLOAT').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1.1, converter.call(1.1)
+        end
+
+        def test_string
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'STRING').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal "1.1", converter.call(1.1)
+        end
+
+        def test_timestamp
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'TIMESTAMP').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1408452095.188766, converter.call(1408452095.188766)
+        end
+
+        def test_record
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'RECORD').create_converter }
+        end
+      end
+
+      class TestStringConverter < Test::Unit::TestCase
+        SCHEMA_TYPE = :string
+
+        def test_boolean
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'BOOLEAN').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal true, converter.call('true')
+          assert_equal false, converter.call('false')
+          assert_raise { converter.call('foo') }
+        end
+
+        def test_integer
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'INTEGER').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1, converter.call('1')
+          assert_raise { converter.call('1.1') }
+        end
+
+        def test_float
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'FLOAT').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1.1, converter.call('1.1')
+          assert_raise { converter.call('foo') }
+        end
+
+        def test_string
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'STRING').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal "foo", converter.call("foo")
+        end
+
+        def test_timestamp
+          converter = ValueConverterFactory.new(
+            SCHEMA_TYPE, 'TIMESTAMP',
+            timestamp_format: '%Y-%m-%d', timezone: 'Asia/Tokyo'
+          ).create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal 1456412400.0, converter.call("2016-02-26")
+
+          # Users must care of BQ timestamp format by themselves with no timestamp_format
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'TIMESTAMP').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal "2016-02-26 00:00:00", converter.call("2016-02-26 00:00:00")
+        end
+
+        def test_record
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'RECORD').create_converter
+          assert_equal({'foo'=>'foo'}, converter.call(%Q[{"foo":"foo"}]))
+          assert_raise { converter.call('foo') }
+        end
+      end
+
+      class TestTimestampConverter < Test::Unit::TestCase
+        SCHEMA_TYPE = :timestamp
+
+        def test_boolean
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'BOOLEAN').create_converter }
+        end
+
+        def test_integer
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'INTEGER').create_converter
+          assert_equal nil, converter.call(nil)
+          expected = 1456444800
+          assert_equal expected, converter.call(Time.at(expected))
+        end
+
+        def test_float
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'FLOAT').create_converter
+          assert_equal nil, converter.call(nil)
+          expected = 1456444800.100000
+          assert_equal expected, converter.call(Time.at(expected))
+        end
+
+        def test_string
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'STRING').create_converter
+          assert_equal nil, converter.call(nil)
+          timestamp = Time.parse("2016-02-26 00:00:00.100000 UTC")
+          expected = "2016-02-26 00:00:00.100000"
+          assert_equal expected, converter.call(timestamp)
+
+          converter = ValueConverterFactory.new(
+            SCHEMA_TYPE, 'STRING',
+            timestamp_format: '%Y-%m-%d', timezone: 'Asia/Tokyo'
+          ).create_converter
+          timestamp = Time.parse("2016-02-25 15:00:00.100000 UTC")
+          expected = "2016-02-26"
+          assert_equal expected, converter.call(timestamp)
+        end
+
+        def test_timestamp
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'TIMESTAMP').create_converter
+          assert_equal nil, converter.call(nil)
+          expected = 1456444800.100000
+          assert_equal expected, converter.call(Time.at(expected))
+        end
+
+        def test_record
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'RECORD').create_converter }
+        end
+      end
+
+      class TestJsonConverter < Test::Unit::TestCase
+        SCHEMA_TYPE = :json
+
+        def test_boolean
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'BOOLEAN').create_converter }
+        end
+
+        def test_integer
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'INTEGER').create_converter }
+        end
+
+        def test_float
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'FLOAT').create_converter }
+        end
+
+        def test_string
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'STRING').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal(%Q[{"foo":"foo"}], converter.call({'foo'=>'foo'}))
+        end
+
+        def test_timestamp
+          assert_raise { ValueConverterFactory.new(SCHEMA_TYPE, 'TIMESTAMP').create_converter }
+        end
+
+        def test_record
+          converter = ValueConverterFactory.new(SCHEMA_TYPE, 'RECORD').create_converter
+          assert_equal nil, converter.call(nil)
+          assert_equal({'foo'=>'foo'}, converter.call({'foo'=>'foo'}))
+        end
+      end
+
+      def test_strict_false
+        converter = ValueConverterFactory.new(:string, 'BOOLEAN', strict: false).create_converter
+        assert_equal nil, converter.call('foo')
+
+        converter = ValueConverterFactory.new(:string, 'INTEGER', strict: false).create_converter
+        assert_equal nil, converter.call('foo')
+      end
+    end
+  end
+end

metadata

@@ -1,83 +1,144 @@
 --- !ruby/object:Gem::Specification
 name: embulk-output-bigquery
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0.pre1
 platform: ruby
 authors:
 - Satoshi Akama
+- Naotoshi Seo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-19 00:00:00.000000000 Z
+date: 2016-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: google-api-client
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
-  name: bundler
+        version: '0'
   prerelease: false
-  type: :development
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: tzinfo
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
+  name: embulk
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
-  name: rake
+        version: 0.8.2
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.6
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.6
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
+  prerelease: false
+  type: :development
 description: Embulk plugin that insert records to Google BigQuery.
 email:
 - satoshiakama@gmail.com
+- sonots@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - CHANGELOG.md
+- Gemfile
+- LICENSE.txt
 - README.md
-- build.gradle
-- config/checkstyle/checkstyle.xml
-- config/checkstyle/default.xml
-- gradle/wrapper/gradle-wrapper.jar
-- gradle/wrapper/gradle-wrapper.properties
-- gradlew
-- gradlew.bat
+- Rakefile
+- embulk-output-bigquery.gemspec
+- example/config_client_options.yml
+- example/config_csv.yml
+- example/config_delete_in_advance.yml
+- example/config_expose_errors.yml
+- example/config_guess_from_embulk_schema.yml
+- example/config_guess_with_column_options.yml
+- example/config_gzip.yml
+- example/config_jsonl.yml
+- example/config_mode_append.yml
+- example/config_mode_append_direct.yml
+- example/config_payload_column.yml
+- example/config_payload_column_index.yml
+- example/config_prevent_duplicate_insert.yml
+- example/config_replace.yml
+- example/config_replace_backup.yml
+- example/config_skip_file_generation.yml
+- example/config_table_strftime.yml
+- example/config_template_table.yml
+- example/config_uncompressed.yml
+- example/config_with_rehearsal.yml
+- example/example.csv
+- example/example.jsonl
+- example/example.yml
+- example/json_key.json
+- example/nested_example.jsonl
+- example/schema.json
+- example/schema_expose_errors.json
 - lib/embulk/output/bigquery.rb
-- settings.gradle
-- src/main/java/org/embulk/output/BigqueryAuthentication.java
-- src/main/java/org/embulk/output/BigqueryOutputPlugin.java
-- src/main/java/org/embulk/output/BigqueryWriter.java
-- src/test/java/org/embulk/output/TestBigqueryAuthentication.java
-- src/test/java/org/embulk/output/TestBigqueryOutputPlugin.java
-- src/test/java/org/embulk/output/TestBigqueryWriter.java
-- classpath/commons-codec-1.3.jar
-- classpath/commons-logging-1.1.1.jar
-- classpath/embulk-output-bigquery-0.2.3.jar
-- classpath/google-api-client-1.20.0.jar
-- classpath/google-api-services-bigquery-v2-rev205-1.20.0.jar
-- classpath/google-http-client-1.20.0.jar
-- classpath/google-http-client-jackson2-1.20.0.jar
-- classpath/google-oauth-client-1.20.0.jar
-- classpath/guava-jdk5-13.0.jar
-- classpath/httpclient-4.0.1.jar
-- classpath/httpcore-4.0.1.jar
-- classpath/jsr305-1.3.9.jar
+- lib/embulk/output/bigquery/bigquery_client.rb
+- lib/embulk/output/bigquery/file_writer.rb
+- lib/embulk/output/bigquery/helper.rb
+- lib/embulk/output/bigquery/value_converter_factory.rb
+- test/helper.rb
+- test/test_bigquery_client.rb
+- test/test_configure.rb
+- test/test_example.rb
+- test/test_file_writer.rb
+- test/test_helper.rb
+- test/test_transaction.rb
+- test/test_value_converter_factory.rb
 homepage: https://github.com/embulk/embulk-output-bigquery
 licenses:
-- Apache-2.0
+- MIT
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -85,18 +146,26 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.4.8
 signing_key:
 specification_version: 4
 summary: Google BigQuery output plugin for Embulk
-test_files: []
+test_files:
+- test/helper.rb
+- test/test_bigquery_client.rb
+- test/test_configure.rb
+- test/test_example.rb
+- test/test_file_writer.rb
+- test/test_helper.rb
+- test/test_transaction.rb
+- test/test_value_converter_factory.rb