vanagon 0.3.18

data/spec/lib/vanagon/platform/rpm_spec.rb

@@ -0,0 +1,41 @@
+require 'vanagon/platform/rpm'
+
+describe "Vanagon::Platform::RPM" do
+  let(:platforms) do
+    [
+      {
+        :name                   => "el-5-i386",
+        :os_name                => "el",
+        :os_version             => "5",
+        :architecture           => "i386",
+        :output_dir             => "el/5/products/i386",
+        :output_dir_with_target => "el/5/thing/i386",
+      },
+      {
+        :name                   => "fedora-21-x86_64",
+        :os_name                => "fedora",
+        :os_version             => "21",
+        :architecture           => "x86_64",
+        :output_dir             => "fedora/21/products/x86_64",
+        :output_dir_with_target => "fedora/21/thing/x86_64",
+      },
+    ]
+  end
+
+  describe "#output_dir" do
+    it "returns an output dir consistent with the packaging repo" do
+      platforms.each do |plat|
+        cur_plat = Vanagon::Platform::RPM.new(plat[:name])
+        expect(cur_plat.output_dir).to eq(plat[:output_dir])
+      end
+    end
+
+    it "adds the target repo in the right way" do
+      platforms.each do |plat|
+        cur_plat = Vanagon::Platform::RPM.new(plat[:name])
+        expect(cur_plat.output_dir('thing')).to eq(plat[:output_dir_with_target])
+      end
+    end
+  end
+end
+

data/spec/lib/vanagon/platform/solaris_11_spec.rb

@@ -0,0 +1,44 @@
+require 'vanagon/platform/solaris_11'
+
+describe "Vanagon::Platform::Solaris_11" do
+  let(:platform) do
+    {
+      :name => 'solaris-11-i386',
+      :block => %Q[platform "solaris-11-i386" do |plat| end]
+    }
+  end
+
+  let(:versions) do
+    [
+      # Leading and trailing - stripped
+      { :original => "-1.2.3-", :final => "1.2.3" },
+
+      # Non-numeric stripped
+      { :original => "-1.2bcd.3aaz-", :final => "1.2.3" },
+
+      # Leading, non-singular zeroes stripped
+      { :original => "1.0.2.00123", :final => "1.0.2.123" },
+      { :original => "1.0000.2.00123", :final => "1.0.2.123" },
+    ]
+  end
+
+  describe '#ips_version' do
+    it 'strips invalid characters from the version' do
+      versions.each do |ver|
+        plat = Vanagon::Platform::DSL.new(platform[:name])
+        plat.instance_eval(platform[:block])
+        expect(plat._platform.ips_version(ver[:original], '1')).to eq("#{ver[:final]},5.11-1")
+      end
+    end
+
+    it 'handles the release field correctly' do
+      1.upto(3) do |i|
+        versions.each do |ver|
+          plat = Vanagon::Platform::DSL.new(platform[:name])
+          plat.instance_eval(platform[:block])
+          expect(plat._platform.ips_version(ver[:original], i)).to eq("#{ver[:final]},5.11-#{i}")
+        end
+      end
+    end
+  end
+end

data/spec/lib/vanagon/platform_spec.rb

@@ -0,0 +1,53 @@
+require 'vanagon/platform'
+
+describe "Vanagon::Platform" do
+  let(:platforms) do
+    [
+      {
+        :name         => "debian-6-i386",
+        :os_name      => "debian",
+        :os_version   => "6",
+        :architecture => "i386",
+      },
+      {
+        :name         => "el-5-i386",
+        :os_name      => "el",
+        :os_version   => "5",
+        :architecture => "i386",
+      },
+      {
+        :name         => "CumulusLinux-2.2-amd64",
+        :os_name      => "CumulusLinux",
+        :os_version   => "2.2",
+        :architecture => "amd64",
+      },
+    ]
+  end
+
+  describe "#os_name" do
+    it "returns the os_name for the platform" do
+      platforms.each do |plat|
+        cur_plat = Vanagon::Platform.new(plat[:name])
+        expect(cur_plat.os_name).to eq(plat[:os_name])
+      end
+    end
+  end
+
+  describe "#os_version" do
+    it "returns the the os_version for the platform" do
+      platforms.each do |plat|
+        cur_plat = Vanagon::Platform.new(plat[:name])
+        expect(cur_plat.os_version).to eq(plat[:os_version])
+      end
+    end
+  end
+
+  describe "#architecture" do
+    it "returns the architecture for the platform" do
+      platforms.each do |plat|
+        cur_plat = Vanagon::Platform.new(plat[:name])
+        expect(cur_plat.architecture).to eq(plat[:architecture])
+      end
+    end
+  end
+end

data/spec/lib/vanagon/project/dsl_spec.rb

@@ -0,0 +1,203 @@
+require 'vanagon/project/dsl'
+require 'vanagon/driver'
+require 'vanagon/common'
+
+describe 'Vanagon::Project::DSL' do
+  let (:project_block) {
+"project 'test-fixture' do |proj|
+end" }
+  let (:configdir) { '/a/b/c' }
+
+  describe '#version_from_git' do
+    it 'sets the version based on the git describe' do
+      expect(Vanagon::Driver).to receive(:configdir).and_return(configdir)
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      expect(Vanagon::Utilities).to receive(:git_version).with(File.expand_path('..', configdir)).and_return('1.2.3-1234')
+      proj.version_from_git
+      expect(proj._project.version).to eq('1.2.3.1234')
+    end
+  end
+
+  describe '#directory' do
+    it 'adds a directory to the list of directories' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.directory('/a/b/c/d', mode: '0755')
+      expect(proj._project.directories).to include(Vanagon::Common::Pathname.new('/a/b/c/d', mode: '0755'))
+    end
+  end
+
+  describe '#user' do
+    it 'sets a user for the project' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.user('test-user')
+      expect(proj._project.user).to eq(Vanagon::Common::User.new('test-user'))
+    end
+  end
+
+  describe '#target_repo' do
+    it 'sets the target_repo for the project' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.target_repo "pc1"
+      expect(proj._project.repo).to eq("pc1")
+    end
+  end
+
+  describe '#noarch' do
+    it 'sets noarch on the project to true' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.noarch
+      expect(proj._project.noarch).to eq(true)
+    end
+  end
+
+  describe '#identifier' do
+    it 'sets the identifier for the project' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.identifier "com.example"
+      expect(proj._project.identifier).to eq("com.example")
+    end
+  end
+
+  describe '#cleanup_during_build' do
+    it 'sets @cleanup to true' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.cleanup_during_build
+      expect(proj._project.cleanup).to eq(true)
+    end
+
+    it 'defaults to nil' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      expect(proj._project.cleanup).to be_nil
+    end
+  end
+
+  describe "#write_version_file" do
+    let(:version_file) { '/opt/puppetlabs/puppet/VERSION' }
+
+    it 'sets version_file for the project' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.write_version_file(version_file)
+      expect(proj._project.version_file.path).to eq(version_file)
+    end
+  end
+
+  describe "#release" do
+    it 'sets the release for the project' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.release '12'
+      expect(proj._project.release).to eq('12')
+    end
+
+    it 'defaults to 1' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      expect(proj._project.release).to eq('1')
+    end
+  end
+
+  describe "#provides" do
+    it 'adds the package provide to the list of provides' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.provides('thing1')
+      proj.provides('thing2')
+      expect(proj._project.get_provides.count).to eq(2)
+      expect(proj._project.get_provides.first.provide).to eq('thing1')
+      expect(proj._project.get_provides.last.provide).to eq('thing2')
+    end
+
+    it 'supports versioned provides' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.provides('thing1', '1.2.3')
+      expect(proj._project.get_provides.count).to eq(1)
+      expect(proj._project.get_provides.first.provide).to eq('thing1')
+      expect(proj._project.get_provides.first.version).to eq('1.2.3')
+     end
+
+    it 'gets rid of duplicates' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.provides('thing1', '1.2.3')
+      proj.provides('thing1', '1.2.3')
+      expect(proj._project.get_provides.count).to eq(1)
+      expect(proj._project.get_provides.first.provide).to eq('thing1')
+      expect(proj._project.get_provides.first.version).to eq('1.2.3')
+    end
+  end
+
+  describe "#replaces" do
+    it 'adds the package replacement to the list of replacements' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.replaces('thing1')
+      proj.replaces('thing2')
+      expect(proj._project.get_replaces.count).to eq(2)
+      expect(proj._project.get_replaces.first.replacement).to eq('thing1')
+      expect(proj._project.get_replaces.last.replacement).to eq('thing2')
+     end
+
+    it 'supports versioned replaces' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.replaces('thing1', '1.2.3')
+      expect(proj._project.get_replaces.count).to eq(1)
+      expect(proj._project.get_replaces.first.replacement).to eq('thing1')
+      expect(proj._project.get_replaces.first.version).to eq('1.2.3')
+     end
+
+    it 'gets rid of duplicates' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {})
+      proj.instance_eval(project_block)
+      proj.replaces('thing1', '1.2.3')
+      proj.replaces('thing1', '1.2.3')
+      expect(proj._project.get_replaces.count).to eq(1)
+      expect(proj._project.get_replaces.first.replacement).to eq('thing1')
+      expect(proj._project.get_replaces.first.version).to eq('1.2.3')
+    end
+  end
+
+  describe "#component" do
+    let(:project_block) {
+"project 'test-fixture' do |proj|
+  proj.component 'some-component'
+end"
+    }
+
+    let(:component) { double(Vanagon::Component) }
+
+    before do
+      allow_any_instance_of(Vanagon::Project::DSL).to receive(:puts)
+      allow(Vanagon::Driver).to receive(:configdir).and_return(configdir)
+      allow(Vanagon::Component).to receive(:load_component).with('some-component', any_args).and_return(component)
+    end
+
+    it 'stores the component in the project if the included components set is empty' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {}, [])
+      proj.instance_eval(project_block)
+      expect(proj._project.components).to include(component)
+    end
+
+    it 'stores the component in the project if the component name is listed in the included components set' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {}, ['some-component'])
+      proj.instance_eval(project_block)
+      expect(proj._project.components).to include(component)
+    end
+
+    it 'does not store the component if the included components set is not empty and does not include the component name' do
+      proj = Vanagon::Project::DSL.new('test-fixture', {}, ['some-different-component'])
+      proj.instance_eval(project_block)
+      expect(proj._project.components).to_not include(component)
+    end
+  end
+end

data/spec/lib/vanagon/project_spec.rb

@@ -0,0 +1,44 @@
+require 'vanagon/project'
+require 'vanagon/driver'
+
+describe 'Vanagon::Project' do
+  let(:component) { double(Vanagon::Component) }
+  let(:configdir) { '/a/b/c' }
+
+  let(:project_block) {
+    "project 'test-fixture' do |proj|
+    proj.component 'some-component'
+    end"
+  }
+
+  before do
+    allow_any_instance_of(Vanagon::Project::DSL).to receive(:puts)
+    allow(Vanagon::Driver).to receive(:configdir).and_return(configdir)
+    allow(Vanagon::Component).to receive(:load_component).with('some-component', any_args).and_return(component)
+  end
+
+  describe '#get_root_directories' do
+    let(:test_sets) do
+      [
+        {
+          :directories => ["/opt/puppetlabs/bin", "/etc/puppetlabs", "/var/log/puppetlabs", "/etc/puppetlabs/puppet", "/opt/puppetlabs"],
+          :results => ["/opt/puppetlabs", "/etc/puppetlabs", "/var/log/puppetlabs"],
+        },
+        {
+          :directories => ["/opt/puppetlabs/bin", "/etc/puppetlabs", "/var/log/puppetlabs", "/etc/puppetlabs/puppet", "/opt/puppetlabs/lib"],
+          :results => ["/opt/puppetlabs/bin", "/etc/puppetlabs", "/var/log/puppetlabs", "/opt/puppetlabs/lib"],
+        },
+      ]
+    end
+
+    it 'returns only the highest level directories' do
+      test_sets.each do |set|
+        expect(component).to receive(:directories).and_return([])
+        proj = Vanagon::Project::DSL.new('test-fixture', {}, [])
+        proj.instance_eval(project_block)
+        set[:directories].each {|dir| proj.directory dir }
+        expect(proj._project.get_root_directories.sort).to eq(set[:results].sort)
+      end
+    end
+  end
+end

data/spec/lib/vanagon/utilities_spec.rb

@@ -0,0 +1,140 @@
+require 'vanagon/utilities'
+require 'tmpdir'
+
+describe "Vanagon::Utilities" do
+  describe "#find_program_on_path" do
+    let(:command) { "thingie" }
+
+    it 'finds commands on the PATH' do
+      path_elems = ENV['PATH'].split(File::PATH_SEPARATOR)
+      path_elems.each_with_index do |path_elem, i|
+        expect(FileTest).to receive(:executable?).with(File.join(path_elem, command)).and_return(i == 0)
+        break
+      end
+
+      expect(Vanagon::Utilities.find_program_on_path(command)).to eq(File.join(path_elems.first, command))
+    end
+
+    it 'finds commands on the PATH' do
+      path_elems = ENV['PATH'].split(File::PATH_SEPARATOR)
+      path_elems.each_with_index do |path_elem, i|
+        expect(FileTest).to receive(:executable?).with(File.join(path_elem, command)).and_return(i == path_elems.length - 1)
+      end
+
+      expect(Vanagon::Utilities.find_program_on_path(command)).to eq(File.join(path_elems.last, command))
+    end
+
+    it 'raises an error if required is true and command is not found' do
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path_elem|
+        expect(FileTest).to receive(:executable?).with(File.join(path_elem, command)).and_return(false)
+      end
+
+      expect { Vanagon::Utilities.find_program_on_path(command) }.to raise_error(RuntimeError)
+    end
+
+    it 'returns false if required is false and command is not found' do
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path_elem|
+        expect(FileTest).to receive(:executable?).with(File.join(path_elem, command)).and_return(false)
+      end
+
+      expect(Vanagon::Utilities.find_program_on_path(command, false)).to be(false)
+    end
+  end
+
+  describe "#is_git_repo?" do
+    let(:dir) { Dir.mktmpdir }
+    after(:each) { FileUtils.rm_rf(dir) }
+
+    it "returns false if not in a git repo" do
+      expect(Vanagon::Utilities.is_git_repo?(dir)).to be(false)
+    end
+
+    it "returns true if in a git repo" do
+      Dir.chdir(dir) do
+        Vanagon::Utilities.git('init')
+      end
+
+      expect(Vanagon::Utilities.is_git_repo?(dir)).to be(true)
+    end
+  end
+
+  describe "#git_version" do
+    let(:dir) { Dir.mktmpdir }
+    after(:each) { FileUtils.rm_rf(dir) }
+
+    it "raises an exception if not in a git repo" do
+      expect { Vanagon::Utilities.git_version(dir) }.to raise_error(RuntimeError)
+    end
+
+    it "returns a git tag based version if there are tags in the repo" do
+      Dir.chdir(dir) do
+        Vanagon::Utilities.git('init')
+        Vanagon::Utilities.git('commit --allow-empty -m "testing this ish"')
+        Vanagon::Utilities.git('tag 1.2.3')
+      end
+
+      expect(Vanagon::Utilities.git_version(dir)).to eq('1.2.3')
+    end
+
+    it "returns empty string if there are no tags" do
+      Dir.chdir(dir) do
+        Vanagon::Utilities.git('init')
+      end
+
+      expect(Vanagon::Utilities.git_version(dir)).to be_empty
+    end
+  end
+
+  describe '#ssh_command' do
+    it 'adds the correct flags to the command if VANAGON_SSH_KEY is set' do
+      expect(Vanagon::Utilities).to receive(:find_program_on_path).with('ssh').and_return('/tmp/ssh')
+      ENV['VANAGON_SSH_KEY'] = '/a/b/c'
+      expect(Vanagon::Utilities.ssh_command).to include('/tmp/ssh -i /a/b/c')
+      ENV['VANAGON_SSH_KEY'] = nil
+    end
+
+    it 'returns just the path to ssh if VANAGON_SSH_KEY is not set' do
+      expect(Vanagon::Utilities).to receive(:find_program_on_path).with('ssh').and_return('/tmp/ssh')
+      expect(Vanagon::Utilities.ssh_command).to include('/tmp/ssh')
+    end
+
+    it 'sets the port to 22 when none is specified' do
+      expect(Vanagon::Utilities).to receive(:find_program_on_path).with('ssh').and_return('/tmp/ssh')
+      expect(Vanagon::Utilities.ssh_command).to include('-p 22')
+    end
+
+    it 'sets the port to 2222 when that is specified' do
+      expect(Vanagon::Utilities).to receive(:find_program_on_path).with('ssh').and_return('/tmp/ssh')
+      expect(Vanagon::Utilities.ssh_command(2222)).to include('-p 2222')
+    end
+
+    it 'disables strict host checking' do
+      expect(Vanagon::Utilities).to receive(:find_program_on_path).with('ssh').and_return('/tmp/ssh')
+      expect(Vanagon::Utilities.ssh_command).to include('-o StrictHostKeyChecking=no')
+    end
+
+    it 'sets known hosts file to /dev/null' do
+      expect(Vanagon::Utilities).to receive(:find_program_on_path).with('ssh').and_return('/tmp/ssh')
+      expect(Vanagon::Utilities.ssh_command).to include('-o UserKnownHostsFile=/dev/null')
+    end
+  end
+
+  describe '#retry_with_timeout' do
+    let (:tries) { 7 }
+    let (:timeout) { 2 }
+    let (:host) { 'abcd' }
+    let (:command) { 'echo' }
+    let (:port) { 1234 }
+
+    it 'raises a Vanagon::Error if the command fails n times' do
+      expect(Vanagon::Utilities).to receive(:remote_ssh_command).with(host, command, port).exactly(tries).times.and_raise(RuntimeError)
+      expect{ Vanagon::Utilities.retry_with_timeout(tries, timeout) { Vanagon::Utilities.remote_ssh_command(host, command, port) } }.to raise_error(Vanagon::Error)
+    end
+
+    it 'returns true if the command succeeds within n times' do
+      expect(Vanagon::Utilities).to receive(:remote_ssh_command).with(host, command, port).exactly(tries - 1).times.and_raise(RuntimeError)
+      expect(Vanagon::Utilities).to receive(:remote_ssh_command).with(host, command, port).exactly(1).times.and_return(true)
+      expect(Vanagon::Utilities.retry_with_timeout(tries, timeout) { Vanagon::Utilities.remote_ssh_command(host, command, port) }).to be(true)
+    end
+  end
+end