omnibus-sonian 1.2.0.1

data/spec/data/software/erchef.rb

@@ -0,0 +1,40 @@
+#
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+name "erchef"
+version "4b19a96d57bff9bbf4764d7323b92a0944009b9e"
+
+dependencies ["erlang", "rsync", "curl"]
+
+source :git => "git://github.com/opscode/erchef"
+
+relative_path "erchef"
+
+env = {
+  "PATH" => "#{install_dir}/embedded/bin:#{ENV["PATH"]}",
+  "LDFLAGS" => "-L#{install_dir}/embedded/lib -I#{install_dir}/embedded/include",
+  "CFLAGS" => "-L#{install_dir}/embedded/lib -I#{install_dir}/embedded/include",
+  "LD_RUN_PATH" => "#{install_dir}/embedded/lib"
+}
+
+build do
+  command "make distclean", :env => env
+  command "make rel", :env => env
+  command "mkdir -p #{install_dir}/embedded/service/erchef"
+  command "#{install_dir}/embedded/bin/rsync -a --delete --exclude=.git/*** --exclude=.gitignore ./rel/erchef/ #{install_dir}/embedded/service/erchef/"
+  command "rm -rf #{install_dir}/embedded/service/erchef/log"
+end

data/spec/fetchers/net_fetcher_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Omnibus::NetFetcher do
+  it "should download and uncompress zip files" do
+    software_mock = stub 'software'
+    software_mock.stub :project_file => 'file.zip',
+                       :name         => 'file',
+                       :source       => '/tmp/out',
+                       :checksum     => 'abc123',
+                       :source_uri   => 'http://example.com/file.zip',
+                       :source_dir   => '/tmp/out',
+                       :project_dir  => '/tmp/project'
+    net_fetcher = Omnibus::NetFetcher.new software_mock
+    net_fetcher.extract_cmd.should == 'unzip file.zip -d /tmp/out'
+  end
+end

data/spec/overrides_spec.rb

@@ -0,0 +1,114 @@
+require 'omnibus/overrides'
+require 'spec_helper'
+
+describe Omnibus::Overrides do
+  describe "#parse_file" do
+
+    let(:overrides){Omnibus::Overrides.parse_file(file)}
+    subject{overrides}
+
+    context "with a valid overrides file" do
+      let(:file){ overrides_path("good") }
+
+      its(:size){should eq(5)}
+      its(["foo"]){should eq("1.2.3")}
+      its(["bar"]){should eq("0.0.1")}
+      its(["baz"]){should eq("deadbeefdeadbeefdeadbeefdeadbeef")}
+      its(["spunky"]){should eq("master")}
+      its(["monkey"]){should eq("release")}
+    end
+
+    context "with an overrides file that contains a bad line" do
+      let(:file){ overrides_path("bad_line")}
+      
+      it "fails" do
+        expect{ overrides }.to raise_error(ArgumentError, "Invalid overrides line: 'THIS IS A BAD LINE'")
+      end
+    end
+
+    context "with an overrides file that contains duplicates" do
+      let(:file){ overrides_path("with_dupes") }
+      let(:duplicated_package){"erchef"}
+      it "fails" do
+        expect{ overrides }.to raise_error(ArgumentError, "Multiple overrides present for '#{duplicated_package}' in overrides file #{file}!")
+      end
+    end
+
+    context "when passed 'nil'" do
+      let(:file){nil}
+      it{should be_nil}
+    end
+  end #parse_file
+
+  describe "#resolve_override_file" do
+    before :each do
+      @original = ENV['OMNIBUS_OVERRIDE_FILE']
+      ENV['OMNIBUS_OVERRIDE_FILE'] = env_override_file
+    end
+    
+    after :each do
+      ENV['OMNIBUS_OVERRIDE_FILE'] = @original
+    end
+    
+    subject{ Omnibus::Overrides.resolve_override_file }
+    
+    context "with no environment variable set" do
+      let(:env_override_file){nil}
+
+      before :each do
+        stub_const("Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME", new_default_file)
+      end
+    
+      context "and a non-existent overrides file" do
+        let(:new_default_file){ "/this/file/totally/does/not/exist.txt" }
+        it{should be_nil}
+      end
+    
+      context "with an existing overrides file" do
+        let(:path){overrides_path("good")}
+        let(:new_default_file){ path }
+        it{should eq(path)}
+      end      
+    end # no environment variable
+
+    context "with OMNIBUS_OVERRIDE_FILE environment variable set" do
+      context "to an existing file" do
+        let(:path){ overrides_path("good") }
+        let(:env_override_file){ path  }
+        it{should eq(path)}
+      end
+
+      context "to a non-existent file" do
+        let(:env_override_file){ "/this/file/totally/does/not/exist.txt"}
+        it{should be_nil}
+      end
+
+      context "to a non-existent file, but with an existing DEFAULT_OVERRIDE_FILE_NAME file" do
+        let(:env_override_file){ "/this/file/totally/does/not/exist.txt"}
+        let(:new_default_file){overrides_path("good")}
+
+        it "should still return 'nil', because environment variable has priority" do
+          stub_const("Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME", new_default_file)
+
+          File.exist?(Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME).should be_true
+          ENV['OMNIBUS_OVERRIDE_FILE'].should_not be_nil
+          
+          subject.should be_nil
+        end
+      end
+    end
+  end
+
+  describe "#overrides" do
+    context "when an overrides file cannot be found" do
+      before :each do
+        Omnibus::Overrides.stub(:resolve_override_file).and_return(nil)
+      end
+      
+      it "returns an empty hash" do
+        Omnibus::Overrides.overrides.should eq({})
+      end
+    end
+  end
+  
+end

data/spec/package_release_spec.rb

@@ -0,0 +1,197 @@
+#
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'omnibus/package_release'
+require 'spec_helper'
+
+describe Omnibus::PackageRelease do
+  let(:s3_key) { "s3key" }
+  let(:s3_secret) { "hey-bezos-store-my-stuff" }
+  let(:s3_bucket) { "myorg-omnibus-packages" }
+  let(:pkg_path) { "pkg/chef_11.4.0-183-g2c0040c-0.el6.x86_64.rpm" }
+  let(:pkg_metadata_path) { "#{pkg_path}.metadata.json" }
+
+  let(:config) do
+    {
+      :release_s3_access_key => s3_key,
+      :release_s3_secret_key => s3_secret,
+      :release_s3_bucket => s3_bucket
+    }
+  end
+  subject(:package_release) do
+    Omnibus::PackageRelease.new(pkg_path)
+  end
+
+  it "has a package path" do
+    package_release.package_path.should == pkg_path
+  end
+
+  it "defaults to `:private' access policy" do
+    package_release.access_policy.should == :private
+  end
+
+  describe "validating configuration" do
+
+    before do
+      Omnibus.stub!(:config).and_return(config)
+    end
+
+    it "validates that the s3 key is set" do
+      config.delete(:release_s3_access_key)
+      lambda { package_release.validate_config! }.should raise_error(Omnibus::InvalidS3ReleaseConfiguration)
+    end
+
+    it "validates that the s3 secret key is set" do
+      config.delete(:release_s3_secret_key)
+      lambda { package_release.validate_config! }.should raise_error(Omnibus::InvalidS3ReleaseConfiguration)
+    end
+
+    it "validates that the s3 bucket is set" do
+      config.delete(:release_s3_bucket)
+      lambda { package_release.validate_config! }.should raise_error(Omnibus::InvalidS3ReleaseConfiguration)
+    end
+
+    it "does not error on a valid configuration" do
+      lambda { package_release.validate_config! }.should_not raise_error
+    end
+  end
+
+  describe "validating package for upload" do
+    it "ensures that the package file exists" do
+      lambda { package_release.validate_package! }.should raise_error(Omnibus::NoPackageFile)
+    end
+
+    it "ensures that there is a metadata file for the package" do
+      File.should_receive(:exist?).with(pkg_path).and_return(true)
+      File.should_receive(:exist?).with(pkg_metadata_path).and_return(false)
+      lambda { package_release.validate_package! }.should raise_error(Omnibus::NoPackageMetadataFile)
+    end
+  end
+
+  context "with a valid config and package" do
+
+    let(:basename) { "chef_11.4.0-183-g2c0040c-0.el6.x86_64.rpm" }
+    let(:md5) { "016f2e0854c69901b3f0ad8f99ffdb75" }
+    let(:platform_path) { "el/6/x86_64" }
+    let(:pkg_content) { "expected package content" }
+
+    let(:metadata_json) do
+      <<-E
+{
+  "platform": "el",
+  "platform_version": "6",
+  "arch": "x86_64",
+  "version": "11.4.0-183-g2c0040c",
+  "basename": "#{basename}",
+  "md5": "#{md5}",
+  "sha256": "21191ab698d1663a5e738e470fad16a2c6efee05ed597002f2e846ec80ade38c"
+}
+      E
+    end
+
+    before do
+      package_release.stub!(:config).and_return(config)
+      File.stub(:exist?).with(pkg_metadata_path).and_return(true)
+      File.stub(:exist?).with(pkg_path).and_return(true)
+      IO.stub(:read).with(pkg_metadata_path).and_return(metadata_json)
+      IO.stub(:read).with(pkg_path).and_return(pkg_content)
+    end
+
+    it "configures s3 with the given credentials" do
+      expected_s3_config = {
+        :access_key         => s3_key,
+        :secret_access_key  => s3_secret,
+        :bucket             => s3_bucket,
+        :adaper             => :net_http
+      }
+      UberS3.should_receive(:new).with(expected_s3_config)
+      package_release.s3_client
+    end
+
+    it "generates the relative path for the package s3 key" do
+      package_release.platform_path.should == platform_path
+    end
+
+
+    it "uploads the package and metadata" do
+      package_release.s3_client.should_receive(:store).with(
+        "#{platform_path}/#{basename}.metadata.json",
+        metadata_json,
+        :access => :private
+      )
+      package_release.s3_client.should_receive(:store).with(
+        "#{platform_path}/#{basename}",
+        pkg_content,
+        :access => :private,
+        :content_md5 => md5
+      )
+      package_release.release
+    end
+
+    context "and a callback is given for after upload" do
+      let(:upload_records) { [] }
+
+      subject(:package_release) do
+        Omnibus::PackageRelease.new(pkg_path) do |uploaded|
+          upload_records << uploaded
+        end
+      end
+
+      it "fires the after_upload callback for each item uploaded" do
+        package_release.s3_client.should_receive(:store).with(
+          "#{platform_path}/#{basename}.metadata.json",
+          metadata_json,
+          :access => :private
+        )
+        package_release.s3_client.should_receive(:store).with(
+          "#{platform_path}/#{basename}",
+          pkg_content,
+          :access => :private,
+          :content_md5 => md5
+        )
+        package_release.release
+
+        upload_records.should == [ "#{platform_path}/#{basename}.metadata.json",
+                                   "#{platform_path}/#{basename}" ]
+      end
+    end
+
+    context "and the package is public" do
+
+      subject(:package_release) do
+        Omnibus::PackageRelease.new(pkg_path, :access => :public_read)
+      end
+
+      it "uploads the package and metadata" do
+        package_release.s3_client.should_receive(:store).with(
+          "#{platform_path}/#{basename}.metadata.json",
+          metadata_json,
+          :access => :public_read
+        )
+        package_release.s3_client.should_receive(:store).with(
+          "#{platform_path}/#{basename}",
+          pkg_content,
+          :access => :public_read,
+          :content_md5 => md5
+        )
+        package_release.release
+      end
+    end
+
+  end
+
+end

data/spec/s3_cacher_spec.rb

@@ -0,0 +1,47 @@
+#
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'omnibus/s3_cacher'
+
+describe Omnibus::S3Cache do
+
+  describe '#tarball_software' do
+    subject(:tarball_software) { described_class.new.tarball_software }
+
+    let(:source_a) { stub(source: { url: 'a' }) }
+    let(:source_b) { stub(source: { url: 'b' }) }
+    let(:source_c) { stub(source: {}) }
+    let(:projects) { [
+      stub({ library: [source_a, source_c] }),
+      stub({ library: [source_c, source_b] })
+    ] }
+    let(:software_with_urls) { [source_a, source_b] }
+
+    before do
+      Omnibus.stub(config: stub({
+        s3_bucket: 'test', s3_access_key: 'test', s3_secret_key: 'test'
+      }))
+
+      Omnibus.stub(projects: projects)
+    end
+
+    it 'lists all software with urls' do
+      tarball_software.should == software_with_urls
+    end
+  end
+end

data/spec/software_spec.rb

@@ -0,0 +1,85 @@
+require 'rake/dsl_definition'
+require 'omnibus/software'
+
+require 'spec_helper'
+
+describe Omnibus::Software do
+
+  let(:project) do
+    p = mock(Omnibus::Project)
+    p.should_receive(:install_path).any_number_of_times.and_return("monkeys")
+    p
+  end
+
+  let(:software_name) { "erchef" }
+  let(:software_file){ software_path(software_name) }
+  let(:version_from_file){ "4b19a96d57bff9bbf4764d7323b92a0944009b9e" }
+  let(:software){ Omnibus::Software.load(software_file, project) }
+
+  before :each do
+    # We don't want to mess with any of this stuff for these
+    # tests... we're just looking at version info right now
+    Omnibus::Software.any_instance.stub(:render_tasks)
+  end
+
+  subject { software }
+
+  describe "#whitelist_file" do
+
+    it "appends to the whitelist_files array" do
+      software.whitelist_files.size.should equal 0
+      software.whitelist_file(/foo\/bar/)
+      software.whitelist_files.size.should equal 1
+    end
+
+    it "converts Strings to Regexp instances" do
+      software.whitelist_file "foo/bar"
+      software.whitelist_files.size.should equal 1
+      software.whitelist_files.first.should be_kind_of(Regexp)
+    end
+  end
+
+  context "testing version overrides" do
+
+    context "without overrides" do
+      its(:name){should eq(software_name)}
+      its(:version){should eq(version_from_file)}
+      its(:given_version){should eq(software.version)}
+      its(:override_version){should be_nil}
+    end
+
+    context "with overrides" do
+      let(:override_software_version){"6.6.6"}
+      let(:overrides) do
+        {override_software_name => override_software_version}
+      end
+      let(:software){Omnibus::Software.load(software_file, project, overrides)}
+
+      context "but not for this software" do
+        let(:override_software_name){"chaos_monkey"}
+
+        it "really should not have any overrides for this software" do
+          overrides.should_not have_key(software_name)
+        end
+
+        its(:version){should eq(version_from_file)}
+        its(:given_version){should eq(software.version)}
+        its(:override_version){should be_nil}
+      end
+
+      context "for this software" do
+        let(:override_software_name){software_name}
+
+        it "really should have an override for this software" do
+          overrides.should have_key(software_name)
+        end
+
+        its(:version){should eq(override_software_version)}
+        its(:override_version){should eq(software.version)}
+        its(:version){should_not eq(software.given_version)}
+        its(:given_version){should eq(version_from_file)}
+      end
+    end
+
+  end
+end