diff --git a/app/models/host.rb b/app/models/host.rb index f4b11fd..ef789d4 100644 --- a/app/models/host.rb +++ b/app/models/host.rb @@ -1,276 +1,272 @@ # The bacula database must be independent from all of our application logic. # For this reason we have Host which is the application equivalent of a Bacula Client. # # A host is being created from our application. When it receives all the configuration # which is required it gets dispatched to bacula through some configuration files. After # that, a client with the exact same config is generated by bacula. class Host < ActiveRecord::Base STATUSES = { pending: 0, configured: 1, dispatched: 2, deployed: 3, updated: 4, redispatched: 5, for_removal: 6 } has_many :ownerships has_many :users, through: :ownerships, inverse_of: :hosts belongs_to :client, class_name: :Client, foreign_key: :name, primary_key: :name belongs_to :verifier, class_name: :User, foreign_key: :verifier_id, primary_key: :id has_many :filesets, dependent: :destroy has_many :job_templates, dependent: :destroy has_many :schedules, dependent: :destroy validates :file_retention, :job_retention, :port, :password, presence: true validates :port, numericality: true validates :fqdn, presence: true, uniqueness: true validate :fqdn_format scope :not_baculized, -> { joins("left join Client on Client.Name = hosts.name").where(Client: { Name: nil }) } scope :unverified, -> { where(verified: false) } before_validation :set_retention, :unset_baculized, :sanitize_name state_machine :status, initial: :pending do STATUSES.each do |status_name, value| state status_name, value: value end after_transition [:dispatched, :redispatched, :configured, :updated] => :deployed do |host| host.job_templates.enabled. update_all(baculized: true, baculized_at: Time.now, updated_at: Time.now) end event :add_configuration do transition [:pending, :dispatched] => :configured end event :dispatch do transition :configured => :dispatched end event :redispatch do transition :updated => :redispatched end event :set_deployed do transition [:dispatched, :redispatched, :configured, :updated] => :deployed end event :change_deployed_config do transition [:deployed, :redispatched, :for_removal] => :updated end event :mark_for_removal do transition [:dispatched, :deployed, :updated, :redispatched] => :for_removal end event :disable do transition all => :pending end end # Constructs the final Bacula configuration for the host by appending configs for # # * Client # * Jobs # * Schedules # * Filesets # # by calling their `to_bacula_config_array` methods. # # @return [Array] containing each element's configuration line by line def baculize_config - templates = job_templates.enabled.includes(:fileset, :schedule) + templates = job_templates.includes(:fileset, :schedule) result = [self] + templates.map {|x| [x, x.fileset, x.schedule] }.flatten.compact.uniq result.map(&:to_bacula_config_array) end # Constructs the final Bacula configuration for the host by appending configs for # # * Client # * Jobs # * Schedules # * Filesets # # by calling their `to_bacula_config_array` methods. # # It hides the password. # # @return [Array] containing each element's configuration line by line def baculize_config_no_pass baculize_config.join("\n").gsub(/Password = ".*"$/, 'Password = "*************"') end # Constructs an array where each element is a line for the Client's bacula config # # @return [Array] def to_bacula_config_array [ "Client {", " Name = #{name}", " Address = #{fqdn}", " FDPort = #{port}", " Catalog = #{client_settings[:catalog]}", " Password = \"#{password}\"", " File Retention = #{file_retention} #{file_retention_period_type}", " Job Retention = #{job_retention} #{job_retention_period_type}", " AutoPrune = #{auto_prune_human}", "}" ] end # Shows the host's auto_prune setting def auto_prune_human client_settings[:autoprune] end # Uploads the host's config to bacula # Reloads bacula server # # It updates the host's status accordingly def dispatch_to_bacula return false if not needs_dispatch? bacula_handler.deploy_config end # Removes a Host from bacula configuration. # Reloads bacula server # # If all go well it changes the host's status and returns true def remove_from_bacula return false unless needs_revoke? bacula_handler.undeploy_config end # Restores a host's backup to a preselected location # # @param location[String] the desired restore location def restore(location) return false if not restorable? bacula_handler.restore(location) end # Runs the given backup job ASAP def backup_now(job_name) bacula_handler.backup_now(job_name) end # Determinex weather a host: # # * has all it takes to be deployed but # * the config is not yet sent to bacula # # @return [Boolean] def needs_dispatch? verified? && (can_dispatch? || can_redispatch?) end # Determines weather a host is marked for removal # # @return [Boolean] def needs_revoke? for_removal? end # Handles the host's job changes by updating the host's status def recalculate - if job_templates(true).enabled.any? - add_configuration || change_deployed_config - else - mark_for_removal || disable - end + add_configuration || change_deployed_config end # Fetches an info message concerning the host's deploy status def display_message if !verified? { message: 'Your host needs to be verified by an admin', severity: :alert } elsif pending? { message: 'client not configured yet', severity: :alert } elsif configured? || dispatched? { message: 'client not deployed to Bacula', severity: :alert } elsif updated? || redispatched? { message: 'client configuration changed, deploy needed', severity: :alert } elsif for_removal? { message: 'pending client configuration withdraw', severity: :error } elsif inactive? { message: 'client disabled', severity: :alert } end end # Determines if a host can issue a restore job. # # @returns [Boolean] true if the host's client can issue a restore job def restorable? client.present? && client.is_backed_up? end # @return [User] the first of the host's users def first_user users.order('ownerships.created_at asc').first end # Marks the host as verified and sets the relevant metadata # # @param admin_verifier[Integer] the verifier's id def verify(admin_verifier) self.verified = true self.verifier_id = admin_verifier self.verified_at = Time.now save end private # automatic setters def sanitize_name self.name = fqdn end # Sets the file and job retention according to the global settings def set_retention self.file_retention = client_settings[:file_retention] self.file_retention_period_type = client_settings[:file_retention_period_type] self.job_retention = client_settings[:job_retention] self.job_retention_period_type = client_settings[:job_retention_period_type] end def unset_baculized self.baculized = false if new_record? true end # validation def fqdn_format regex = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{1,63}(? { where(enabled: true) } # Constructs an array where each element is a line for the Job's bacula config # # @return [Array] def to_bacula_config_array ['Job {'] + options_array.map { |x| " #{x}" } + job_settings.map { |k,v| " #{k.capitalize} = #{v}" } + ['}'] end # Fetches the Job's priority def priority job_settings[:priority] end # Helper method for the job template's enabled status def enabled_human enabled? ? 'yes' : 'no' end # Helper method for the job template's schedule name # # @return [String] The schedule's name or nothing def schedule_human schedule.present? ? schedule.name : '-' end # Generates a name that will be used for the configuration file. # It is the name that will be sent to Bacula through the configuration # files. # # @return [String] def name_for_config "#{host.name} #{name}" end # Sends a hot backup request to Bacula via BaculaHandler def backup_now return false if not (enabled? && baculized? && backup?) host.backup_now(name) end private def name_format unless name =~ /^[a-zA-Z0-1\.-_ ]+$/ self.errors.add(:name, :format) end end def notify_host host.recalculate end # Sets the default job_type as backup def set_job_type self.job_type = :backup if job_type.nil? end def options_array result = [ "Name = \"#{name_for_config}\"", + "Enabled = #{enabled_human}", "FileSet = \"#{fileset.name_for_config}\"", "Client = \"#{host.name}\"", "Type = \"#{job_type.capitalize}\"", "Schedule = \"#{schedule.name_for_config}\"" ] if client_before_run_file.present? result += ["Client Run Before Job = \"#{client_before_run_file}\""] end if client_after_run_file.present? result += ["Client Run After Job = \"#{client_after_run_file}\""] end result end # Fetches and memoizes the general configuration settings for Jobs # # @see ConfigurationSetting.current_job_settings # @return [Hash] containing the settings def job_settings @job_settings ||= ConfigurationSetting.current_job_settings end end diff --git a/lib/bacula_handler.rb b/lib/bacula_handler.rb index a17e5d7..34778d3 100644 --- a/lib/bacula_handler.rb +++ b/lib/bacula_handler.rb @@ -1,184 +1,184 @@ class BaculaHandler require 'net/scp' attr_accessor :host, :templates, :client, :jobs, :schedules, :filesets # Initializes a BaculaHandler instance. # # Sets `host` and `templates` attributes. # Sets the temporal files that contain the client's configuration # # @param host[Host] A the host instance the the bacula handler will act upon def initialize(host) @host = host - @templates = host.job_templates.enabled.includes(:fileset, :schedule) + @templates = host.job_templates.includes(:fileset, :schedule) @client = get_client_file @jobs = get_jobs_file @schedules = get_schedules_file @filesets = get_filesets_file end # Deploys the host's config to the bacula director by # # * uploading the configuration # * reloadind the bacula director # # Updates the host's status accordingly # # @return [Boolean] false if something went wrong def deploy_config return false unless send_config if reload_bacula host.set_deployed else host.dispatch || host.redispatch end end # Removes the host's configuration from the bacula director by # # * removing the host's configuration files # * reloading the bacula director # # Updates the host's status accordingly # # @return [Boolean] false if something went wrong def undeploy_config return false unless remove_config host.disable if reload_bacula end # Schedules an immediate backup to the bacula director for the given host and job # # @param job_name[String] the job's name def backup_now(job_name) job = host.job_templates.enabled.find_by(name: job_name) return false unless job command = "echo \"run job=\\\"#{job.name_for_config}\\\" yes\" | #{bconsole}" log(command) exec_with_timeout(command, 2) end # Schedules an immediate restore to the bacula director for the given host. # # @param location[String] the desired restore location def restore(location="/tmp/bacula-restore") command = "echo \"restore client=\\\"#{host.name}\\\" where=\\\"#{location}\\\" select current all done yes\" | #{bconsole}" log(command) exec_with_timeout(command, 2) end private def get_client_file file = a_tmpfile file.write host.to_bacula_config_array.join("\n") file.close file end def get_jobs_file file = a_tmpfile file.write templates.map(&:to_bacula_config_array).join("\n") file.close file end def get_schedules_file file = a_tmpfile file.write templates.map(&:schedule).uniq.map(&:to_bacula_config_array).join("\n") file.close file end def get_filesets_file file = a_tmpfile file.write templates.map(&:fileset).uniq.map(&:to_bacula_config_array).join("\n") file.close file end def send_config begin Net::SCP.upload!( ssh_settings[:host], ssh_settings[:username], client.path, ssh_settings[:path] + 'clients/' + host.name + '.conf', ssh: { keys: [ssh_settings[:key_file]] } ) Net::SCP.upload!( ssh_settings[:host], ssh_settings[:username], jobs.path, ssh_settings[:path] + 'jobs/' + host.name + '.conf', ssh: { keys: [ssh_settings[:key_file]] } ) Net::SCP.upload!( ssh_settings[:host], ssh_settings[:username], schedules.path, ssh_settings[:path] + 'schedules/' + host.name + '.conf', ssh: { keys: [ssh_settings[:key_file]] } ) Net::SCP.upload!( ssh_settings[:host], ssh_settings[:username], filesets.path, ssh_settings[:path] + 'filesets/' + host.name + '.conf', ssh: { keys: [ssh_settings[:key_file]] } ) rescue return false end true end def remove_config begin Net::SSH.start(ssh_settings[:host], ssh_settings[:username], keys: ssh_settings[:key_file]) do |ssh| ssh.exec!("rm #{ssh_settings[:path]}*/#{host.name}.conf") end rescue return false end true end def reload_bacula command = "echo \"reload quit\" | #{bconsole}" exec_with_timeout(command, 2) end def exec_with_timeout(command, sec) begin Timeout::timeout(sec) do `#{command}` end rescue return false end true end def bconsole "bconsole -c #{Rails.root}/config/bconsole.conf" end def ssh_settings @ssh_settings ||= YAML::load(File.open("#{Rails.root}/config/ssh.yml"))[Rails.env]. symbolize_keys end def a_tmpfile file = Tempfile.new(host.name) file.chmod(0666) file end def log(msg) Rails.logger.warn("[BaculaHandler]: #{msg}") end end diff --git a/spec/models/host_spec.rb b/spec/models/host_spec.rb index 96ca938..154928d 100644 --- a/spec/models/host_spec.rb +++ b/spec/models/host_spec.rb @@ -1,314 +1,288 @@ require 'spec_helper' describe Host do context 'validates' do it "presence of Password" do expect(Host.new).to have(1).errors_on(:password) end it 'numericality of :port' do expect(Host.new(port: :lala)).to have(2).errors_on(:port) end [:file_retention, :job_retention, :name].each do |field| it "#{field} is set automatically" do host = Host.new(fqdn: 'test') host.valid? expect(host.send(field)).to be_present end end end context 'when fqdn is invalid' do let(:host) { FactoryGirl.build(:host, fqdn: :lala) } it 'has errors' do expect(host).to have(1).errors_on(:fqdn) end end context 'name field' do let(:host) { FactoryGirl.create(:host, name: nil) } it 'is generated by the system' do expect(host.name).to be end end describe '#to_bacula_config_array' do let(:host) { FactoryGirl.create(:host) } it "is a valid client directive" do expect(host.to_bacula_config_array).to include('Client {') expect(host.to_bacula_config_array).to include('}') end it "contains Address directive" do expect(host.to_bacula_config_array).to include(" Address = #{host.fqdn}") end it "contains FDPort directive" do expect(host.to_bacula_config_array).to include(" FDPort = #{host.port}") end it "contains Catalog directive" do expect(host.to_bacula_config_array). to include(" Catalog = #{ConfigurationSetting.current_client_settings[:catalog]}") end it "contains Password directive" do expect(host.to_bacula_config_array).to include(" Password = \"#{host.password}\"") end it "contains File Retention directive" do expect(host.to_bacula_config_array). to include(" File Retention = #{host.file_retention} days") end it "contains Job Retention directive" do expect(host.to_bacula_config_array). to include(" Job Retention = #{host.job_retention} days") end it "contains AutoPrune directive" do expect(host.to_bacula_config_array).to include(" AutoPrune = yes") end end describe '#baculize_config' do let!(:host) { FactoryGirl.create(:host) } let!(:fileset) { FactoryGirl.create(:fileset, host: host) } let!(:other_fileset) { FactoryGirl.create(:fileset, host: host) } let!(:schedule) { FactoryGirl.create(:schedule) } let!(:other_schedule) { FactoryGirl.create(:schedule) } let!(:enabled_job) do FactoryGirl.create(:job_template, host: host, schedule: schedule, fileset: fileset, enabled: true) end let!(:disabled_job) do FactoryGirl.create(:job_template, host: host, schedule: other_schedule, fileset: other_fileset, enabled: false) end subject { host.baculize_config } it 'includes the client\'s config' do expect(subject).to include(host.to_bacula_config_array) end - it 'includes the enabled job template\'s configs' do + it 'includes the all the job template\'s configs' do expect(subject).to include(enabled_job.to_bacula_config_array) - expect(subject).to_not include(disabled_job.to_bacula_config_array) + expect(subject).to include(disabled_job.to_bacula_config_array) end - it 'includes the used schedules\'s configs' do + it 'includes all the used schedules\'s configs' do expect(subject).to include(schedule.to_bacula_config_array) - expect(subject).to_not include(other_schedule.to_bacula_config_array) + expect(subject).to include(other_schedule.to_bacula_config_array) end - it 'includes the used filesets\'s configs' do + it 'includes all the used filesets\'s configs' do expect(subject).to include(fileset.to_bacula_config_array) - expect(subject).to_not include(other_fileset.to_bacula_config_array) + expect(subject).to include(other_fileset.to_bacula_config_array) end end describe '#dispatch_to_bacula' do let(:configured_host) { FactoryGirl.create(:host, :configured) } let(:updated_host) { FactoryGirl.create(:host, :updated) } context 'for non verified hosts' do let(:unverified_host) { FactoryGirl.create(:host, :configured) } it 'returns false' do expect(unverified_host.dispatch_to_bacula).to eq(false) end end it 'calls BaculaHandler#deploy_config' do BaculaHandler.any_instance.should_receive(:deploy_config) configured_host.dispatch_to_bacula end context 'when the config does not reach bacula' do before do BaculaHandler.any_instance.should_receive(:send_config) { false } end it 'returns false' do expect(configured_host.dispatch_to_bacula).to eq(false) end it 'does not change the status of a configured host' do expect { configured_host.dispatch_to_bacula }. to_not change { configured_host.reload.status } end it 'does not change the status of an updated host' do expect { updated_host.dispatch_to_bacula }. to_not change { updated_host.reload.status } end end context 'when the config is sent to bacula' do before do BaculaHandler.any_instance.should_receive(:send_config) { true } end context 'and bacula gets reloaded' do before do BaculaHandler.any_instance.should_receive(:reload_bacula) { true } end it 'makes the configured host deployed' do configured_host.dispatch_to_bacula expect(configured_host.reload).to be_deployed end it 'makes the updated host deployed' do updated_host.dispatch_to_bacula expect(updated_host.reload).to be_deployed end end context 'but bacula fails to reload' do before do BaculaHandler.any_instance.should_receive(:reload_bacula) { false } end it 'makes the configured host dispatcheda' do configured_host.dispatch_to_bacula expect(configured_host.reload).to be_dispatched end it 'makes the updated host redispatched' do updated_host.dispatch_to_bacula expect(updated_host.reload).to be_redispatched end end end end describe '#remove_from_bacula' do let(:host) { FactoryGirl.create(:host, status: Host::STATUSES[:for_removal]) } context 'when the config is NOT removed from bacula' do before { BaculaHandler.any_instance.should_receive(:remove_config) { false } } it 'returns false' do expect(host.remove_from_bacula).to eq(false) end it 'does not alter the host\'s status' do expect { host.remove_from_bacula }. to_not change { host.reload.status } end end context 'when the config is removed from bacula' do before { BaculaHandler.any_instance.should_receive(:remove_config) { true } } context 'and bacula gets reloaded' do before { BaculaHandler.any_instance.should_receive(:reload_bacula) { true } } it 'returns true' do expect(host.remove_from_bacula).to eq(true) end it 'changes the host\'s status to pending' do expect { host.remove_from_bacula }. to change { host.reload.human_status_name }.from('for removal').to('pending') end end end end describe '#recalculate' do - context 'when the host does NOT have enabled jobs' do - let(:host) { FactoryGirl.create(:host, :with_disabled_jobs) } + let(:host) { FactoryGirl.create(:host, :with_enabled_jobs) } - context 'and is configured' do - before { host.update_column(:status, Host::STATUSES[:configured]) } + [:configured, :updated].each do |status| + context "a #{status} host" do + before { host.update_column(:status, Host::STATUSES[status]) } - it 'becomes pending' do - expect { host.recalculate }. - to change { host.reload.human_status_name }.from('configured').to('pending') - end - end - - [:dispatched, :deployed, :updated, :redispatched].each do |status| - context "and is #{status}" do - before { host.update_column(:status, Host::STATUSES[status]) } - - it 'becomes for_removal' do - expect { host.recalculate }. - to change { host.reload.human_status_name }.from(status.to_s).to('for removal') - end + it "stays #{status}" do + expect { host.recalculate }.to_not change { host.reload.status } end end end - context 'when host has enabled jobs' do - let(:host) { FactoryGirl.create(:host, :with_enabled_jobs) } - - [:configured, :updated].each do |status| - context "a #{status} host" do - before { host.update_column(:status, Host::STATUSES[status]) } + context 'a pending host' do + before { host.update_column(:status, Host::STATUSES[:pending]) } - it "stays #{status}" do - expect { host.recalculate }.to_not change { host.reload.status } - end - end + it 'becomes configured' do + expect { host.recalculate }. + to change { host.reload.human_status_name }. + from('pending').to('configured') end + end - context 'a pending host' do - before { host.update_column(:status, Host::STATUSES[:pending]) } + context 'a dispatched host' do + before { host.update_column(:status, Host::STATUSES[:dispatched]) } - it 'becomes configured' do - expect { host.recalculate }. - to change { host.reload.human_status_name }. - from('pending').to('configured') - end + it 'becomes configured' do + expect { host.recalculate }. + to change { host.reload.human_status_name }. + from('dispatched').to('configured') end + end - context 'a dispatched host' do - before { host.update_column(:status, Host::STATUSES[:dispatched]) } + [:deployed, :redispatched, :for_removal].each do |status| + context "a #{status} host" do + before { host.update_column(:status, Host::STATUSES[status]) } - it 'becomes configured' do + it 'becomes updated' do expect { host.recalculate }. to change { host.reload.human_status_name }. - from('dispatched').to('configured') - end - end - - [:deployed, :redispatched, :for_removal].each do |status| - context "a #{status} host" do - before { host.update_column(:status, Host::STATUSES[status]) } - - it 'becomes updated' do - expect { host.recalculate }. - to change { host.reload.human_status_name }. - from(host.human_status_name).to('updated') - end + from(host.human_status_name).to('updated') end end end end describe '#verify' do let!(:host) { FactoryGirl.create(:host, verified: false) } let(:admin) { FactoryGirl.create(:user, :admin) } it 'verifies host' do host.verify(admin.id) expect(host).to be_verified end it 'sets the verification credentials' do host.verify(admin.id) expect(host.verifier_id).to eq(admin.id) expect(host.verified_at).not_to be nil end end end diff --git a/spec/models/job_template_spec.rb b/spec/models/job_template_spec.rb index c11c746..d2243ea 100644 --- a/spec/models/job_template_spec.rb +++ b/spec/models/job_template_spec.rb @@ -1,154 +1,158 @@ require 'spec_helper' describe JobTemplate do context 'validates' do it 'name must be present' do expect(JobTemplate.new).to have(2).errors_on(:name) end it 'name must be unique on host\'s scope' do job_1 = FactoryGirl.create(:job_template, name: 'a name') job_2 = FactoryGirl.build(:job_template, name: 'a name') job_3 = FactoryGirl.build(:job_template, name: 'a name', host: job_1.host) expect(job_2).to be_valid expect(job_3).to_not be_valid end it 'fileset_id must be present' do expect(JobTemplate.new).to have(1).errors_on(:fileset_id) end it 'schedule_id must be present' do expect(JobTemplate.new).to have(1).errors_on(:schedule_id) end it 'schedule_id must NOT be present for :restore jobs' do expect(JobTemplate.new(job_type: :restore)).to have(0).errors_on(:schedule_id) end end # automatic assignments context 'when no job_type is given' do let(:job_template) { FactoryGirl.create(:job_template) } it 'sets the job_type to :backup' do expect(job_template).to be_backup end end context 'when enabling a job' do [:pending, :dispatched].each do |status| context "of a #{status} host" do let(:host) { FactoryGirl.create(:host) } let!(:job) { FactoryGirl.create(:job_template, host: host) } before { host.update_column(:status, Host::STATUSES[status]) } it 'becomes configured' do expect { job.enabled = true job.save }.to change { host.reload.human_status_name }.from(status.to_s).to('configured') end end end context 'of a configured host' do let(:host) { FactoryGirl.create(:host) } let!(:job) { FactoryGirl.create(:job_template, host: host) } before { host.update_column(:status, Host::STATUSES[:configured]) } it 'stays configured' do expect { job.enabled = true job.save }.to_not change { host.reload.human_status_name } end end context 'of a updated host' do let(:host) { FactoryGirl.create(:host) } let!(:job) { FactoryGirl.create(:job_template, host: host) } before { host.update_column(:status, Host::STATUSES[:updated]) } it 'stays updated' do expect { job.enabled = true job.save }.to_not change { host.reload.human_status_name } end end [:deployed, :redispatched].each do |status| context "of a #{status} host" do let(:host) { FactoryGirl.create(:host) } let!(:job) { FactoryGirl.create(:job_template, host: host) } before { host.update_column(:status, Host::STATUSES[status]) } it 'becomes updated' do expect { job.enabled = true job.save }.to change { host.reload.human_status_name }.from(status.to_s).to('updated') end end end end describe '#to_bacula_config_array' do let(:job_template) do FactoryGirl.create(:job_template, client_before_run_file: 'test', client_after_run_file: 'test2') end subject { job_template.to_bacula_config_array } it 'has a Job structure' do expect(subject.first).to eq('Job {') expect(subject.last).to eq('}') end ConfigurationSetting.current_job_settings.each do |k, v| it "assigns #{k.capitalize} param" do expect(subject).to include(" #{k.capitalize} = #{v}") end end + it 'assigns Enabled param' do + expect(subject).to include(" Enabled = #{job_template.enabled_human}") + end + it 'assigns Name param prefixed with the host\'s name' do expect(subject).to include(" Name = \"#{job_template.name_for_config}\"") end it 'assigns FileSet param' do expect(subject).to include(" FileSet = \"#{job_template.fileset.name_for_config}\"") end it 'assigns Client param' do expect(subject).to include(" Client = \"#{job_template.host.name}\"") end it 'assigns Type param' do expect(subject).to include(" Type = \"#{job_template.job_type.capitalize}\"") end it 'assigns Schedule param' do expect(subject).to include(" Schedule = \"#{job_template.schedule.name_for_config}\"") end it 'assigns Client Run After Job param' do expect(subject).to include(" Client Run After Job = \"#{job_template.client_after_run_file}\"") end it 'assigns Client Run After Job param' do expect(subject).to include(" Client Run Before Job = \"#{job_template.client_before_run_file}\"") end end end