naf 1.1.4 → 2.0.0

data/spec/controllers/naf/affinities_controller_spec.rb

@@ -5,7 +5,6 @@ module Naf
 
 
     it "should respond with the affinity index" do
-      Affinity.should_receive(:all).and_return([])
       get :index
       response.should be_success
     end

data/spec/controllers/naf/applications_controller_spec.rb

@@ -65,8 +65,9 @@ module Naf
     end
 
     context "on the create action" do
-      let(:valid_app) { mock_model(Application, save: true, application_schedule: nil, id: 5)  }
-      let(:invalid_app) { mock_model(Application, save: false) }
+      let(:application_schedule) { mock_model(ApplicationSchedule, application_run_group_name: 'command', prerequisites: []) }
+      let(:valid_app) { mock_model(Application, save: true, id: 5, update_attributes: true, application_schedule: application_schedule) }
+      let(:invalid_app) { mock_model(Application, save: false, update_attributes: false, application_schedule: application_schedule) }
 
       it "should redirect to show when valid" do
         Application.should_receive(:new).and_return(valid_app)

data/spec/controllers/naf/machine_affinity_slots_controller_spec.rb

@@ -6,7 +6,6 @@ module Naf
     let(:model_class) { MachineAffinitySlot}
 
     it "should respond with index action nested under machine" do
-      model_class.should_receive(:where).with({ machine_id: "1" }).and_return([])
       get :index, machine_id: 1
       response.should render_template("naf/datatable")
       response.should be_success

data/spec/controllers/naf/machines_controller_spec.rb

@@ -10,8 +10,8 @@ module Naf
     end
 
     it "should respond with the show action" do
+      machine = FactoryGirl.create(:machine, id: 5, server_address: '127.0.0.2')
       id = 5
-      Machine.should_receive(:find).with("5").and_return(nil)
       get :show, id: id
       response.should be_success
     end

data/spec/dummy/config/logging/naf.yml

@@ -12,11 +12,3 @@ log4r_config:
         date_pattern: '%y%m%d %H:%M:%S.%L'
         pattern     : '%d pid=%p jid=%g %C %l %M'
         type        : PatternFormatter
-
-    - type: PapertrailOutputter
-      name: papertrail
-      port: 0 # XXX put your papertrail port here
-      program: naf_application
-      formatter:
-        pattern     : 'pid=%p %C %l %M'
-        type        : PatternFormatter

data/spec/dummy/config/logging/nafjob.yml

@@ -2,15 +2,6 @@ log4r_config:
   outputters:
     - type     : StdoutOutputter
       name     : stdout
-      formatter:
-        date_pattern: '%y%m%d %H:%M:%S.%L'
-        pattern     : '%d pid=%p jid=%g %C %l %M'
-        type        : PatternFormatter
-
-    - type: PapertrailOutputter
-      name: papertrail
-      port: 0 # XXX put your papertrail port here
-      program: jid(%g)
       formatter:
         pattern     : '%C %l %M'
         type        : PatternFormatter

data/spec/dummy/config/logging/nafrunner.yml

@@ -2,16 +2,6 @@ log4r_config:
   outputters:
     - type     : StdoutOutputter
       name     : stdout
-      level    : DEBUG
-      formatter:
-        date_pattern: '%y%m%d %H:%M:%S.%L'
-        pattern     : '%d runner_pid=%p %C %l %M'
-        type        : PatternFormatter
-
-    - type: PapertrailOutputter
-      name: papertrail
-      port: 0 # XXX put your papertrail port here
-      program: runner
       formatter:
         pattern     : '%C %l %M'
         type        : PatternFormatter

data/spec/factories/naf.rb

@@ -336,6 +336,10 @@ FactoryGirl.define do
     end
   end
 
+  factory :affinity_classification, class: ::Naf::AffinityClassification do
+    sequence(:affinity_classification_name) { |n| "affinity_classification_#{n}" }
+  end
+
   #############################################################
   #######   Affinity Tabs and Slots   #########################
   #############################################################

data/spec/models/logical/naf/application_spec.rb

@@ -17,7 +17,7 @@ module Logical
                        :prerequisites,
                        :deleted,
                        :visible] }
-      let(:physical_app) { FactoryGirl.create(:application) }
+      let(:physical_app) { FactoryGirl.create(:application, application_schedule: FactoryGirl.create(:schedule_base)) }
       let!(:logical_app) { Application.new(physical_app) }
       let(:scheduled_physical_app) {
         FactoryGirl.create(:scheduled_application, application_schedule: FactoryGirl.create(:schedule_at_time))
@@ -25,9 +25,8 @@ module Logical
 
       context "Class Methods" do
         it "search method should return array of wrapper around physical application" do
-          app = logical_app
-          Application.search(params: nil).map(&:id).should include(app.id)
-          Application.search(params: nil).should have(1).items
+          Application.search(params: nil).map(&:id).should include(logical_app.id)
+          Application.search(params: nil).should have(2).items
           Application.search(params: nil).should be_a(Array)
         end
       end

data/spec/models/logical/naf/job_creator_spec.rb

@@ -3,29 +3,99 @@ require 'spec_helper'
 module Logical
   module Naf
     describe JobCreator do
-      context "with regard to queuing from an application_schedule" do
-        context "a new queued job should get from an application_schedule" do
-
-          let(:app_schedule_for_canary) {
-            tab = FactoryGirl.create(:canary_app_schedule_affinity_tab)
-            tab.application_schedule
-          }
-          let(:job_creator) { JobCreator.new }
-
-          before do
-            ::Naf::HistoricalJob.delete_all
-            ::Naf::HistoricalJobAffinityTab.delete_all
-            ::Naf::ApplicationSchedule.destroy_all
-            app_schedule_for_canary.enqueue_backlogs = true
-          end
-
-          it "affinities" do
-            job_creator.queue_application_schedule(app_schedule_for_canary)
-            ::Naf::HistoricalJob.first.historical_job_affinity_tabs.map(&:affinity_id).
-              should == app_schedule_for_canary.application_schedule_affinity_tabs.map(&:affinity_id)
-          end
+
+      let!(:job_creator) { ::Logical::Naf::JobCreator.new }
+      let!(:historical_job) { FactoryGirl.create(:job) }
+      let(:application) { FactoryGirl.create(:scheduled_application) }
+
+      describe '#queue_application' do
+        it 'not queue an application if the group limit is less than number of queued/running jobs' do
+          historical_job.application_run_group_name = application.application_schedule.application_run_group_name
+          historical_job.command = application.command
+          historical_job.save!
+          job_creator.create_queue_job(historical_job)
+
+          job_creator.queue_application(application,
+                                        application.application_schedule.application_run_group_restriction,
+                                        application.application_schedule.application_run_group_name).should be_nil
+        end
+
+        it 'return a historical_job that has been queued' do
+          job_creator.queue_application(application,
+                                        application.application_schedule.application_run_group_restriction,
+                                        application.application_schedule.application_run_group_name).should be_instance_of(::Naf::HistoricalJob)
+        end
+
+        it 'create affinity tabs when affinities are present' do
+          job_creator.queue_application(application,
+                                        application.application_schedule.application_run_group_restriction,
+                                        application.application_schedule.application_run_group_name,
+                                        1,
+                                        0,
+                                        [::Naf::Affinity.first])
+          ::Naf::HistoricalJobAffinityTab.should have(1).records
+        end
+      end
+
+      describe '#retrieve_jobs' do
+        before do
+          FactoryGirl.create(:queued_job, application_run_group_name: 'Test',
+                                          application_run_group_limit: 1)
+        end
+
+        it 'return the correct records' do
+          job_creator.retrieve_jobs(::Naf::QueuedJob, '::Naf::QueuedJob.test hello world', 'Test').
+            count.to_i.should == 1
+        end
+      end
+
+      describe '#queue_application_schedule' do
+        it 'raise error if schedule has been queued' do
+          expect { job_creator.queue_application_schedule(application.application_schedule, [application.application_schedule.id]) }.
+            to raise_error(::Naf::HistoricalJob::JobPrerequisiteLoop)
+        end
+
+        it 'return a historical_job that has been queued' do
+          job_creator.queue_application_schedule(application.application_schedule).should be_instance_of(::Naf::HistoricalJob)
+        end
+      end
+
+      describe '#queue_rails_job' do
+        it 'create and return a historical_job' do
+          job = job_creator.queue_rails_job(:command)
+          job.should be_instance_of(::Naf::HistoricalJob)
+        end
+
+        it 'create affinity tabs when affinites are present' do
+          job_creator.queue_rails_job(:command,
+                                      ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
+                                      :command,
+                                      1,
+                                      0,
+                                      [::Naf::Affinity.first])
+
+          ::Naf::HistoricalJobAffinityTab.should have(1).records
+        end
+      end
+
+      describe '#verify_and_create_prerequisites' do
+        before do
+          prereq_job = FactoryGirl.create(:job)
+          job_creator.verify_and_create_prerequisites(historical_job, [prereq_job])
+        end
+
+        it 'insert a row correctly into naf.historical_job_prerequisites' do
+          ::Naf::HistoricalJobPrerequisite.should have(1).records
         end
       end
+
+      describe '#create_queue_job' do
+        it 'insert a row correctly into naf.queued_jobs' do
+          job_creator.create_queue_job(historical_job)
+          ::Naf::QueuedJob.should have(1).records
+        end
+      end
+
     end
 
   end

data/spec/models/logical/naf/job_spec.rb

@@ -203,10 +203,18 @@ module Logical
           job.run_time.should == '0h0m6s'
         end
 
-        it "show correct run time when job is running" do
-          historical_job.started_at = Time.zone.now - 3.seconds
-          historical_job.finished_at = nil
-          job.run_time.should == '0h0m3s'
+        describe "show correct run time when job is running" do
+          it "less than 2 days" do
+            historical_job.started_at = Time.zone.now - 3.hours
+            historical_job.finished_at = nil
+            job.run_time.should == '3h0m0s'
+          end
+
+          it "more than 2 days" do
+            historical_job.started_at = Time.zone.now - 3.days
+            historical_job.finished_at = nil
+            job.run_time.should == '3d0h0m0s'
+          end
         end
 
         it "show correct run time when job has not started" do
@@ -262,13 +270,18 @@ module Logical
       end
 
       describe "#tags" do
+        before do
+          running_job = FactoryGirl.create(:running_job_base, historical_job: historical_job)
+          historical_job.running_job = running_job
+        end
+
         it "show custom visible tags" do
-          historical_job.tags = '{test}'
+          historical_job.running_job.tags = '{test}'
           job.tags.should == 'test'
         end
 
         it "not show system or custom invisible tags" do
-          historical_job.tags = '{$test,_test}'
+          historical_job.running_job.tags = '{$test,_test}'
           job.tags.should == ''
         end
 

data/spec/models/logical/naf/log_file_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module Logical
+  module Naf
+    describe LogFile do
+
+      before(:all) do
+        Timecop.freeze(Time.zone.now)
+      end
+
+      after(:all) do
+        Timecop.return
+        `rm -rf log_spec/`
+      end
+
+      let!(:log_file) { ::Logical::Naf::LogFile.new('log_spec') }
+      let!(:time) { Time.zone.now }
+      let!(:log_line) {
+        JSON.pretty_generate({
+          line_number: 1,
+          output_time: time.strftime("%Y-%m-%d %H:%M:%S.%L"),
+          message: 'test message'
+        })
+      }
+
+    	describe '<<' do
+        before do
+          log_file << 'test message'
+        end
+
+        it 'encapsulate the message in JSON format' do
+          log_file.lines_cache.should == log_line
+        end
+
+        it 'increment the line_number' do
+          log_file.line_number.should == 2
+        end
+    	end
+
+    	describe 'write' do
+        before do
+          log_file.open
+          log_file << 'test message'
+          log_file.write
+        end
+
+        it 'clear the lines_cache' do
+          log_file.lines_cache.should == ''
+        end
+
+        it 'save the logs to the file' do
+          File.open(log_file.file.path, 'r').read.should == log_line
+        end
+    	end
+
+    	describe 'flush' do
+        before do
+          log_file.open
+          log_file.file.write('test message')
+          log_file.flush
+        end
+
+        it 'update the file with content written' do
+          File.open(log_file.file.path, 'r').read.should == 'test message'
+        end
+    	end
+
+    	describe 'open' do
+        before do
+          log_file.open
+        end
+
+        it 'create the file path' do
+          log_file.file.path.should == "log_spec/1_#{time.strftime('%Y%m%d_%H%M%S')}.json"
+        end
+    	end
+
+    	describe 'close' do
+        before do
+          log_file.open
+          log_file.close
+        end
+
+        it 'close the file stream' do
+          log_file.file.should == nil
+        end
+    	end
+
+    	describe 'check_file_size' do
+        before do
+          log_file.open
+          log_file << 'test message'
+          log_file.write
+          stub_const('::Logical::Naf::LogFile::LOG_MAX_SIZE', 1)
+          log_file.check_file_size
+        end
+
+        it 'create a new file when size > LOG_MAX_SIZE' do
+          log_file.file.path.should == "log_spec/2_#{time.strftime('%Y%m%d_%H%M%S')}.json"
+        end
+    	end
+
+    end
+  end
+end

data/spec/models/logical/naf/machine_runner_invocation_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Logical
+  module Naf
+
+    describe MachineRunnerInvocation do
+
+    	let!(:machine_runner) { FactoryGirl.create(:machine_runner) }
+    	let!(:machine) { ::Logical::Naf::Machine.new(machine_runner.machine) }
+    	let!(:invocation1) { FactoryGirl.create(:machine_runner_invocation, machine_runner: machine_runner) }
+    	let!(:invocation2) { FactoryGirl.create(:machine_runner_invocation, machine_runner: machine_runner) }
+    	let!(:invocations) {
+    		[[invocation1.id,
+    			invocation1.created_at.to_s,
+    			invocation1.machine_runner_id,
+    			[machine.id, machine.name.to_s],
+    			invocation1.pid,
+    			invocation1.status.gsub('-', ' ').split.map(&:capitalize).join(' '),
+    			invocation1.commit_information,
+    			invocation1.deployment_tag,
+    			invocation1.repository_name],
+    		 [invocation2.id,
+    		 	invocation2.created_at.to_s,
+    		 	invocation2.machine_runner_id,
+    		 	[machine.id, machine.name.to_s],
+    		 	invocation2.pid,
+    			invocation2.status.gsub('-', ' ').split.map(&:capitalize).join(' '),
+    			invocation2.commit_information,
+    			invocation2.deployment_tag,
+    			invocation2.repository_name]]
+    	}
+
+    	describe '#to_array' do
+    		it 'return invocation information in correct order' do
+    			::Logical::Naf::MachineRunnerInvocation.to_array(0, 'asc', nil).should == invocations
+    		end
+    	end
+
+    end
+  end
+end

data/spec/models/logical/naf/machine_runner_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Logical
+  module Naf
+
+    describe MachineRunner do
+
+    	let!(:machine_runner1) { FactoryGirl.create(:machine_runner) }
+      let!(:machine_runner2) { FactoryGirl.create(:machine_runner) }
+    	let!(:machine) { ::Logical::Naf::Machine.new(machine_runner1.machine) }
+    	let!(:invocation1) { FactoryGirl.create(:machine_runner_invocation, machine_runner: machine_runner1) }
+    	let!(:invocation2) { FactoryGirl.create(:machine_runner_invocation, machine_runner: machine_runner2) }
+    	let!(:invocations) {
+    		[[machine_runner1.id,
+          machine_runner1.created_at.to_s,
+          machine.id,
+          machine_runner1.runner_cwd,
+          invocation1.id,
+          invocation1.pid,
+          invocation1.status.gsub('-', ' ').split.map(&:capitalize).join(' '),
+          0,
+          ''],
+         [machine_runner2.id,
+          machine_runner2.created_at.to_s,
+          machine.id,
+          machine_runner2.runner_cwd,
+          invocation2.id,
+          invocation2.pid,
+          invocation2.status.gsub('-', ' ').split.map(&:capitalize).join(' '),
+          0,
+          '']]
+    	}
+
+    	describe '#to_array' do
+    		it 'return invocation information in correct order' do
+    			::Logical::Naf::MachineRunner.to_array(0, 'asc').should == invocations
+    		end
+    	end
+
+    end
+  end
+end