naf 1.1.0

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module Logical
+  module Naf
+
+    describe Machine do
+      let(:physical_machine) { FactoryGirl.create(:machine)  }
+      let(:physical_machine_two) { FactoryGirl.create(:machine_two) }
+      let(:columns) { [:id,
+                       :server_name,
+                       :server_address,
+                       :server_note,
+                       :enabled,
+                       :process_pool_size,
+                       :last_checked_schedules_at,
+                       :last_seen_alive_at,
+                       :log_level,
+                       :affinities,
+                       :marked_down] }
+
+      it "to_hash should return with the specified columns" do
+        logical_machine = Machine.new(physical_machine)
+        logical_machine.to_hash.keys.should eql(columns)
+      end
+
+      it "should alias the thread_pool_size method, as process_pool_size" do
+        logical_machine = Machine.new(physical_machine)
+        logical_machine.should_receive(:thread_pool_size).and_return(5)
+        logical_machine.process_pool_size
+      end
+
+      it "should render last_checked_schedules_at nicely" do
+        physical_machine.mark_checked_schedule
+        logical_machine = Machine.new(physical_machine)
+        logical_machine.should_receive(:time_ago_in_words).and_return("")
+        logical_machine.last_checked_schedules_at.split(',').first.should =~ /ago$/
+      end
+
+      it "should render last_seen_alive_at nicely" do
+        physical_machine.mark_alive
+        logical_machine = Machine.new(physical_machine)
+        logical_machine.should_receive(:time_ago_in_words).and_return("")
+        logical_machine.last_seen_alive_at.split(',').first.should =~ /ago$/
+      end
+
+      context "Class Methods," do
+        it "all should return an array of logical wrappers around machines" do
+          machine = physical_machine
+          machine_two = physical_machine_two
+
+          logical_machine = Machine.new(machine)
+          Machine.all.map(&:id).should include(machine.id)
+          Machine.all.map(&:id).should include(machine_two.id)
+          Machine.all.should be_a(Array)
+          Machine.all.should have(2).items
+        end
+      end
+    end
+
+  end
+end

data/spec/models/naf/affinity_classification_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Naf
+  describe AffinityClassification do
+    # Mass-assignment
+    [:affinity_classification_name].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 have_many(:affinities) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:affinity_classification_name) }
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#purpose" do
+      let!(:purpose_affinity_classification) { FactoryGirl.create(:purpose_affinity_classification) }
+
+      it "return the purpose affinity classification" do
+        ::Naf::AffinityClassification.purpose.should == purpose_affinity_classification
+      end
+    end
+
+    describe "#location" do
+      let!(:location_affinity_classification) { FactoryGirl.create(:location_affinity_classification) }
+
+      it "return the location affinity classification" do
+        ::Naf::AffinityClassification.location.should == location_affinity_classification
+      end
+    end
+
+    describe "#application" do
+      let!(:application_affinity_classification) { FactoryGirl.create(:application_affinity_classification) }
+
+      it "return the application affinity classification" do
+        ::Naf::AffinityClassification.application.should == application_affinity_classification
+      end
+    end
+
+  end
+end

data/spec/models/naf/affinity_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module Naf
+  describe Affinity do
+    let!(:normal) { FactoryGirl.create(:normal_affinity) }
+    let(:canary) { FactoryGirl.create(:canary_affinity) }
+    let(:perennial) { FactoryGirl.create(:perennial_affinity) }
+
+    # Mass-assignment
+    [:affinity_classification_id,
+     :affinity_name,
+     :selectable,
+     :affinity_short_name,
+     :affinity_note].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(:affinity_classification) }
+    it { should have_many(:application_schedule_affinity_tabs) }
+    it { should have_many(:machine_affinity_slots) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:affinity_classification_id) }
+    it { should validate_presence_of(:affinity_name) }
+    it { should validate_uniqueness_of(:affinity_short_name) }
+
+    ['', 'aa', 'aA', 'Aa', 'AA', '_a', 'a1', 'A1', '_9'].each do |v|
+      it { should allow_value(v).for(:affinity_short_name) }
+    end
+
+    ['1_', '3A', '9a'].each do |v|
+      it { should_not allow_value(v).for(:affinity_short_name) }
+    end
+
+    context "keeps with the starting seed rows for the table" do
+      it "for normal" do
+        normal.id.should == 1
+      end
+
+      it "for canary" do
+        canary.id.should == 2
+      end
+
+      it "for perennial" do
+        perennial.id.should == 3
+      end
+    end
+
+    context "with regard to creation" do
+      let(:invalid_affinity) { FactoryGirl.build(:affinity, affinity_name: "") }
+
+      it "it should not be valid with an empty name" do
+        invalid_affinity.save.should_not be_true
+        invalid_affinity.should have(2).errors_on(:affinity_name)
+      end
+    end
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    context "with regard to delegation" do
+      let(:classification) { normal.affinity_classification }
+
+      it "should delegate the affinity_classfication_name method" do
+        classification.should_receive(:affinity_classification_name)
+        normal.affinity_classification_name
+      end
+    end
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#selectable" do
+      before do
+        canary.update_attributes!(selectable: false)
+        perennial.update_attributes!(selectable: false)
+      end
+
+      it "return only selectable affinities" do
+        ::Naf::Affinity.selectable.should == [normal]
+      end
+    end
+
+  end
+end

data/spec/models/naf/application_run_group_restriction_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Naf
+  describe ApplicationRunGroupRestriction do
+    # Mass-assignment
+    [:application_run_group_restriction_name].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 have_many(:application_schedules) }
+    it { should have_many(:historical_jobs) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:application_run_group_restriction_name) }
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#no_limit" do
+      let!(:no_limit) { FactoryGirl.create(:no_limit) }
+
+      it "return the no limit group restriction" do
+        ::Naf::ApplicationRunGroupRestriction.no_limit.should == no_limit
+      end
+    end
+
+    describe "#limited_per_machine" do
+      let!(:limited_per_machine) { FactoryGirl.create(:limited_per_machine) }
+
+      it "return the limited per machine group restriction" do
+        ::Naf::ApplicationRunGroupRestriction.limited_per_machine.should == limited_per_machine
+      end
+    end
+
+    describe "#limited_per_all_machines" do
+      let!(:limited_per_all_machines) { FactoryGirl.create(:limited_per_all_machines) }
+
+      it "return the limited per all machines group restriction" do
+        ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines.should == limited_per_all_machines
+      end
+    end
+
+  end
+end

data/spec/models/naf/application_schedule_affinity_tab_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module Naf
+  describe ApplicationScheduleAffinityTab do
+    let!(:tab) { FactoryGirl.create(:normal_app_schedule_affinity_tab) }
+
+    # Mass-assignment
+    [:application_schedule_id,
+     :affinity_id,
+     :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(:application_schedule) }
+    it { should belong_to(:affinity) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:application_schedule_id) }
+    it { should validate_presence_of(:affinity_id) }
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    context "with regard to delegation" do
+      context "to affinity" do
+        let!(:affinity) { tab.affinity }
+
+        it "should delegate affinity name" do
+          affinity.should_receive(:affinity_name)
+          tab.affinity_name
+        end
+
+        it "should delegate affinity_classification_name" do
+          affinity.should_receive(:affinity_classification_name)
+          tab.affinity_classification_name
+        end
+      end
+
+      context "to application schedule" do
+        let(:schedule) { tab.application_schedule }
+
+        it "should call the title method" do
+          schedule.should_receive(:title)
+          tab.script_title
+        end
+      end
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    describe "#script_title" do
+      it "return the application schedule title" do
+        tab.application_schedule.application.title = 'App Schedule 1'
+        tab.script_title.should == 'App Schedule 1'
+      end
+    end
+
+    describe "#application" do
+      it "return the application when present" do
+        tab.application.should == tab.application_schedule.application
+      end
+
+      it "return nil when application not present" do
+        tab.application_schedule.application = nil
+        tab.application.should == nil
+      end
+    end
+
+  end
+end

data/spec/models/naf/application_schedule_prerequisite_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Naf
+  describe ApplicationSchedulePrerequisite do
+    # Mass-assignment
+    [:application_schedule_id,
+     :prerequisite_application_schedule_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(:application_schedule) }
+    it { should belong_to(:prerequisite_application_schedule) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:prerequisite_application_schedule_id) }
+
+    describe "uniqueness"do
+      subject { FactoryGirl.create(:schedule_prerequisite) }
+      it { should validate_uniqueness_of(:application_schedule_id).scoped_to(:prerequisite_application_schedule_id) }
+    end
+
+  end
+end

data/spec/models/naf/application_schedule_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+module Naf
+  describe ApplicationSchedule do
+    let!(:schedule) { FactoryGirl.create(:schedule) }
+
+    # Mass-assignment
+    [:application_id,
+     :application_run_group_restriction_id,
+     :application_run_group_name,
+     :run_interval,
+     :priority,
+     :visible,
+     :enabled,
+     :run_start_minute,
+     :application_run_group_limit,
+     :application_schedule_prerequisites_attributes,
+     :enqueue_backlogs].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) }
+    it { should belong_to(:application_run_group_restriction) }
+    it { should have_many(:application_schedule_affinity_tabs) }
+    it { should have_many(:affinities) }
+    it { should have_many(:application_schedule_prerequisites) }
+    it { should have_many(:prerequisites) }
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    it { should validate_presence_of(:application_run_group_restriction_id) }
+
+    [-2147483647, 2147483646, 0].each do |v|
+      it { should allow_value(v).for(:priority) }
+    end
+
+    [-2147483648, 2147483647, 1.0, nil].each do |v|
+      it { should_not allow_value(v).for(:priority) }
+    end
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    context "with regards to delegation" do
+      it "should delegate the title method" do
+        schedule.application.should_receive(:title)
+        schedule.title
+      end
+
+      it "should delegate the application_run_group_restriction_name method" do
+        schedule.application_run_group_restriction.
+          should_receive(:application_run_group_restriction_name)
+        schedule.application_run_group_restriction_name
+      end
+    end
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    describe "#exact_schedules" do
+      it "return schedule when run_start_minute is set" do
+        schedule.update_attributes!(run_start_minute: 1, run_interval: nil)
+        ::Naf::ApplicationSchedule.exact_schedules.should == [schedule]
+      end
+
+      it "return no schedules when run_start_minute is not set" do
+        schedule.update_attributes!(run_start_minute: nil, run_interval: nil)
+        ::Naf::ApplicationSchedule.exact_schedules.should == []
+      end
+    end
+
+    describe "#relative_schedules" do
+      it "return schedule when run_interval is set" do
+        schedule.update_attributes!(run_interval: 60)
+        ::Naf::ApplicationSchedule.relative_schedules.should == [schedule]
+      end
+
+      it "return no schedules when run_interval is not set" do
+        schedule.update_attributes!(run_interval: nil)
+        ::Naf::ApplicationSchedule.relative_schedules.should == []
+      end
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    describe "#to_s" do
+      before do
+        schedule.application.title = 'App1'
+        schedule.save!
+      end
+
+      it "return correct parsing of app" do
+        schedule.to_s.should == "::Naf::ApplicationSchedule<ENABLED, id: #{schedule.id}, " +
+          "\"App1\", start every: 1 minutes>"
+      end
+    end
+
+    describe "#visible_enabled_check" do
+      let(:error_messages) { {
+        visible: ['must be true, or set enabled to false'],
+        enabled: ['must be false, if visible is set to false']
+      } }
+
+      before do
+        schedule.visible = false
+        schedule.visible_enabled_check
+      end
+
+      it "add errors to schedule" do
+        schedule.errors.messages.should == error_messages
+      end
+    end
+
+    describe "#enabled_application_id_unique" do
+      let(:error_message) { {
+        application_id: ['is enabled and has already been taken']
+      } }
+
+      it "return nil if enabled is false" do
+        schedule.enabled = false
+        schedule.enabled_application_id_unique.should == nil
+      end
+
+      it "return nil if enabled is false" do
+        schedule2 = FactoryGirl.create(:schedule)
+        schedule2.application_id = schedule.application_id
+        schedule2.enabled_application_id_unique
+
+        schedule2.errors.messages.should == error_message
+      end
+    end
+
+    describe "#run_interval_at_time_check" do
+      let(:error_messages) { {
+        run_interval: ['or Run start minute must be nil'],
+        run_start_minute: ['or Run interval must be nil']
+      } }
+
+      before do
+        schedule.run_start_minute = 1
+        schedule.run_interval_at_time_check
+      end
+
+      it "add errors to schedule" do
+        schedule.errors.messages.should == error_messages
+      end
+    end
+
+  end
+end