rspec-hive 0.4.2 → 0.6.0

data/spec/lib/rspec/hive/connection_delegator_spec.rb

@@ -1,6 +1,18 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe RSpec::Hive::ConnectionDelegator do
+  let(:day_column) { instance_double(RBHive::TableSchema::Column, name: :day, type: :string) }
+  let(:dth_column) { instance_double(RBHive::TableSchema::Column, name: :dth, type: :int) }
+  let(:hm_column) { instance_double(RBHive::TableSchema::Column, name: :hm, type: :int) }
+  let(:country_column) { instance_double(RBHive::TableSchema::Column, name: :country, type: :string) }
+  let(:table_name) { 'test_table' }
+  let(:table_schema) { instance_double(RBHive::TableSchema, name: table_name) }
+  let(:connection_delegator) { described_class.new(connection, config) }
+  let(:connection) { double('Connection') }
+  let(:config) { double('Config') }
+
   describe '#load_into_table' do
     let(:host_shared_directory_path) { '/tmp/host' }
     let(:docker_file_path) { '/tmp/docked/test_file' }
@@ -11,9 +23,6 @@ RSpec.describe RSpec::Hive::ConnectionDelegator do
       )
     end
     let(:delimiter) { "\t" }
-    let(:table_name) { 'test_table' }
-    let(:table_schema) { instance_double(RBHive::TableSchema, name: table_name) }
-    let(:connection) { double('Connection') }
     let(:file_mock) { double(Tempfile) }
 
     let(:values) { ['a', 'b', 1] }
@@ -24,54 +33,49 @@ RSpec.describe RSpec::Hive::ConnectionDelegator do
       expect(Tempfile).to receive(:open).
         with(table_name, host_shared_directory_path).and_yield(file_mock)
 
-      expect(subject).to receive(:docker_path).
+      expect(connection_delegator).to receive(:docker_path).
         with(file_mock) { docker_file_path }
 
-      expect(subject).to receive(:write_values_to_file).
+      expect(connection_delegator).to receive(:write_values_to_file).
         with(file_mock, values, "\t").once
     end
 
     context 'without partitions' do
       before do
-        expect(subject).to receive(:load_file_to_hive_table).
+        expect(connection_delegator).to receive(:load_file_to_hive_table).
           with(table_name, docker_file_path, nil).once
 
-        expect(subject).not_to receive(:partition_clause)
+        expect(connection_delegator).not_to receive(:partition_clause)
       end
 
-      subject { described_class.new(connection, config) }
-
-      it do
-        subject.load_into_table(table_schema, values)
-      end
+      it { connection_delegator.load_into_table(table_schema, values) }
     end
 
     context 'with partitions' do
       let(:partitions) { {day: '20160101', hm: '2020'} }
+      let(:table_schema) { instance_double(RBHive::TableSchema, name: table_name, partitions: [day_column, hm_column]) }
+
       let(:partition_query) { "PARTITION(day='20160101',hm='2020')" }
+
       before do
-        expect(subject).to receive(:load_file_to_hive_table).
+        expect(connection_delegator).to receive(:load_file_to_hive_table).
           with(table_name, docker_file_path, partition_query).once
-        expect(subject).to receive(:partition_clause).
-          with(partitions) { partition_query }
+        expect(connection_delegator).to receive(:partition_clause).
+          with(table_schema, partitions) { partition_query }
       end
 
-      subject { described_class.new(connection, config) }
-
-      it do
-        subject.load_into_table(table_schema, values, partitions)
-      end
+      it { connection_delegator.load_into_table(table_schema, values, partitions) }
     end
   end
 
   describe '#load_partition' do
-    let(:config) { double('Config') }
-    let(:connection) { double('Connection') }
-
-    let(:table_name) { 'test_table' }
     let(:partitions) do
       [{dth: 'mon', country: 'us'}, {dth: 'tue', country: 'us'}]
     end
+    let(:table_schema) do
+      instance_double(RBHive::TableSchema, name: table_name, partitions: [day_column, hm_column, country_column])
+    end
+
     let(:partition_query) do
       "PARTITION(dth='mon',country='us') PARTITION(dth='tue',country='us')"
     end
@@ -81,43 +85,34 @@ RSpec.describe RSpec::Hive::ConnectionDelegator do
     end
 
     before do
-      expect(subject).to receive(:partition_clause).
-        with(partitions) { partition_query }
+      expect(connection_delegator).to receive(:partition_clause).with(table_schema, partitions) { partition_query }
       expect(connection).to receive(:execute).with(executed_query)
     end
 
-    subject { described_class.new(connection, config) }
-
-    it do
-      subject.load_partitions(table_name, partitions)
-    end
+    it { connection_delegator.load_partitions(table_schema, partitions) }
   end
 
   describe '#partition_clause' do
-    let(:config) { double('Config') }
-    let(:connection) { double('Connection') }
-
     context 'with single partition' do
-      let(:partitions) { {day: '20160101', hm: '2020'} }
-      let(:partition_query) { "PARTITION(day='20160101',hm='2020')" }
-
-      subject { described_class.new(connection, config) }
+      let(:partitions) { {day: 'tue', dth: '20160101'} }
+      let(:table_schema) { instance_double(RBHive::TableSchema, partitions: [day_column, dth_column]) }
+      let(:expected_partition_query) { "PARTITION(day='tue',dth=20160101)" }
 
       it 'translates partition hash to single query' do
-        expect(subject.send(:partition_clause, partitions)).to eq(partition_query)
+        expect(connection_delegator.send(:partition_clause, table_schema, partitions)).to eq(expected_partition_query)
       end
     end
 
     context 'with multiple partitions' do
       let(:partitions) { [{day: 'mon', hm: '2020'}, {day: 'tue', hm: '2020'}, {day: 'mon', hm: '2030'}] }
+      let(:table_schema) { instance_double(RBHive::TableSchema, partitions: [day_column, hm_column]) }
+
       let(:partition_query) do
-        "PARTITION(day='mon',hm='2020') PARTITION(day='tue',hm='2020') PARTITION(day='mon',hm='2030')"
+        "PARTITION(day='mon',hm=2020) PARTITION(day='tue',hm=2020) PARTITION(day='mon',hm=2030)"
       end
 
-      subject { described_class.new(connection, config) }
-
       it 'translates partition hash to combined query' do
-        expect(subject.send(:partition_clause, partitions)).to eq(partition_query)
+        expect(connection_delegator.send(:partition_clause, table_schema, partitions)).to eq(partition_query)
       end
     end
   end
@@ -128,37 +123,23 @@ RSpec.describe RSpec::Hive::ConnectionDelegator do
       [['a', 'b', 1],
        ['aa', 'bb', 22]]
     end
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
     let(:delimiter) { '|' }
     let(:expected_file_content) { "a|b|1\naa|bb|22\n" }
 
-    subject { described_class.new(connection, config) }
     it 'writes values to file in correct format' do
-      subject.send(:write_values_to_file, file, values, delimiter)
+      connection_delegator.send(:write_values_to_file, file, values, delimiter)
       file.rewind
       expect(file.read).to eq(expected_file_content)
     end
   end
 
   describe '#load_file_to_hive_table' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
-    let(:table_name) { 'test_table' }
     let(:file_path) { '/tmp/test' }
-    let(:execute_text) do
-      "load data local inpath '/tmp/test' into table test_table"
-    end
+    let(:execute_text) { "load data local inpath '/tmp/test' into table test_table" }
 
-    before do
-      expect(connection).to receive(:execute).with(execute_text)
-    end
-
-    subject { described_class.new(connection, config) }
+    before { expect(connection).to receive(:execute).with(execute_text) }
 
-    it do
-      subject.send(:load_file_to_hive_table, table_name, file_path)
-    end
+    it { connection_delegator.send(:load_file_to_hive_table, table_name, file_path) }
   end
 
   describe '#translate_to_docker_path' do
@@ -167,7 +148,6 @@ RSpec.describe RSpec::Hive::ConnectionDelegator do
     let(:file_host_path) { '/tmp/host/testfile' }
     let(:expected_file_path) { '/tmp/docker/testfile' }
 
-    let(:connection) { double('Connection') }
     let(:docker_shared_directory_path) { '/tmp/docker' }
     let(:config) do
       double(
@@ -176,54 +156,29 @@ RSpec.describe RSpec::Hive::ConnectionDelegator do
       )
     end
 
-    before do
-      expect(file_mock).to receive(:path) { file_host_path }
-    end
-
-    subject { described_class.new(connection, config) }
+    before { expect(file_mock).to receive(:path) { file_host_path } }
 
-    it do
-      expect(subject.send(:docker_path, file_mock)).
-        to eq(expected_file_path)
-    end
+    it { expect(connection_delegator.send(:docker_path, file_mock)).to eq(expected_file_path) }
   end
 
   describe '#show_tables' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
     let(:fetch_text) { 'SHOW TABLES' }
 
-    before do
-      expect(connection).to receive(:fetch).with(fetch_text)
-    end
-
-    subject { described_class.new(connection, config) }
+    before { expect(connection).to receive(:fetch).with(fetch_text) }
 
-    it do
-      subject.show_tables
-    end
+    it { connection_delegator.show_tables }
   end
 
   describe '#create_database' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
     let(:db_name) { 'test' }
     let(:fetch_text) { 'CREATE DATABASE IF NOT EXISTS `test`' }
 
-    before do
-      expect(connection).to receive(:execute).with(fetch_text)
-    end
+    before { expect(connection).to receive(:execute).with(fetch_text) }
 
-    subject { described_class.new(connection, config) }
-
-    it do
-      subject.create_database(db_name)
-    end
+    it { connection_delegator.create_database(db_name) }
   end
 
   describe '#create_table' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
     let(:table_schema) { double('Table_schema') }
     let(:table_statement) { 'I AM TABLE STATEMENT' }
 
@@ -234,78 +189,43 @@ RSpec.describe RSpec::Hive::ConnectionDelegator do
       expect(connection).to receive(:execute).with(table_statement)
     end
 
-    subject { described_class.new(connection, config) }
-
-    it do
-      subject.create_table(table_schema)
-    end
+    it { connection_delegator.create_table(table_schema) }
   end
 
   describe '#use databaes' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
     let(:db_name) { 'test' }
     let(:fetch_text) { 'USE `test`' }
 
-    before do
-      expect(connection).to receive(:execute).with(fetch_text)
-    end
-
-    subject { described_class.new(connection, config) }
+    before { expect(connection).to receive(:execute).with(fetch_text) }
 
-    it do
-      subject.use_database(db_name)
-    end
+    it { connection_delegator.use_database(db_name) }
   end
 
   describe '#drop_databse' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
     let(:db_name) { 'test' }
     let(:fetch_text) { 'DROP DATABASE `test`' }
 
-    before do
-      expect(connection).to receive(:execute).with(fetch_text)
-    end
+    before { expect(connection).to receive(:execute).with(fetch_text) }
 
-    subject { described_class.new(connection, config) }
-
-    it do
-      subject.drop_database(db_name)
-    end
+    it { connection_delegator.drop_database(db_name) }
   end
 
   describe '#show_databases' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
     let(:fetch_text) { 'SHOW DATABASES' }
 
-    before do
-      expect(connection).to receive(:fetch).with(fetch_text)
-    end
-
-    subject { described_class.new(connection, config) }
+    before { expect(connection).to receive(:fetch).with(fetch_text) }
 
-    it do
-      subject.show_databases
-    end
+    it { connection_delegator.show_databases }
   end
 
   describe '#switch database' do
-    let(:connection) { double('Connection') }
-    let(:config) { double('Config') }
-
     let(:db_name) { 'test_db' }
 
     before do
-      expect(subject).to receive(:create_database).once
-      expect(subject).to receive(:use_database).once
+      expect(connection_delegator).to receive(:create_database).once
+      expect(connection_delegator).to receive(:use_database).once
     end
 
-    subject { described_class.new(connection, config) }
-
-    it do
-      subject.switch_database(db_name)
-    end
+    it { connection_delegator.switch_database(db_name) }
   end
 end

data/spec/lib/rspec/hive/connector_spec.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe RSpec::Hive::Connector do
   describe '#start_connection' do
-    let(:tcli_connection) { double(RBHive::TCLIConnection) }
+    let(:connector) { described_class.new(configuration) }
+    let(:tcli_connection) { class_double(RBHive::TCLIConnection) }
     let(:connection_delegator) { double(RSpec::Hive::ConnectionDelegator) }
     let(:host) { '127.0.0.1' }
     let(:port) { '10000' }
@@ -10,76 +13,68 @@ RSpec.describe RSpec::Hive::Connector do
     let(:hive_options) do
       {'hive.exec.dynamic.partition' => 'true',
        'hive.exec.dynamic.partition.mode' => 'nonstrict',
-       'hive.exec.max.dynamic.partitions.pernodexi' => '100000',
+       'hive.exec.max.dynamic.partitions.pernode' => '100000',
        'hive.exec.max.dynamic.partitions' => '100000',
        'mapred.child.java.opts' => '-Xmx2048m'}
     end
     let(:configuration) do
-      double(
+      instance_double(
         RSpec::Hive::Configuration,
         host: host,
         port: port,
-        hive_options: hive_options
+        hive_options: hive_options,
+        logger: instance_double(Logger)
       )
     end
 
+    before do
+      allow(connector).to receive(:connection_options) { options_mock }
+      allow(configuration.logger).to receive(:info)
+    end
+
     context 'when db_name is provided' do
+      subject { connector.start_connection(db_name) }
+
       let(:db_name) { 'test' }
 
       before do
-        allow(subject).to receive(:connection_options) { options_mock }
-        expect(RBHive::TCLIConnection).to receive(:new).
-          with(host, port, options_mock) { tcli_connection }
+        expect(RBHive::TCLIConnection).to receive(:new).with(host, port, options_mock) { tcli_connection }
         expect(RSpec::Hive::ConnectionDelegator).to receive(:new).
           with(tcli_connection, configuration) { connection_delegator }
-
         expect(connection_delegator).to receive(:open).once
         expect(connection_delegator).to receive(:open_session).once
-        expect(connection_delegator).to receive(:switch_database).
-          with(db_name).once
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition=true;')
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition.mode=nonstrict;')
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions.pernodexi=100000;')
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions=100000;')
-        expect(connection_delegator).to receive(:execute).with('SET mapred.child.java.opts=-Xmx2048m;')
-        allow(configuration).to receive_message_chain(:logger, :info)
+        expect(connection_delegator).to receive(:switch_database).with(db_name).once
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition=true')
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition.mode=nonstrict')
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions.pernode=100000')
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions=100000')
+        expect(connection_delegator).to receive(:execute).with('SET mapred.child.java.opts=-Xmx2048m')
       end
 
-      subject { described_class.new(configuration) }
-
-      it do
-        expect(subject.start_connection(db_name)).to equal(connection_delegator)
-      end
+      it { is_expected.to equal(connection_delegator) }
     end
 
     context 'when db_name is not provided' do
+      subject { connector.start_connection }
+
       let(:db_random_name) { 'rand123' }
 
       before do
-        allow(subject).to receive(:connection_options) { options_mock }
         expect(RSpec::Hive::DbName).to receive(:random_name) { db_random_name }
-        expect(RBHive::TCLIConnection).to receive(:new).
-          with(host, port, options_mock) { tcli_connection }
+        expect(RBHive::TCLIConnection).to receive(:new).with(host, port, options_mock) { tcli_connection }
         expect(RSpec::Hive::ConnectionDelegator).to receive(:new).
           with(tcli_connection, configuration) { connection_delegator }
-
         expect(connection_delegator).to receive(:open).once
         expect(connection_delegator).to receive(:open_session).once
-        expect(connection_delegator).to receive(:switch_database).
-          with(db_random_name).once
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition=true;')
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition.mode=nonstrict;')
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions.pernodexi=100000;')
-        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions=100000;')
-        expect(connection_delegator).to receive(:execute).with('SET mapred.child.java.opts=-Xmx2048m;')
-        allow(configuration).to receive_message_chain(:logger, :info)
+        expect(connection_delegator).to receive(:switch_database).with(db_random_name).once
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition=true')
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.dynamic.partition.mode=nonstrict')
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions.pernode=100000')
+        expect(connection_delegator).to receive(:execute).with('SET hive.exec.max.dynamic.partitions=100000')
+        expect(connection_delegator).to receive(:execute).with('SET mapred.child.java.opts=-Xmx2048m')
       end
 
-      subject { described_class.new(configuration) }
-
-      it do
-        expect(subject.start_connection).to equal(connection_delegator)
-      end
+      it { is_expected.to equal(connection_delegator) }
     end
   end
 end