oneacct-export 0.1.0

data/spec/one_writer_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe OneWriter do
+  subject { one_writer }
+  before :example do
+    Settings.output['output_type'] = 'one_writer_test_output_type'
+  end
+
+  let(:data) { { 'aaa' => 111, 'bbb' => 222 } }
+  let(:testfile) { "#{GEM_DIR}/mock/one_writer_testfile" }
+  let(:dev_null) { '/dev/null' }
+  let(:output) { "#{GEM_DIR}/mock/one_writer_output" }
+
+  describe '#new' do
+    context 'with correct arguments' do
+      before :example do
+        allow(OneWriter).to receive(:template_filename) { testfile }
+      end
+
+      let(:one_writer) do
+        OneWriter.new(data, output, dev_null)
+      end
+
+      it 'takes three parameters and returns OneWriter object' do
+        is_expected.to be_an_instance_of OneWriter
+      end
+
+      it 'correctly assigns three parameters' do
+        expect(subject.data).to eq(data)
+        expect(subject.output).to eq(output)
+        expect(subject.log).to eq(dev_null)
+      end
+    end
+
+    context 'with incorrect arguments' do
+      before :example do
+        allow(OneWriter).to receive(:template_filename) { testfile }
+      end
+
+      it 'fails with ArgumentError if output is nil' do
+        expect { OneWriter.new(data, nil, dev_null) }.to\
+          raise_error(ArgumentError)
+      end
+
+      it 'fails with ArgumentError if data is nil' do
+        expect { OneWriter.new(nil, output, dev_null) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with non existing template file' do
+      before :example do
+        allow(OneWriter).to receive(:template_filename) { 'non_existing' }
+      end
+
+      it 'fails with ArgumentError' do
+        expect { OneWriter.new(data, output, dev_null) }.to\
+          raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#template_filename' do
+    it 'returns template name in form of filename within template directory' do
+      expect(OneWriter.template_filename('test')).to eq("#{GEM_DIR}/lib/templates/test.erb")
+    end
+  end
+
+  describe '.fill_template' do
+    before :example do
+      allow(OneWriter).to receive(:template_filename) { testfile }
+    end
+
+    let(:one_writer) do
+      OneWriter.new(data, output, Logger.new(dev_null))
+    end
+
+    it 'returns result version of a template with data' do
+      expect(subject.fill_template).to eq("aaa: 111\nbbb: 222")
+    end
+  end
+
+  describe '.write_to_tmp' do
+    before :example do
+      allow(OneWriter).to receive(:template_filename) { testfile }
+    end
+
+    after :example do
+      File.delete(tmp) if File.exist?(tmp)
+    end
+
+    let(:tmp) { File.open("#{GEM_DIR}/mock/one_writer_tmp", 'w') }
+    let(:one_writer) do
+      OneWriter.new(data, output, Logger.new(dev_null))
+    end
+
+    it 'writes data into temporary file' do
+      subject.write_to_tmp(tmp, data)
+      expect(File.read(tmp)).to eq(data.to_s)
+    end
+  end
+
+  describe '.copy_to_output' do
+    before :example do
+      allow(OneWriter).to receive(:template_filename) { testfile }
+    end
+
+    after :example do
+      File.delete(to) if File.exist?(to)
+    end
+
+    let(:from) { testfile }
+    let(:to) { "#{GEM_DIR}/mock/one_writer_copy" }
+    let(:one_writer) do
+      OneWriter.new(data, output, Logger.new(dev_null))
+    end
+
+    it 'copies temporary file to output file' do
+      subject.copy_to_output(from, to)
+      expect(File.read(from)).to eq(File.read(to))
+    end
+  end
+
+  describe '.write' do
+    before :example do
+      allow(OneWriter).to receive(:template_filename) { testfile }
+      allow(subject).to receive(:fill_template) { data }
+      allow(Tempfile).to receive(:new) { tmp }
+    end
+
+    let(:one_writer) do
+      OneWriter.new(data, output, Logger.new(dev_null))
+    end
+    let(:tmp) do
+      tmp = double('tmp')
+      allow(tmp).to receive(:path) { "#{GEM_DIR}/mock/one_writer_tmp" }
+      tmp
+    end
+
+    it 'writes result version of a template into output file' do
+      expect(subject).to receive(:write_to_tmp).with(tmp, data)
+      expect(subject).to receive(:copy_to_output).with("#{GEM_DIR}/mock/one_writer_tmp", output)
+      expect(tmp).to receive(:close)
+      subject.write
+    end
+  end
+end

data/spec/oneacct_exporter_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+require 'ostruct'
+
+Sidekiq::Testing.fake!
+
+describe OneacctExporter do
+  subject { oneacct_exporter }
+
+  let(:oneacct_exporter) { OneacctExporter.new({}, Logger.new('/dev/null')) }
+
+  describe '#new' do
+    it 'returns an instance of OneacctExporter' do
+      expect(OneacctExporter.new({}, 'fake_logger')).to be_instance_of(OneacctExporter)
+    end
+
+    context 'with arguments' do
+      let(:range) { { 1 => 2, 3 => 4 } }
+      let(:groups) { { 5 => 6, 7 => 8 } }
+      let(:timeout) { 42 }
+      let(:blocking) { true }
+      let(:logger) { 'fake_logger' }
+      let(:opts) { { range: range, groups: groups, timeout: timeout, blocking: blocking } }
+
+      it 'correctly assignes the arguments' do
+        oe = OneacctExporter.new(opts, logger)
+        expect(oe.log).to eq(logger)
+        expect(oe.groups).to eq(groups)
+        expect(oe.range).to eq(range)
+        expect(oe.blocking).to eq(blocking)
+        expect(oe.timeout).to eq(timeout)
+      end
+    end
+  end
+
+  describe '.export' do
+    before :example do
+      allow(subject).to receive(:clean_output_dir)
+      allow(OneDataAccessor).to receive(:new) { oda }
+    end
+
+    let(:oda) { double('oda') }
+
+    context 'with increasing batch number' do
+      before :example do
+        expect(oda).to receive(:vms).with(0, nil, nil).ordered { [1, 2, 3] }
+        expect(oda).to receive(:vms).with(1, nil, nil).ordered { [4, 5, 6] }
+        expect(oda).to receive(:vms).with(2, nil, nil).ordered { [7, 8, 9] }
+        expect(oda).to receive(:vms).with(3, nil, nil).ordered { nil }
+      end
+
+      it 'will always finish when there are no more vms to process' do
+        subject.export
+      end
+    end
+
+    context 'with non-empty batches of vms' do
+      before :example do
+        Sidekiq::Worker.clear_all
+        allow(oda).to receive(:vms).with(0, nil, nil).ordered { [1, 2, 3] }
+        allow(oda).to receive(:vms).with(1, nil, nil).ordered { [4, 5, 6] }
+        allow(oda).to receive(:vms).with(2, nil, nil).ordered { [7, 8, 9] }
+        allow(oda).to receive(:vms).with(3, nil, nil).ordered { nil }
+      end
+
+      after :example do
+        Sidekiq::Worker.clear_all
+      end
+
+      it 'starts worker for every vm batch' do
+        subject.export
+        expect(OneWorker.jobs.size).to eq(3)
+      end
+
+      it 'starts worker with right vms' do
+        subject.export
+        expect(OneWorker.jobs[0]['args'][0]).to eq('1|2|3')
+        expect(OneWorker.jobs[1]['args'][0]).to eq('4|5|6')
+        expect(OneWorker.jobs[2]['args'][0]).to eq('7|8|9')
+      end
+    end
+
+    context 'with some empty batches of vms' do
+      before :example do
+        Sidekiq::Worker.clear_all
+        allow(oda).to receive(:vms).with(0, nil, nil).ordered { [1, 2, 3] }
+        allow(oda).to receive(:vms).with(1, nil, nil).ordered { [] }
+        allow(oda).to receive(:vms).with(2, nil, nil).ordered { [7, 8, 9] }
+        allow(oda).to receive(:vms).with(3, nil, nil).ordered { [] }
+        allow(oda).to receive(:vms).with(4, nil, nil).ordered { nil }
+      end
+
+      after :example do
+        Sidekiq::Worker.clear_all
+      end
+
+      it 'starts worker for every non-empty vm batch' do
+        subject.export
+        expect(OneWorker.jobs.size).to eq(2)
+      end
+    end
+  end
+
+  describe '.clean_output_dir' do
+    let(:testdir_path) { "#{GEM_DIR}/mock/oneacct_exporter_testdir" }
+
+    before :example do
+      Settings.output['output_dir'] = testdir_path
+      Dir.mkdir(testdir_path)
+    end
+
+    after :example do
+      FileUtils.remove_dir(testdir_path, true)
+    end
+
+    context 'with empty output directory' do
+      it 'remains empty' do
+        subject.clean_output_dir
+        expect(Dir.entries(testdir_path).count).to eq(2)
+      end
+    end
+
+    context 'with not related files' do
+      before :example do
+        FileUtils.touch("#{testdir_path}/aa")
+        FileUtils.touch("#{testdir_path}/11")
+        FileUtils.touch("#{testdir_path}/aa11")
+        FileUtils.touch("#{testdir_path}/11aa")
+        FileUtils.touch("#{testdir_path}/0")
+        FileUtils.touch("#{testdir_path}/01")
+        FileUtils.touch("#{testdir_path}/0000000000001")
+      end
+
+      it 'keeps non-related files in the directory' do
+        subject.clean_output_dir
+        expect(Dir.entries(testdir_path).count).to eq(9)
+      end
+    end
+
+    context 'with related files' do
+      before :example do
+        FileUtils.touch("#{testdir_path}/00000000000001")
+        FileUtils.touch("#{testdir_path}/00000000000002")
+        FileUtils.touch("#{testdir_path}/00000000000003")
+        FileUtils.touch("#{testdir_path}/00000000000004")
+        FileUtils.touch("#{testdir_path}/00000000000005")
+        FileUtils.touch("#{testdir_path}/00000000000006")
+      end
+
+      it 'removes all files and leaves directory empty' do
+        subject.clean_output_dir
+        expect(Dir.entries(testdir_path).count).to eq(2)
+      end
+    end
+
+    context 'with both related and on-related files' do
+      before :example do
+        FileUtils.touch("#{testdir_path}/00000000000001")
+        FileUtils.touch("#{testdir_path}/00000000000002")
+        FileUtils.touch("#{testdir_path}/00000000000003")
+        FileUtils.touch("#{testdir_path}/00000000000004")
+        FileUtils.touch("#{testdir_path}/00000000000005")
+        FileUtils.touch("#{testdir_path}/00000000000006")
+        FileUtils.touch("#{testdir_path}/aa")
+        FileUtils.touch("#{testdir_path}/11")
+        FileUtils.touch("#{testdir_path}/aa11")
+        FileUtils.touch("#{testdir_path}/11aa")
+        FileUtils.touch("#{testdir_path}/0")
+        FileUtils.touch("#{testdir_path}/01")
+        FileUtils.touch("#{testdir_path}/0000000000001")
+      end
+
+      it 'removes all related files and keeps all non-related files' do
+        subject.clean_output_dir
+        expect(Dir.entries(testdir_path).count).to eq(9)
+      end
+    end
+  end
+
+  describe '.all_workers_done?' do
+    context 'with all workers done' do
+      before :example do
+        allow(Sidekiq::Workers).to receive(:new) { [] }
+      end
+
+      it 'returns true' do
+        expect(subject.all_workers_done?).to be true
+      end
+    end
+
+    context 'with some workers still processing' do
+      before :example do
+        allow(Sidekiq::Workers).to receive(:new) { [1, 2] }
+      end
+
+      it 'returns false' do
+        expect(subject.all_workers_done?).to be false
+      end
+    end
+  end
+
+  describe '.queue_empty?' do
+    before :example do
+      Settings.sidekiq['queue'] = 'oneacct_export_test'
+      stats = double('stats')
+      allow(Sidekiq::Stats).to receive(:new) { stats }
+      allow(stats).to receive(:queues) { queues }
+    end
+
+    let(:queues) { { 'queue1' => 5, 'queue2' => 0, 'oneacct_export_test' => 0, 'queue3' => 7 } }
+
+    context 'with empty queue' do
+      it 'returns true' do
+        expect(subject.queue_empty?).to be true
+      end
+    end
+
+    context 'with empty queue' do
+      before :example do
+        queues['oneacct_export_test'] = 10
+      end
+
+      it 'returns false' do
+        expect(subject.queue_empty?).to be false
+      end
+    end
+
+    context 'with empty queue' do
+      before :example do
+        queues.delete 'oneacct_export_test'
+      end
+
+      it 'returns true' do
+        expect(subject.queue_empty?).to be true
+      end
+    end
+  end
+
+  describe '.wait_for_processing' do
+    let(:oneacct_exporter) { OneacctExporter.new({ timeout: 120 }, Logger.new('/dev/null')) }
+
+    context 'without timeout' do
+      it 'ends naturally' do
+        expect(subject).to receive(:queue_empty?).and_return(false, false, true, true, true)
+        expect(subject).to receive(:all_workers_done?).and_return(false, false, true)
+
+        subject.wait_for_processing
+      end
+    end
+
+    context 'with unfinished processing and exceeded timeout' do
+      let(:oneacct_exporter) { OneacctExporter.new({ timeout: 20 }, Logger.new('/dev/null')) }
+
+      it 'ends program' do
+        allow(subject).to receive(:queue_empty?) { false }
+        allow(subject).to receive(:all_workers_done?) { false }
+        expect(subject.log).to receive(:error)
+
+        subject.wait_for_processing
+      end
+    end
+  end
+end

data/spec/oneacct_opts_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe OneacctOpts do
+  before :example do
+    allow(OneWriter).to receive(:template_filename) { "#{GEM_DIR}/mock/one_writer_testfile" }
+  end
+
+  let(:options) { OpenStruct.new }
+
+  describe '#set_defaults' do
+    context 'with empty options' do
+      it 'sets the default values' do
+        OneacctOpts.set_defaults(options)
+        expect(options.blocking).to eq(OneacctOpts::BLOCKING_DEFAULT)
+        expect(options.timeout).to be_nil
+        expect(options.compatibility).to eq(OneacctOpts::COMPATIBILITY_DEFAULT)
+      end
+    end
+
+    context 'with blocking set' do
+      before :example do
+        options.blocking = true
+      end
+
+      it 'keeps the blocking option' do
+        OneacctOpts.set_defaults(options)
+        expect(options.blocking).to eq(true)
+        expect(options.timeout).to eq(OneacctOpts::TIMEOUT_DEFAULT)
+        expect(options.compatibility).to eq(OneacctOpts::COMPATIBILITY_DEFAULT)
+      end
+    end
+
+    context 'with timeout set' do
+      before :example do
+        options.timeout = 42
+      end
+
+      it 'keeps the blocking option' do
+        OneacctOpts.set_defaults(options)
+        expect(options.blocking).to eq(OneacctOpts::BLOCKING_DEFAULT)
+        expect(options.timeout).to eq(42)
+        expect(options.compatibility).to eq(OneacctOpts::COMPATIBILITY_DEFAULT)
+      end
+    end
+
+    context 'with compatibility set' do
+      before :example do
+        options.compatibility = true
+      end
+
+      it 'keeps the blocking option' do
+        OneacctOpts.set_defaults(options)
+        expect(options.blocking).to eq(OneacctOpts::BLOCKING_DEFAULT)
+        expect(options.timeout).to be_nil
+        expect(options.compatibility).to eq(true)
+      end
+    end
+  end
+
+  describe '#check_options_restrictions' do
+    context 'with wrong time range' do
+      before :example do
+        options.records_from = (Time.new + 1000)
+        options.records_to = (Time.new - 1000)
+      end
+
+      it 'fails with ArgumentError' do
+        expect { OneacctOpts.check_options_restrictions(options) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with mixed groups' do
+      before :example do
+        options.include_groups = ['group']
+        options.exclude_groups = ['group']
+      end
+
+      it 'fails with ArgumentError' do
+        expect { OneacctOpts.check_options_restrictions(options) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with group file set without group restriction type' do
+      before :example do
+        options.groups_file = 'file'
+      end
+
+      it 'fails with ArgumentError' do
+        expect { OneacctOpts.check_options_restrictions(options) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with timout set without blocking option' do
+      before :example do
+        options.timeout = 50
+      end
+
+      it 'fails with ArgumentError' do
+        expect { OneacctOpts.check_options_restrictions(options) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with correct set of options' do
+      before :example do
+        options.records_from = (Time.new - 1000)
+        options.records_to = (Time.new + 1000)
+        options.include_groups = []
+        options.groups_file = 'file'
+        options.blocking = true
+        options.timeout = 50
+      end
+
+      it 'finishes without any failure' do
+        OneacctOpts.check_options_restrictions(options)
+      end
+    end
+  end
+
+  describe '#check_settings_restrictions' do
+    before :example do
+      Settings['site_name'] = 'Hogwarts'
+      Settings['cloud_type'] = 'OpenNebula'
+      Settings['endpoint'] = 'machine.hogwarts.co.uk'
+      Settings.output['output_dir'] = '/some/output/dir'
+      Settings.output['output_type'] = 'apel-v0.2'
+      Settings.logging['log_type'] = 'file'
+      Settings.logging['log_file'] = '/var/log/oneacct.log'
+    end
+
+    context 'with missing mandatory paramter' do
+      context 'site_name' do
+        before :example do
+          Settings['site_name'] = nil
+        end
+
+        it 'falis with ArgumentError' do
+          expect { OneacctOpts.check_settings_restrictions }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'cloud_type' do
+        before :example do
+          Settings['cloud_type'] = nil
+        end
+
+        it 'falis with ArgumentError' do
+          expect { OneacctOpts.check_settings_restrictions }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'endpoint' do
+        before :example do
+          Settings['endpoint'] = nil
+        end
+
+        it 'falis with ArgumentError' do
+          expect { OneacctOpts.check_settings_restrictions }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'output_dir' do
+        before :example do
+          Settings.output['output_dir'] = nil
+        end
+
+        it 'falis with ArgumentError' do
+          expect { OneacctOpts.check_settings_restrictions }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'output_type' do
+        before :example do
+          Settings.output['output_type'] = nil
+        end
+
+        it 'falis with ArgumentError' do
+          expect { OneacctOpts.check_settings_restrictions }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context 'with logging set to file without file specified' do
+      before :example do
+        Settings.logging['log_type'] = 'file'
+        Settings.logging['log_file'] = nil
+      end
+
+      it 'falis with ArgumentError' do
+        expect { OneacctOpts.check_settings_restrictions }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with non existing template' do
+      before :example do
+        allow(OneWriter).to receive(:template_filename) { 'nonexisting_file' }
+      end
+
+      it 'falis with ArgumentError' do
+        expect { OneacctOpts.check_settings_restrictions }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with all settings correct' do
+      it 'finishes without any failure' do
+        OneacctOpts.check_settings_restrictions
+      end
+    end
+  end
+
+  describe '#parse' do
+    let(:args) { ['--records-from', '01.01.2014', '--records-to', '01.07.2014', '--include-groups', 'aaa,bbb,ccc', '-b', '-t', '50', '-c'] }
+
+    it 'returns correctly parsed options' do
+      options = OneacctOpts.parse(args)
+      expect(options.records_from).to be_instance_of(Time)
+      expect(options.records_from).to eq(Time.new(2014, 1, 1))
+      expect(options.records_to).to be_instance_of(Time)
+      expect(options.records_to).to eq(Time.new(2014, 7, 1))
+      expect(options.include_groups).to be_instance_of(Array)
+      expect(options.include_groups).to eq(%w(aaa bbb ccc))
+      expect(options.blocking).to be_instance_of(TrueClass)
+      expect(options.blocking).to be true
+      expect(options.timeout).to be_instance_of(Fixnum)
+      expect(options.timeout).to eq(50)
+      expect(options.compatibility).to be_instance_of(TrueClass)
+      expect(options.compatibility).to be true
+    end
+  end
+end