packaging 0.88.77

data/spec/lib/packaging/util/git_tag_spec.rb

@@ -0,0 +1,36 @@
+# -*- ruby -*-
+require 'spec_helper'
+
+describe "Pkg::Util::Git_tag" do
+  context "parse_ref!" do
+    it "fails for a ref that doesn't exist'" do
+      expect { Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "garbagegarbage") }.to raise_error(RuntimeError, /ERROR : Not a ref or sha!/)
+    end
+  end
+
+  context "sha?" do
+    it "sets ref type as a sha when passed a sha" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "4eef05389ebf418b62af17406c7f9f13fa51f975")
+      expect(git_tag.sha?).to eq(true)
+    end
+  end
+
+  context "branch?" do
+    it "sets ref type as a branch when passed a branch" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "main")
+      expect(git_tag.branch?).to eq(true)
+    end
+  end
+
+  context "tag?" do
+    it "sets ref type as a tag when passed a tag" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "tags/0.6.2")
+      expect(git_tag.tag?).to eq(true)
+    end
+
+    it "sets ref type as a tag when passed a fully qualified tag" do
+      git_tag = Pkg::Util::Git_tag.new("git://github.com/puppetlabs/leatherman.git", "refs/tags/0.6.2")
+      expect(git_tag.tag?).to eq(true)
+    end
+  end
+end

data/spec/lib/packaging/util/gpg_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "Pkg::Util::Gpg" do
+  let(:gpg)      { "/local/bin/gpg" }
+  let(:keychain) { "/usr/local/bin/keychain" }
+  let(:gpg_key)  { "abcd1234" }
+  let(:target_file) { "/tmp/file" }
+
+  before(:each) do
+    reset_env(['RPM_GPG_AGENT'])
+    Pkg::Config.gpg_key = gpg_key
+  end
+
+  describe '#key' do
+    it "fails if Pkg::Config.gpg_key isn't set" do
+      allow(Pkg::Config).to receive(:gpg_key).and_return(nil)
+      expect { Pkg::Util::Gpg.key }.to raise_error(RuntimeError)
+    end
+    it "fails if Pkg::Config.gpg_key is an empty string" do
+      allow(Pkg::Config).to receive(:gpg_key).and_return('')
+      expect { Pkg::Util::Gpg.key }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#kill_keychain' do
+    it "doesn't reload the keychain if already loaded" do
+      Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", true)
+      Pkg::Util::Gpg.should_receive(:kill_keychain).never
+      Pkg::Util::Gpg.should_receive(:start_keychain).never
+      Pkg::Util::Gpg.load_keychain
+      Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", nil)
+    end
+
+    it "doesn't reload the keychain if ENV['RPM_GPG_AGENT'] is set" do
+      ENV['RPM_GPG_AGENT'] = 'blerg'
+      Pkg::Util::Gpg.should_receive(:kill_keychain).never
+      Pkg::Util::Gpg.should_receive(:start_keychain).never
+      Pkg::Util::Gpg.load_keychain
+    end
+
+    it 'kills and starts the keychain if not loaded already' do
+      Pkg::Util::Gpg.instance_variable_set("@keychain_loaded", nil)
+      Pkg::Util::Gpg.should_receive(:kill_keychain).once
+      Pkg::Util::Gpg.should_receive(:start_keychain).once
+      Pkg::Util::Gpg.load_keychain
+    end
+  end
+
+  describe '#sign_file' do
+    it 'adds special flags if RPM_GPG_AGENT is set' do
+      ENV['RPM_GPG_AGENT'] = 'blerg'
+      additional_flags = "--no-tty --use-agent"
+      Pkg::Util::Tool.should_receive(:find_tool).with('gpg').and_return(gpg)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{gpg}\s#{additional_flags}\s--armor --detach-sign -u #{gpg_key} #{target_file}")
+      Pkg::Util::Gpg.sign_file(target_file)
+    end
+
+    it 'signs without extra flags when RPM_GPG_AGENT is not set' do
+      Pkg::Util::Tool.should_receive(:find_tool).with('gpg').and_return(gpg)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{gpg}\s\s--armor --detach-sign -u #{gpg_key} #{target_file}")
+      Pkg::Util::Gpg.sign_file(target_file)
+    end
+  end
+end

data/spec/lib/packaging/util/jenkins_spec.rb

@@ -0,0 +1,112 @@
+# -*- ruby -*-
+require 'spec_helper'
+
+describe Pkg::Util::Jenkins do
+  let(:build_host) {"Jenkins-foo"}
+  let(:name) {"job-foo"}
+  around do |example|
+    old_build_host = Pkg::Config.jenkins_build_host
+    Pkg::Config.jenkins_build_host = build_host
+    example.run
+    Pkg::Config.jenkins_build_host = old_build_host
+  end
+
+  describe "#create_jenkins_job" do
+    let(:xml_file) {"bar.xml"}
+
+    it "should call curl_form_data with the correct arguments" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/createItem?name=#{name}", ["-H", '"Content-Type: application/xml"', "--data-binary", "@#{xml_file}"])
+      Pkg::Util::Jenkins.create_jenkins_job(name, xml_file)
+    end
+  end
+
+  describe "#jenkins_job_exists?" do
+
+    it "should call curl_form_data with correct arguments" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 0])
+      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name)
+    end
+
+    it "should return false on job not existing" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 1])
+      Pkg::Util::Execution.should_receive(:success?).and_return(false)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_false
+    end
+
+    it "should return false if curl_form_data raised a runtime error" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(false)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_false
+    end
+
+    it "should return true when job exists" do
+      Pkg::Util::Net.should_receive(:curl_form_data).with("http://#{build_host}/job/#{name}/config.xml", ["--silent", "--fail"], :quiet => true).and_return(['output', 0])
+      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+      Pkg::Util::Jenkins.jenkins_job_exists?(name).should be_true
+    end
+  end
+
+  describe '#poll_jenkins_job' do
+    let(:job_url) { "http://cat.meow/" }
+    let(:build_url) { "#{job_url}/1" }
+    let(:result) { "SUCCESS" }
+    let(:job_hash) { {'lastBuild' => { 'url' => build_url } }}
+    let(:build_hash) { {'result' => result, 'building' => false } }
+
+    before :each do
+      subject.stub(:get_jenkins_info).with(job_url).and_return(job_hash)
+      subject.stub(:wait_for_build).with(build_url).and_return(build_hash)
+    end
+
+    context "when polling the given url" do
+      it "return the resulting build_hash when build completes successfully" do
+        subject.poll_jenkins_job(job_url)
+      end
+    end
+  end
+
+  describe '#wait_for_build' do
+    let(:job_url) { "http://cat.meow/" }
+    let(:build_url) { "#{job_url}/1" }
+    let(:build_hash) { {'building' => false } }
+
+    context "when waiting for the given build to finish" do
+      it "return the resulting build_hash when build completes successfully" do
+        subject.should_receive(:get_jenkins_info).with(job_url).and_return(build_hash)
+        subject.wait_for_build(job_url)
+      end
+    end
+  end
+
+  describe '#get_jenkins_info' do
+    let(:url) { "http://cat.meow/" }
+    let(:uri) { URI(url) }
+    let(:response) { double }
+    let(:valid_json) { "{\"employees\":[
+    {\"firstName\":\"John\", \"lastName\":\"Doe\"},
+    {\"firstName\":\"Anna\", \"lastName\":\"Smith\"},
+    {\"firstName\":\"Peter\", \"lastName\":\"Jones\"} ]}" }
+
+    before :each do
+      response.stub(:body).and_return( valid_json )
+      response.stub(:code).and_return( '200' )
+      Pkg::Util::Jenkins.should_receive(:URI).and_return(uri)
+    end
+
+    context "when making HTTP GET request to given url" do
+      it "should return Hash of JSON contents when response is non-error" do
+        Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
+        subject.get_jenkins_info(url)
+      end
+
+      it "should raise Runtime error when response is error" do
+        response.stub(:code).and_return( '400' )
+        Net::HTTP.should_receive(:get_response).with(uri).and_return(response)
+        expect{
+          subject.get_jenkins_info(url)
+        }.to raise_error(Exception, /Unable to query .*, please check that it is valid./)
+      end
+    end
+  end
+
+end

data/spec/lib/packaging/util/misc_spec.rb

@@ -0,0 +1,31 @@
+# -*- ruby -*-
+require 'spec_helper'
+
+describe 'Pkg::Util::Misc' do
+  context "#search_and_replace" do
+    let(:orig_string) { "#!/bin/bash\necho '__REPO_NAME__'" }
+    let(:updated_string) { "#!/bin/bash\necho 'abcdefg'" }
+    let(:good_replacements) do
+      { __REPO_NAME__: Pkg::Paths.repo_name }
+    end
+    let(:warn_replacements) do
+      { __REPO_NAME__: nil }
+    end
+
+    it 'replaces the token with the Pkg::Config variable' do
+      Pkg::Config.config_from_hash({:project => "foo", :repo_name => 'abcdefg'})
+      Pkg::Util::Misc.search_and_replace(orig_string, good_replacements).should eq(updated_string)
+    end
+
+    it 'does no replacement if the Pkg::Config variable is not set' do
+      Pkg::Config.config_from_hash({:project => 'foo',})
+      Pkg::Util::Misc.search_and_replace(orig_string, good_replacements).should eq(orig_string)
+    end
+
+    it 'warns and continues if the Pkg::Config variable is unknown to packaging' do
+      Pkg::Config.config_from_hash({:project => 'foo',})
+      Pkg::Util::Misc.should_receive(:warn).with("replacement value for '#{warn_replacements.keys.first}' probably shouldn't be nil")
+      Pkg::Util::Misc.search_and_replace(orig_string, warn_replacements).should eq(orig_string)
+    end
+  end
+end

data/spec/lib/packaging/util/net_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+require 'socket'
+require 'open3'
+
+describe "Pkg::Util::Net" do
+  let(:target)     { "/tmp/placething" }
+  let(:target_uri) { "http://google.com" }
+  let(:content)    { "stuff" }
+  let(:rsync)      { "/bin/rsync" }
+  let(:ssh)        { "/usr/local/bin/ssh" }
+  let(:s3cmd)      { "/usr/local/bin/s3cmd" }
+
+  describe "#fetch_uri" do
+    context "given a target directory" do
+      it "does nothing if the directory isn't writable" do
+        File.stub(:writable?).with(File.dirname(target)) { false }
+        File.should_receive(:open).never
+        Pkg::Util::Net.fetch_uri(target_uri, target)
+      end
+
+      it "writes the content of the uri to a file if directory is writable" do
+        File.should_receive(:writable?).once.with(File.dirname(target)) { true }
+        File.should_receive(:open).once.with(target, 'w')
+        Pkg::Util::Net.fetch_uri(target_uri, target)
+      end
+    end
+  end
+
+  describe "hostname utils" do
+
+    describe "hostname" do
+      it "should return the hostname of the current host" do
+        Socket.stub(:gethostname) { "foo" }
+        Pkg::Util::Net.hostname.should eq("foo")
+      end
+    end
+
+    describe "check_host" do
+      context "with required :true" do
+        it "should raise an exception if the passed host does not match the current host" do
+          Socket.stub(:gethostname) { "foo" }
+          Pkg::Util::Net.should_receive(:check_host).and_raise(RuntimeError)
+          expect{ Pkg::Util::Net.check_host("bar", :required => true) }.to raise_error(RuntimeError)
+        end
+      end
+
+      context "with required :false" do
+        it "should return nil if the passed host does not match the current host" do
+          Socket.stub(:gethostname) { "foo" }
+          Pkg::Util::Net.check_host("bar", :required => false).should be_nil
+        end
+      end
+    end
+  end
+
+  describe "remote_ssh_cmd" do
+    it "should be able to call via deprecated shim" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
+      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+      Pkg::Util::Net.remote_ssh_cmd("foo", "bar", true)
+    end
+  end
+
+  describe "remote_execute" do
+    it "should fail if ssh is not present" do
+      Pkg::Util::Tool.stub(:find_tool).with("ssh") { fail }
+      Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_raise(RuntimeError)
+      expect{ Pkg::Util::Net.remote_execute("foo", "bar") }.to raise_error(RuntimeError)
+    end
+
+    it "should be able to not fail fast" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Kernel.should_receive(:system).with("#{ssh}  -t foo 'bar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute(
+          "foo", "bar", capture_output: false, extra_options: '', fail_fast: false)
+    end
+
+    it "should be able to trace output" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -x;bar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute(
+          "foo", "bar", capture_output: false, fail_fast: false, trace: true)
+    end
+
+    context "without output captured" do
+      it "should execute a command :foo on a host :bar using Kernel" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute("foo", "bar")
+      end
+
+      it "should escape single quotes in the command" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute("foo", "b'ar")
+      end
+
+      it "should raise an error if ssh fails" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(false)
+        expect{ Pkg::Util::Net.remote_execute("foo", "bar") }
+          .to raise_error(RuntimeError, /failed./)
+      end
+    end
+
+    context "with output captured" do
+      it "should execute a command :foo on a host :bar using Pkg::Util::Execution.capture3" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute("foo", "bar", capture_output: true)
+      end
+
+      it "should escape single quotes in the command" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(true)
+        Pkg::Util::Net.remote_execute("foo", "b'ar", capture_output: true)
+      end
+
+      it "should raise an error if ssh fails" do
+        Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+        Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
+        Pkg::Util::Execution.should_receive(:success?).and_return(false)
+        expect{ Pkg::Util::Net.remote_execute("foo", "bar", capture_output: true) }
+          .to raise_error(RuntimeError, /failed./)
+      end
+    end
+  end
+
+  describe "#rsync_to" do
+    defaults = "--recursive --hard-links --links --verbose --omit-dir-times --no-perms --no-owner --no-group"
+    it "should fail if rsync is not present" do
+      Pkg::Util::Tool.stub(:find_tool).with("rsync") { fail }
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_raise(RuntimeError)
+      expect{ Pkg::Util::Net.rsync_to("foo", "bar", "boo") }.to raise_error(RuntimeError)
+    end
+
+    it "should rsync 'thing' to 'foo@bar:/home/foo' with flags '#{defaults} --ignore-existing'" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} --ignore-existing thing foo@bar:/home/foo", true)
+      Pkg::Util::Net.rsync_to("thing", "foo@bar", "/home/foo")
+    end
+
+    it "rsyncs 'thing' to 'foo@bar:/home/foo' with flags that don't include --ignore-existing" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} thing foo@bar:/home/foo", true)
+      Pkg::Util::Net.rsync_to("thing", "foo@bar", "/home/foo", extra_flags: [])
+    end
+
+    it "rsyncs 'thing' to 'foo@bar:/home/foo' with flags that don't include arbitrary flags" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} --foo-bar --and-another-flag thing foo@bar:/home/foo", true)
+      Pkg::Util::Net.rsync_to("thing", "foo@bar", "/home/foo", extra_flags: ["--foo-bar", "--and-another-flag"])
+    end
+  end
+
+  describe "#s3sync_to" do
+    it "should fail if s3cmd is not present" do
+      Pkg::Util::Tool.should_receive(:find_tool).with('s3cmd', :required => true).and_raise(RuntimeError)
+      Pkg::Util::Execution.should_not_receive(:capture3).with("#{s3cmd} sync  'foo' s3://bar/boo/")
+      expect{ Pkg::Util::Net.s3sync_to("foo", "bar", "boo") }.to raise_error(RuntimeError)
+    end
+
+    it "should fail if ~/.s3cfg is not present" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("s3cmd").and_return(s3cmd)
+      Pkg::Util::File.should_receive(:file_exists?).with(File.join(ENV['HOME'], '.s3cfg')).and_return(false)
+      expect{ Pkg::Util::Net.s3sync_to("foo", "bar", "boo") }.to raise_error(RuntimeError, /does not exist/)
+    end
+
+    it "should s3 sync 'thing' to 's3://foo@bar/home/foo/' with no flags" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("s3cmd").and_return(s3cmd)
+      Pkg::Util::File.should_receive(:file_exists?).with(File.join(ENV['HOME'], '.s3cfg')).and_return(true)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{s3cmd} sync  'thing' s3://foo@bar/home/foo/")
+      Pkg::Util::Net.s3sync_to("thing", "foo@bar", "home/foo")
+    end
+
+    it "should s3 sync 'thing' to 's3://foo@bar/home/foo/' with --delete-removed and --acl-public" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("s3cmd").and_return(s3cmd)
+      Pkg::Util::File.should_receive(:file_exists?).with(File.join(ENV['HOME'], '.s3cfg')).and_return(true)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{s3cmd} sync --delete-removed --acl-public 'thing' s3://foo@bar/home/foo/")
+      Pkg::Util::Net.s3sync_to("thing", "foo@bar", "home/foo", ["--delete-removed", "--acl-public"])
+    end
+  end
+
+  describe "#rsync_from" do
+    defaults = "--recursive --hard-links --links --verbose --omit-dir-times --no-perms --no-owner --no-group"
+    it "should fail if rsync is not present" do
+      Pkg::Util::Tool.stub(:find_tool).with("rsync") { fail }
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_raise(RuntimeError)
+      expect{ Pkg::Util::Net.rsync_from("foo", "bar", "boo") }.to raise_error(RuntimeError)
+    end
+
+    it "should not include the flags '--ignore-existing' by default" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} foo@bar:thing /home/foo", true)
+      Pkg::Util::Net.rsync_from("thing", "foo@bar", "/home/foo")
+    end
+
+    it "should rsync 'thing' from 'foo@bar' to '/home/foo' with flags '#{defaults}'" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} foo@bar:thing /home/foo", true)
+      Pkg::Util::Net.rsync_from("thing", "foo@bar", "/home/foo")
+    end
+
+    it "rsyncs 'thing' from 'foo@bar:/home/foo' with flags that don't include arbitrary flags" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("rsync").and_return(rsync)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{rsync} #{defaults} --foo-bar --and-another-flag foo@bar:thing /home/foo", true)
+      Pkg::Util::Net.rsync_from("thing", "foo@bar", "/home/foo", extra_flags: ["--foo-bar", "--and-another-flag"])
+    end
+  end
+
+  describe "#curl_form_data" do
+    let(:curl) {"/bin/curl"}
+    let(:form_data) {["name=FOO"]}
+    let(:options) { {:quiet => true} }
+
+    it "should return false on failure" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i '#{target_uri}'").and_return(['stdout', 'stderr', 1])
+      Pkg::Util::Net.curl_form_data(target_uri).should eq(['stdout', 1])
+    end
+
+
+    it "should curl with just the uri" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i '#{target_uri}'")
+      Pkg::Util::Net.curl_form_data(target_uri)
+    end
+
+    it "should curl with the form data and uri" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i #{form_data[0]} '#{target_uri}'")
+      Pkg::Util::Net.curl_form_data(target_uri, form_data)
+    end
+
+    it "should curl with form data, uri, and be quiet" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("curl").and_return(curl)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{curl} -i #{form_data[0]} '#{target_uri}'").and_return(['stdout', 'stderr', 0])
+      Pkg::Util::Net.curl_form_data(target_uri, form_data, options).should eq(['', 0])
+    end
+
+  end
+
+  describe "#print_url_info" do
+    it "should output correct formatting" do
+      Pkg::Util::Net.should_receive(:puts).with("\n////////////////////////////////////////////////////////////////////////////////\n\n
+  Build submitted. To view your build progress, go to\n#{target_uri}\n\n
+////////////////////////////////////////////////////////////////////////////////\n\n")
+      Pkg::Util::Net.print_url_info(target_uri)
+    end
+  end
+end