naf 1.1.0

data/spec/models/naf/naf_base_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Naf
+  describe NafBase do
+    describe "with regard to configuration" do
+      it "should inherit from the correct model_class" do
+        NafBase.superclass.should == Naf.model_class
+      end
+      it "should have the correctly set full table name prefix" do
+        NafBase.full_table_name_prefix.should == "#{::Naf.schema_name}."
+      end
+    end
+  end
+end

data/spec/models/naf/queued_job_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+module Naf
+  describe QueuedJob do
+    # Mass-assignment
+    [:application_id,
+     :application_type_id,
+     :command,
+     :application_run_group_restriction_id,
+     :application_run_group_name,
+     :application_run_group_limit,
+     :priority].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(:historical_job) }
+    it { should belong_to(:application) }
+    it { should belong_to(:application_type) }
+    it { should belong_to(:application_run_group_restriction) }
+
+    #--------------------
+    # *** 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) }
+    it { should validate_presence_of(:priority) }
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#order_by_priority" do
+      let!(:high_priority_job) { FactoryGirl.create(:queued_job, priority: 1) }
+      let!(:low_priority_job) { FactoryGirl.create(:queued_job, priority: 2) }
+      let!(:low_priority_job2) { FactoryGirl.create(:queued_job, priority: 2) }
+
+      it "return records in correct order" do
+        Naf::QueuedJob.order_by_priority.
+          should == [high_priority_job, low_priority_job, low_priority_job2]
+      end
+    end
+
+    describe "#exclude_run_group_names" do
+      let!(:included_job) { FactoryGirl.create(:queued_job, application_run_group_name: 'test 1') }
+      let!(:excluded_job) { FactoryGirl.create(:queued_job, application_run_group_name: 'test 2') }
+
+      it "return queued jobs not included in the run group names" do
+        Naf::QueuedJob.exclude_run_group_names(['test 2']).
+          should == [included_job]
+      end
+
+      it "return all queued jobs when run group names are not specified" do
+        Naf::QueuedJob.exclude_run_group_names([]).
+          should == [included_job, excluded_job]
+      end
+    end
+
+    describe "#runnable_by_machine" do
+      let!(:included_job) { FactoryGirl.create(:queued_job, application_run_group_name: 'test 1') }
+      let!(:excluded_job) { FactoryGirl.create(:queued_job, application_run_group_name: 'test 2') }
+
+      it "return queued jobs not included in the run group names" do
+        Naf::QueuedJob.exclude_run_group_names(['test 2']).
+          should == [included_job]
+      end
+
+      it "return all queued jobs when run group names are not specified" do
+        Naf::QueuedJob.exclude_run_group_names([]).
+          should == [included_job, excluded_job]
+      end
+    end
+
+    describe "#prerequisites_finished" do
+      let!(:prerequesite_needed_historical_job) { FactoryGirl.create(:job, finished_at: nil) }
+      let!(:prerequesite_historical_job) { FactoryGirl.create(:job) }
+      let!(:historical_job) { FactoryGirl.create(:job) }
+      let!(:prerequesite_needed_queued_job) {
+        FactoryGirl.create(:queued_job, id: prerequesite_needed_historical_job.id,
+                                        historical_job: prerequesite_needed_historical_job)
+      }
+      let!(:queued_job) {
+        FactoryGirl.create(:queued_job, id: historical_job.id,
+                                        historical_job: historical_job)
+      }
+      let!(:prerequesite) {
+        FactoryGirl.create(:historical_job_prerequesite, prerequisite_historical_job: prerequesite_historical_job,
+                                                         historical_job: prerequesite_needed_historical_job)
+      }
+
+      it "return queued jobs not included in the run group names" do
+        Naf::QueuedJob.prerequisites_finished.
+          should == [queued_job]
+      end
+    end
+
+    describe "#weight_available_on_machine" do
+      let!(:machine) { mock_model(Machine) }
+      let!(:cpu_affinity_slot) { mock_model(MachineAffinitySlot, affinity_id: 4, affinity_parameter: 5.0) }
+      let!(:memory_affinity_slot) { mock_model(MachineAffinitySlot, affinity_id: 5, affinity_parameter: 5.0) }
+      let!(:queued_job) { FactoryGirl.create(:queued_job) }
+
+      before do
+        ::Naf::RunningJob.any_instance.stub(:affinity_weights).
+          and_return(1 => 0.0, 2 => 0.0, 3 => 0.0, 4 => 1.0, 5 => 1.0)
+      end
+
+      it "return queued job when machine has cpus left" do
+        memory_affinity_slot = mock_model(MachineAffinitySlot, affinity_id: 5, affinity_parameter: 0.0)
+        machine.stub(:machine_affinity_slots).and_return([cpu_affinity_slot, memory_affinity_slot])
+        ::Naf::QueuedJob.stub(:check_weight_sum).
+          and_return([])
+
+        ::Naf::QueuedJob.weight_available_on_machine(machine).
+          should == [queued_job]
+      end
+
+      it "return queued job when machine has cpus and memory left" do
+        machine.stub(:machine_affinity_slots).and_return([cpu_affinity_slot, memory_affinity_slot])
+        ::Naf::QueuedJob.stub(:check_weight_sum).
+          and_return([])
+
+        ::Naf::QueuedJob.weight_available_on_machine(machine).
+          should == [queued_job]
+      end
+
+      it "return queued job when machine does not have cpu/memory restriction" do
+        machine.stub(:machine_affinity_slots).and_return([])
+
+        ::Naf::QueuedJob.weight_available_on_machine(machine).
+          should == [queued_job]
+      end
+    end
+
+    describe "#check_weight_sum" do
+      let!(:queued_job) { FactoryGirl.create(:queued_job) }
+      let!(:affinity) { FactoryGirl.create(:affinity, id: 4, affinity_name: 'cpus') }
+      let!(:affinity_tab) { FactoryGirl.create(:job_affinity_tab_base,
+                                               historical_job: queued_job.historical_job,
+                                               affinity_id: affinity.id,
+                                               affinity_parameter: 1)}
+      it "does not return queued job when machine has cpus left" do
+        ::Naf::QueuedJob.check_weight_sum(4, 1, 3).
+          should == []
+      end
+
+      it "does not return queued job when job does not have cpu affinity" do
+        affinity_tab.delete
+        ::Naf::QueuedJob.check_weight_sum(4, 1, 3).
+          should == []
+      end
+
+      it "return jobs when machine does not have cpus left" do
+        ::Naf::QueuedJob.check_weight_sum(4, 3, 3).
+          should == [queued_job]
+      end
+    end
+
+  end
+end

data/spec/models/naf/running_job_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+module Naf
+  describe RunningJob do
+    let!(:running_job) { FactoryGirl.create(:running_job_base) }
+
+    # Mass-assignment
+    [:application_id,
+     :application_type_id,
+     :command,
+     :application_run_group_restriction_id,
+     :application_run_group_name,
+     :application_run_group_limit,
+     :started_on_machine_id,
+     :pid,
+     :request_to_terminate,
+     :marked_dead_by_machine_id,
+     :log_level,
+     :started_at].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(:historical_job) }
+    it { should belong_to(:application) }
+    it { should belong_to(:application_type) }
+    it { should belong_to(:application_run_group_restriction) }
+    it { should belong_to(:started_on_machine) }
+    it { should belong_to(:marked_dead_by_machine) }
+
+    #--------------------
+    # *** 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) }
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#started_on" do
+      let(:machine) { mock_model(Machine) }
+      before do
+        running_job.started_on_machine = machine
+      end
+
+      it "return the correct job record" do
+        ::Naf::RunningJob.should_receive(:where).and_return([running_job])
+        ::Naf::RunningJob.started_on(machine).should == [running_job]
+      end
+    end
+
+    describe "#in_run_group" do
+      it "return the correct job record" do
+        ::Naf::RunningJob.should_receive(:where).and_return([running_job])
+        ::Naf::RunningJob.in_run_group('test').should == [running_job]
+      end
+    end
+
+    describe "#assigned_jobs" do
+      let(:machine) { mock_model(Machine) }
+
+      it "return the correct job record" do
+        ::Naf::RunningJob.stub(:started_on).and_return([running_job])
+        ::Naf::RunningJob.assigned_jobs(machine).should == [running_job]
+      end
+    end
+
+    describe "#affinity_weights" do
+      let(:machine) { FactoryGirl.create(:machine) }
+      before do
+        cpu_affinity = FactoryGirl.create(:affinity, id: 4, affinity_name: 'cpus')
+        memory_affinity = FactoryGirl.create(:affinity, id: 5, affinity_name: 'memory')
+        FactoryGirl.create(:job_affinity_tab_base, historical_job: running_job.historical_job,
+                                                   affinity: cpu_affinity,
+                                                   affinity_parameter: 1.0)
+        FactoryGirl.create(:job_affinity_tab_base, historical_job: running_job.historical_job,
+                                                   affinity: memory_affinity,
+                                                   affinity_parameter: 1.0)
+
+        running_job.started_on_machine = machine
+        running_job.save!
+      end
+
+      it "return the correct sum of affinity parameters for each affinity" do
+        ::Naf::RunningJob.affinity_weights(machine).should == { 1 => 0.0,
+                                                                2 => 0.0,
+                                                                3 => 0.0,
+                                                                4 => 1.0,
+                                                                5 => 1.0 }
+      end
+    end
+
+
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module Process::Naf
+  describe Application do
+
+
+  end
+end

data/spec/models/process/naf/janitor_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Process::Naf
+
+  describe Janitor do
+
+
+
+  end
+end

data/spec/models/process/naf/runner_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Process::Naf
+
+  describe Runner do
+
+
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] ||= "test"
+
+# What will our dummy Rails app be?
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+
+require 'rspec/rails'
+require 'rspec/autorun'
+require 'factory_girl'
+
+ENGINE_RAILS_ROOT = File.join(File.dirname(__FILE__), '../')
+
+# Require supporting files in spec/support
+Dir[File.join(ENGINE_RAILS_ROOT, "spec/support/**/*.rb")].each {|f| require f }
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.include Naf::Engine.routes.url_helpers
+  config.infer_base_class_for_anonymous_controllers = true
+  config.include EngineRouting, type: :controller
+end
+
+FactoryGirl.find_definitions
+
+# Create the DB Seed Records via Factories
+affinities = [:normal_affinity, :canary_affinity, :perennial_affinity]
+classifications = [:location_affinity_classification, :purpose_affinity_classification, :application_affinity_classification]
+restrictions = [:no_limit, :limited_per_machine, :limited_per_all_machines]
+
+(affinities + classifications + restrictions).each do |seed|
+  FactoryGirl.create(seed)
+end

data/spec/support/engine_routing.rb

@@ -0,0 +1,27 @@
+module EngineRouting
+  def get(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "GET")
+  end
+
+  # Executes a request simulating POST HTTP method and set/volley the response
+  def post(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "POST")
+  end
+
+  # Executes a request simulating PUT HTTP method and set/volley the response
+  def put(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "PUT")
+  end
+
+  # Executes a request simulating DELETE HTTP method and set/volley the response
+  def delete(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "DELETE")
+  end
+
+  private
+
+  def process_action(action, parameters = nil, session = nil, flash = nil, method = "GET")
+    parameters ||= {}
+    process(action, parameters.merge!(use_route: :naf), session, flash, method)
+  end
+end

data/spec/support/script_spec_helper.rb

@@ -0,0 +1,58 @@
+module ScriptSpecHelper
+  # Run the script defined in a spec's let(:script)
+  # It rescues from the SystemExit exception that all scripts raise
+  # once they are finished (this is how the runner is setup)
+
+  # Yield to the given block before the script is run
+  # This is useful for setup code
+  # or if script is an instance, you can write some expectations or stubs
+  # Example:
+  #
+  #   require 'spec_helper'
+  #   module Process
+  #     describe MyCoolScript do
+  #       let(:script) { Process::MyCoolScript.new }
+  #       it "should should find five downloads" do
+  #         run_script do
+  #           script.should_receive(:downloads).and_return(5)
+  #         end
+  #       end
+  #     end
+  #   end
+  def run_script(*args)
+    exit_status = 0
+    # Lets not log anything when we run tests of the scripts,
+    # especially if we are using Papertrail
+    # If any args were passed, set them to ARGV for the script to use.
+    #log_level_args = ["--log-configuration-files", "config/logging/af.yml,config/logging/test.yml"]
+    log_level_args = ["--log-configuration-files", "config/logging/test.yml"]
+
+    if args.length > 0
+      old_args = ARGV[0..-1]
+      ARGV[0..-1] = args + log_level_args
+    else
+      ARGV[0..-1] = log_level_args
+    end
+
+    begin
+      if block_given?
+        yield
+      elsif script.is_a?(Class)
+        # script is a class, use the normal run method
+        script.run
+      else
+        # script is an instance, run it the way Af runs it.
+        # https://github.com/fiksu/af/blob/master/lib/af/application.rb
+        script._run
+        script._work
+      end
+    rescue SystemExit => e
+      exit_status = e.status
+    ensure
+      # Reset ARGV if it was changed
+      ARGV[0..-1] = old_args if args.length > 0
+    end
+
+    exit_status
+  end
+end