td 0.13.2 → 0.14.0

data/spec/td/command/table_spec.rb

@@ -22,11 +22,11 @@ module TreasureData::Command
         }
         db_tables = create_tables.call(db.name)
 
-        client.stub(:tables).with(db.name).and_return(db_tables)
+        allow(client).to receive(:tables).with(db.name).and_return(db_tables)
 
         command = Class.new { include TreasureData::Command }.new
-        command.stub(:get_client).and_return(client)
-        command.stub(:get_database).and_return(db)
+        allow(command).to receive(:get_client).and_return(client)
+        allow(command).to receive(:get_database).and_return(db)
 
         op = List::CommandParser.new('table:list', %w[], %w[db], false, %w(full_access_db), true)
         expect {
@@ -51,14 +51,14 @@ module TreasureData::Command
         fa_db_tables = create_tables.call(fa_db.name)
         own_db_tables = create_tables.call(own_db.name)
 
-        client.stub(:databases).and_return([qo_db, fa_db, own_db])
+        allow(client).to receive(:databases).and_return([qo_db, fa_db, own_db])
 
-        client.stub(:tables).with(qo_db.name).and_return(qo_db_tables)
-        client.stub(:tables).with(fa_db.name).and_return(fa_db_tables)
-        client.stub(:tables).with(own_db.name).and_return(own_db_tables)
+        allow(client).to receive(:tables).with(qo_db.name).and_return(qo_db_tables)
+        allow(client).to receive(:tables).with(fa_db.name).and_return(fa_db_tables)
+        allow(client).to receive(:tables).with(own_db.name).and_return(own_db_tables)
 
         command = Class.new { include TreasureData::Command }.new
-        command.stub(:get_client).and_return(client)
+        allow(command).to receive(:get_client).and_return(client)
 
         op = List::CommandParser.new('table:list', %w[], %w[db], false, %w(), true)
         expect {
@@ -72,8 +72,8 @@ module TreasureData::Command
         db = TreasureData::Database.new(client, 'import_only_db', nil, 1234, Time.now.to_i, Time.now.to_i, nil, 'import_only')
 
         command = Class.new { include TreasureData::Command }.new
-        command.stub(:get_client).and_return(client)
-        command.stub(:get_database).and_return(db)
+        allow(command).to receive(:get_client).and_return(client)
+        allow(command).to receive(:get_database).and_return(db)
 
         op = List::CommandParser.new('table:list', %w[], %w[db], false, %w(import_only_db), true)
         expect {
@@ -99,15 +99,15 @@ module TreasureData::Command
         fa_db_tables = create_tables.call(fa_db.name)
         own_db_tables = create_tables.call(own_db.name)
 
-        client.stub(:databases).and_return([io_db, qo_db, fa_db, own_db])
+        allow(client).to receive(:databases).and_return([io_db, qo_db, fa_db, own_db])
 
-        client.stub(:tables).with(io_db.name).and_raise("not permitted")
-        client.stub(:tables).with(qo_db.name).and_return(qo_db_tables)
-        client.stub(:tables).with(fa_db.name).and_return(fa_db_tables)
-        client.stub(:tables).with(own_db.name).and_return(own_db_tables)
+        allow(client).to receive(:tables).with(io_db.name).and_raise("not permitted")
+        allow(client).to receive(:tables).with(qo_db.name).and_return(qo_db_tables)
+        allow(client).to receive(:tables).with(fa_db.name).and_return(fa_db_tables)
+        allow(client).to receive(:tables).with(own_db.name).and_return(own_db_tables)
 
         command = Class.new { include TreasureData::Command }.new
-        command.stub(:get_client).and_return(client)
+        allow(command).to receive(:get_client).and_return(client)
 
         op = List::CommandParser.new('table:list', %w[], %w[db], false, %w(), true)
         expect {
@@ -122,8 +122,8 @@ module TreasureData::Command
         let(:db) { TreasureData::Database.new(client, 'full_access_db', nil, 1000, Time.now.to_i, Time.now.to_i, nil, 'full_access') }
         let(:command) do
           command = Class.new { include TreasureData::Command }.new
-          command.stub(:get_client).and_return(client)
-          command.stub(:get_database).and_return(db)
+          allow(command).to receive(:get_client).and_return(client)
+          allow(command).to receive(:get_database).and_return(db)
           command
         end
 
@@ -135,7 +135,7 @@ module TreasureData::Command
             }
           }
           db_tables = create_tables.call(db.name)
-          client.stub(:tables).with(db.name).and_return(db_tables)
+          allow(client).to receive(:tables).with(db.name).and_return(db_tables)
         end
 
         subject do
@@ -156,26 +156,26 @@ module TreasureData::Command
 
         context "without --format" do
           let(:options) { [] }
-          it { should include(number_format) }
-          it { should_not include(number_raw) }
+          it { is_expected.to include(number_format) }
+          it { is_expected.not_to include(number_raw) }
         end
 
         context "with --format table" do
           let(:options) { %w(--format table) }
-          it { should include(number_format) }
-          it { should_not include(number_raw) }
+          it { is_expected.to include(number_format) }
+          it { is_expected.not_to include(number_raw) }
         end
 
         context "with --format csv" do
           let(:options) { %w(--format csv) }
-          it { should_not include(number_format) }
-          it { should include(number_raw) }
+          it { is_expected.not_to include(number_format) }
+          it { is_expected.to include(number_raw) }
         end
 
         context "with --format tsv" do
           let(:options) { %w(--format tsv) }
-          it { should_not include(number_format) }
-          it { should include(number_raw) }
+          it { is_expected.not_to include(number_format) }
+          it { is_expected.to include(number_raw) }
         end
       end
     end
@@ -188,8 +188,8 @@ module TreasureData::Command
 
       describe 'auto create table' do
         before do
-          command.stub(:get_client) { client }
-          command.stub(:do_table_import)
+          allow(command).to receive(:get_client) { client }
+          allow(command).to receive(:do_table_import)
         end
 
         context 'set --auto-create-table' do
@@ -198,7 +198,7 @@ module TreasureData::Command
           }
 
           it 'create table' do
-            command.should_receive(:create_database_and_table_if_not_exist).with(client, db_name, table_name)
+            expect(command).to receive(:create_database_and_table_if_not_exist).with(client, db_name, table_name)
             command.table_import(option)
           end
         end
@@ -209,7 +209,7 @@ module TreasureData::Command
           }
 
           it 'not create table' do
-            command.should_not_receive(:create_database_and_table_if_not_exist)
+            expect(command).not_to receive(:create_database_and_table_if_not_exist)
             command.table_import(option)
           end
         end
@@ -217,8 +217,8 @@ module TreasureData::Command
 
       describe 'time key' do
         before do
-          command.stub(:get_client) { client }
-          command.stub(:do_table_import)
+          allow(command).to receive(:get_client) { client }
+          allow(command).to receive(:do_table_import)
         end
         let(:input_params) {{
           db_name: "database",
@@ -237,7 +237,7 @@ module TreasureData::Command
             end
 
             it "with '#{tk_option}' option" do
-              command.should_receive(:do_table_import).with(client, input_params)
+              expect(command).to receive(:do_table_import).with(client, input_params)
               command.table_import(option)
             end
           end
@@ -253,7 +253,7 @@ module TreasureData::Command
           end
 
           it 'without \'-t / --time-key\' option' do
-            command.should_receive(:do_table_import).with(client, input_params)
+            expect(command).to receive(:do_table_import).with(client, input_params)
             command.table_import(option)
           end
         end
@@ -274,19 +274,19 @@ module TreasureData::Command
       }
 
       before do
-        command.stub(:get_client) { client }
-        command.stub(:get_database).with(client, db_name).and_return(database)
+        allow(command).to receive(:get_client) { client }
+        allow(command).to receive(:get_database).with(client, db_name).and_return(database)
       end
 
       context "from table isn't exists" do
         let(:cmd_args) { [db_name, from_table_name, dest_table_name] }
 
         before do
-          database.stub(:table).with(from_table_name).and_return { raise }
+          allow(database).to receive(:table).with(from_table_name) { raise }
         end
 
         it "can't rename table" do
-          command.should_receive(:exit).with(1).and_return { raise CallSystemExitError }
+          expect(command).to receive(:exit).with(1) { raise CallSystemExitError }
 
           expect { command.table_rename(option) }.to raise_error
           expect(stderr_io.string).to     include(from_table_name)
@@ -298,18 +298,18 @@ module TreasureData::Command
         let(:cmd_args) { [db_name, from_table_name, dest_table_name] }
 
         before do
-          database.stub(:table).with(from_table_name).and_return
+          allow(database).to receive(:table).with(from_table_name)
         end
 
         context "dest_table isn't exists" do
           before do
-            database.stub(:table).with(dest_table_name).and_return { raise }
+            allow(database).to receive(:table).with(dest_table_name) { raise }
           end
 
           it 'create dest table and rename table' do
-            client.should_receive(:create_log_table).with(db_name, dest_table_name)
-            client.should_receive(:swap_table).with(db_name, from_table_name, dest_table_name)
-            client.should_receive(:delete_table).with(db_name, from_table_name)
+            expect(client).to receive(:create_log_table).with(db_name, dest_table_name)
+            expect(client).to receive(:swap_table).with(db_name, from_table_name, dest_table_name)
+            expect(client).to receive(:delete_table).with(db_name, from_table_name)
 
             command.table_rename(option)
 
@@ -320,11 +320,11 @@ module TreasureData::Command
 
         context "dest_tableis is exist" do
           before do
-            database.stub(:table).with(dest_table_name).and_return
+            allow(database).to receive(:table).with(dest_table_name)
           end
 
           it "can't rename table" do
-            command.should_receive(:exit).with(1).and_return { raise CallSystemExitError }
+            expect(command).to receive(:exit).with(1) { raise CallSystemExitError }
 
             expect { command.table_rename(option) }.to raise_error
             expect(stderr_io.string).not_to include(from_table_name)
@@ -337,18 +337,18 @@ module TreasureData::Command
         let(:cmd_args) { [db_name, from_table_name, dest_table_name, '--overwrite'] }
 
         before do
-          database.stub(:table).with(from_table_name).and_return
+          allow(database).to receive(:table).with(from_table_name)
         end
 
         context "dest_table isn't exists" do
           before do
-            database.stub(:table).with(dest_table_name).and_return { raise }
+            allow(database).to receive(:table).with(dest_table_name) { raise }
           end
 
           it 'create dest table and rename table' do
-            client.should_receive(:create_log_table).with(db_name, dest_table_name)
-            client.should_receive(:swap_table).with(db_name, from_table_name, dest_table_name)
-            client.should_receive(:delete_table).with(db_name, from_table_name)
+            expect(client).to receive(:create_log_table).with(db_name, dest_table_name)
+            expect(client).to receive(:swap_table).with(db_name, from_table_name, dest_table_name)
+            expect(client).to receive(:delete_table).with(db_name, from_table_name)
 
             command.table_rename(option)
             expect(stderr_io.string).to include(from_table_name)
@@ -358,12 +358,12 @@ module TreasureData::Command
 
         context "dest_tableis is exist" do
           before do
-            database.stub(:table).with(dest_table_name).and_return
+            allow(database).to receive(:table).with(dest_table_name)
           end
 
           it 'overwrite dest table' do
-            client.should_receive(:swap_table).with(db_name, from_table_name, dest_table_name)
-            client.should_receive(:delete_table).with(db_name, from_table_name)
+            expect(client).to receive(:swap_table).with(db_name, from_table_name, dest_table_name)
+            expect(client).to receive(:delete_table).with(db_name, from_table_name)
 
             command.table_rename(option)
             expect(stderr_io.string).to include(from_table_name)

data/spec/td/common_spec.rb

@@ -8,14 +8,14 @@ module TreasureData::Command
       values = [0, 1, 10, 1023]
       values.each {|v|
         it "uses B as label and has no suffix (#{v})" do
-          TreasureData::Command::humanize_bytesize(v, 1).should == "#{v} B"
+          expect(TreasureData::Command::humanize_bytesize(v, 1)).to eq("#{v} B")
         end
       }
     end
 
     describe 'for 1024' do
       it 'uses kB and does not have a suffix' do
-        TreasureData::Command::humanize_bytesize(1024).should == "1 kB"
+        expect(TreasureData::Command::humanize_bytesize(1024)).to eq("1 kB")
       end
     end
     describe 'for values between 1025 and (1024^2 - 1)' do
@@ -35,7 +35,7 @@ module TreasureData::Command
 
     describe 'for 1024^2' do
       it 'uses MB and does not have a suffix' do
-        TreasureData::Command::humanize_bytesize(1024 ** 2).should == "1 MB"
+        expect(TreasureData::Command::humanize_bytesize(1024 ** 2)).to eq("1 MB")
       end
     end
     describe 'for values between (1024^2 + 1) and (1024^3 - 1)' do
@@ -55,7 +55,7 @@ module TreasureData::Command
 
     describe 'for 1024^3' do
       it 'uses GB and does not have a suffix' do
-        TreasureData::Command::humanize_bytesize(1024 ** 3).should == "1 GB"
+        expect(TreasureData::Command::humanize_bytesize(1024 ** 3)).to eq("1 GB")
       end
     end
     describe 'for values between (1024^3 + 1) and (1024^4 - 1)' do
@@ -75,7 +75,7 @@ module TreasureData::Command
 
     describe 'for 1024^4' do
       it 'uses TB and does not have a suffix' do
-        TreasureData::Command::humanize_bytesize(1024 ** 4).should == "1 TB"
+        expect(TreasureData::Command::humanize_bytesize(1024 ** 4)).to eq("1 TB")
       end
     end
     describe 'for values between (1024^4 + 1) and (1024^5 - 1)' do
@@ -95,7 +95,7 @@ module TreasureData::Command
 
     describe 'for 1024^5' do
       it 'uses TB and does not have a suffix' do
-        TreasureData::Command::humanize_bytesize(1024 ** 5).should == "1024 TB"
+        expect(TreasureData::Command::humanize_bytesize(1024 ** 5)).to eq("1024 TB")
       end
     end
     describe 'for values between (1024^5 + 1) and (1024^6 - 1)' do
@@ -183,8 +183,8 @@ module TreasureData::Command
         ret = indicator.update
         if ret == true
           diff = curr_time - last_time
-          diff.should be >= 2
-          diff.should be < 3
+          expect(diff).to be >= 2
+          expect(diff).to be < 3
           last_time = curr_time
         end
         sleep(0.5)
@@ -202,8 +202,8 @@ module TreasureData::Command
         while (curr_time = Time.now.to_i) < end_time do
           ret = indicator.update
           if ret == true
-            (curr_time - last_time).should be >= periodicity
-            (curr_time - last_time).should be < (periodicity + 1)
+            expect(curr_time - last_time).to be >= periodicity
+            expect(curr_time - last_time).to be < (periodicity + 1)
             last_time = curr_time
           end
           sleep(0.5)
@@ -235,13 +235,13 @@ module TreasureData::Command
 
     describe 'create database' do
       before do
-        client.stub(:create_log_table)
+        allow(client).to receive(:create_log_table)
       end
 
       context 'client.database success' do
         it 'not call client.create_database' do
-          client.should_receive(:database).with(database_name)
-          client.should_not_receive(:create_database)
+          expect(client).to receive(:database).with(database_name)
+          expect(client).not_to receive(:create_database)
 
           call_create_database_and_table_if_not_exist
           expect(stderr_io.string).not_to include "Database '#{database_name}'"
@@ -250,12 +250,12 @@ module TreasureData::Command
 
       context 'client.database raise NotFoundError' do
         before do
-          client.should_receive(:database).with(database_name).and_return { raise TreasureData::NotFoundError }
+          expect(client).to receive(:database).with(database_name) { raise TreasureData::NotFoundError }
         end
 
         context 'craet_database success' do
           it 'call client.create_database' do
-            client.should_receive(:create_database).with(database_name)
+            expect(client).to receive(:create_database).with(database_name)
 
             call_create_database_and_table_if_not_exist
             expect(stderr_io.string).to include "Database '#{database_name}'"
@@ -264,7 +264,7 @@ module TreasureData::Command
 
         context 'craet_database raise AlreadyExistsError' do
           it 'resuce in method' do
-            client.should_receive(:create_database).with(database_name).and_return { raise TreasureData::AlreadyExistsError }
+            expect(client).to receive(:create_database).with(database_name) { raise TreasureData::AlreadyExistsError }
 
             expect {
               call_create_database_and_table_if_not_exist
@@ -277,8 +277,8 @@ module TreasureData::Command
 
       context 'client.database raise ForbiddenError' do
         it 'not call client.create_database' do
-          client.should_receive(:database).with(database_name).and_return { raise TreasureData::ForbiddenError }
-          client.should_not_receive(:create_database)
+          expect(client).to receive(:database).with(database_name) { raise TreasureData::ForbiddenError }
+          expect(client).not_to receive(:create_database)
 
           call_create_database_and_table_if_not_exist
           expect(stderr_io.string).not_to include "Database '#{database_name}'"
@@ -288,12 +288,12 @@ module TreasureData::Command
 
     describe 'create table' do
       before do
-        client.stub(:database)
+        allow(client).to receive(:database)
       end
 
       context 'create_log_table success' do
         it 'show message' do
-          client.should_receive(:create_log_table).with(database_name, table_name)
+          expect(client).to receive(:create_log_table).with(database_name, table_name)
 
           call_create_database_and_table_if_not_exist
           expect(stderr_io.string).to include "Table '#{database_name}.#{table_name}'"
@@ -302,7 +302,7 @@ module TreasureData::Command
 
       context 'create_log_table raise AlreadyExistsError' do
         it 'resuce in method' do
-          client.should_receive(:create_log_table).with(database_name, table_name).and_return { raise TreasureData::AlreadyExistsError }
+          expect(client).to receive(:create_log_table).with(database_name, table_name) { raise TreasureData::AlreadyExistsError }
 
           expect {
             call_create_database_and_table_if_not_exist

data/spec/td/updater_spec.rb

@@ -21,9 +21,9 @@ module TreasureData::Updater
 
         describe 'endpoints methods' do
           it 'use the default root path' do
-            TreasureData::Updater.endpoint_root.should == default_toolbelt_url
-            TreasureData::Updater.version_endpoint.should =~ Regexp.new(default_toolbelt_url)
-            TreasureData::Updater.update_package_endpoint.should =~ Regexp.new(default_toolbelt_url)
+            expect(TreasureData::Updater.endpoint_root).to eq(default_toolbelt_url)
+            expect(TreasureData::Updater.version_endpoint).to match(Regexp.new(default_toolbelt_url))
+            expect(TreasureData::Updater.update_package_endpoint).to match(Regexp.new(default_toolbelt_url))
           end
         end
       end
@@ -34,9 +34,9 @@ module TreasureData::Updater
         end
         describe 'endpoints methods' do
           it 'use the custom root path' do
-            TreasureData::Updater.endpoint_root.should == ENV['TD_TOOLBELT_UPDATE_ROOT']
-            TreasureData::Updater.version_endpoint.should =~ Regexp.new(ENV['TD_TOOLBELT_UPDATE_ROOT'])
-            TreasureData::Updater.update_package_endpoint.should =~ Regexp.new(ENV['TD_TOOLBELT_UPDATE_ROOT'])
+            expect(TreasureData::Updater.endpoint_root).to eq(ENV['TD_TOOLBELT_UPDATE_ROOT'])
+            expect(TreasureData::Updater.version_endpoint).to match(Regexp.new(ENV['TD_TOOLBELT_UPDATE_ROOT']))
+            expect(TreasureData::Updater.update_package_endpoint).to match(Regexp.new(ENV['TD_TOOLBELT_UPDATE_ROOT']))
           end
         end
         after do
@@ -137,13 +137,13 @@ module TreasureData::Updater
       subject { updater.kick }
 
       context "not updated" do
-        before { updater.stub(:existent_jar_updated_time).and_return(Time.now) }
+        before { allow(updater).to receive(:existent_jar_updated_time).and_return(Time.now) }
 
         it_behaves_like "jar_update behavior"
       end
 
       context "updated" do
-        before { updater.stub(:existent_jar_updated_time).and_return(Time.at(0)) }
+        before { allow(updater).to receive(:existent_jar_updated_time).and_return(Time.at(0)) }
 
         it_behaves_like "jar_update behavior"
       end