jenkins_pipeline_builder 0.6.0 → 0.7.0

data/spec/lib/jenkins_pipeline_builder/extensions_spec.rb

@@ -42,12 +42,6 @@ describe JenkinsPipelineBuilder::Extension do
         expect(extension.plugin_id).to eq 'foo'
       end
     end
-    context 'min_version' do
-      it 'sets the min_version if a parameter is provided' do
-        extension.min_version('foo')
-        expect(extension.min_version).to eq 'foo'
-      end
-    end
     context 'jenkins_name' do
       it 'sets the jenkins_name if a parameter is provided' do
         extension.jenkins_name('foo')
@@ -78,51 +72,39 @@ describe JenkinsPipelineBuilder::Extension do
         expect(extension.type).to eq 'foo'
       end
     end
+    context 'min_version' do
+      it 'sets the min_version if a parameter is provided' do
+        extension.min_version('foo')
+        expect(extension.min_version).to eq 'foo'
+      end
+    end
     context 'xml' do
       it 'saves the block' do
-        extension.xml do
-          true
-        end
+        extension.xml -> { true }
         expect(extension.xml.call).to be true
       end
-      it 'uses the path if provided' do
-        extension.xml('foo') do
-          true
-        end
-        expect(extension.path).to eq 'foo'
-      end
       it 'returns the saved block if there none is provided' do
-        extension.xml do
-          true
-        end
+        extension.xml -> { true }
         expect(extension.xml).to be_kind_of Proc
       end
     end
     context 'after' do
       it 'saves the block' do
-        extension.after do
-          true
-        end
+        extension.after -> { true }
         expect(extension.after.call).to be true
       end
       it 'returns the saved block if there none is provided' do
-        extension.after do
-          true
-        end
+        extension.after -> { true }
         expect(extension.after).to be_kind_of Proc
       end
     end
     context 'before' do
       it 'saves the block' do
-        extension.before do
-          true
-        end
+        extension.before -> { true }
         expect(extension.before.call).to be true
       end
       it 'returns the saved block if there none is provided' do
-        extension.before do
-          true
-        end
+        extension.before -> { true }
         expect(extension.before).to be_kind_of Proc
       end
     end
@@ -130,7 +112,8 @@ describe JenkinsPipelineBuilder::Extension do
       it 'returns true if errors is empty' do
         extension.name 'foo'
         extension.plugin_id 'foo'
-        extension.min_version 'foo'
+        extension.min_version '0.2'
+        extension.xml -> { true }
         extension.type 'foo'
         extension.path 'foo'
         expect(extension.errors).to be_empty
@@ -143,3 +126,102 @@ describe JenkinsPipelineBuilder::Extension do
     end
   end
 end
+
+describe JenkinsPipelineBuilder::ExtensionSet do
+  subject(:set) { JenkinsPipelineBuilder::ExtensionSet.new }
+
+  before :each do
+    set.name 'example'
+  end
+
+  context 'xml' do
+    it 'returns the block for the correct version'
+    it 'sets the min_version if a parameter is provided' do
+      set.xml version: '0.2' do
+        true
+      end
+      expect(set.blocks).to have_key '0.2'
+    end
+    it 'uses the path if provided' do
+      set.xml path: 'foo' do
+        true
+      end
+      expect(set.blocks['0'][:path]).to eq 'foo'
+    end
+  end
+
+  context '#extension' do
+    def new_ext(version = '0.0')
+      ext = JenkinsPipelineBuilder::Extension.new
+      ext.name 'foo'
+      ext.plugin_id 'foo'
+      ext.min_version version
+      ext.xml -> { true }
+      ext.type 'foo'
+      ext.path 'foo'
+      ext
+    end
+
+    def ext_versions(versions)
+      versions.each do |v|
+        ext = new_ext(v)
+        expect(ext).to be_valid
+        set.extensions << ext
+      end
+
+      expect(set).to be_valid
+      expect(set.extensions.size).to eq versions.size
+    end
+
+    it 'returns an extension' do
+      ext_versions ['0.0']
+      set.installed_version = '0.1'
+      expect(set.extension).to be_kind_of JenkinsPipelineBuilder::Extension
+    end
+
+    it 'returns the highest that is lower than the installed version' do
+      ext_versions ['0.0', '0.2']
+
+      set.installed_version = '0.1'
+
+      expect(set.extension.min_version).to eq '0.0'
+    end
+
+    it 'returns highest available if the installed version is higher' do
+      ext_versions ['0.0', '0.2']
+
+      set.installed_version = '0.3'
+
+      expect(set.extension.min_version).to eq '0.2'
+    end
+
+    it 'works for complicated version comparions' do
+      ext_versions ['10.5', '9.2', '100.4']
+
+      set.installed_version = '11.3'
+
+      expect(set.extension.min_version).to eq '10.5'
+    end
+
+    it 'raises an error if the registered versions are too high' do
+      ext_versions ['10.5', '9.2']
+
+      set.installed_version = '1.3'
+
+      expect { set.extension.min_version }.to raise_error
+    end
+
+    it 'works for snapshot/beta stuff' do
+      ext_versions ['1.9', '2.3']
+
+      set.installed_version = '2.0-SNAPSHOT (private-06/06/2014 09:51-bgaulin)'
+      # Other examples
+      # set.installed_version = '2.0-beta-1'
+      # set.installed_version = '2.0+build.93'
+      # set.installed_version = '2.0.8'
+
+      expect(set.extension.min_version).to eq '1.9'
+
+    end
+  end
+end

data/spec/lib/jenkins_pipeline_builder/generator_spec.rb

@@ -1,6 +1,9 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe JenkinsPipelineBuilder::Generator do
+  after :each do
+    JenkinsPipelineBuilder.registry.clear_versions
+  end
 
   before(:all) do
     JenkinsPipelineBuilder.credentials = {
@@ -10,7 +13,6 @@ describe JenkinsPipelineBuilder::Generator do
       password: 'password',
       log_location: '/dev/null'
     }
-    JenkinsPipelineBuilder.client
     @generator = JenkinsPipelineBuilder.generator
   end
 
@@ -18,8 +20,6 @@ describe JenkinsPipelineBuilder::Generator do
     @generator.debug = false
     @generator.job_collection = {}
     @generator.remote_depends = {}
-    @generator.module_registry = JenkinsPipelineBuilder::ModuleRegistry.new
-    JenkinsPipelineBuilder.load_registry
   end
 
   describe 'initialized in before(:example)' do
@@ -67,6 +67,10 @@ describe JenkinsPipelineBuilder::Generator do
   end
 
   describe '#bootstrap' do
+    before :each do
+      allow(JenkinsPipelineBuilder.client).to receive(:plugin).and_return double(
+        list_installed: { 'description' => '20.0', 'git' => '20.0' })
+    end
     it 'produces no errors while creating pipeline SamplePipeline with view' do
       @generator.debug = true
       job_name = 'SamplePipeline'
@@ -97,6 +101,10 @@ describe JenkinsPipelineBuilder::Generator do
   end
 
   describe '#pull_request' do
+    before :each do
+      allow(JenkinsPipelineBuilder.client).to receive(:plugin).and_return double(
+        list_installed: { 'description' => '20.0', 'git' => '20.0' })
+    end
     it 'produces no errors while creating pipeline PullRequest' do
       # Dummy data
       purge = []
@@ -129,7 +137,7 @@ describe JenkinsPipelineBuilder::Generator do
       @generator.debug = true
       job_name = 'PullRequest'
       path = File.expand_path('../fixtures/generator_tests/pullrequest_pipeline', __FILE__)
-      JenkinsPipelineBuilder::PullRequestGenerator.should_receive(:new).once.and_return(
+      expect(JenkinsPipelineBuilder::PullRequestGenerator).to receive(:new).once.and_return(
         double(purge: purge, create: create, jobs: jobs)
       )
       success = @generator.pull_request(path, job_name)

data/spec/lib/jenkins_pipeline_builder/module_registry_spec.rb

@@ -1,26 +1,29 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe JenkinsPipelineBuilder::ModuleRegistry do
+  after :each do
+    JenkinsPipelineBuilder.registry.clear_versions
+  end
   describe '#register' do
     it 'should return item by a specified path' do
 
       registry = JenkinsPipelineBuilder::ModuleRegistry.new
-      ext = double
-      allow(ext).to receive(:name).and_return :foo
-      registry.register [:job], ext
+      set = double
+      allow(set).to receive(:name).and_return :foo
+      registry.register [:job], set
 
-      expect(registry.get('job/foo').first.name).to eq :foo
+      expect(registry.get('job/foo').name).to eq :foo
     end
 
     it 'registered the builders correctly' do
       builders = {
-        multi_job: [0],
-        maven3: [0],
-        shell_command: [0],
-        inject_vars_file: [0],
-        blocking_downstream: [0],
-        remote_job: [0],
-        copy_artifact: [0]
+        multi_job: ['0'],
+        maven3: ['0'],
+        shell_command: ['0'],
+        inject_vars_file: ['0'],
+        blocking_downstream: ['0'],
+        remote_job: ['0'],
+        copy_artifact: ['0']
       }
       registry = JenkinsPipelineBuilder.registry.registry
       expect(registry[:job][:builders].size).to eq builders.size
@@ -32,12 +35,13 @@ describe JenkinsPipelineBuilder::ModuleRegistry do
         end
       end
     end
+
     it 'registered the triggers correctly' do
       triggers = {
-        git_push: [0],
-        scm_polling: [0],
-        periodic_build: [0],
-        upstream: [0]
+        git_push: ['0'],
+        scm_polling: ['0'],
+        periodic_build: ['0'],
+        upstream: ['0']
       }
       registry = JenkinsPipelineBuilder.registry.registry
       expect(registry[:job][:triggers].size).to eq triggers.size
@@ -51,15 +55,15 @@ describe JenkinsPipelineBuilder::ModuleRegistry do
     end
     it 'registered the job_attributes correctly' do
       job_attributes = {
-        description: [0],
-        scm_params: [0],
-        hipchat: [0],
-        priority: [0],
-        parameters: [0],
-        discard_old: [0],
-        throttle: [0],
-        prepare_environment: [0],
-        concurrent_build: [0]
+        description: ['0'],
+        scm_params: ['0'],
+        hipchat: ['0'],
+        priority: ['0'],
+        parameters: ['0'],
+        discard_old: ['0'],
+        throttle: ['0'],
+        prepare_environment: ['0'],
+        concurrent_build: ['0']
       }
       registry = JenkinsPipelineBuilder.registry.registry
       # There are 4 sub types so, we don't count those
@@ -74,22 +78,21 @@ describe JenkinsPipelineBuilder::ModuleRegistry do
     end
     it 'registered the publishers correctly' do
       publishers = {
-        description_setter: [0],
-        downstream: [0],
-        hipchat: [0],
-        git: [0],
-        junit_result: [0],
-        coverage_result: [0],
-        post_build_script: [0],
-        groovy_postbuild: [0],
-        archive_artifact: [0],
-        email_notifications: [0]
+        description_setter: ['0'],
+        downstream: ['0'],
+        hipchat: ['0'],
+        git: ['0'],
+        junit_result: ['0'],
+        coverage_result: ['0'],
+        post_build_script: ['0'],
+        groovy_postbuild: ['0'],
+        archive_artifact: ['0'],
+        email_notifications: ['0'],
+        sonar_result: ['0']
       }
       registry = JenkinsPipelineBuilder.registry.registry
-      expect(registry[:job][:publishers].size).to eq publishers.size
+      expect(registry[:job][:publishers].keys).to match_array publishers.keys
       publishers.each do |publisher, versions|
-        expect(registry[:job][:publishers]).to have_key publisher
-
         versions.each do |version|
           expect(registry[:job][:publishers][publisher]).to have_min_version version
         end
@@ -97,14 +100,13 @@ describe JenkinsPipelineBuilder::ModuleRegistry do
     end
     it 'registered the wrappers correctly' do
       wrappers = {
-        ansicolor: [0],
-        timestamp: [0],
-        name: [0],
+        ansicolor: ['0'],
+        timestamp: ['0'],
         rvm: ['0', '0.5'],
-        inject_passwords: [0],
-        inject_env_var: [0],
-        artifactory: [0],
-        maven3artifactory: [0]
+        inject_passwords: ['0'],
+        inject_env_var: ['0'],
+        artifactory: ['0'],
+        maven3artifactory: ['0']
       }
       registry = JenkinsPipelineBuilder.registry.registry
       expect(registry[:job][:wrappers].size).to eq wrappers.size
@@ -121,6 +123,23 @@ describe JenkinsPipelineBuilder::ModuleRegistry do
 
   end
 
+  describe '#version' do
+    before :all do
+      JenkinsPipelineBuilder.credentials = {
+        server_ip: '127.0.0.1',
+        server_port: 8080,
+        username: 'username',
+        password: 'password',
+        log_location: '/dev/null'
+      }
+    end
+
+    it 'pulls the version from the registry if it is not memoized' do
+      expect(JenkinsPipelineBuilder.client).to receive(:plugin).and_return double(list_installed: { 'one' => '0.1' })
+      subject.versions
+    end
+  end
+
   describe '#entries' do
 
   end
@@ -144,4 +163,143 @@ describe JenkinsPipelineBuilder::ModuleRegistry do
   describe '#execute_extension' do
   end
 
+  describe 'executing a registry item' do
+    before :all do
+      class XmlException < StandardError
+      end
+      class BeforeException < StandardError
+      end
+      class AfterException < StandardError
+      end
+      JenkinsPipelineBuilder.credentials = {
+        server_ip: '127.0.0.1',
+        server_port: 8080,
+        username: 'username',
+        password: 'password',
+        log_location: '/dev/null'
+      }
+    end
+
+    let(:params) { { wrappers: { test_name: :foo } } }
+
+    before :each do
+      allow(JenkinsPipelineBuilder.client).to receive(:plugin).and_return double(
+        list_installed: { 'test_name' => '20.0', 'unorderedTest' => '20.0' })
+      @n_xml = Nokogiri::XML::Document.new
+
+      wrapper do
+        name :test_name
+        plugin_id 'test_name'
+
+        xml do
+          true
+        end
+      end
+      expect(JenkinsPipelineBuilder.registry.registry[:job][:wrappers]).to have_key :test_name
+      @ext = JenkinsPipelineBuilder.registry.registry[:job][:wrappers][:test_name].extension
+
+    end
+
+    after :each do
+      JenkinsPipelineBuilder.registry.registry[:job][:wrappers].delete :test_name
+    end
+
+    it 'calls the xml block when executing the item' do
+      @ext.xml -> (_) { fail XmlException, 'foo' }
+
+      expect do
+        JenkinsPipelineBuilder.registry.traverse_registry_path('job', params, @n_xml)
+      end.to raise_error XmlException
+    end
+
+    it 'calls the before block' do
+      @ext.before -> (_) { fail BeforeException, 'foo' }
+
+      expect do
+        JenkinsPipelineBuilder.registry.traverse_registry_path('job', params, @n_xml)
+      end.to raise_error BeforeException
+    end
+
+    it 'calls the after block' do
+      @ext.after -> (_) { fail AfterException, 'foo' }
+
+      expect do
+        JenkinsPipelineBuilder.registry.traverse_registry_path('job', params, @n_xml)
+      end.to raise_error AfterException
+    end
+
+    context 'unordered dsl' do
+      let(:params) { { wrappers: { unordered_test: :foo } } }
+
+      after :each do
+        JenkinsPipelineBuilder.registry.registry[:job][:wrappers].delete :unordered_test
+      end
+
+      it 'works with before first' do
+        wrapper do
+          name :unordered_test
+          plugin_id 'unorderedTest'
+
+          before do
+            fail BeforeException, 'foo'
+          end
+
+          xml do
+            true
+          end
+        end
+
+        expect(JenkinsPipelineBuilder.registry.registry[:job][:wrappers]).to have_key :unordered_test
+        @ext = JenkinsPipelineBuilder.registry.registry[:job][:wrappers][:unordered_test].extension
+
+        expect do
+          JenkinsPipelineBuilder.registry.traverse_registry_path('job', params, @n_xml)
+        end.to raise_error BeforeException
+      end
+
+      it 'works with after first' do
+        wrapper do
+          name :unordered_test
+          plugin_id 'unorderedTest'
+
+          after do
+            fail AfterException, 'foo'
+          end
+
+          xml do
+            true
+          end
+        end
+
+        expect(JenkinsPipelineBuilder.registry.registry[:job][:wrappers]).to have_key :unordered_test
+        @ext = JenkinsPipelineBuilder.registry.registry[:job][:wrappers][:unordered_test].extension
+
+        expect do
+          JenkinsPipelineBuilder.registry.traverse_registry_path('job', params, @n_xml)
+        end.to raise_error AfterException
+      end
+
+      it 'works with xml first' do
+        wrapper do
+          name :unordered_test
+          plugin_id 'unorderedTest'
+
+          xml do
+            fail XmlException, 'foo'
+          end
+
+          after do
+            true
+          end
+        end
+
+        expect(JenkinsPipelineBuilder.registry.registry[:job][:wrappers]).to have_key :unordered_test
+        @ext = JenkinsPipelineBuilder.registry.registry[:job][:wrappers][:unordered_test].extension
+
+        expect do
+          JenkinsPipelineBuilder.registry.traverse_registry_path('job', params, @n_xml)
+        end.to raise_error XmlException
+      end
+    end
+  end
 end