guard-bosh 0.1.0

data/spec/guard/bosh/job_default_properties_loader_spec.rb

@@ -0,0 +1,69 @@
+require 'guard/bosh/job_default_properties_loader'
+
+require 'pathname'
+require 'yaml'
+
+describe Guard::Bosh::JobDefaultPropertiesLoader do
+  let(:release_dir) { Pathname.new('/path/to/a/release') }
+  let(:job_spec_excerpt) do
+    {
+      'properties' =>
+      {
+        'redis.port' => {
+          'description' => 'Port to listen for requests to redis server',
+          'default' => 6379
+        },
+        'redis.password' => {
+          'description' => 'Password to access redis server',
+          'default' => 'password'
+        },
+        'redis.master' => {
+          'description' => 'IP address or hostname of the Redis master node'
+        },
+        'redis.compression.rdb' => {
+          'description' => 'Compress when dumping databases?',
+          'default' => true
+        },
+        'redis.blazingly.fast' => {
+          'description' => 'Empty hash should be created for parent key'
+        }
+      }
+    }
+  end
+  subject do
+    Guard::Bosh::JobDefaultPropertiesLoader.new(
+      release_dir: release_dir
+    )
+  end
+
+  it 'returns the properties that have defaults in the job spec' do
+    expect(YAML).to receive(:load_file).with(
+      Pathname.new('/path/to/a/release/jobs/job-name/spec')).and_return(job_spec_excerpt)
+    job_defaults = subject.load_properties(job_name: 'job-name')
+    expect(job_defaults).to include(
+      'redis' => {
+        'blazingly' => {},
+        'port' => 6379,
+        'password' => 'password',
+        'compression' => {
+          'rdb' => true
+        }
+      }
+    )
+  end
+
+  it 'ignores properties that do not have defaults defined' do
+    expect(YAML).to receive(:load_file).with(
+      Pathname.new('/path/to/a/release/jobs/job-name/spec')).and_return(job_spec_excerpt)
+    job_defaults = subject.load_properties(job_name: 'job-name')
+    expect(job_defaults['redis'].keys).not_to include('master')
+  end
+
+  it 'includes an empty hash for intermediate keys' do
+    expect(YAML).to receive(:load_file).with(
+      Pathname.new('/path/to/a/release/jobs/job-name/spec')).and_return(job_spec_excerpt)
+    job_defaults = subject.load_properties(job_name: 'job-name')
+    expect(job_defaults['redis'].keys).to include('blazingly')
+    expect(job_defaults['redis']['blazingly']).to be_empty
+  end
+end

data/spec/guard/bosh/job_properties_loader_spec.rb

@@ -0,0 +1,50 @@
+require 'guard/bosh/job_properties_loader'
+
+describe Guard::Bosh::JobPropertiesLoader do
+  let(:deployment_manifest) do
+    {
+      'jobs' => [
+        {
+          'instances' => 1,
+          'name' => 'redis_leader_z1',
+          'networks' => [{ 'name' => 'redis1', 'static_ips' => ['10.244.2.6'] }],
+          'persistent_disk' => 0,
+          'properties' => { 'network' => 'redis1', 'redis' => nil },
+          'resource_pool' => 'small_z1',
+          'templates' => [{ 'name' => 'redis', 'release' => 'redis' }]
+        },
+        {
+          'instances' => 2,
+          'name' => 'redis_z1',
+          'networks' => [{ 'name' => 'redis1', 'static_ips' => ['10.244.2.10', '10.244.2.14'] }],
+          'persistent_disk' => 0,
+          'properties' => { 'network' => 'redis1', 'redis' => { 'master' => '10.244.2.6' } },
+          'resource_pool' => 'small_z1',
+          'templates' => [{ 'name' => 'redis', 'release' => 'redis' }],
+          'update' => { 'canaries' => 10 }
+        }
+      ]
+    }
+  end
+  subject do
+    Guard::Bosh::JobPropertiesLoader.new(
+      deployment_manifest: deployment_manifest
+    )
+  end
+
+  context 'when the job exists within the deployment manifest' do
+    it 'returns the properties defined at the job level' do
+      job_properties = subject.load_properties(manifest_job_name: 'redis_z1')
+      expect(job_properties).to eq(
+        'network' => 'redis1', 'redis' => { 'master' => '10.244.2.6' }
+      )
+    end
+  end
+
+  context 'when the job does not exist in the deployment manifest' do
+    it 'returns an empty' do
+      job_properties = subject.load_properties(manifest_job_name: 'missing_job')
+      expect(job_properties).to be_empty
+    end
+  end
+end

data/spec/guard/bosh/job_repository_spec.rb

@@ -0,0 +1,56 @@
+require 'guard/bosh/job_repository'
+
+describe Guard::Bosh::JobRepository do
+  let(:manifest) do
+    {
+      'jobs' => [
+        {
+          'name' => 'redis_leader_z1',
+          'templates' => [{ 'name' => 'redis', 'release' => 'redis' }]
+        },
+        {
+          'name' => 'postgresql_z1',
+          'template' => 'postgresql',
+          'properties' => {}
+        },
+        {
+          'name' => 'redis_slave_z2',
+          'templates' => [{ 'name' => 'redis', 'release' => 'redis' }]
+        }
+      ]
+    }
+  end
+
+  subject do
+    Guard::Bosh::JobRepository.new(manifest)
+  end
+
+  describe '#job_templates' do
+    it 'returns all job templates' do
+      expect(subject.job_templates).to eq(%w(postgresql redis))
+    end
+  end
+
+  describe '#find_by_template' do
+    context 'when there are multiple jobs that use a job template' do
+      it 'returns all jobs that use that template' do
+        expect(subject.find_by_template('redis')).to eq(%w(redis_leader_z1 redis_slave_z2))
+      end
+    end
+  end
+
+  describe '#template_paths' do
+    it 'looks up the template paths from the job specification' do
+      expect(YAML).to receive(:load_file).with(Pathname.new('jobs/redis/spec')).and_return(
+        'templates' => {
+          'redis_ctl.sh.erb' => 'bin/redis_ctl.sh',
+          'redis.conf.erb' => 'config/redis.conf'
+        }
+      )
+      expect(subject.template_paths('redis')).to eq([
+        Pathname.new('jobs/redis/templates/redis_ctl.sh.erb'),
+        Pathname.new('jobs/redis/templates/redis.conf.erb')
+      ])
+    end
+  end
+end

data/spec/guard/bosh/notifier_spec.rb

@@ -0,0 +1,40 @@
+require 'guard/bosh/notifier'
+
+describe Guard::Bosh::Notifier do
+  before do
+    allow(Guard::Compat::UI).to receive(:notify)
+    allow(Guard::Compat::UI).to receive(:error)
+  end
+
+  context 'when there are no errors' do
+    it 'reports success' do
+      expect(Guard::Compat::UI).to receive(:notify).with(
+        'Succeeded',
+        title: 'BOSH',
+        image: :success,
+        priority: -2
+      )
+      subject.notify([])
+    end
+  end
+
+  context 'when there are errors' do
+    it 'reports failure' do
+      expect(Guard::Compat::UI).to receive(:notify).with(
+        'Failed',
+        title: 'BOSH',
+        image: :failed,
+        priority: 2
+      )
+      subject.notify([
+        { template: 'config.erb', status: :failure, detail: 'Missing property: redis.port' }
+      ])
+    end
+    it 'outputs the template the error occurred in and the detail' do
+      expect(Guard::Compat::UI).to receive(:error).with('config.erb: Missing property: redis.port')
+      subject.notify([
+        { template: 'config.erb', status: :failure, detail: 'Missing property: redis.port' }
+      ])
+    end
+  end
+end

data/spec/guard/bosh/package_resolver_spec.rb

@@ -0,0 +1,23 @@
+require 'guard/bosh/package_resolver'
+
+require 'pathname'
+
+describe Guard::Bosh::PackageResolver do
+  subject do
+    Guard::Bosh::PackageResolver.new(Pathname.new('/path/to/release/dir/'))
+  end
+
+  it 'resolves the package associated with the specified job' do
+    expect(YAML).to receive(:load_file).with(
+      Pathname.new('/path/to/release/dir/jobs/redis/spec')
+    ).and_return('packages' => ['redis'])
+    expect(subject.resolve('redis')).to eq(['redis'])
+  end
+
+  it 'raises if the job spec cannot be loaded' do
+    expect(YAML).to receive(:load_file)
+    expect do
+      subject.resolve('redis')
+    end.to raise_error
+  end
+end

data/spec/guard/bosh/template_checker_spec.rb

@@ -0,0 +1,67 @@
+require 'guard/bosh/template_checker'
+
+require 'guard/bosh/effective_properties_calculator'
+
+describe Guard::Bosh::TemplateChecker do
+  let(:properties_calculator) do
+    instance_double(Guard::Bosh::EffectivePropertiesCalculator)
+  end
+  let(:apply_specification) do
+    instance_double(Guard::Bosh::ApplySpecification)
+  end
+  let(:template_renderer) do
+    instance_double(Guard::Bosh::TemplateRenderer)
+  end
+  subject do
+    Guard::Bosh::TemplateChecker.new(
+      deployment_manifest: 'a/deployment/manifest.yml',
+      properties_calculator: properties_calculator,
+      apply_specification: apply_specification,
+      template_renderer: template_renderer
+    )
+  end
+
+  before do
+    allow(properties_calculator).to receive(:calculate_effective_properties)
+    allow(apply_specification).to receive(:generate).and_return('apply' => 'specification')
+    allow(template_renderer).to receive(:render)
+  end
+
+  it 'builds a context to evaluate the template in' do
+    expect(properties_calculator).to receive(
+      :calculate_effective_properties).with(
+        manifest_job_name: 'redis_leader_z1',
+        job_name: 'redis'
+    ).and_return('effective' => 'properties')
+    expect(apply_specification).to receive(:generate).with(
+      properties: { 'effective' => 'properties' },
+      job_name: 'redis_leader_z1')
+    subject.check(
+      manifest_job_name: 'redis_leader_z1',
+      job_name: 'redis',
+      template: 'jobs/redis/templates/redis.conf.erb'
+    )
+  end
+
+  it 'renders the template in context' do
+    expect(template_renderer).to receive(:render).with(
+      context: { 'apply' => 'specification' },
+      template: 'jobs/redis/templates/redis.conf.erb'
+    )
+    subject.check(
+      manifest_job_name: 'redis_leader_z1',
+      job_name: 'redis',
+      template: 'jobs/redis/templates/redis.conf.erb'
+    )
+  end
+
+  it 'returns any errors generated by the template render' do
+    expect(template_renderer).to receive(:render).and_return(['missing property'])
+    errors = subject.check(
+      manifest_job_name: 'redis_leader_z1',
+      job_name: 'redis',
+      template: 'jobs/redis/templates/redis.conf.erb'
+    )
+    expect(errors).to eq(['missing property'])
+  end
+end

data/spec/guard/bosh/template_renderer_spec.rb

@@ -0,0 +1,29 @@
+require 'guard/bosh/template_renderer'
+
+require 'pathname'
+
+describe Guard::Bosh::TemplateRenderer do
+  subject do
+    Guard::Bosh::TemplateRenderer.new
+  end
+
+  context 'when the template contains no errors' do
+    it 'reports that no error occurred' do
+      bosh_renderer = instance_double(::Bosh::Template::Renderer)
+      expect(::Bosh::Template::Renderer).to receive(:new).with(context: '{}').and_return(bosh_renderer)
+      expect(bosh_renderer).to receive(:render).with('config.erb')
+      result = subject.render(context: {}, template: 'config.erb')
+      expect(result).to eq(template: 'config.erb', status: :success, detail: '')
+    end
+  end
+
+  context 'when the template refers to an unknown property' do
+    it 'reports the missing property' do
+      bosh_renderer = instance_double(::Bosh::Template::Renderer)
+      expect(::Bosh::Template::Renderer).to receive(:new).with(context: '{}').and_return(bosh_renderer)
+      expect(bosh_renderer).to receive(:render).with('config.erb').and_raise(::Bosh::Template::UnknownProperty.new('redis.port'))
+      result = subject.render(context: {}, template: 'config.erb')
+      expect(result).to eq(template: 'config.erb', status: :failure, detail: 'Missing property: redis.port')
+    end
+  end
+end

data/spec/guard/bosh_spec.rb

@@ -0,0 +1,202 @@
+require 'pathname'
+require 'guard/compat/test/helper'
+
+require 'guard/bosh/change_assessor'
+require 'guard/bosh/job_repository'
+require 'guard/bosh/template_checker'
+require 'guard/bosh/notifier'
+
+describe Guard::Bosh do
+  let(:change_assessor) { instance_double(Guard::Bosh::ChangeAssessor) }
+  let(:job_repository) { instance_double(Guard::Bosh::JobRepository) }
+  let(:template_checker) { instance_double(Guard::Bosh::TemplateChecker) }
+  let(:notifier) { instance_double(Guard::Bosh::Notifier) }
+  let(:deployment_manifest_path) { '/path/to/manifest.yml' }
+
+  subject do
+    Guard::Bosh.new(
+      deployment_manifest: deployment_manifest_path,
+      change_assessor: change_assessor,
+      job_repository: job_repository,
+      template_checker: template_checker,
+      notifier: notifier
+    )
+  end
+
+  context 'when a deployment manifest is not specified' do
+    it 'raises an error' do
+      expect { Guard::Bosh.new }.to raise_error(
+        'Please specify the deployment_manifest in your Guardfile')
+    end
+  end
+
+  context 'when a template is modified' do
+    before do
+      expect(change_assessor).to receive(:determine_scope).with(
+        ['jobs/redis/templates/redis.conf.erb']).and_return(
+          [:single_template, 'redis'])
+      expect(job_repository).to receive(:find_by_template).with(
+        'redis').and_return(%w(redis_leader_z1 redis_slave_z2))
+    end
+    context 'when there are no errors' do
+      it 'checks the template for errors' do
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_leader_z1',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis.conf.erb'
+        ).and_return([])
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_slave_z2',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis.conf.erb'
+        ).and_return([])
+        expect(notifier).to receive(:notify).with([]).once
+        subject.run_on_modifications(['jobs/redis/templates/redis.conf.erb'])
+      end
+    end
+    context 'when there are errors' do
+      it 'reports the errors' do
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_leader_z1',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis.conf.erb'
+        ).and_return([{
+                       template: 'config.erb',
+                       status: :failure,
+                       detail: 'Missing property: redis.port'
+                     }])
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_slave_z2',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis.conf.erb'
+        ).and_return([{
+                       template: 'config.erb',
+                       status: :failure,
+                       detail: 'Missing property: redis.port'
+                     }])
+        expect(notifier).to receive(:notify).with([
+          {
+            template: 'config.erb',
+            status: :failure,
+            detail: 'Missing property: redis.port'
+          },
+          {
+            template: 'config.erb',
+            status: :failure,
+            detail: 'Missing property: redis.port'
+          }
+        ]).once
+        expect(subject).to receive(:throw).with(:task_has_failed)
+        subject.run_on_modifications(['jobs/redis/templates/redis.conf.erb'])
+      end
+    end
+  end
+
+  context 'when a job specification is modified' do
+    before do
+      expect(change_assessor).to receive(:determine_scope).with(
+        ['jobs/redis/spec']).and_return([:all_templates_for_job, 'redis'])
+
+      expect(job_repository).to receive(:find_by_template).with(
+        'redis').and_return(%w(redis_leader_z1 redis_slave_z2))
+
+      expect(job_repository).to receive(:template_paths).with('redis').and_return([
+        'jobs/redis/templates/redis_ctl.sh.erb',
+        'jobs/redis/templates/redis.conf.erb'
+      ])
+    end
+    context 'when there are no errors' do
+      it 'checks the template for errors' do
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_leader_z1',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis_ctl.sh.erb'
+        ).and_return([])
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_leader_z1',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis.conf.erb'
+        ).and_return([])
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_slave_z2',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis_ctl.sh.erb'
+        ).and_return([])
+        expect(template_checker).to receive(:check).with(
+          manifest_job_name: 'redis_slave_z2',
+          job_name: 'redis',
+          template: 'jobs/redis/templates/redis.conf.erb'
+        ).and_return([])
+        expect(notifier).to receive(:notify).with([]).once
+        subject.run_on_modifications(['jobs/redis/spec'])
+      end
+    end
+  end
+
+  shared_context 'expect a complete check of all templates' do
+    before do
+      expect(job_repository).to receive(:job_templates).and_return(
+        %w(postgresql redis))
+      expect(job_repository).to receive(:template_paths).with('postgresql').and_return([
+        'jobs/postgresql/templates/pg_hba.conf.erb'
+      ])
+      expect(job_repository).to receive(:template_paths).with('redis').and_return([
+        'jobs/redis/templates/redis_ctl.sh.erb',
+        'jobs/redis/templates/redis.conf.erb'
+      ])
+      expect(template_checker).to receive(:check).with(
+        manifest_job_name: 'redis_slave_z2',
+        job_name: 'redis',
+        template: 'jobs/redis/templates/redis.conf.erb'
+      ).and_return([])
+      expect(job_repository).to receive(:find_by_template).with(
+      'redis').and_return(%w(redis_leader_z1 redis_slave_z2))
+      expect(job_repository).to receive(:find_by_template).with(
+        'postgresql').and_return(['postgresql_z1'])
+      expect(template_checker).to receive(:check).with(
+        manifest_job_name: 'redis_leader_z1',
+        job_name: 'redis',
+        template: 'jobs/redis/templates/redis_ctl.sh.erb'
+      ).and_return([])
+      expect(template_checker).to receive(:check).with(
+        manifest_job_name: 'redis_leader_z1',
+        job_name: 'redis',
+        template: 'jobs/redis/templates/redis.conf.erb'
+      ).and_return([])
+      expect(template_checker).to receive(:check).with(
+        manifest_job_name: 'redis_slave_z2',
+        job_name: 'redis',
+        template: 'jobs/redis/templates/redis_ctl.sh.erb'
+      ).and_return([])
+      expect(template_checker).to receive(:check).with(
+        manifest_job_name: 'postgresql_z1',
+        job_name: 'postgresql',
+        template: 'jobs/postgresql/templates/pg_hba.conf.erb'
+      ).and_return([])
+      expect(notifier).to receive(:notify).with([]).once
+    end
+  end
+
+  context 'when the manifest is modified' do
+    include_context 'expect a complete check of all templates'
+    it 'checks all jobs and templates for errors' do
+      allow(subject).to receive(:reload_deployment_manifest)
+      expect(change_assessor).to receive(:determine_scope).with(
+        [deployment_manifest_path]).and_return([:all])
+      subject.run_on_modifications([deployment_manifest_path])
+    end
+    it 'reloads the manifest' do
+      allow(change_assessor).to receive(:determine_scope).with(
+        [deployment_manifest_path]).and_return([:all])
+      expect(subject).to receive(:reload_deployment_manifest)
+      subject.run_on_modifications([deployment_manifest_path])
+    end
+  end
+
+  context 'when the user requests that all templates are checked' do
+    include_context 'expect a complete check of all templates'
+    it 'checks all jobs and templates for errors' do
+      subject.run_all
+    end
+  end
+end