kpm 0.7.2 → 0.10.0

data/spec/kpm/unit/uninstaller_spec.rb

@@ -1,108 +1,154 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe KPM::Uninstaller do
-
+  let(:destination) { Dir.mktmpdir('uninstaller_spec') }
   let(:uninstaller) { KPM::Uninstaller.new(destination) }
-  let(:destination) { 'somedir' }
 
   let(:plugins_manager_mock) { double(KPM::PluginsManager) }
   let(:sha1_checker_mock) { double(KPM::Sha1Checker) }
+
+  let(:plugin_info) do
+    {
+      plugin_name: plugin_name,
+      plugin_key: plugin_key,
+      plugin_path: plugin_path,
+      versions: [{ version: version1, :is_default => false, :is_disabled => false, :sha1 => nil }, { version: version2, :is_default => true, :is_disabled => false, :sha1 => nil }],
+      type: 'java',
+      group_id: 'group',
+      artifact_id: 'artifact',
+      packaging: 'jar',
+      classifier: nil
+    }
+  end
+  let(:plugin_name) { 'plugin-name' }
+  let(:plugin_key) { 'plugin-key' }
+  let(:plugin_path) { "#{destination}/plugins/java/#{plugin_name}" }
+  let(:version1) { '1.0' }
+  let(:version2) { '2.0' }
+
   before do
-    KPM::Inspector.stub_chain(:new, :inspect).and_return(installed_plugins)
-    KPM::PluginsManager.stub(:new).and_return(plugins_manager_mock)
-    KPM::Sha1Checker.stub(:from_file).and_return(sha1_checker_mock)
+    allow(KPM::PluginsManager).to receive(:new).and_return(plugins_manager_mock)
+    allow(KPM::Sha1Checker).to receive(:from_file).and_return(sha1_checker_mock)
+
+    # Calls by the Inspector
+    allow(plugins_manager_mock).to receive(:get_identifier_key_and_entry) do
+      [plugin_key, { 'group_id' => plugin_info[:group_id],
+                     'artifact_id' => plugin_info[:artifact_id],
+                     'packaging' => plugin_info[:packaging] }]
+    end
+    allow(sha1_checker_mock).to receive(:all_sha1) { {} }
   end
 
-  context 'when plugin is not installed' do
-    let(:installed_plugins) { {} }
+  context 'utility methods' do
+    it 'raises an error when directory to delete is invalid' do
+      expect do
+        uninstaller.send(:validate_dir_for_rmrf, '/home/john')
+      end.to raise_error(ArgumentError, 'Path /home/john is not a valid directory')
+    end
+    it 'raises an error when directory to delete is not safe' do
+      expect do
+        uninstaller.send(:validate_dir_for_rmrf, '/tmp')
+      end.to raise_error(ArgumentError, "Path /tmp is not a subdirectory of #{destination}")
+    end
+  end
+
+  context 'when no plugin is installed' do
+    it 'raises an error when uninstalling a plugin' do
+      expect do
+        uninstaller.uninstall_plugin(plugin_name)
+      end.to raise_error(StandardError, "No plugin with key/name '#{plugin_name}' found installed. Try running 'kpm inspect' for more info")
+    end
 
-    it 'raises a plugin not found error' do
-      expect {
-        uninstaller.uninstall_plugin('adyen')
-      }.to raise_error(StandardError, "No plugin with key/name 'adyen' found installed. Try running 'kpm inspect' for more info")
+    it 'raises an internal error when uninstalling a plugin' do
+      expect do
+        uninstaller.send(:remove_plugin_versions, plugin_info, true, [version1, version2])
+      end.to raise_error(ArgumentError, "Path #{plugin_info[:plugin_path]}/#{version1} is not a valid directory")
     end
+
+    it 'raises an error when uninstalling a plugin version' do
+      expect do
+        uninstaller.send(:remove_plugin_version, plugin_info, '3.0')
+      end.to raise_error(ArgumentError, "Path #{plugin_info[:plugin_path]}/3.0 is not a valid directory")
+    end
+
+    it { expect(uninstaller.send(:categorize_plugins)).to eq({ to_be_deleted: [], to_keep: [] }) }
   end
 
   context 'when plugin is installed' do
-    let(:installed_plugins) do
-      {
-          plugin_name => {
-              plugin_key: plugin_key,
-              plugin_path: plugin_path,
-              versions: [{version: version}],
-              group_id: 'group',
-              artifact_id: 'artifact',
-              packaging: 'jar'
-          }
-      }
+    before do
+      FileUtils.mkdir_p(plugin_version1_path)
+      FileUtils.mkdir_p(plugin_version2_path)
+      FileUtils.ln_s(plugin_version2_path, Pathname.new(plugin_path).join('SET_DEFAULT'))
+    end
+    let(:plugin_version1_path) { File.join(plugin_path, version1) }
+    let(:plugin_version2_path) { File.join(plugin_path, version2) }
+
+    it 'looks up a plugin by name' do
+      expect(uninstaller.send(:find_plugin, plugin_name)).to eq(plugin_info)
+    end
+
+    it 'looks up a plugin by key' do
+      expect(uninstaller.send(:find_plugin, plugin_key)).to eq(plugin_info)
     end
 
-    let(:plugin_name) { 'plugin-name' }
-    let(:plugin_key) { 'plugin-key' }
-    let(:plugin_path) { 'plugin-path' }
-    let(:version) { '1.0' }
+    it 'uninstalls if user confirms action' do
+      expect(KPM.ui).to receive(:ask).and_return('y')
 
-    it 'uninstalls a plugin by name' do
-      FileUtils.should_receive(:rmtree).with(plugin_path)
-      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
-      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version}")
+      expect(plugins_manager_mock).to receive(:remove_plugin_identifier_key).with(plugin_key)
+      expect(sha1_checker_mock).to receive(:remove_entry!).with("group:artifact:jar:#{version1}")
+      expect(sha1_checker_mock).to receive(:remove_entry!).with("group:artifact:jar:#{version2}")
 
-      uninstaller.uninstall_plugin(plugin_name).should be_true
+      expect(uninstaller.uninstall_plugin(plugin_name)).to be_truthy
     end
 
-    it 'uninstalls a plugin by key' do
-      FileUtils.should_receive(:rmtree).with(plugin_path)
-      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
-      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version}")
+    it 'does nothing if user cancels' do
+      expect(KPM.ui).to receive(:ask).and_return('n')
 
-      uninstaller.uninstall_plugin(plugin_key).should be_true
+      expect(uninstaller.uninstall_plugin(plugin_name)).to be_falsey
     end
-  end
 
-  context 'when plugin is installed' do
-    let(:installed_plugins) do
-      {
-          plugin_name => {
-              plugin_key: plugin_key,
-              plugin_path: plugin_path,
-              versions: [{version: version1},{version: version2}],
-              group_id: 'group',
-              artifact_id: 'artifact',
-              packaging: 'jar'
-          }
-      }
-    end
-
-    let(:plugin_name) { 'plugin-name' }
-    let(:plugin_key) { 'plugin-key' }
-    let(:plugin_path) { 'plugin-path' }
-    let(:version1) { '1.0' }
-    let(:version2) { '2.0' }
+    it 'uninstalls all plugins without confirmation if the force option is given' do
+      expect(plugins_manager_mock).to receive(:remove_plugin_identifier_key).with(plugin_key)
+      expect(sha1_checker_mock).to receive(:remove_entry!).with("group:artifact:jar:#{version1}")
+      expect(sha1_checker_mock).to receive(:remove_entry!).with("group:artifact:jar:#{version2}")
 
-    it 'uninstalls if user confirms action' do
-      KPM.ui.should_receive(:ask).and_return('y')
+      expect(uninstaller.uninstall_plugin(plugin_name, true)).to be_truthy
+    end
 
-      FileUtils.should_receive(:rmtree).with(plugin_path)
-      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
-      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version1}")
-      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version2}")
+    it 'uninstalls one version without confirmation if the force option is given' do
+      expect(sha1_checker_mock).to receive(:remove_entry!).with("group:artifact:jar:#{version1}")
 
-      uninstaller.uninstall_plugin(plugin_name).should be_true
+      expect(uninstaller.uninstall_plugin(plugin_name, true, version1)).to be_truthy
     end
 
-    it 'does nothing if user cancels' do
-      KPM.ui.should_receive(:ask).and_return('n')
+    it 'raises an error when uninstalling a version that does not exist' do
+      expect do
+        uninstaller.uninstall_plugin(plugin_name, true, '3.0')
+      end.to raise_error(ArgumentError)
+    end
 
-      uninstaller.uninstall_plugin(plugin_name).should be_false
+    it 'categorizes plugins depending on default flag' do
+      expect(uninstaller.send(:categorize_plugins)).to eq({ to_be_deleted: [[plugin_info, version1]], to_keep: [[plugin_info, version2]] })
     end
 
-    it 'uninstalls without confirmation if the force option is given' do
-      FileUtils.should_receive(:rmtree).with(plugin_path)
-      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
-      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version1}")
-      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version2}")
+    it 'does not cleanup if dry-run is set' do
+      expect(uninstaller.uninstall_non_default_plugins(true)).to be_falsey
+    end
+
+    it 'does cleanup if dry-run isn\'t set' do
+      expect(sha1_checker_mock).to receive(:remove_entry!).with("group:artifact:jar:#{version1}")
+
+      plugin_info_copy = Marshal.load(Marshal.dump(plugin_info))
+      expect(KPM::Inspector.new.inspect(destination)).to eq({ plugin_name => plugin_info_copy })
+
+      expect(uninstaller.uninstall_non_default_plugins(false)).to be_truthy
+      plugin_info_copy[:versions].delete_at(0)
+      expect(KPM::Inspector.new.inspect(destination)).to eq({ plugin_name => plugin_info_copy })
 
-      uninstaller.uninstall_plugin(plugin_name, true).should be_true
+      # Second time is a no-op
+      expect(uninstaller.uninstall_non_default_plugins).to be_falsey
     end
   end
 end

data/spec/kpm/unit_mysql/account_spec.rb

@@ -1,51 +1,50 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe KPM::Account do
-  
   shared_context 'account' do
     include_context 'connection_setup'
 
-    let(:account_class) { described_class.new(nil,[killbill_api_key,killbill_api_secrets],
-                                             [killbill_user, killbill_password],url,
-                                             db_name, [db_username, db_password],db_host,db_port,nil,logger)}
-    let(:dummy_account_id) {SecureRandom.uuid}
-    let(:account_id_invalid) {SecureRandom.uuid}
-    let(:dummy_data) {
+    let(:account_class) do
+      described_class.new(nil, [killbill_api_key, killbill_api_secret],
+                          [killbill_user, killbill_password], url,
+                          db_name, [db_username, db_password], db_host, db_port, nil, logger)
+    end
+    let(:dummy_account_id) { SecureRandom.uuid }
+    let(:account_id_invalid) { SecureRandom.uuid }
+    let(:account_id) { creating_account_with_client }
+    let(:dummy_data) do
       "-- accounts record_id|id|external_key|email|name|first_name_length|currency|billing_cycle_day_local|parent_account_id|is_payment_delegated_to_parent|payment_method_id|time_zone|locale|address1|address2|company_name|city|state_or_province|country|postal_code|phone|notes|migrated|is_notified_for_invoices|created_date|created_by|updated_date|updated_by|tenant_record_id\n"\
       "5|#{dummy_account_id}|#{dummy_account_id}|willharnet@example.com|Will Harnet||USD|0||||UTC||||Company\\N{VERTICAL LINE}\\N{LINE FEED}Name||||||||false|2017-04-03T15:50:14.000+0000|demo|2017-04-05T15:01:39.000+0000|Killbill::Stripe::PaymentPlugin|2\n"\
       "-- account_history record_id|id|target_record_id|external_key|email|name|first_name_length|currency|billing_cycle_day_local|parent_account_id|payment_method_id|is_payment_delegated_to_parent|time_zone|locale|address1|address2|company_name|city|state_or_province|country|postal_code|phone|notes|migrated|is_notified_for_invoices|change_type|created_by|created_date|updated_by|updated_date|tenant_record_id\n"\
       "3|#{SecureRandom.uuid}|5|#{dummy_account_id}|willharnet@example.com|Will Harnet||USD|0||||UTC||||Company\\N{VERTICAL LINE}\\N{LINE FEED}Name||||||||false|INSERT|demo|2017-04-03T15:50:14.000+0000|demo|2017-04-03T15:50:14.000+0000|2\n"
-    }
-    let(:cols_names) {dummy_data.split("\n")[0].split(" ")[2]}
-    let(:cols_data) {dummy_data.split("\n")[1]}
-    let(:table_name) {dummy_data.split("\n")[0].split(" ")[1]}
-    let(:obfuscating_marker) {:email}
-    let(:mysql_cli) {"mysql --user=#{db_username} --password=#{db_password} --host=#{db_host} --port=#{db_port} "}
-    let(:test_ddl) {Dir["#{Dir.pwd}/**/account_test_ddl.sql"][0]}
-
+    end
+    let(:cols_names) { dummy_data.split("\n")[0].split(' ')[2] }
+    let(:cols_data) { dummy_data.split("\n")[1] }
+    let(:table_name) { dummy_data.split("\n")[0].split(' ')[1] }
+    let(:obfuscating_marker) { :email }
+    let(:mysql_cli) { "mysql --user=#{db_username} --password=#{db_password} --host=#{db_host} --port=#{db_port} " }
+    let(:test_ddl) { Dir["#{Dir.pwd}/**/account_test_ddl.sql"][0] }
   end
 
   describe '#initialize' do
-    include_context 'account'  
+    include_context 'account'
 
     context 'when creating an instance of account class' do
-
       it 'when initialized with defaults' do
         expect(described_class.new).to be_an_instance_of(KPM::Account)
       end
 
       it 'when initialized with options' do
-        account_class.should be_an_instance_of(KPM::Account)
+        expect(account_class).to be_an_instance_of(KPM::Account)
         expect(account_class.instance_variable_get(:@killbill_api_key)).to eq(killbill_api_key)
-        expect(account_class.instance_variable_get(:@killbill_api_secrets)).to eq(killbill_api_secrets)
+        expect(account_class.instance_variable_get(:@killbill_api_secret)).to eq(killbill_api_secret)
         expect(account_class.instance_variable_get(:@killbill_user)).to eq(killbill_user)
         expect(account_class.instance_variable_get(:@killbill_password)).to eq(killbill_password)
         expect(account_class.instance_variable_get(:@killbill_url)).to eq(url)
-
       end
-
     end
-
   end
 
   # export data tests
@@ -53,46 +52,38 @@ describe KPM::Account do
     include_context 'account'
 
     context 'when fetching account from api' do
-
       it 'when account id not found' do
-        expect{ account_class.send(:fetch_export_data, account_id_invalid) }.to raise_error(Interrupt, 'Account id not found')
+        expect { account_class.send(:fetch_export_data, account_id_invalid) }.to raise_error(Interrupt, 'Account id not found')
       end
 
       it 'when account id found' do
-        account_id = creating_account_with_client
         expect(account_id).to match(/\w{8}(-\w{4}){3}-\w{12}?/)
-        expect{ account_class.send(:fetch_export_data, account_id) }.not_to raise_error(Interrupt, 'Account id not found')
+        expect { account_class.send(:fetch_export_data, account_id) }.not_to raise_error
         expect(account_class.send(:fetch_export_data, account_id)).to match(account_id)
       end
-
     end
-
   end
 
   describe '#process_export_data' do
     include_context 'account'
 
     context 'when processing data to export' do
-
       it 'when column name qty eq column data qty' do
-        expect(account_class.send(:process_export_data, cols_data, table_name, cols_names.split("|")).split("|").size).to eq(cols_names.split("|").size)
+        expect(account_class.send(:process_export_data, cols_data, table_name, cols_names.split('|')).split('|').size).to eq(cols_names.split('|').size)
       end
 
       it 'when obfuscating data' do
         marker_index = 0
-        cols_names.split("|").each do |col_name|
-          if col_name.equal?(obfuscating_marker.to_s)
-            break
-          end
+        cols_names.split('|').each do |col_name|
+          break if col_name.equal?(obfuscating_marker.to_s)
+
           marker_index += 1
         end
 
-        obfuscating_marker_data = account_class.send(:process_export_data, cols_data, table_name, cols_names.split("|")).split("|")
+        obfuscating_marker_data = account_class.send(:process_export_data, cols_data, table_name, cols_names.split('|')).split('|')
         expect(obfuscating_marker_data[marker_index]).to be_nil
       end
-
     end
-
   end
 
   describe '#remove_export_data' do
@@ -101,51 +92,42 @@ describe KPM::Account do
     it 'when obfuscating value' do
       expect(account_class.send(:remove_export_data, table_name, obfuscating_marker.to_s, 'willharnet@example.com')).to be_nil
     end
-
   end
 
   describe '#export' do
     include_context 'account'
 
     context 'when exporting data' do
-
       it 'when file created' do
-        expect(File.exist?(account_class.send(:export, dummy_data))).to be_true
+        expect(File.exist?(account_class.send(:export, dummy_data))).to be_truthy
       end
 
       it 'when file contains account record' do
-        expect(File.readlines(account_class.send(:export, dummy_data)).grep(/#{table_name}/)).to be_true
-        expect(File.readlines(account_class.send(:export, dummy_data)).grep(/#{cols_names}/)).to be_true
+        expect(File.readlines(account_class.send(:export, dummy_data)).grep(/#{table_name}/)).to be_truthy
+        expect(File.readlines(account_class.send(:export, dummy_data)).grep(/#{cols_names}/)).to be_truthy
       end
-
     end
-
   end
 
   describe '#export_data' do
     include_context 'account'
 
     context 'when exporting data; main method' do
-
       it 'when no account id' do
-        expect{ account_class.export_data }.to raise_error(Interrupt, 'Account id not found')
+        expect { account_class.export_data }.to raise_error(Interrupt, 'Account id not found')
       end
 
       it 'when file created' do
-        account_id = creating_account_with_client
         expect(account_id).to match(/\w{8}(-\w{4}){3}-\w{12}?/)
-        expect(File.exist?(account_class.export_data(account_id))).to be_true
+        expect(File.exist?(account_class.export_data(account_id))).to be_truthy
       end
 
       it 'when file contains account record' do
-        account_id = creating_account_with_client
         expect(account_id).to match(/\w{8}(-\w{4}){3}-\w{12}?/)
-        expect(File.readlines(account_class.export_data(account_id)).grep(/#{table_name}/)).to be_true
-        expect(File.readlines(account_class.export_data(account_id)).grep(/#{cols_names}/)).to be_true
+        expect(File.readlines(account_class.export_data(account_id)).grep(/#{table_name}/)).to be_truthy
+        expect(File.readlines(account_class.export_data(account_id)).grep(/#{cols_names}/)).to be_truthy
       end
-
     end
-
   end
 
   # import data tests
@@ -153,14 +135,14 @@ describe KPM::Account do
     include_context 'account'
 
     it 'when data delimiter is sniffed as "|"' do
-      open (dummy_data_file), 'w' do |io|
-          io.puts(dummy_data)
+      File.open(dummy_data_file, 'w') do |io|
+        io.puts(dummy_data)
       end
-      
+
       expect(account_class.send(:sniff_delimiter, dummy_data_file)).to eq('|')
     end
   end
-  
+
   describe '#fill_empty_column' do
     include_context 'account'
 
@@ -173,7 +155,7 @@ describe KPM::Account do
     include_context 'account'
 
     it 'when valid date value' do
-      expect{DateTime.parse(account_class.send(:fix_dates, '2017-04-05T15:01:39.000+0000'))}.not_to raise_error(ArgumentError)
+      expect { DateTime.parse(account_class.send(:fix_dates, '2017-04-05T15:01:39.000+0000')) }.not_to raise_error
     end
 
     it 'when valid date value match YYYY-MM-DD HH:MM:SS' do
@@ -181,7 +163,7 @@ describe KPM::Account do
     end
 
     it 'when invalid date value' do
-      expect{DateTime.parse(account_class.send(:fix_dates, 'JO'))}.to raise_error(ArgumentError)
+      expect { DateTime.parse(account_class.send(:fix_dates, 'JO')) }.to raise_error(ArgumentError)
     end
   end
 
@@ -196,7 +178,6 @@ describe KPM::Account do
       it 'when false' do
         expect(account_class.send(:replace_boolean, false)).to eq(0)
       end
-
     end
   end
 
@@ -222,7 +203,6 @@ describe KPM::Account do
     it 'when field is search_key1 and table bus_events_history' do
       expect(account_class.send(:replace_account_record_id, 'bus_events_history', 'search_key1', '1')).to eq(:@account_record_id)
     end
-
   end
 
   describe '#replace_tenant_record_id' do
@@ -242,7 +222,6 @@ describe KPM::Account do
       account_class.instance_variable_set(:@tenant_record_id, 10)
       expect(account_class.send(:replace_tenant_record_id, 'bus_events_history', 'search_key2', '1')).to eq(10)
     end
-
   end
 
   describe '#replace_uuid' do
@@ -259,19 +238,39 @@ describe KPM::Account do
         expect(account_class.send(:replace_uuid, table_name, 'other_id', dummy_account_id)).to eq(dummy_account_id)
       end
     end
-
   end
 
   describe '#sanitize' do
     include_context 'account'
 
     it 'when skip payment method' do
-      expect(account_class.send(:sanitize, 'payment_methods', 'plugin_name', 'Payment Method',true)).to eq('__EXTERNAL_PAYMENT__')
+      expect(account_class.send(:sanitize, 'payment_methods', 'plugin_name', 'Payment Method', true)).to eq('__EXTERNAL_PAYMENT__')
     end
     it 'when nothing to sanitize' do
-      expect(account_class.send(:sanitize, table_name, 'id', dummy_account_id,false)).to eq(dummy_account_id)
+      expect(account_class.send(:sanitize, table_name, 'id', dummy_account_id, false)).to eq(dummy_account_id)
+    end
+  end
+
+  describe '#sanitize_for_b64_date' do
+    include_context 'account'
+
+    let(:non_encoded_b64) do
+      # This is my test data
+      'This is my test data'
+    end
+
+    let(:encoded_b64) do
+      # This is my test data
+      'VGhpcyBpcyBteSB0ZXN0IGRhdGE='
+    end
+
+    it 'when b64 encoded data' do
+      expect(account_class.send(:b64_decode_if_needed, encoded_b64).value).to start_with('LOAD_FILE("')
     end
 
+    it 'when b64 non encoded data' do
+      expect(account_class.send(:b64_decode_if_needed, non_encoded_b64)).to eq(non_encoded_b64)
+    end
   end
 
   describe '#process_import_data' do
@@ -279,153 +278,139 @@ describe KPM::Account do
 
     context 'when processing data to import' do
       it 'when column name qty eq column data qty without record_id' do
-        account_class.instance_variable_set(:@generate_record_id,true)
-        expect(account_class.send(:process_import_data, cols_data, table_name, cols_names.split('|'), false, []).size).to eq(cols_names.split("|").size-1)
+        account_class.instance_variable_set(:@generate_record_id, true)
+        expect(account_class.send(:process_import_data, cols_data, table_name, cols_names.split('|'), false, []).size).to eq(cols_names.split('|').size - 1)
       end
     end
-
   end
 
   describe '#import_data' do
     include_context 'account'
 
     context 'when data to import; main import method' do
-      
       it 'when creating test schema' do
         db = create_test_schema
         expect(db).to eq(db_name)
       end
-      
+
       it 'when importing data with empty file' do
         File.new(dummy_data_file, 'w+').close
-        expect{account_class.import_data(dummy_data_file,nil,true,false,true) }.to raise_error(Interrupt,"Data on #{dummy_data_file} is invalid")
+        expect { account_class.import_data(dummy_data_file, nil, true, false, true) }.to raise_error(Interrupt, "Data on #{dummy_data_file} is invalid")
         File.delete(dummy_data_file)
       end
-      
+
       it 'when importing data with no file' do
-        expect{account_class.import_data(dummy_data_file,nil,true,false,true) }.to raise_error(Interrupt, "File #{dummy_data_file} does not exist")
+        expect { account_class.import_data(dummy_data_file, nil, true, false, true) }.to raise_error(Interrupt, "File #{dummy_data_file} does not exist")
       end
-      
+
       it 'when importing data with new record_id' do
-        open (dummy_data_file), 'w' do |io|
+        File.open(dummy_data_file, 'w') do |io|
           io.puts(dummy_data)
         end
-        expect{account_class.import_data(dummy_data_file,nil,true,false,true) }.not_to raise_error(Interrupt)
+        expect { account_class.import_data(dummy_data_file, nil, true, false, true) }.not_to raise_error
 
         verify_data(dummy_account_id)
 
-        row_count_inserted = delete_statement('accounts','id',dummy_account_id)
+        row_count_inserted = delete_statement('accounts', 'id', dummy_account_id)
         expect(row_count_inserted).to eq('1')
-        row_count_inserted = delete_statement('account_history','external_key',dummy_account_id)
+        row_count_inserted = delete_statement('account_history', 'external_key', dummy_account_id)
         expect(row_count_inserted).to eq('1')
       end
 
       it 'when importing data reusing record_id' do
-        open (dummy_data_file), 'w' do |io|
+        File.open(dummy_data_file, 'w') do |io|
           io.puts(dummy_data)
         end
-        expect{account_class.import_data(dummy_data_file,nil,true,false,false) }.not_to raise_error(Interrupt)
+        expect { account_class.import_data(dummy_data_file, nil, true, false, false) }.not_to raise_error
 
         verify_data(dummy_account_id)
 
-        row_count_inserted = delete_statement('accounts','id',dummy_account_id)
+        row_count_inserted = delete_statement('accounts', 'id', dummy_account_id)
         expect(row_count_inserted).to eq('1')
-        row_count_inserted = delete_statement('account_history','external_key',dummy_account_id)
+        row_count_inserted = delete_statement('account_history', 'external_key', dummy_account_id)
         expect(row_count_inserted).to eq('1')
       end
 
       it 'when importing data with different tenant_record_id' do
-        open (dummy_data_file), 'w' do |io|
+        File.open(dummy_data_file, 'w') do |io|
           io.puts(dummy_data)
         end
-        expect{account_class.import_data(dummy_data_file,10,true,false,true) }.not_to raise_error(Interrupt)
+        expect { account_class.import_data(dummy_data_file, 10, true, false, true) }.not_to raise_error
 
         verify_data(dummy_account_id)
 
-        row_count_inserted = delete_statement('accounts','id',dummy_account_id)
+        row_count_inserted = delete_statement('accounts', 'id', dummy_account_id)
         expect(row_count_inserted).to eq('1')
-        row_count_inserted = delete_statement('account_history','external_key',dummy_account_id)
+        row_count_inserted = delete_statement('account_history', 'external_key', dummy_account_id)
         expect(row_count_inserted).to eq('1')
       end
 
       it 'when round trip' do
-        open (dummy_data_file), 'w' do |io|
+        File.open(dummy_data_file, 'w') do |io|
           io.puts(dummy_data)
         end
-        expect{account_class.import_data(dummy_data_file,10,true,true,true) }.not_to raise_error(Interrupt)
+        expect { account_class.import_data(dummy_data_file, 10, true, true, true) }.not_to raise_error
         new_account_id = account_class.instance_variable_get(:@tables_id)
 
         verify_data(new_account_id['accounts_id'])
 
-        row_count_inserted = delete_statement('accounts','id',new_account_id['accounts_id'])
+        row_count_inserted = delete_statement('accounts', 'id', new_account_id['accounts_id'])
         expect(row_count_inserted).to eq('1')
-        row_count_inserted = delete_statement('account_history','external_key',new_account_id['accounts_id'])
+        row_count_inserted = delete_statement('account_history', 'external_key', new_account_id['accounts_id'])
         expect(row_count_inserted).to eq('1')
       end
-      
+
       it 'when droping test schema' do
         response = drop_test_schema
         expect(response).to match('')
       end
-     
     end
- 
   end
-  
-  private 
-    def creating_account_with_client
-      if $account_id.nil?
-        KillBillClient.url = url
-        
-        options = {
-          :username => killbill_user,
-          :password => killbill_password,
-          :api_key => killbill_api_key,
-          :api_secret => killbill_api_secrets
-        }
-    
-        account = KillBillClient::Model::Account.new
-        account.name = 'KPM Account Test'
-        account.first_name_length = 3
-        account.external_key = SecureRandom.uuid
-        account.currency = 'USD'
-        account = account.create('kpm_account_test', 'kpm_account_test', 'kpm_account_test', options)
-        
-        $account_id = account.account_id
 
-      end
-      
-      $account_id
-    end
+  private
+
+  def creating_account_with_client
+    KillBillClient.url = url
+
+    options = {
+      username: killbill_user,
+      password: killbill_password,
+      api_key: killbill_api_key,
+      api_secret: killbill_api_secret
+    }
+
+    account = KillBillClient::Model::Account.new
+    account.name = 'KPM Account Test'
+    account.first_name_length = 3
+    account.external_key = SecureRandom.uuid
+    account.currency = 'USD'
+    account = account.create('kpm_account_test', 'kpm_account_test', 'kpm_account_test', options)
+
+    account.account_id
+  end
 
   def verify_data(account_id)
     response = `#{mysql_cli} #{db_name} -e "select company_name FROM accounts WHERE id = '#{account_id}';" 2>&1`
     response_msg = response.split("\n")
     company_name = response_msg[response_msg.size - 1]
 
-    expect(company_name).to eq("Company|\\nName")
-   end
+    expect(company_name).to eq('Company|\\nName')
+  end
 
-   def delete_statement(table_name,column_name,account_id)
-      response = `#{mysql_cli} #{db_name} -e "DELETE FROM #{table_name} WHERE #{column_name} = '#{account_id}'; SELECT ROW_COUNT();" 2>&1`
-      response_msg = response.split("\n")
-      row_count_inserted = response_msg[response_msg.size - 1]
-        
-      row_count_inserted
-    end
-    
-    def create_test_schema
-      response = `#{mysql_cli} -e "CREATE DATABASE IF NOT EXISTS #{db_name};"`
-      response = `#{mysql_cli} #{db_name} < "#{test_ddl}" 2>&1`
-      response_msg = response.split("\n")
-      used_database = response_msg[response_msg.size - 1]
-        
-      used_database
-    end
-    
-    def drop_test_schema
-      response = `#{mysql_cli} -e "DROP DATABASE #{db_name};"`;
-      response
-    end
+  def delete_statement(table_name, column_name, account_id)
+    response = `#{mysql_cli} #{db_name} -e "DELETE FROM #{table_name} WHERE #{column_name} = '#{account_id}'; SELECT ROW_COUNT();" 2>&1`
+    response_msg = response.split("\n")
+    response_msg[response_msg.size - 1]
+  end
 
-end
+  def create_test_schema
+    `#{mysql_cli} -e "CREATE DATABASE IF NOT EXISTS #{db_name};"`
+    response = `#{mysql_cli} #{db_name} < "#{test_ddl}" 2>&1`
+    response_msg = response.split("\n")
+    response_msg[response_msg.size - 1]
+  end
+
+  def drop_test_schema
+    `#{mysql_cli} -e "DROP DATABASE #{db_name};"`
+  end
+end