naf 1.1.0

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Logical
+  module Naf
+    describe Application do
+      let(:columns) { [:id,
+                       :title,
+                       :short_name,
+                       :script_type_name,
+                       :application_run_group_name,
+                       :application_run_group_restriction_name,
+                       :application_run_group_limit,
+                       :enabled,
+                       :enqueue_backlogs,
+                       :run_time,
+                       :affinities,
+                       :prerequisites,
+                       :deleted,
+                       :visible] }
+      let(:physical_app) { FactoryGirl.create(:application) }
+      let!(:logical_app) { Application.new(physical_app) }
+      let(:scheduled_physical_app) {
+        FactoryGirl.create(:scheduled_application, application_schedule: FactoryGirl.create(:schedule_at_time))
+      }
+
+      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).should be_a(Array)
+        end
+      end
+
+      it "should delegate command to the physical app" do
+        logical_app.should_receive(:command).and_return("")
+        logical_app.command
+      end
+
+      it "to_hash should have the specified columns" do
+        logical_app.to_hash.keys.should == columns
+      end
+
+      it "should render run_start_minute" do
+        scheduled_physical_app.application_schedule.run_start_minute.should be_a(Fixnum)
+
+        Application.new(scheduled_physical_app).run_start_minute.should be_a(String)
+      end
+
+      it "should delegate methods to its schedule" do
+        methods = [:application_run_group_restriction_name,
+                   :run_interval,
+                   :application_run_group_name,
+                   :run_start_minute]
+        schedule = scheduled_physical_app.application_schedule
+        logical_scheduled_app = Application.new(scheduled_physical_app)
+
+        methods.each do |m|
+          schedule.should_receive(m).and_return(nil)
+        end
+
+        methods.each do |m|
+          logical_scheduled_app.send(m)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,32 @@
+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
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module Logical
+  module Naf
+    describe JobFetcher do
+      let(:job) { FactoryGirl.create(:job) }
+      let(:normal_slot) { FactoryGirl.create(:normal_machine_affinity_slot, machine: FactoryGirl.create(:machine)) }
+      let(:required_perennial_slot) { FactoryGirl.create(:required_perennial_slot, machine: FactoryGirl.create(:machine_two)) }
+      let(:normal_machine) { normal_slot.machine }
+      let(:perennial_machine) { required_perennial_slot.machine }
+      let(:normal_tab) { FactoryGirl.create(:normal_job_affinity_tab) }
+      let(:perennial_tab) { FactoryGirl.create(:perennial_job_affinity_tab) }
+      let(:normal_job) { normal_tab.job }
+      let(:perennial_job) { perennial_tab.job }
+      let(:perennial_job_fetcher) { JobFetcher.new(perennial_machine) }
+      let(:normal_job_fetcher) { JobFetcher.new(normal_machine) }
+
+      before(:all) do
+        ::Naf::HistoricalJob.delete_all
+      end
+
+      before do
+        ::Naf::MachineAffinitySlot.delete_all
+        FactoryGirl.create(:affinity, id: 4, affinity_name: 'cpus')
+        FactoryGirl.create(:affinity, id: 5, affinity_name: 'memory')
+      end
+
+      #----------------------------
+      # ***   Shared Examples   ***
+      #++++++++++++++++++++++++++++
+
+      shared_examples "inserts machine affinity slots correctly" do
+        it { required_perennial_slot.required.should be_true }
+        it { normal_slot.required.should be_false }
+      end
+
+      shared_examples "fetches next job correctly" do
+        it "asserts next job is not equal to first job" do
+          first_job.should_not == second_job
+        end
+
+        it "insert row correctly into historical_jobs" do
+          ::Naf::HistoricalJob.queued_between(Time.zone.now - ::Naf::HistoricalJob::JOB_STALE_TIME, Time.zone.now).
+            where(started_at: nil).first.should == first_job
+        end
+
+        it "return correctly next fetched job" do
+          FactoryGirl.create(:queued_job, historical_job: second_job)
+          fetcher.fetch_next_job.historical_job.should == second_job
+        end
+      end
+
+      describe "single affinity" do
+        context "jobs that don't have the affinity a machine requires" do
+          before do
+            job
+            perennial_job
+          end
+
+          it "return 0 affinity tabs for first job" do
+            job.historical_job_affinity_tabs.should be_empty
+          end
+
+          it_should_behave_like "inserts machine affinity slots correctly"
+          it_should_behave_like "fetches next job correctly" do
+            let(:first_job) { job }
+            let(:second_job) { perennial_job }
+            let(:fetcher) { perennial_job_fetcher }
+          end
+        end
+
+        context "jobs that the machine doesn't have an affinity for" do
+          before do
+            perennial_job
+            normal_job
+          end
+
+          it_should_behave_like "inserts machine affinity slots correctly"
+          it_should_behave_like "fetches next job correctly" do
+            let(:first_job) { perennial_job }
+            let(:second_job) { normal_job }
+            let(:fetcher) { normal_job_fetcher }
+          end
+        end
+      end
+
+      describe "multiple affinities" do
+        let(:canary_machine) {
+          slot = FactoryGirl.create(:canary_slot, machine: FactoryGirl.create(:machine))
+          slot.machine
+        }
+        let(:canary_job) {
+          tab = FactoryGirl.create(:canary_job_affinity_tab)
+          tab.job
+        }
+        let(:canary_perennial_machine) {
+          slot_one = FactoryGirl.create(:required_canary_slot, machine: FactoryGirl.create(:machine_two))
+          slot_two = FactoryGirl.create(:required_perennial_slot, machine: FactoryGirl.create(:machine_two))
+          slot_two.machine
+        }
+        let(:canary_perennial_job) {
+          first_tab  = FactoryGirl.create(:canary_job_affinity_tab)
+          second_tab = FactoryGirl.create(:perennial_job_affinity_tab, historical_job: first_tab.job)
+          second_tab.job
+        }
+        let(:canary_job_fetcher) { JobFetcher.new(canary_machine) }
+        let(:canary_perennial_job_fetcher) { JobFetcher.new(canary_perennial_machine) }
+
+        context "jobs that the machine doesn't have an affinity for" do
+          before do
+            canary_job
+            canary_perennial_job
+          end
+
+          it_should_behave_like "inserts machine affinity slots correctly"
+          it_should_behave_like "fetches next job correctly" do
+            let(:first_job) { canary_job }
+            let(:second_job) { canary_perennial_job }
+            let(:fetcher) { canary_perennial_job_fetcher }
+          end
+        end
+
+        context "jobs that the machine doesn't have one affinity for" do
+          before do
+            canary_perennial_job
+            canary_job
+          end
+
+          it_should_behave_like "inserts machine affinity slots correctly"
+          it_should_behave_like "fetches next job correctly" do
+            let(:first_job) { canary_perennial_job }
+            let(:second_job) { canary_job }
+            let(:fetcher) { canary_job_fetcher }
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,282 @@
+require 'spec_helper'
+
+module Logical
+  module Naf
+    describe Job do
+
+      TIME_DISPLAY_REGEX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} (AM|PM)$/
+
+      STATUS_MAP = {
+        job: "Queued",
+        canceled_job: "Terminated",
+        terminating_job: "Terminating",
+        running_job: "Running",
+        failed_to_start_job: "Failed to Start",
+        finished_job: "Finished",
+        job_with_error: "Error 1",
+        job_with_signal: "Signaled 1"
+      }
+
+      let!(:job) { Job.new(FactoryGirl.create(:finished_job)) }
+      let!(:historical_job) { job.instance_variable_get(:@job) }
+
+      it "should return the correct statuses" do
+        STATUS_MAP.each do |job_type, expected_status|
+          logical_job = Job.new(FactoryGirl.create(job_type))
+          logical_job.status.should eql(expected_status)
+        end
+      end
+
+      context "#title" do
+        let(:scheduled_job) { Job.new(FactoryGirl.create(:scheduled_job)) }
+
+        context "for a job scheduled from an application" do
+          it "should get the title from the application_schedule" do
+            scheduled_job.title.should eql(scheduled_job.application.title)
+          end
+        end
+
+        context "for an ad hoc job" do
+          it "should get the title, formed from its command" do
+            job = Job.new(FactoryGirl.create(:job, command: "Yo"*30))
+            job.title.should eql(job.command)
+          end
+        end
+      end
+
+      context "with regard to the timestamps" do
+        it "should display started_at nicely" do
+          job.started_at.should be_a(String)
+          job.started_at.should =~ /-0h3m/
+        end
+
+        it "should display finished_at nicely" do
+          job.finished_at.should be_a(String)
+          job.finished_at.split(',').first.should =~ /ago$/
+        end
+
+        it "should display queued time explicitly as string" do
+          job.queued_time.should be_a(String)
+          job.queued_time.should =~ TIME_DISPLAY_REGEX
+        end
+      end
+
+      context "#to_detailed_hash" do
+        let(:detailed_hash) { Job.new(FactoryGirl.create(:finished_job)).to_detailed_hash }
+
+        it "should display started_at, and finished_at explicitly as a string" do
+          [:started_at, :finished_at].each do |timestamp|
+            detailed_hash[timestamp].should be_a String
+            detailed_hash[timestamp].should =~ TIME_DISPLAY_REGEX
+          end
+        end
+      end
+
+      context "#to_hash" do
+        let(:columns) {
+          [:id,
+           :server,
+           :pid,
+           :queued_time,
+           :title,
+           :started_at,
+           :finished_at,
+           :run_time,
+           :affinities,
+           :tags,
+           :status] }
+
+        it "should have the following columns" do
+          job.to_hash.keys.should. == columns
+        end
+      end
+
+      context "#search" do
+        before(:all) do
+          ::Naf::HistoricalJob.delete_all
+          @job_status_type_map = {}
+          STATUS_MAP.each{ |factory, status|
+            @job_status_type_map[status.downcase.split(' ').join('_')] = Job.new(FactoryGirl.create(factory))
+          }
+        end
+
+        it "should filter by status correctly" do
+          @job_status_type_map.each do |status, logical_job|
+            Job.search(status: status, limit: 10).map(&:id).should include(logical_job.id)
+          end
+        end
+
+        it "should not filter by status when 'all' is specified" do
+          job_ids = @job_status_type_map.values.map(&:id)
+          result_ids = Job.search(status: 'all', limit: 10).map(&:id)
+          job_ids.each do |job_id|
+            result_ids.should include job_id
+          end
+        end
+
+        context "for other filtering and searching" do
+          let(:job_one) { FactoryGirl.create(:running_job,
+                                             pid: 400,
+                                             command: "MyScript.run --thing friend") }
+          let(:job_two) { FactoryGirl.create(:running_job,
+                                             application_type: FactoryGirl.create(:bash_command_app_type),
+                                             pid: 500,
+                                             command: "ps aux | grep ssh",
+                                             priority: 5,
+                                             application_run_group_restriction: FactoryGirl.create(:limited_per_machine),
+                                             application_run_group_name: "crazy group") }
+
+          before do
+            ::Naf::HistoricalJob.delete_all
+            job_one
+            job_two
+            ::Naf::HistoricalJob.all.should have(2).items
+          end
+
+          it "should filter by application type" do
+            id_one = job_one.application_type_id
+            Job.search(application_type_id: id_one, limit: 10).map(&:id).should == [job_one.id]
+            id_two = job_two.application_type_id
+            Job.search(application_type_id: id_two, limit: 10).map(&:id).should == [job_two.id]
+          end
+
+          it "should filter by run_group_restriction" do
+            id_one = job_one.application_run_group_restriction_id
+            Job.search(application_run_group_restriction_id: id_one, limit: 10).map(&:id).should == [job_one.id]
+            id_two = job_two.application_run_group_restriction_id
+            Job.search(application_run_group_restriction_id: id_two, limit: 10).map(&:id).should == [job_two.id]
+          end
+
+          it "should filter by priority" do
+            priority_one = job_one.priority
+            Job.search(priority: priority_one, limit: 10).map(&:id).should == [job_one.id]
+            priority_two = job_two.priority
+            Job.search(priority: priority_two, limit: 10).map(&:id).should == [job_two.id]
+          end
+
+          it "should filter by pid" do
+            pid_one = job_one.pid
+            Job.search(pid: pid_one, limit: 10).map(&:id).should == [job_one.id]
+            pid_two = job_two.pid
+            Job.search(pid: pid_two, limit: 10).map(&:id).should == [job_two.id]
+          end
+
+          it "should find jobs where the command is like the query" do
+            Job.search(command: "friend", limit: 10).map(&:id).should == [job_one.id]
+            Job.search(command: "ssh", limit: 10).map(&:id).should == [job_two.id]
+          end
+
+          it "should find jobs where the application_run_group_name is like the query" do
+            Job.search(application_run_group_name: "crazy", limit: 10).map(&:id).should == [job_two.id]
+          end
+        end
+      end
+
+      describe "#get_job_scope" do
+        before do
+          ::Naf::HistoricalJob.delete_all
+        end
+        let!(:finished_job) { FactoryGirl.create(:finished_job) }
+
+        it "return correct job when scope is specified" do
+          ::Logical::Naf::Job.get_job_scope({ status: :finished }).should == [finished_job]
+        end
+
+        it "return correct jobs when scope is not specified" do
+          historical_job = FactoryGirl.create(:job)
+          ::Logical::Naf::Job.get_job_scope({}).should == [finished_job, historical_job]
+        end
+      end
+
+      describe "#run_time" do
+        before do
+          Timecop.freeze(Time.zone.now)
+        end
+
+        after do
+          Timecop.return
+        end
+
+        it "show correct run time when job has finished" do
+          historical_job.started_at = Time.zone.now - 6.seconds
+          historical_job.finished_at = Time.zone.now
+          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'
+        end
+
+        it "show correct run time when job has not started" do
+          historical_job.started_at = nil
+          historical_job.finished_at = nil
+          job.run_time.should == ''
+        end
+      end
+
+      describe "#started_at" do
+        before do
+          Timecop.freeze(Time.zone.now)
+        end
+
+        after do
+          Timecop.return
+        end
+
+        it "show correct run time when job has started < 60 seconds ago" do
+          historical_job.started_at = Time.zone.now - 10.seconds
+          job.started_at.should =~ /10 seconds ago/
+        end
+
+        it "show correct run time when job has started >= 60 seconds and < 2 days ago" do
+          historical_job.started_at = Time.zone.now - 6.hours
+          job.started_at.should =~ /-6h0m/
+        end
+
+        it "show correct run time when job has started <= 2 days ago" do
+          historical_job.started_at = Time.zone.now - 3.days
+          job.started_at.should =~ /3 days ago/
+        end
+      end
+
+      describe "#finished_at" do
+        before do
+          Timecop.freeze(Time.zone.now)
+        end
+
+        after do
+          Timecop.return
+        end
+
+        it "show correct run time when job has finished" do
+          historical_job.finished_at = Time.zone.now - 3.seconds
+          job.finished_at.should =~ /less than 5 seconds ago/
+        end
+
+        it "show correct run time when job has not finished" do
+          historical_job.finished_at = nil
+          job.finished_at.should == ''
+        end
+      end
+
+      describe "#tags" do
+        it "show custom visible tags" do
+          historical_job.tags = '{test}'
+          job.tags.should == 'test'
+        end
+
+        it "not show system or custom invisible tags" do
+          historical_job.tags = '{$test,_test}'
+          job.tags.should == ''
+        end
+
+        it "return nil when tags is not present" do
+           job.tags.should == nil
+        end
+      end
+
+    end
+  end
+end