td-client 1.0.0-java

data/lib/td/client/version.rb

@@ -0,0 +1,5 @@
+module TreasureData
+  class Client
+    VERSION = '1.0.0'
+  end
+end

data/lib/td/core_ext/openssl/ssl/sslcontext/set_params.rb

@@ -0,0 +1,18 @@
+require 'openssl'
+module OpenSSL
+  module SSL
+    class SSLContext
+
+      # For disabling SSLv3 connection in favor of POODLE Attack protection
+      #
+      # Allow 'options' customize through Thread local storage since
+      # Net::HTTP does not support 'options' configuration.
+      #
+      alias original_set_params set_params
+      def set_params(params={})
+        original_set_params(params)
+        self.options |= OP_NO_SSLv3 if Thread.current[:SET_SSL_OP_NO_SSLv3]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+
+# XXX skip coverage setting if run appveyor. Because, fail to push coveralls in appveyor.
+unless ENV['APPVEYOR']
+  begin
+    if defined?(:RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
+      # SimpleCov officially supports MRI 1.9+ only for now
+      # https://github.com/colszowka/simplecov#ruby-version-compatibility
+
+      require 'simplecov'
+      require 'coveralls'
+
+      SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+        SimpleCov::Formatter::HTMLFormatter,
+        Coveralls::SimpleCov::Formatter
+      ])
+      SimpleCov.start("test_frameworks")
+    end
+  rescue NameError
+    # skip measuring coverage at Ruby 1.8
+  end
+end
+
+require 'rspec'
+require 'webmock/rspec'
+WebMock.disable_net_connect!(:allow_localhost => true)
+
+include WebMock::API
+
+$LOAD_PATH << File.dirname(__FILE__)+"../lib"
+require 'td-client'
+require 'msgpack'
+require 'json'
+
+include TreasureData
+
+shared_context 'common helper' do
+  let :account_id do
+    1
+  end
+
+  let :headers do
+    if RUBY_VERSION >= "2.0.0"
+      {'Accept' => '*/*', 'Accept-Encoding' => /gzip/, 'Date' => /.*/, 'User-Agent' => /Ruby/}
+    else
+      {'Accept' => '*/*', 'Date' => /.*/, 'User-Agent' => /Ruby/}
+    end
+  end
+
+  def stub_api_request(method, path, opts = nil)
+    scheme = 'https'
+    with_opts = {:headers => headers}
+    if opts
+      scheme = 'http' if opts[:ssl] == false
+      with_opts[:query] = opts[:query] if opts[:query]
+    end
+    stub_request(method, "#{scheme}://api.treasuredata.com#{path}").with(with_opts)
+  end
+
+  def e(s)
+    s.to_s.gsub(/[^*\-0-9A-Z_a-z]/){|x|'%%%02X' % x.ord}
+  end
+end

data/spec/td/client/access_control_api_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'td/client/spec_resources'
+require 'json'
+
+describe 'Access Control API' do
+  include_context 'spec symbols'
+  include_context 'common helper'
+
+  let :api do
+    # no retry for GET
+    API.new(nil, {:max_cumul_retry_delay => -1})
+  end
+
+  describe 'all apis' do
+    it 'is deprecated' do
+      stub_api_request(:post, "/v3/acl/grant").to_return(:status => 500)
+      expect {
+        api.grant_access_control('subject', 'action', 'scope', [])
+      }.to raise_error(TreasureData::APIError)
+
+      stub_api_request(:post, "/v3/acl/revoke").to_return(:status => 500)
+      expect {
+        api.revoke_access_control('subject', 'action', 'scope')
+      }.to raise_error(TreasureData::APIError)
+
+      stub_api_request(:get, "/v3/acl/test", :query => {'user' => 'user', 'action' => 'action', 'scope' => 'scope'}).to_return(:status => 422)
+      expect {
+        api.test_access_control('user', 'action', 'scope')
+      }.to raise_error(TreasureData::APIError)
+
+      stub_api_request(:get, "/v3/acl/list").to_return(:status => 500)
+      expect {
+        api.list_access_controls
+      }.to raise_error(TreasureData::APIError)
+    end
+  end
+end

data/spec/td/client/account_api_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'td/client/spec_resources'
+require 'json'
+
+describe 'Account API' do
+  include_context 'spec symbols'
+  include_context 'common helper'
+
+  let :api do
+    API.new(nil)
+  end
+
+  describe 'show_account' do
+    it 'returns account properties' do
+      stub_api_request(:get, "/v3/account/show").
+        to_return(:body => {'account' => {'id' => 1, 'plan' => 0, 'storage_size' => 2, 'guaranteed_cores' => 3, 'maximum_cores' => 4, 'created_at' => '2014-12-14T17:24:00+0900'}}.to_json)
+      expect(api.show_account).to eq([1, 0, 2, 3, 4, "2014-12-14T17:24:00+0900"])
+    end
+  end
+
+  describe 'account_core_utilization' do
+    it 'returns core utilization' do
+      from = '2014-12-01T00:00:00+0900'
+      to = '2015-01-01T00:00:00+0900'
+      stub_api_request(:get, "/v3/account/core_utilization", :query => {'from' => from, 'to' => to}).
+        to_return(:body => {'from' => from, 'to' => to, 'interval' => 1, 'history' => ['dummy']}.to_json)
+      r = api.account_core_utilization(from, to)
+      expect(r[0]).to eq(Time.parse(from))
+      expect(r[1]).to eq(Time.parse(to))
+      expect(r[2]).to eq(1)
+      expect(r[3]).to eq(['dummy'])
+    end
+  end
+end

data/spec/td/client/api_error_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe APIError do
+  let (:message){ 'message' }
+  let (:api_backtrace){ double('api_backtrace') }
+  describe 'new' do
+    context '' do
+      it do
+        exc = APIError.new(message, api_backtrace)
+        expect(exc).to be_an(APIError)
+        expect(exc.message).to eq message
+        expect(exc.api_backtrace).to eq api_backtrace
+      end
+    end
+    context 'api_backtrace is ""' do
+      let (:api_backtrace){ '' }
+      it do
+        exc = APIError.new(message, api_backtrace)
+        expect(exc).to be_an(APIError)
+        expect(exc.message).to eq message
+        expect(exc.api_backtrace).to be_nil
+      end
+    end
+    context 'api_backtrace is nil' do
+      let (:api_backtrace){ nil }
+      it do
+        exc = APIError.new(message, api_backtrace)
+        expect(exc).to be_an(APIError)
+        expect(exc.message).to eq message
+        expect(exc.api_backtrace).to be_nil
+      end
+    end
+  end
+end
+
+describe AlreadyExistsError do
+  let (:message){ 'message' }
+  let (:api_backtrace){ double('api_backtrace') }
+  let (:conflicts_with){ '12345' }
+  describe 'new' do
+    context '' do
+      it do
+        exc = AlreadyExistsError.new(message, api_backtrace)
+        expect(exc).to be_an(AlreadyExistsError)
+        expect(exc.message).to eq message
+        expect(exc.api_backtrace).to eq api_backtrace
+      end
+    end
+    context 'api_backtrace is ""' do
+      let (:api_backtrace){ '' }
+      it do
+        exc = AlreadyExistsError.new(message, api_backtrace)
+        expect(exc).to be_an(AlreadyExistsError)
+        expect(exc.message).to eq message
+        expect(exc.api_backtrace).to be_nil
+      end
+    end
+    context 'api_backtrace is nil' do
+      let (:api_backtrace){ nil }
+      it do
+        exc = AlreadyExistsError.new(message, api_backtrace)
+        expect(exc).to be_an(AlreadyExistsError)
+        expect(exc.message).to eq message
+        expect(exc.api_backtrace).to be_nil
+      end
+    end
+    context 'conflict' do
+      it do
+        exc = AlreadyExistsError.new(message, api_backtrace, conflicts_with)
+        expect(exc).to be_an(AlreadyExistsError)
+        expect(exc.message).to eq message
+        expect(exc.api_backtrace).to eq api_backtrace
+        expect(exc.conflicts_with).to eq conflicts_with
+      end
+    end
+  end
+end

data/spec/td/client/api_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe API do
+  it 'initialize should raise an error with invalid endpoint' do
+    expect {
+      API.new(nil, :endpoint => 'smtp://api.tester.com:1000')
+    }.to raise_error(RuntimeError, /Invalid endpoint:/)
+  end
+
+  VALID_NAMES = [
+    'abc',
+    'abc_cd',
+    '_abc_cd',
+    '_abc_',
+    'ab0_',
+    'ab0',
+  ]
+
+  INVALID_NAMES = {
+    'a' => 'a__',
+    'a'*257 => 'a'*253+'__',
+    'abcD' => 'abcd',
+    'a-b*' => 'a_b_',
+  }
+
+  describe 'normalizer' do
+    it 'normalized_msgpack should convert Bignum into String' do
+      h = {'key' => 1111111111111111111111111111111111}
+      unpacked = MessagePack.unpack(API.normalized_msgpack(h))
+      expect(unpacked['key']).to eq(h['key'].to_s)
+
+      h = {'key' => -1111111111111111111111111111111111}
+      unpacked = MessagePack.unpack(API.normalized_msgpack(h))
+      expect(unpacked['key']).to eq(h['key'].to_s)
+    end
+
+    it 'normalized_msgpack with out argument should convert Bignum into String' do
+      h = {'key' => 1111111111111111111111111111111111, 'key2' => -1111111111111111111111111111111111, 'key3' => 0}
+      out = ''
+      API.normalized_msgpack(h, out)
+      unpacked = MessagePack.unpack(out)
+      expect(unpacked['key']).to eq(h['key'].to_s)
+      expect(unpacked['key2']).to eq(h['key2'].to_s)
+      expect(unpacked['key3']).to eq(h['key3']) # don't touch non-too-big integer
+    end
+
+    it 'normalize_database_name should return normalized data' do
+      INVALID_NAMES.each_pair {|ng,ok|
+        expect(API.normalize_database_name(ng)).to eq(ok)
+      }
+      expect {
+        API.normalize_database_name('')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'normalize_table_name should return normalized data' do
+      INVALID_NAMES.each_pair {|ng,ok|
+        expect(API.normalize_table_name(ng)).to eq(ok)
+      }
+      # empty
+      expect {
+        API.normalize_table_name('')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'normalize_database_name should return valid data' do
+      VALID_NAMES.each {|ok|
+        expect(API.normalize_database_name(ok)).to eq(ok)
+      }
+    end
+  end
+
+  describe 'validator' do
+    describe "'validate_database_name'" do
+      it 'should raise a ParameterValidationError exceptions' do
+        INVALID_NAMES.each_pair {|ng,ok|
+          expect {
+            API.validate_database_name(ng)
+          }.to raise_error(ParameterValidationError)
+        }
+        # empty
+        expect {
+          API.validate_database_name('')
+        }.to raise_error(ParameterValidationError)
+      end
+
+      it 'should return valid data' do
+        VALID_NAMES.each {|ok|
+          expect(API.validate_database_name(ok)).to eq(ok)
+        }
+      end
+    end
+
+    describe "'validate_table_name'" do
+      it 'should raise a ParameterValidationError exception' do
+        INVALID_NAMES.each_pair {|ng,ok|
+          expect {
+            API.validate_table_name(ng)
+          }.to raise_error(ParameterValidationError)
+        }
+        expect {
+          API.validate_table_name('')
+        }.to raise_error(ParameterValidationError)
+      end
+
+      it 'should return valid data' do
+        VALID_NAMES.each {|ok|
+          expect(API.validate_database_name(ok)).to eq(ok)
+        }
+      end
+    end
+
+    describe "'validate_result_set_name'" do
+      it 'should raise a ParameterValidationError exception' do
+        INVALID_NAMES.each_pair {|ng,ok|
+          expect {
+            API.validate_result_set_name(ng)
+          }.to raise_error(ParameterValidationError)
+        }
+        # empty
+        expect {
+          API.validate_result_set_name('')
+        }.to raise_error(ParameterValidationError)
+      end
+
+      it 'should return valid data' do
+        VALID_NAMES.each {|ok|
+          expect(API.validate_result_set_name(ok)).to eq(ok)
+        }
+      end
+    end
+
+    describe "'validate_column_name'" do
+      it 'should raise a ParameterValidationError exception' do
+        [''].each { |ng|
+          expect {
+            API.validate_column_name(ng)
+          }.to raise_error(ParameterValidationError)
+        }
+      end
+
+      it 'should return valid data' do
+        VALID_NAMES.each {|ok|
+          expect(API.validate_column_name(ok)).to eq(ok)
+        }
+        ['a', 'a'*255].each {|ok|
+          expect(API.validate_column_name(ok)).to eq(ok)
+        }
+      end
+    end
+
+    describe "'validate_sql_alias_name'" do
+      it 'should raise a ParameterValidationError exception' do
+        [''].each { |ng|
+          expect{API.validate_sql_alias_name(ng)}.to raise_error(ParameterValidationError)
+        }
+        valid = ("a".."z").to_a.join<<("0".."9").to_a.join<<"_"
+        ("\x00".."\x7F").each { |ng|
+          next if valid.include?(ng)
+          expect{API.validate_sql_alias_name(ng)}.to raise_error(ParameterValidationError)
+        }
+      end
+
+      it 'should return valid data' do
+        VALID_NAMES.each {|ok|
+          expect(API.validate_sql_alias_name(ok)).to eq(ok)
+        }
+        ['a', '_a', 'a_', 'a'*512].each {|ok|
+          expect(API.validate_sql_alias_name(ok)).to eq(ok)
+        }
+      end
+    end
+
+    describe "'generic validate_name'" do
+      it 'should raise a ParameterValidationError exception' do
+        # wrong target
+        expect {
+          API.validate_name("", 3, 256, '')
+        }.to raise_error(ParameterValidationError)
+        INVALID_NAMES.each_pair {|ng,ok|
+          expect {
+            API.validate_name("generic", 3, 256, ng)
+          }.to raise_error(ParameterValidationError)
+        }
+        # empty
+        expect {
+          API.validate_name("generic", 3, 256, '')
+        }.to raise_error(ParameterValidationError)
+        # too short - one less than left limit
+        expect {
+          API.validate_name("generic", 3, 256, 'ab')
+        }.to raise_error(ParameterValidationError)
+      end
+
+      it 'should return valid data' do
+        VALID_NAMES.each {|ok|
+          expect(API.validate_name("generic", 3, 256, ok)).to eq(ok)
+        }
+        # esplore left boundary
+        expect(API.validate_name("generic", 2, 256, 'ab')).to eq('ab')
+        expect(API.validate_name("generic", 1, 256, 'a')).to eq('a')
+        # explore right boundary
+        expect(API.validate_name("generic", 3, 256, 'a' * 256)).to eq('a' * 256)
+        expect(API.validate_name("generic", 3, 128, 'a' * 128)).to eq('a' * 128)
+      end
+    end
+
+    describe 'checking GET API content length with ssl' do
+      include_context 'common helper'
+
+      let(:api) { API.new(nil, endpoint: endpoint) }
+      let :packed do
+        s = StringIO.new(String.new)
+        Zlib::GzipWriter.wrap(s) do |f|
+          f << ['hello', 'world'].to_json
+        end
+        s.string
+      end
+
+      before do
+        stub_api_request(:get, '/v3/job/result/12345', ssl: ssl).
+          with(:query => {'format' => 'json'}).
+          to_return(
+            :headers => {'Content-Encoding' => 'gzip'}.merge(content_length),
+            :body => packed
+          )
+      end
+
+      subject (:get_api_call) {
+        api.job_result_format(12345, 'json', StringIO.new(String.new))
+      }
+
+      context 'without ssl' do
+        let(:endpoint) { "http://#{API::DEFAULT_ENDPOINT}" }
+        let(:ssl) { false }
+        let(:content_length) { {'Content-Length' => packed.size} }
+
+        it 'not called #completed_body?' do
+          expect(api).not_to receive(:completed_body?)
+
+          get_api_call
+        end
+      end
+
+      context 'with ssl' do
+        let(:endpoint) { "https://#{API::DEFAULT_ENDPOINT}" }
+        let(:ssl) { true }
+
+        context 'without Content-Length' do
+          let(:content_length) { {} }
+
+          it 'api accuess succeded' do
+            expect { get_api_call }.not_to raise_error
+          end
+        end
+
+        context 'with Content-Length' do
+          context 'match Content-Length and body.size' do
+            let(:content_length) { {'Content-Length' => packed.size} }
+
+            it 'api accuess succeded' do
+              expect { get_api_call }.not_to raise_error
+            end
+          end
+        end
+      end
+    end
+  end
+end