naf 1.1.0

data/spec/models/naf/application_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+module Naf
+  describe Application do
+    let!(:app) { FactoryGirl.create(:application) }
+
+    # Mass-assignment
+    [:title,
+     :command,
+     :application_type_id,
+     :log_level,
+     :short_name,
+     :deleted,
+     :application_schedule,
+     :application_schedule_attributes].each do |a|
+      it { should allow_mass_assignment_of(a) }
+    end
+
+    [:id,
+     :created_at,
+     :updated_at].each do |a|
+      it { should_not allow_mass_assignment_of(a) }
+    end
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    it { should belong_to(:application_type) }
+    it { should have_one(:application_schedule) }
+    it { should have_many(:historical_jobs) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:application_type_id) }
+    it { should validate_presence_of(:command) }
+    it { should validate_presence_of(:title) }
+    it { should validate_uniqueness_of(:title) }
+    it { should validate_uniqueness_of(:short_name) }
+
+    ['', 'aa', 'aA', 'Aa', 'AA', '_a', 'a1', 'A1', '_9'].each do |v|
+      it { should allow_value(v).for(:short_name) }
+    end
+
+    ['1_', '3A', '9a'].each do |v|
+      it { should_not allow_value(v).for(:short_name) }
+    end
+
+    context "upon creation" do
+      let(:app_base) { FactoryGirl.build(:application_base, command: "::Naf::HistoricalJob.test hello_world",
+                                                            title: "Test Hello World") }
+      let(:incomplete_app_base) { FactoryGirl.build( :application_base) }
+
+      it "should save with a command and title specified" do
+        app_base.save.should be_true
+      end
+
+      it "should not save without a command or a title" do
+        incomplete_app_base.save.should_not be_true
+      end
+
+      context "with regard to the title" do
+        it "should not save when another title is taken" do
+          app_2 = FactoryGirl.build(:application, title: app.title)
+          app_2.save.should_not be_true
+          app_2.should have(1).error_on(:title)
+        end
+      end
+    end
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    context "with regard to delegation" do
+      let(:application_type) { app.application_type }
+
+      it "should delegate the script_type_name" do
+        application_type.should_receive(:script_type_name)
+        app.script_type_name
+      end
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    describe "#to_s" do
+      before do
+        app.update_attributes!(title: 'App1')
+      end
+
+      it "return correct parsing of app" do
+        app.to_s.should == "::Naf::Application<id: #{app.id}, App1>"
+      end
+    end
+
+    describe "#last_queued_job" do
+      it "return correct queued job" do
+        queued_job1 = FactoryGirl.create(:queued_job, application_id: app.id)
+        queued_job1.historical_job.update_attributes!(application_id: app.id)
+        queued_job2 = FactoryGirl.create(:queued_job, application_id: app.id)
+        queued_job2.historical_job.update_attributes!(application_id: app.id)
+
+        app.last_queued_job.should == queued_job2.historical_job
+      end
+
+      it "return nil when there are no jobs" do
+        app.last_queued_job.should == nil
+      end
+    end
+
+    describe "#short_name_if_it_exist" do
+      it "return app's short_name" do
+        app.update_attributes!(short_name: 'App1')
+        app.short_name_if_it_exist.should == 'App1'
+      end
+
+      it "return app's title" do
+        app.short_name = nil
+        app.update_attributes!(title: 'Application 1')
+        app.short_name_if_it_exist.should == 'Application 1'
+      end
+    end
+
+  end
+end

data/spec/models/naf/application_type_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+module Naf
+  describe ApplicationType do
+    let(:rails) { FactoryGirl.create(:rails_app_type) }
+    let(:bash_command) { FactoryGirl.create(:bash_command_app_type) }
+    let(:bash_script) { FactoryGirl.create(:bash_script_app_type) }
+    let(:ruby) { FactoryGirl.create(:ruby_script_app_type) }
+    let!(:job) { FactoryGirl.create(:job) }
+
+    # Mass-assignment
+    [:enabled,
+     :script_type_name,
+     :description,
+     :invocation_method].each do |a|
+      it { should allow_mass_assignment_of(a) }
+    end
+
+    [:id,
+     :created_at,
+     :updated_at].each do |a|
+      it { should_not allow_mass_assignment_of(a) }
+    end
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    it { should have_many(:applications) }
+    it { should have_many(:historical_jobs) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:script_type_name) }
+    it { should validate_presence_of(:invocation_method) }
+
+    context "For a Rails Application" do
+      before do
+        job.application_type = rails
+        job.save!
+      end
+
+      it "has the starting id" do
+        rails.id.should == 1
+      end
+
+      it "should invoke the rails_invocator" do
+        rails.should_receive(:rails_invocator).and_return(nil)
+        job.spawn
+      end
+    end
+
+    context "For a bash command" do
+      before do
+        job.application_type = bash_command
+        job.save!
+      end
+
+      it "has the starting id" do
+        bash_command.id.should == 2
+      end
+
+      it "should invoke the bash_command_invocator" do
+        bash_command.should_receive(:bash_command_invocator).and_return(nil)
+        job.spawn
+      end
+    end
+
+    context "For a bash script" do
+      before do
+        job.application_type = bash_script
+        job.save!
+      end
+
+      it "has the starting id" do
+        bash_script.id.should == 3
+      end
+
+      it "should invoke the bash_script_invocator" do
+        bash_script.should_receive(:bash_script_invocator).and_return(nil)
+        job.spawn
+      end
+    end
+
+    context "For a ruby script" do
+      before do
+        job.application_type = ruby
+        job.save!
+      end
+
+      it "has the starting id" do
+        ruby.id.should == 4
+      end
+
+      it "should invoke the ruby_script_invocator" do
+        ruby.should_receive(:ruby_script_invocator).and_return(nil)
+        job.spawn
+      end
+    end
+
+  end
+end

data/spec/models/naf/historical_job_affinity_tab_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Naf
+  describe HistoricalJobAffinityTab do
+    let!(:historical_job_affinity_tab) { FactoryGirl.create(:normal_job_affinity_tab) }
+
+    # Mass-assignment
+    [:affinity_id,
+     :historical_job_id,
+     :historical_job,
+     :affinity_parameter].each do |a|
+      it { should allow_mass_assignment_of(a) }
+    end
+
+    [:id,
+     :created_at].each do |a|
+      it { should_not allow_mass_assignment_of(a) }
+    end
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    it { should belong_to(:affinity) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:affinity_id) }
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#job" do
+      let(:job) { FactoryGirl.create(:job) }
+
+      it "return the correct job" do
+        historical_job_affinity_tab.historical_job_id = job.id
+        historical_job_affinity_tab.job.should == job
+      end
+    end
+
+    describe "#script_type_name" do
+      it "return the correct name" do
+        historical_job_affinity_tab.script_type_name.should == "rails"
+      end
+    end
+
+    describe "#command" do
+      it "return the correct command" do
+        historical_job_affinity_tab.command.
+          should == "::Naf::HistoricalJob.test hello world"
+      end
+    end
+
+  end
+end

data/spec/models/naf/historical_job_prerequisite_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Naf
+  describe HistoricalJobPrerequisite do
+
+    # Mass-assignment
+    [:historical_job_id,
+     :prerequisite_historical_job_id].each do |a|
+      it { should allow_mass_assignment_of(a) }
+    end
+
+    [:id,
+     :created_at].each do |a|
+      it { should_not allow_mass_assignment_of(a) }
+    end
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    it { should belong_to(:historical_job) }
+    it { should belong_to(:prerequisite_historical_job) }
+
+  end
+end

data/spec/models/naf/historical_job_spec.rb

@@ -0,0 +1,334 @@
+require 'spec_helper'
+
+module Naf
+  describe HistoricalJob do
+
+    before(:all) do
+      ::Naf::HistoricalJob.delete_all
+    end
+
+    let!(:historical_job) { FactoryGirl.create(:job) }
+
+    # Mass-assignment
+    [:application_id,
+     :application_type_id,
+     :command,
+     :application_run_group_restriction_id,
+     :application_run_group_name,
+     :application_run_group_limit,
+     :priority,
+     :started_on_machine_id,
+     :failed_to_start,
+     :pid,
+     :exit_status,
+     :termination_signal,
+     :state,
+     :request_to_terminate,
+     :marked_dead_by_machine_id,
+     :log_level,
+     :tags,
+     :machine_runner_invocation_id].each do |a|
+      it { should allow_mass_assignment_of(a) }
+    end
+
+    [:id,
+     :created_at,
+     :updated_at].each do |a|
+      it { should_not allow_mass_assignment_of(a) }
+    end
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    it { should belong_to(:application_type) }
+    it { should belong_to(:started_on_machine) }
+    it { should belong_to(:marked_dead_by_machine) }
+    it { should belong_to(:application) }
+    it { should belong_to(:application_run_group_restriction) }
+    it { should belong_to(:machine_runner_invocation) }
+    it { should have_many(:historical_job_prerequisites) }
+    it { should have_many(:prerequisites) }
+    it { should have_many(:historical_job_affinity_tabs) }
+    it { should have_many(:affinities) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:application_type_id) }
+    it { should validate_presence_of(:command) }
+    it { should validate_presence_of(:application_run_group_restriction_id) }
+
+    [1, 100, 2147483646, ''].each do |v|
+      it { should allow_value(v).for(:application_run_group_limit) }
+    end
+
+    [0, 2147483647, 1.1].each do |v|
+      it { should_not allow_value(v).for(:application_run_group_limit) }
+    end
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#full_table_name_prefix" do
+      it "return the correct string" do
+        ::Naf::HistoricalJob.full_table_name_prefix.should == 'naf.'
+      end
+    end
+
+    describe "#queued_between" do
+      before do
+        FactoryGirl.create(:job, created_at: Time.zone.now - 5.minutes)
+      end
+
+      it "return the correct queued job" do
+        ::Naf::HistoricalJob.queued_between(Time.zone.now - 1.minutes, Time.zone.now).
+          should == [historical_job]
+      end
+    end
+
+    describe "#canceled" do
+      it "return jobs requested to terminate" do
+        historical_job.update_attributes!(request_to_terminate: true)
+        ::Naf::HistoricalJob.canceled.should == [historical_job]
+      end
+
+      it "return nil when no jobs have been requested to terminate" do
+        ::Naf::HistoricalJob.canceled.should == []
+      end
+    end
+
+    describe "#application_last_runs" do
+      before do
+        historical_job.update_attributes!(application_id: FactoryGirl.create(:application).id)
+      end
+
+      it "return job when it finished running" do
+        historical_job.finished_at = Time.zone.now
+        historical_job.save!
+        ::Naf::HistoricalJob.application_last_runs.first.application.should == historical_job.application
+      end
+
+      it "return nil when job has not finished running" do
+        ::Naf::HistoricalJob.application_last_runs.should == []
+      end
+    end
+
+    describe "#application_last_queued" do
+      let(:historical_job2) { FactoryGirl.create(:job) }
+      before do
+        application = FactoryGirl.create(:application)
+        historical_job.update_attributes!(application_id: application.id)
+        historical_job2.update_attributes!(application_id: application.id)
+      end
+
+      it "return correct application id" do
+        ::Naf::HistoricalJob.application_last_queued.first.should == historical_job2
+      end
+    end
+
+    describe "#finished" do
+      it "return jobs that have finished running" do
+        historical_job.finished_at = Time.zone.now
+        historical_job.save!
+        ::Naf::HistoricalJob.finished.should == [historical_job]
+      end
+
+      it "return jobs requested to terminate" do
+        historical_job.update_attributes!(request_to_terminate: true)
+        ::Naf::HistoricalJob.finished.should == [historical_job]
+      end
+
+      it "return nil when no jobs have been requested to terminate or have finished running" do
+        ::Naf::HistoricalJob.finished.should == []
+      end
+    end
+
+    describe "#queued_status" do
+      let(:historical_job2) { FactoryGirl.create(:job, finished_at: Time.zone.now) }
+      let(:historical_job3) { FactoryGirl.create(:job, started_at: Time.zone.now) }
+
+      it "return correct jobs" do
+        FactoryGirl.create(:job, request_to_terminate: true)
+        ::Naf::HistoricalJob.queued_status.
+          order(:id).should == [historical_job, historical_job2, historical_job3]
+      end
+    end
+
+    describe "#running_status" do
+      let(:historical_job2) { FactoryGirl.create(:job, finished_at: Time.zone.now) }
+
+      it "return correct jobs" do
+        historical_job.started_at = Time.zone.now
+        historical_job.save!
+        FactoryGirl.create(:job, request_to_terminate: true)
+
+        ::Naf::HistoricalJob.running_status.
+          order(:id).should == [historical_job, historical_job2]
+      end
+    end
+
+    describe "#queued_with_waiting" do
+      it "return correct jobs" do
+        FactoryGirl.create(:job, request_to_terminate: true)
+        ::Naf::HistoricalJob.queued_with_waiting.
+          order(:id).should == [historical_job]
+      end
+    end
+
+    describe "#errored" do
+      let(:historical_job2) { FactoryGirl.create(:job, request_to_terminate: true) }
+      let(:historical_job3) { FactoryGirl.create(:job, finished_at: Time.zone.now,
+                                                       exit_status: 1) }
+
+      it "return correct jobs" do
+        ::Naf::HistoricalJob.errored.
+          order(:id).should == [historical_job2, historical_job3]
+      end
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    describe "#to_s" do
+      before do
+        historical_job.update_attributes!(command: "puts 'hi'")
+      end
+
+      it "return correct parsing of app" do
+        historical_job.to_s.should == "::Naf::HistoricalJob<QUEUED, id: #{historical_job.id}, \"puts \'hi\'\">"
+      end
+    end
+
+    describe "#title" do
+      it "return correct application title when present" do
+        historical_job.application = FactoryGirl.create(:application, title: 'App1')
+        historical_job.title.should == 'App1'
+      end
+
+      it "return nil when application not present" do
+        historical_job.title.should == nil
+      end
+    end
+
+    describe "#machine_started_on_server_name" do
+      it "return correct machine server name when present" do
+        historical_job.started_on_machine = FactoryGirl.create(:machine, server_name: 'Machine1')
+        historical_job.machine_started_on_server_name.should == 'Machine1'
+      end
+
+      it "return nil when machine not present" do
+        historical_job.machine_started_on_server_name.should == nil
+      end
+    end
+
+    describe "#machine_started_on_server_address" do
+      it "return correct machine server name when present" do
+        historical_job.started_on_machine = FactoryGirl.create(:machine)
+        historical_job.machine_started_on_server_address.should == '0.0.0.1'
+      end
+
+      it "return nil when machine not present" do
+        historical_job.machine_started_on_server_address.should == nil
+      end
+    end
+
+    describe "#historical_job_affinity_tabs" do
+      it "return affinity tabs associated with historical_job" do
+        affinity_tab = FactoryGirl.create(:normal_job_affinity_tab, historical_job: historical_job)
+        historical_job.historical_job_affinity_tabs.should == [affinity_tab]
+      end
+    end
+
+    describe "#job_affinities" do
+      it "return affinities associated with historical_job" do
+        affinity_tab = FactoryGirl.create(:normal_job_affinity_tab, historical_job: historical_job)
+        historical_job.job_affinities.should == [affinity_tab.affinity]
+      end
+    end
+
+    describe "#affinity_ids" do
+      it "return affinities associated with historical_job" do
+        affinity_tab = FactoryGirl.create(:normal_job_affinity_tab, historical_job: historical_job)
+        historical_job.affinity_ids.should == [affinity_tab.affinity.id]
+      end
+    end
+
+    describe "#historical_job_prerequisites" do
+      it "return historical job prerequisites associated with historical_job" do
+        historical_job_prerequesite = FactoryGirl.
+          create(:historical_job_prerequesite, historical_job: historical_job,
+                                               prerequisite_historical_job: FactoryGirl.create(:job))
+        historical_job.historical_job_prerequisites.should == [historical_job_prerequesite]
+      end
+    end
+
+    describe "#prerequisites" do
+      it "return prerequisites associated with historical_job" do
+        prerequisite = FactoryGirl.create(:job)
+        historical_job_prerequesite = FactoryGirl.
+          create(:historical_job_prerequesite, historical_job: historical_job,
+                                               prerequisite_historical_job: prerequisite)
+        historical_job.prerequisites.should == [prerequisite]
+      end
+    end
+
+    describe "#verify_prerequisites" do
+      it "not raise error when job is not in a prerequisite loop" do
+        historical_job2 = FactoryGirl.create(:job)
+        expect { historical_job.verify_prerequisites([historical_job2]) }.not_to raise_error
+      end
+
+      it "raise an error when job is in a prerequesite loop" do
+        expect { historical_job.verify_prerequisites([historical_job]) }.to raise_error
+      end
+    end
+
+    describe "#add_tags" do
+      before do
+        historical_job.tags = "{$pre-work}"
+      end
+
+      it "insert unique tag" do
+        historical_job.add_tags([::Naf::HistoricalJob::SYSTEM_TAGS[:work]])
+        historical_job.tags.should == "{$pre-work,$work}"
+      end
+
+      it "not insert non-unique tag" do
+        historical_job.add_tags([::Naf::HistoricalJob::SYSTEM_TAGS[:pre_work]])
+        historical_job.tags.should == "{$pre-work}"
+      end
+    end
+
+    describe "#remove_tags" do
+      before do
+        historical_job.tags = "{$pre-work}"
+      end
+
+      it "remove existing tag" do
+        historical_job.remove_tags([::Naf::HistoricalJob::SYSTEM_TAGS[:pre_work]])
+        historical_job.tags.should == "{}"
+      end
+
+      it "not update tags when removing non-existing tag" do
+        historical_job.remove_tags([::Naf::HistoricalJob::SYSTEM_TAGS[:work]])
+        historical_job.tags.should == "{$pre-work}"
+      end
+    end
+
+    describe "#remove_all_tags" do
+      before do
+        historical_job.tags = "{$pre-work}"
+      end
+
+      it "remove any existing tags" do
+        historical_job.remove_all_tags
+        historical_job.tags.should == "{}"
+      end
+    end
+
+  end
+end