bigquery-client 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a72ed82925d59afe55c4712320ac7ef7c8d9432
-  data.tar.gz: 6926b3af5110b3869a86b771d15eaca4d173a422
+  metadata.gz: edc1852a762f3a210c21f52f68cc4e86f1b4d63d
+  data.tar.gz: 8b5e41ca6514e45f48734a1ee373f486fee4a8f9
 SHA512:
-  metadata.gz: f44875d3135a175ee079a84c181be2bda7ee3cd6b19eb6684648dc5e34adf3f8cfd2a492670cc1d8df7d9c2a5ad20b3b9cec0680f3a93babec6ac56b0eb19933
-  data.tar.gz: e473078ae2aff543169c68f160caf14dc5e51781cf4d3c16fc59389a9f758b98ec4f91dd307d45406a0aeeb6770943baa6e577614b7fc2d39f09c5b402d0347a
+  metadata.gz: 517febf8c68c0b83fa566673d7caf0492067a950133b67d03dc5ec587390b994354ba222b920332b5270479ad8016f7aa9327339132f30a50c168b0fcbd2ef65
+  data.tar.gz: dad3b8e445ad4f7bf2028f7f285aaaf4c1a69e610bcaff90f7b2c661c4c3dde18c0de26243d589edd325b3ee4ac693798f16deac40a66ae9e027f132d5bff04c

data/.env.example

@@ -0,0 +1,3 @@
+BIGQUERY_PROJECT=your-project-42
+BIGQUERY_EMAIL=1234567890@developer.gserviceaccount.com
+BIGQUERY_PRIVATE_KEY_PATH=/path/to/keyfile.p12

data/.gitignore

@@ -1,6 +1,7 @@
 /.bundle/
 /.yardoc
 /.ruby-version
+/.env
 /Gemfile.lock
 /_yardoc/
 /coverage/

data/README.md

@@ -1,7 +1,6 @@
 # BigQuery Client
 
 [![Gem Version](https://badge.fury.io/rb/bigquery-client.svg)](http://badge.fury.io/rb/bigquery-client)
-[![Build Status](https://travis-ci.org/ttanimichi/bigquery-client.svg)](https://travis-ci.org/ttanimichi/bigquery-client)
 
 A Ruby interface to the BigQuery API.
 
@@ -25,48 +24,46 @@ client = BigQuery::Client.new(
   auth_method:            "private_key"
 )
 
-client.show hoge hoge
-
+client.sql "SELECT * FROM publicdata:samples.wikipedia LIMIT 10"
 ```
 
 ## Available API methods
 
-ref. https://cloud.google.com/bigquery/docs/reference/v2/
-
-| Resource type | Method          | Function           | Support               |
-|---------------|-----------------|--------------------|:---------------------:|
-| Tables        | delete          | `drop_table`       | :white_check_mark:    |
-| Tables        | get             | `fetch_table_info` | :white_check_mark:    |
-| Tables        | get             | `fetch_schema`     | :white_check_mark:    |
-| Tables        | insert          | `create_table`     | :white_check_mark:    |
-| Tables        | list            | `list_tables`      | :white_check_mark:    |
-| Tables        | patch           | `patch_table`      | :white_check_mark:    |
-| Tables        | update          | `update_table`     | :white_check_mark:    |
-| Tabledata     | insertAll       |                    | :white_medium_square: |
-| Tabledata     | list            | `list_table`       | :white_check_mark:    |
-| Datasets      | delete          |                    | :white_medium_square: |
-| Datasets      | get             |                    | :white_medium_square: |
-| Datasets      | insert          |                    | :white_medium_square: |
-| Datasets      | list            | `list_datasets`    | :white_check_mark:    |
-| Datasets      | patch           |                    | :white_medium_square: |
-| Datasets      | update          |                    | :white_medium_square: |
-| Jobs          | get             |                    | :white_medium_square: |
-| Jobs          | getQueryResults |                    | :white_medium_square: |
-| Jobs          | insert          |                    | :white_medium_square: |
-| Jobs          | list            |                    | :white_medium_square: |
-| Jobs          | query           |                    | :white_medium_square: |
-| Projects      | list            | `list_projects`    | :white_check_mark:    |
+https://cloud.google.com/bigquery/docs/reference/v2/
+
+| Resource type | Method          | Function                      | Support               |
+|---------------|-----------------|-------------------------------|:---------------------:|
+| Tabledata     | insertAll       | `insert`, `insert_all`        | :white_check_mark:    |
+| Tabledata     | list            | `list_tabledata`              | :white_check_mark:    |
+| Tables        | list            | `tables`, `list_tables`       | :white_check_mark:    |
+| Tables        | get             | `fetch_schema`, `fetch_table` | :white_check_mark:    |
+| Tables        | insert          | `create_table`                | :white_check_mark:    |
+| Tables        | patch           | `patch_table`                 | :white_check_mark:    |
+| Tables        | update          | `update_table`                | :white_check_mark:    |
+| Tables        | delete          | `delete_table`                | :white_check_mark:    |
+| Jobs          | query           | `sql`, `jobs_query`           | :white_check_mark:    |
+| Jobs          | insert          | `load`                        | :white_check_mark:    |
+| Jobs          | list            | `jobs`                        | :white_check_mark:    |
+| Jobs          | get             | `fetch_job`                   | :white_check_mark:    |
+| Jobs          | getQueryResults | `query_results`               | :white_check_mark:    |
+| Datasets      | list            | `datasets`, `list_datasets`   | :white_check_mark:    |
+| Datasets      | get             | `fetch_dataset`               | :white_medium_square: |
+| Datasets      | insert          | `create_dataset`              | :white_check_mark:    |
+| Datasets      | patch           | `patch_dataset`               | :white_medium_square: |
+| Datasets      | update          | `update_dataset`              | :white_medium_square: |
+| Datasets      | delete          | `delete_dataset`              | :white_check_mark:    |
+| Projects      | list            | `projects`, `list_projects`   | :white_check_mark:    |
 
 ## Usage
 
 ```ruby
 # insert
-client.insert("your_table", uid: "john", age: 42)
+client.insert("your_table", nickname: "john", age: 42)
 
 # insert multiple rows
 rows = [
-  { uid: "foo", age: 43 },
-  { uid: "bar", age: 44 }
+  { nickname: "foo", age: 43 },
+  { nickname: "bar", age: 44 }
 ]
 client.insert("your_table", rows)
 
@@ -77,17 +74,66 @@ schema = [
 ]
 client.create_table("new_table", schema)
 
+# SQL
+client.sql "SELECT * FROM your_dataset.your_table LIMIT 100"
+
+# SQL (public data)
+client.sql "SELECT * FROM publicdata:samples.wikipedia LIMIT 10"
+
+# tables
+client.tables
+#=> ["your_table", "your_table2", "your_table3"]
+
+# datasets
+client.datasets
+#=> ["your_dataset", "your_dataset2"]
+
 # fetch schema
 client.fetch_schema("your_table")
-#=> [{"name"=>"uid", "type"=>"STRING"}, {"name"=>"age", "type"=>"INTEGER"}]
+#=> [{"name"=>"nickname", "type"=>"STRING"}, {"name"=>"age", "type"=>"INTEGER"}]
+
+# delete table
+client.delete_table('your_table')
+
+# create dataset
+client.create_dataset('your_dataset')
+
+# delete dataset
+client.delete_dataset('your_dataset')
 ```
 
 ## TODO
 
 - [ ] Support all API methods
+- [ ] Improve `load`
+  - Support load-from-GCS flow and POST-request flow
+  - ref. https://cloud.google.com/bigquery/loading-data-into-bigquery
 - [ ] Support OAuth installed application credentials
 - [ ] Google API discovery expiration
 
+## How to run tests
+
+Please create a file named `.env` on the root of this repository. You can use `.env.example` file as a template.
+
+```
+% cp .env.example .env
+```
+
+and edit `.env` file properly.
+
+```
+BIGQUERY_PROJECT=your-project-42
+BIGQUERY_EMAIL=1234567890@developer.gserviceaccount.com
+BIGQUERY_PRIVATE_KEY_PATH=/path/to/keyfile.p12
+```
+
+Then run tests.
+
+```
+% bundle install
+% bundle exec rake
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/ttanimichi/bigquery-client/fork )

data/bigquery-client.gemspec

@@ -22,7 +22,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rr'
-  spec.add_development_dependency 'test-unit', '~> 3.0.2'
-  spec.add_development_dependency 'test-unit-rr', '~> 1.0.3'
+  spec.add_development_dependency 'test-unit', '~> 3.0.0'
+  spec.add_development_dependency 'dotenv', '~> 1.0.0'
+  spec.add_development_dependency 'awesome_print'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-doc'
+  spec.add_development_dependency 'pry-byebug'
 end

data/lib/bigquery-client/client.rb

@@ -22,7 +22,9 @@ module BigQuery
       params[:parameters] ||= {}
       params[:parameters][:projectId] ||= @project
       params[:parameters][:datasetId] ||= @dataset
-      client.execute(params)
+      result = client.execute(params)
+      handle_error(result) if result.error?
+      JSON.parse(result.body) unless result.body.empty?
     end
 
     def bigquery

data/lib/bigquery-client/datasets.rb

@@ -2,5 +2,47 @@
 
 module BigQuery
   module Datasets
+    def datasets
+      list_datasets['datasets'].map {|dataset| dataset['datasetReference']['datasetId'] }
+    end
+
+    def list_datasets
+      access_api(
+        api_method: bigquery.datasets.list
+      )
+    end
+
+    def fetch_dataset
+      raise NotImplementedError
+    end
+
+    def create_dataset(name)
+      access_api(
+        api_method: bigquery.datasets.insert,
+        body_object: {
+          datasetReference: {
+            datasetId: name
+          }
+        }
+      )
+    end
+
+    def patch_dataset
+      raise NotImplementedError
+    end
+
+    def update_dataset
+      raise NotImplementedError
+    end
+
+    def delete_dataset(name)
+      access_api(
+        api_method: bigquery.datasets.delete,
+        parameters: {
+          datasetId: name,
+          deleteContents: true
+        }
+      )
+    end
   end
 end

data/lib/bigquery-client/jobs.rb

@@ -2,5 +2,69 @@
 
 module BigQuery
   module Jobs
+    def sql(query, options = {})
+      result = jobs_query(query, options)
+      names = result['schema']['fields'].map {|field| field['name'] }
+      types = result['schema']['fields'].map {|field| field['type'] }
+      records = result['rows'].map {|row| row['f'].map {|record| record['v'] } }
+      convert(records, types).map { |values| [names, values].transpose.to_h }
+    end
+
+    def jobs_query(query, options = {})
+      default = { query: query, timeoutMs: 600_000 }
+      access_api(
+        api_method: bigquery.jobs.query,
+        body_object: default.merge(options)
+      )
+    end
+
+    def load(options = {})
+      access_api(
+        api_method: bigquery.jobs.insert,
+        body_object: {
+          configuration: {
+            load: options
+          }
+        }
+      )
+    end
+
+    def jobs(options = {})
+      access_api(
+        api_method: bigquery.jobs.list,
+        parameters: options
+      )
+    end
+
+    def fetch_job(id, options = {})
+      access_api(
+        api_method: bigquery.jobs.get,
+        parameters: { jobId: id }.merge(options)
+      )
+    end
+
+    def query_results(id, options = {})
+      access_api(
+        api_method: bigquery.jobs.get_query_results,
+        parameters: { jobId: id }.merge(options)
+      )
+    end
+
+    private
+
+    def convert(records, types)
+      records.map do |values|
+        values.map.with_index do |value, index|
+          case types[index]
+          when 'INTEGER'
+            value.to_i
+          when 'BOOLEAN'
+            value == 'true'
+          else
+            value
+          end
+        end
+      end
+    end
   end
 end

data/lib/bigquery-client/projects.rb

@@ -2,13 +2,14 @@
 
 module BigQuery
   module Projects
+    def projects
+      list_projects['projects'].map {|project| project['id'] }
+    end
+
     def list_projects
-      result = access_api(
-        api_method: bigquery.projects.list,
-        parameters: {
-        }
+      access_api(
+        api_method: bigquery.projects.list
       )
-      JSON.parse(result.body)
     end
   end
 end

data/lib/bigquery-client/tabledata.rb

@@ -2,9 +2,9 @@
 
 module BigQuery
   module Tabledata
-    def insert(table, args)
-      rows = args.is_a?(Array) ? args : [args]
-      result = access_api(
+    def insert(table, arg)
+      rows = arg.is_a?(Array) ? arg : [arg]
+      access_api(
         api_method: bigquery.tabledata.insert_all,
         parameters: {
           tableId: table
@@ -13,7 +13,16 @@ module BigQuery
           rows: rows.map { |row| { json: row } }
         }
       )
-      handle_error(result) if result.error?
+    end
+    alias_method :insert_all, :insert
+
+    def list_tabledata(table)
+      access_api(
+        api_method: bigquery.tabledata.list,
+        parameters: {
+          tableId: table
+        }
+      )
     end
   end
 end

data/lib/bigquery-client/tables.rb

@@ -2,77 +2,79 @@
 
 module BigQuery
   module Tables
-    def create_table(name, schema)
-      result = access_api(
-        api_method: bigquery.tables.insert,
-        body_object: {
-          tableReference: {
-            tableId: name
-          },
-          schema: {
-            fields: schema
-          }
-        }
-      )
-      handle_error(result) if result.error?
+    def tables(options = {})
+      (list_tables(options)['tables'] || []).map {|t| t['tableReference']['tableId'] }
     end
 
     def list_tables(options = {})
-      result = access_api(
+      access_api(
         api_method: bigquery.tables.list,
         parameters: options
       )
-      handle_error(result) if result.error?
-      JSON.parse(result.body)
     end
 
-    def update_table(name, options = {})
-      result = access_api(
-        api_method: bigquery.tables.update,
+    def fetch_schema(table)
+      fetch_table(table)['schema']['fields']
+    end
+
+    def fetch_table(table)
+      access_api(
+        api_method: bigquery.tables.get,
         parameters: {
-          tableId: name
-        },
-        body_object: options
+          tableId: table
+        }
       )
-      handle_error(result) if result.error?
-      JSON.parse(result.body)
     end
 
-    def patch_table(name, options = {})
-      result = access_api(
+    def create_table(table, schema)
+      access_api(
+        api_method: bigquery.tables.insert,
+        body_object: {
+          tableReference: {
+            tableId: table
+          },
+          schema: {
+            fields: schema
+          }
+        }
+      )
+    end
+
+    def patch_table(table, schema)
+      access_api(
         api_method: bigquery.tables.patch,
         parameters: {
-          tableId: name
+          tableId: table
         },
-        body_object: options
+        body_object: {
+          schema: {
+            fields: schema
+          }
+        }
       )
-      handle_error(result) if result.error?
-      JSON.parse(result.body)
     end
 
-    def fetch_schema(table)
-      fetch_table_info(table)['schema']['fields']
-    end
-
-    def fetch_table_info(table)
-      result = access_api(
-        api_method: bigquery.tables.get,
+    def update_table(table, schema)
+      access_api(
+        api_method: bigquery.tables.update,
         parameters: {
           tableId: table
+        },
+        body_object: {
+          schema: {
+            fields: schema
+          }
         }
       )
-      handle_error(result) if result.error?
-      JSON.parse(result.body)
     end
 
-    def drop_table(name)
-      result = access_api(
+    def delete_table(table)
+      access_api(
         api_method: bigquery.tables.delete,
         parameters: {
-          tableId: name
+          tableId: table
         }
       )
-      handle_error(result) if result.error?
     end
   end
 end

data/lib/bigquery-client/version.rb

@@ -1,5 +1,5 @@
 module BigQuery
   class Client
-    VERSION = '0.2.1'
+    VERSION = '0.3.0'
   end
 end

data/test/helper.rb

@@ -1,6 +1,35 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
-require 'bigquery-client'
 require 'test/unit'
-require 'test/unit/rr'
-require 'rr'
+require 'bigquery-client'
+require 'dotenv'
+require 'awesome_print'
+require 'pry-byebug'
+
+if defined?(PryByebug)
+  Pry.commands.alias_command 'c', 'continue'
+  Pry.commands.alias_command 's', 'step'
+  Pry.commands.alias_command 'n', 'next'
+  Pry.commands.alias_command 'f', 'finish'
+end
+
+Dotenv.load
+
+$dataset = 'test_bigquery_client'
+
+$client = BigQuery::Client.new(
+  project:                ENV['BIGQUERY_PROJECT'],
+  email:                  ENV['BIGQUERY_EMAIL'],
+  private_key_path:       ENV['BIGQUERY_PRIVATE_KEY_PATH'],
+  dataset:                $dataset,
+  private_key_passphrase: 'notasecret',
+  auth_method:            'private_key'
+)
+
+$client.datasets.select { |dataset|
+  Regexp.new($dataset) =~ dataset
+}.each { |dataset|
+  $client.delete_dataset(dataset)
+}
+
+$client.create_dataset($dataset)

data/test/test_client.rb

@@ -1,171 +1,9 @@
 require 'helper'
 
 class ClientTest < Test::Unit::TestCase
-  def setup
-    @client = BigQuery::Client.new(
-      project:                '1234567890',
-      dataset:                'my_dataset',
-      email:                  '1234567890@developer.gserviceaccount.com',
-      private_key_path:       '/path/to/keyfile.p12',
-      private_key_passphrase: 'itsasecret',
-      auth_method:            'private_key'
-    )
-  end
-
   def test_initialize
-    actual = @client.instance_variables
-    expected = [:@project, :@dataset, :@email, :@private_key_path, :@private_key_passphrase, :@auth_method]
-    assert { actual.sort == expected.sort }
-  end
-
-  def test_create_table
-    params = {
-      api_method: 'create_table',
-      body_object: {
-        tableReference: {
-          tableId: 'my_table'
-        },
-        schema: {
-          fields: [
-            { name: 'foo', type: 'timestamp' },
-            { name: 'bar', type: 'string' }
-          ]
-        }
-      },
-      parameters: {
-        projectId: '1234567890',
-        datasetId: 'my_dataset'
-      }
-    }
-    auth = Object.new
-    mock(client = Object.new) do |client|
-      client.discovered_api('bigquery', 'v2') { mock!.tables.mock!.insert { 'create_table' } }
-      client.execute(params) { mock(Object.new).error? { false } }
-      client.authorization = auth
-    end
-    mock(Google::APIClient).new.with_any_args { client }
-    mock(Google::APIClient::JWTAsserter).new.with_any_args { mock(Object.new).authorize { auth } }
-    mock(Google::APIClient::PKCS12).load_key('/path/to/keyfile.p12', 'itsasecret')
-    schema = [{name: 'foo', type: 'timestamp'}, { name: 'bar', type: 'string'}]
-    assert { @client.create_table('my_table', schema).nil? }
-  end
-
-  def test_insert
-    params = {
-      api_method: 'insert_all',
-      parameters: {
-        projectId: '1234567890',
-        datasetId: 'my_dataset',
-        tableId:   'my_table'
-      },
-      body_object: {
-        rows: [ { json: { a: 'b', c: 'd' } } ]
-      }
-    }
-    auth = Object.new
-    mock(client = Object.new) do |client|
-      client.discovered_api('bigquery', 'v2') { mock!.tabledata.mock!.insert_all { 'insert_all' } }
-      client.execute(params) { mock(Object.new).error? { false } }
-      client.authorization = auth
-    end
-    mock(Google::APIClient).new.with_any_args { client }
-    mock(Google::APIClient::JWTAsserter).new.with_any_args { mock(Object.new).authorize { auth } }
-    mock(Google::APIClient::PKCS12).load_key('/path/to/keyfile.p12', 'itsasecret')
-    assert { @client.insert('my_table', a: 'b', c: 'd').nil? }
-  end
-
-  def test_insert_rows
-    params = {
-      api_method: 'insert_all',
-      parameters: {
-        projectId: '1234567890',
-        datasetId: 'my_dataset',
-        tableId:   'my_table'
-      },
-      body_object: {
-        rows: [
-          { json: { 'a' => 'b' } },
-          { json: { 'b' => 'c' } }
-        ]
-      }
-    }
-    auth = Object.new
-    mock(client = Object.new) do |client|
-      client.discovered_api('bigquery', 'v2') { mock!.tabledata.mock!.insert_all { 'insert_all' } }
-      client.execute(params) { mock(Object.new).error? { false } }
-      client.authorization = auth
-    end
-    mock(Google::APIClient).new.with_any_args { client }
-    mock(Google::APIClient::JWTAsserter).new.with_any_args { mock(Object.new).authorize { auth } }
-    mock(Google::APIClient::PKCS12).load_key('/path/to/keyfile.p12', 'itsasecret')
-    rows = [{'a' => 'b'}, {'b' => 'c'}]
-    assert { @client.insert('my_table', rows).nil? }
-  end
-
-  def test_fetch_schema
-    params = {
-      api_method: 'tables_get',
-      parameters: {
-        tableId:   'my_table',
-        projectId: '1234567890',
-        datasetId: 'my_dataset'
-      }
-    }
-    result_body = JSON.generate(
-      {
-        schema: {
-          fields: [
-            { name: 'time', type: 'TIMESTAMP' },
-            { name: 'tty',  type: 'STRING'    }
-          ]
-        }
-      }
-    )
-    auth = Object.new
-    mock(result = Object.new) do |result|
-      result.error? { false }
-      result.body   { result_body }
-    end
-    mock(client = Object.new) do |client|
-      client.discovered_api('bigquery', 'v2') { mock!.tables.mock!.get { 'tables_get' } }
-      client.execute(params) { result }
-      client.authorization = auth
-    end
-    mock(Google::APIClient).new.with_any_args { client }
-    mock(Google::APIClient::JWTAsserter).new.with_any_args { mock(Object.new).authorize { auth } }
-    mock(Google::APIClient::PKCS12).load_key('/path/to/keyfile.p12', 'itsasecret')
-    expected = [
-      { 'name' => 'time', 'type' => 'TIMESTAMP' },
-      { 'name' => 'tty',  'type' => 'STRING'    }
-    ]
-    assert { @client.fetch_schema('my_table') == expected }
-  end
-
-  def test_errors
-    errors = [
-      { code: 404, klass: BigQuery::NotFound        },
-      { code: 409, klass: BigQuery::Conflict        },
-      { code: 403, klass: BigQuery::ClientError     },
-      { code: 503, klass: BigQuery::ServerError     },
-      { code: 301, klass: BigQuery::UnexpectedError }
-    ]
-    errors.each do |error|
-      auth = Object.new
-      mock(result = Object.new) do |result|
-        result.error?        { true }
-        result.status        { error[:code] }
-        result.error_message { 'this is an error message' }
-      end
-      mock(client = Object.new) do |client|
-        client.execute.with_any_args { result }
-        client.authorization = auth
-      end
-      mock(@client).bigquery { mock!.tabledata.mock!.insert_all }
-      mock(Google::APIClient).new.with_any_args { client }
-      mock(Google::APIClient::JWTAsserter).new.with_any_args { mock(Object.new).authorize { auth } }
-      mock(Google::APIClient::PKCS12).load_key('/path/to/keyfile.p12', 'itsasecret')
-      rows = [{'a' => 'b'}, {'b' => 'c'}]
-      assert_raise(error[:klass]) { @client.insert('my_table', rows) }
-    end
+    actual  = $client.instance_variables
+    minimal = [:@project, :@dataset, :@email, :@private_key_path, :@private_key_passphrase, :@auth_method]
+    assert { minimal - actual == [] }
   end
 end

data/test/test_datasets.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+class DatasetsTest < Test::Unit::TestCase
+  def test_datasets
+    dataset_name = "#{$dataset}_test_datasets"
+    $client.create_dataset(dataset_name)
+    $client.datasets.include?(dataset_name)
+  end
+
+  def test_create_dataset
+    dataset_name = "#{$dataset}_create_dataset"
+    $client.create_dataset(dataset_name)
+  end
+
+  def test_delete_dataset
+    dataset_name = "#{$dataset}_delete_dataset"
+    $client.create_dataset(dataset_name)
+    before = $client.datasets
+    $client.delete_dataset(dataset_name)
+    after = $client.datasets
+    actual = before - after
+    expected = [dataset_name]
+    assert { actual == expected }
+  end
+end

data/test/test_jobs.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class JobsTest < Test::Unit::TestCase
+  @@query = <<-"EOS"
+    SELECT
+      born_alive_alive, mother_residence_state, is_male
+    FROM
+      publicdata:samples.natality
+    ORDER BY
+      day
+    LIMIT
+      100
+  EOS
+
+  def test_sql
+    result = $client.sql(@@query)
+    assert { result.size == 100 }
+    assert { result.sample["born_alive_alive"].is_a? Fixnum }
+    assert { result.sample["mother_residence_state"].is_a? String }
+    assert { result.sample["is_male"] == true || result.first["is_male"] == false }
+  end
+end

data/test/test_projects.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+class ProjectsTest < Test::Unit::TestCase
+  def test_projects
+    actual = $client.projects.first
+    expected = ENV['BIGQUERY_PROJECT']
+    assert { actual == expected }
+  end
+
+  def test_list_projects
+    actual = $client.list_projects['projects'].first['id']
+    expected = ENV['BIGQUERY_PROJECT']
+    assert { actual == expected }
+  end
+end

data/test/test_tabledata.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class TablesTest < Test::Unit::TestCase
+  def test_insert
+    table_name = __method__.to_s
+    schema = [{ name: 'bar', type: 'string' }]
+    $client.create_table(table_name, schema)
+    result = $client.insert(table_name, bar: "foo")
+    assert { result['kind'] == 'bigquery#tableDataInsertAllResponse' }
+  end
+
+  def test_insert_with_array
+    table_name = __method__.to_s
+    schema = [{ name: 'bar', type: 'string' }]
+    $client.create_table(table_name, schema)
+    result = $client.list_tabledata(table_name)
+    rows = [{ bar: "foo" },  { bar: "foo2" },  { bar: "foo3" }]
+    result = $client.insert(table_name, rows)
+    assert { result['kind'] == 'bigquery#tableDataInsertAllResponse' }
+  end
+
+  def test_list_tabledata
+    table_name = __method__.to_s
+    schema = [{ name: 'bar', type: 'string' }]
+    $client.create_table(table_name, schema)
+    result = $client.list_tabledata(table_name)
+    assert { result['kind'] == "bigquery#tableDataList" }
+  end
+end

data/test/test_tables.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+class TablesTest < Test::Unit::TestCase
+  def test_tables
+    table_name = __method__.to_s
+    schema = [{ name: 'bar', type: 'string' }]
+    $client.create_table(table_name, schema)
+    assert { $client.tables.include?(table_name) }
+  end
+
+  def test_fetch_schema
+    table_name = __method__.to_s
+    schema = [{ name: 'bar', type: 'string' }]
+    $client.create_table(table_name, schema)
+    result = $client.fetch_schema(table_name)
+    assert { result == [{"name"=>"bar", "type"=>"STRING"}] }
+  end
+
+  def test_create_table
+    table_name = __method__.to_s
+    schema = [{ name: 'bar', type: 'string' }]
+    before = $client.tables
+    $client.create_table(table_name, schema)
+    after  = $client.tables
+    actual = after - before
+    expected = [table_name]
+    assert { expected == actual }
+  end
+
+  def test_delete_table
+    table_name = __method__.to_s
+    schema = [{ name: 'bar', type: 'string' }]
+    $client.create_table(table_name, schema)
+    before = $client.tables
+    $client.delete_table(table_name)
+    after  = $client.tables
+    actual = before - after
+    expected = [table_name]
+    assert { actual == expected }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bigquery-client
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Tsukuru Tanimichi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-api-client
@@ -53,7 +53,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rr
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: awesome_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,33 +95,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit-rr
+  name: pry-doc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: '0'
 description: 
 email:
 - ttanimichi@hotmail.com
@@ -101,8 +143,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".env.example"
 - ".gitignore"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -119,6 +161,11 @@ files:
 - lib/bigquery-client/version.rb
 - test/helper.rb
 - test/test_client.rb
+- test/test_datasets.rb
+- test/test_jobs.rb
+- test/test_projects.rb
+- test/test_tabledata.rb
+- test/test_tables.rb
 homepage: https://github.com/ttanimichi/bigquery-client
 licenses:
 - MIT
@@ -146,3 +193,9 @@ summary: A Ruby interface to the BigQuery API.
 test_files:
 - test/helper.rb
 - test/test_client.rb
+- test/test_datasets.rb
+- test/test_jobs.rb
+- test/test_projects.rb
+- test/test_tabledata.rb
+- test/test_tables.rb
+has_rdoc: 

data/.travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - 2.2.0
-
-script: bundle exec rake test