td-client 0.8.85 → 0.9.0dev1

data/spec/td/client/api_error_spec.rb

@@ -1,77 +0,0 @@
-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/model_schema_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-require 'td/client/spec_resources'
-
-describe 'TreasureData::Schema::Field' do
-  describe '.new' do
-    context 'name="v"' do
-      it 'raises ParameterValidationError' do
-        expect{ Schema::Field.new('v', 'int') }.to raise_error(ParameterValidationError)
-      end
-    end
-    context 'name="time"' do
-      it 'raises ParameterValidationError' do
-        expect{ Schema::Field.new('time', 'int') }.to raise_error(ParameterValidationError)
-      end
-    end
-    context 'name with UTF-8' do
-      it 'works' do
-        name = "\u3042\u3044\u3046"
-        f = Schema::Field.new(name, 'int')
-        expect(f.name).to eq name
-        expect(f.type).to eq 'int'
-        expect(f.sql_alias).to be_nil
-      end
-    end
-    context 'with sql_alias' do
-      it 'raises' do
-        f = Schema::Field.new('t:t', 'int', 'alice')
-        expect(f.name).to eq 't:t'
-        expect(f.type).to eq 'int'
-        expect(f.sql_alias).to eq 'alice'
-      end
-    end
-    context 'with invalid sql_alias' do
-      it 'raises' do
-        expect{ Schema::Field.new('t:t', 'int', 't:t') }.to raise_error(ParameterValidationError)
-      end
-    end
-  end
-end
-
-describe 'TreasureData::Schema' do
-  describe '.parse' do
-    let(:columns){ ["foo:int", "BAR\u3070\u30FC:string@bar", "baz:baz!:array<double>@baz"] }
-    it do
-      sc = Schema.parse(columns)
-      expect(sc.fields.size).to eq 3
-      expect(sc.fields[0].name).to eq 'foo'
-      expect(sc.fields[0].type).to eq 'int'
-      expect(sc.fields[0].sql_alias).to be_nil
-      expect(sc.fields[1].name).to eq "BAR\u3070\u30FC"
-      expect(sc.fields[1].type).to eq 'string'
-      expect(sc.fields[1].sql_alias).to eq 'bar'
-      expect(sc.fields[2].name).to eq 'baz:baz!'
-      expect(sc.fields[2].type).to eq 'array<double>'
-      expect(sc.fields[2].sql_alias).to eq 'baz'
-    end
-  end
-
-  describe '.new' do
-    it do
-      f = Schema::Field.new('a', 'int')
-      sc = Schema.new([f])
-      expect(sc.fields[0]).to eq f
-    end
-  end
-
-  describe '#fields' do
-    it do
-      f = Schema::Field.new('a', 'int')
-      sc = Schema.new([f])
-      expect(sc.fields[0]).to eq f
-    end
-  end
-
-  describe '#add_field' do
-    it do
-      f = Schema::Field.new('a', 'int')
-      sc = Schema.new([f])
-      sc.add_field('b', 'double', 'bb')
-      expect(sc.fields[1].name).to eq 'b'
-    end
-    it 'raises ParameterValidationError if name is duplicated' do
-      f = Schema::Field.new('a', 'int')
-      sc = Schema.new([f])
-      expect{ sc.add_field('a', 'double') }.to raise_error(ParameterValidationError)
-    end
-    it 'raises ParameterValidationError if sql_alias is duplicated' do
-      f = Schema::Field.new('a', 'int')
-      sc = Schema.new([f])
-      expect{ sc.add_field('abc', 'double', 'a') }.to raise_error(ParameterValidationError)
-    end
-  end
-
-  describe '#merge' do
-    it do
-      sc1 = Schema.parse(['foo:int', 'bar:float'])
-      sc2 = Schema.parse(['bar:double', 'baz:string'])
-      sc3 = sc1.merge(sc2)
-      expect(sc3.fields.size).to eq 3
-      expect(sc3.fields[0].name).to eq 'foo'
-      expect(sc3.fields[0].type).to eq 'int'
-      expect(sc3.fields[1].name).to eq 'bar'
-      expect(sc3.fields[1].type).to eq 'double'
-      expect(sc3.fields[2].name).to eq 'baz'
-      expect(sc3.fields[2].type).to eq 'string'
-    end
-    it do
-      sc1 = Schema.parse(['foo:int', 'bar:float'])
-      sc2 = Schema.parse(['bar:double@foo'])
-      expect{ sc1.merge(sc2) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#to_json' do
-    it do
-      sc = Schema.parse(['foo:int', 'bar:float@baz'])
-      expect(sc.to_json).to eq '[["foo","int"],["bar","float","baz"]]'
-    end
-  end
-
-  describe '#from_json' do
-    it do
-      sc = Schema.new
-      sc.from_json [["foo","int"],["bar","float","baz"]]
-      expect(sc.fields.size).to eq 2
-      expect(sc.fields[0].name).to eq 'foo'
-      expect(sc.fields[0].type).to eq 'int'
-      expect(sc.fields[0].sql_alias).to be_nil
-      expect(sc.fields[1].name).to eq 'bar'
-      expect(sc.fields[1].type).to eq 'float'
-      expect(sc.fields[1].sql_alias).to eq 'baz'
-    end
-  end
-end