vagrant-proxyconf 1.5.2 → 2.0.1

data/spec/unit/vagrant-proxyconf/action/configure_svn_proxy_spec.rb

@@ -1,6 +1,15 @@
 require 'spec_helper'
 require 'vagrant-proxyconf/action/configure_svn_proxy'
 
+def mock_write_config(machine)
+  allow(machine).to receive_message_chain(:communicate, :sudo).with("rm -f /tmp/vagrant-proxyconf", error_check: false)
+  allow(machine).to receive_message_chain(:communicate, :upload)
+  allow(machine).to receive_message_chain(:communicate, :sudo).with("chmod 0644 /tmp/vagrant-proxyconf")
+  allow(machine).to receive_message_chain(:communicate, :sudo).with("chown root:root /tmp/vagrant-proxyconf")
+  allow(machine).to receive_message_chain(:communicate, :sudo).with("mkdir -p /etc/subversion")
+  allow(machine).to receive_message_chain(:communicate, :sudo).with("mv -f /tmp/vagrant-proxyconf /etc/subversion/servers")
+end
+
 describe VagrantPlugins::ProxyConf::Action::ConfigureSvnProxy do
 
   describe '#config_name' do
@@ -8,6 +17,82 @@ describe VagrantPlugins::ProxyConf::Action::ConfigureSvnProxy do
     it      { is_expected.to eq 'svn_proxy' }
   end
 
+  describe "#configure_machine" do
+    let(:config) { OpenStruct.new }
+    let(:machine) { double('machine') }
+
+    subject do
+      svn_proxy = described_class.new(nil, nil)
+      svn_proxy.instance_variable_set(:@machine, machine)
+
+      allow(svn_proxy).to receive(:config) { config }
+      allow(machine).to receive_message_chain(:guest, :capability?).with(:svn_proxy_conf).and_return(@supported)
+      allow(machine).to receive_message_chain(:guest, :capability).with(:svn_proxy_conf).and_return(@supported)
+
+      mock_write_config(machine)
+
+      svn_proxy.send(:configure_machine)
+    end
+
+    it 'returns nil, when not supported' do
+      @supported = false
+
+      config.http = 'http://some-svn-proxy:8080'
+      config.no_proxy = 'localhost'
+
+      is_expected.to eq nil
+    end
+
+    it 'returns true, when supported' do
+      @supported = true
+
+      config.http = 'http://some-svn-proxy:8080'
+      config.no_proxy = 'localhost'
+
+      is_expected.to eq true
+    end
+
+  end
+
+  describe "#unconfigure_machine" do
+    let(:config) { OpenStruct.new }
+    let(:machine) { double('machine') }
+
+    subject do
+      svn_proxy = described_class.new(nil, nil)
+      svn_proxy.instance_variable_set(:@machine, machine)
+
+      allow(svn_proxy).to receive(:config) { config }
+      allow(machine).to receive_message_chain(:guest, :capability?).with(:svn_proxy_conf).and_return(@supported)
+      allow(machine).to receive_message_chain(:guest, :capability).with(:svn_proxy_conf).and_return(@supported)
+
+      allow(machine).to receive_message_chain(:communicate, :sudo).with("touch /etc/subversion/servers")
+      allow(machine).to receive_message_chain(:communicate, :sudo).with("sed -i.bak -e '/^http-proxy-/d' /etc/subversion/servers")
+      allow(machine).to receive_message_chain(:communicate, :sudo).with("chown root:root /etc/subversion/servers")
+      allow(machine).to receive_message_chain(:communicate, :sudo).with("chmod 0644 /etc/subversion/servers")
+
+      svn_proxy.send(:unconfigure_machine)
+    end
+
+    it 'returns nil, when not supported' do
+      @supported = false
+
+      config.http = 'http://some-svn-proxy:8080'
+      config.no_proxy = 'localhost'
+
+      is_expected.to eq nil
+    end
+
+    it 'returns true, when supported' do
+      @supported = true
+
+      config.http = 'http://some-svn-proxy:8080'
+      config.no_proxy = 'localhost'
+
+      is_expected.to eq true
+    end
+  end
+
   describe '#svn_config' do
     subject do
       action = described_class.new(nil, nil)

data/spec/unit/vagrant-proxyconf/action/configure_yum_proxy_spec.rb

@@ -41,4 +41,104 @@ describe VagrantPlugins::ProxyConf::Action::ConfigureYumProxy do
       it { is_expected.to eq %q{-v proxy=http://proxy.com:8080 -v user=foo\% -v pass=abc\#123} }
     end
   end
+
+  describe "#configure_machine" do
+    let(:machine) { double('machine') }
+    let(:config) { OpenStruct.new }
+
+    context "when not supported" do
+      subject do
+        yum_proxy = described_class.new(nil, nil)
+        yum_proxy.instance_variable_set(:@machine, machine)
+
+        allow(yum_proxy).to receive(:config) { config }
+        allow(machine).to receive_message_chain(:guest, :capability?).with(:yum_proxy_conf).and_return(false)
+        allow(machine).to receive_message_chain(:guest, :capability).with(:yum_proxy_conf).and_return(nil)
+
+        yum_proxy.send(:configure_machine)
+      end
+
+      it 'returns nil' do
+        is_expected.to eq nil
+      end
+    end
+
+    context "when supported" do
+      subject do
+        yum_proxy = described_class.new(nil, nil)
+        yum_proxy.instance_variable_set(:@machine, machine)
+
+        config.http = "http://username:pass@some-yum-proxy-server:8080"
+
+        allow(yum_proxy).to receive(:config) { config }
+        allow(machine).to receive_message_chain(:guest, :capability?).with(:yum_proxy_conf).and_return(true)
+        allow(machine).to receive_message_chain(:guest, :capability).with(:yum_proxy_conf).and_return("/etc/yum.conf")
+
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("rm -f /tmp/vagrant-proxyconf", error_check: false)
+        allow(machine).to receive_message_chain(:communicate, :upload)
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("touch /etc/yum.conf")
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("gawk -f /tmp/vagrant-proxyconf -v proxy=http://some-yum-proxy-server:8080 -v user=username -v pass=pass /etc/yum.conf > /etc/yum.conf.new")
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("chmod 0644 /etc/yum.conf.new")
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("chown root:root /etc/yum.conf.new")
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("mv -f /etc/yum.conf.new /etc/yum.conf")
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("rm -f /tmp/vagrant-proxyconf")
+
+        yum_proxy.send(:configure_machine)
+      end
+
+      it 'returns true' do
+        is_expected.to eq true
+      end
+
+    end
+  end
+
+  describe "#unconfigure_machine" do
+    let(:machine) { double('machine') }
+    let(:config) { OpenStruct.new }
+
+    context "when not supported" do
+      subject do
+        yum_proxy = described_class.new(nil, nil)
+        yum_proxy.instance_variable_set(:@machine, machine)
+
+        allow(yum_proxy).to receive(:config) { config }
+        allow(machine).to receive_message_chain(:guest, :capability?).with(:yum_proxy_conf).and_return(false)
+        allow(machine).to receive_message_chain(:guest, :capability).with(:yum_proxy_conf).and_return(nil)
+
+        yum_proxy.send(:unconfigure_machine)
+      end
+
+      it 'returns nil' do
+        is_expected.to eq nil
+      end
+    end
+
+    context "when supported" do
+      subject do
+        yum_proxy = described_class.new(nil, nil)
+        yum_proxy.instance_variable_set(:@machine, machine)
+
+        config.proxy = OpenStruct.new
+        config.proxy.enabled = false
+        config.http = "http://username:pass@some-yum-proxy-server:8080"
+
+        allow(yum_proxy).to receive(:config) { config }
+        allow(machine).to receive(:config) { config }
+
+        allow(machine).to receive_message_chain(:guest, :capability?).with(:yum_proxy_conf).and_return(true)
+        allow(machine).to receive_message_chain(:guest, :capability).with(:yum_proxy_conf).and_return("/etc/yum.conf")
+
+        allow(machine).to receive_message_chain(:communicate, :test).with("grep '^proxy' /etc/yum.conf").and_return(true)
+        allow(machine).to receive_message_chain(:communicate, :sudo).with("sed -i.bak -e '/^proxy/d' /etc/yum.conf")
+
+        yum_proxy.send(:unconfigure_machine)
+      end
+
+      it 'returns true' do
+        is_expected.to eq true
+      end
+    end
+  end
+
 end

data/spec/unit/vagrant-proxyconf/action/is_enabled_spec.rb

@@ -20,26 +20,176 @@ describe VagrantPlugins::ProxyConf::Action::IsEnabled do
     end
   end
 
-  [false, ''].each do |value|
-    context "with `config.proxy.enabled=#{value.inspect}`" do
-      let(:enabled) { value }
+  describe "#has_proxy_env_var?" do
+    subject do
+      is_enabled = described_class.new(app, env)
 
-      it "results to falsy" do
-        described_class.new(app, {}).call(env)
-        expect(env[:result]).to be_falsey
+      is_enabled.send(:has_proxy_env_var?, var)
+    end
+
+    context "when HTTP_PROXY is set in the environment and config.proxy.enabled=true" do
+      let(:enabled) { true }
+      let(:var) { 'HTTP_PROXY' }
+
+      before :each do
+        ENV[var] = 'http://localhost:8888'
+      end
+
+      after :each do
+        ENV[var] = nil
+      end
+
+      it { expect(ENV[var]).to eq 'http://localhost:8888' }
+
+      it { is_expected.to eq true }
+    end
+
+    context "when HTTPS_PROXY="" is set in the environment and config.proxy.enabled=true" do
+      let(:enabled) { true }
+      let(:var) { 'HTTPS_PROXY' }
+
+      before :each do
+        ENV[var] = ''
+      end
+
+      after :each do
+        ENV[var] = nil
+      end
+
+      it { expect(ENV[var]).to eq '' }
+      it { is_expected.to eq false }
+    end
+
+  end
+
+  describe "#plugin_disabled?" do
+
+    subject do
+      is_enabled = described_class.new(app, env)
+      is_enabled.send(:plugin_disabled?, env[:machine].config.proxy)
+    end
+
+    context "given config.proxy.enabled=false" do
+      let(:enabled) { false }
+
+      it { is_expected.to eq true }
+    end
+
+    context "given config.proxy.enabled=''" do
+      let(:enabled) { "" }
+
+      it { is_expected.to eq true }
+    end
+
+    context "given config.proxy.enabled=nil" do
+      let(:enabled) { false }
+
+      it { is_expected.to eq true }
+    end
+
+    context "given config.proxy.enabled={}" do
+      let(:enabled) { false }
+
+      it { is_expected.to eq true }
+    end
+
+    context "given config.proxy.enabled={:foo => 'bar'}" do
+      let(:enabled) do
+        {:foo => 'bar'}
       end
+
+      it { is_expected.to eq false }
+    end
+
+    context "given config.proxy.enabled=true" do
+      let(:enabled) { true }
+
+      it { is_expected.to eq false }
     end
+
+    context "given config.proxy.enabled='http://localhost:8080'" do
+      let(:enabled) { 'http://localhost:8080' }
+
+      it { is_expected.to eq false }
+    end
+
   end
 
-  [nil, true, :auto, 'yes please'].each do |value|
-    context "with `config.proxy.enabled=#{value.inspect}`" do
-      let(:enabled) { value }
+  describe "#plugin_enabled?" do
+    subject do
+      is_enabled = described_class.new(app, env)
+      is_enabled.send(:plugin_enabled?, env[:machine].config.proxy)
+    end
+
+    context "when config.proxy.enabled=false and ENV['HTTP_PROXY']='http://localhost:8888'" do
+      let(:enabled) { false }
+      let(:var) { 'HTTP_PROXY' }
+
+      before :each do
+        ENV[var] = 'http://localhost:8888'
+      end
 
-      it "results to truthy" do
-        described_class.new(app, {}).call(env)
-        expect(env[:result]).to be_truthy
+      after :each do
+        ENV[var] = nil
       end
+
+      it { is_expected.to eq false }
     end
+
+  end
+
+  describe "#call" do
+    [false, '', {}, nil].each do |value|
+      context "with `config.proxy.enabled=#{value.inspect}`" do
+        let(:enabled) { value }
+
+        it "results to falsy" do
+          described_class.new(app, {}).call(env)
+          expect(env[:result]).to be_falsey
+        end
+      end
+    end
+
+    [true, :auto, 'yes please', {:foo => 'yes'}].each do |value|
+      context "with `config.proxy.enabled=#{value.inspect}` and HTTP_PROXY=http://localhost:8888" do
+        let(:enabled) { value }
+        let(:var) { 'HTTP_PROXY' }
+
+        before :each do
+          ENV[var] = 'http://localhost:8888'
+        end
+
+        after :each do
+          ENV[var] = nil
+        end
+
+        it "results to truthy" do
+          described_class.new(app, {}).call(env)
+          expect(env[:result]).to be_truthy
+        end
+      end
+    end
+
+    [true, :auto, 'yes please', {:foo => 'yes'}].each do |value|
+      context "with `config.proxy.enabled=#{value.inspect}` and HTTP_PROXY=''" do
+        let(:enabled) { value }
+        let(:var) { 'HTTP_PROXY' }
+
+        before :each do
+          ENV[var] = ''
+        end
+
+        after :each do
+          ENV[var] = nil
+        end
+
+        it "results to truthy" do
+          described_class.new(app, {}).call(env)
+          expect(env[:result]).to be_falsey
+        end
+      end
+    end
+
   end
 
 end

data/spec/unit/vagrant-proxyconf/cap/linux/docker_proxy_conf_spec.rb

@@ -17,7 +17,7 @@ describe VagrantPlugins::ProxyConf::Cap::Linux::DockerProxyConf do
         (c == 'docker') ? '/path/to/docker' : false
       end
       allow(communicator).to receive(:test) do |c|
-        c == 'cat /etc/redhat-release'
+        c == '[ -f /etc/redhat-release ]'
       end
 
       expect(described_class.docker_proxy_conf(machine)).to eq '/etc/sysconfig/docker'

data/spec/unit/vagrant-proxyconf/cap/util_spec.rb

@@ -13,7 +13,7 @@ describe VagrantPlugins::ProxyConf::Cap::Util do
 
     it "returns the path when the command is installed" do
       expect(communicator).to receive(:execute).
-        with('which foo', error_check: false).
+        with('command -v foo', error_check: false).
         and_yield(:stdout, "/path/to/foo\n").
         and_yield(:stdout, "PROMPT\n").
         and_yield(:stderr, "not foo\n").
@@ -23,7 +23,7 @@ describe VagrantPlugins::ProxyConf::Cap::Util do
 
     it "returns false when the command is not installed" do
       expect(communicator).to receive(:execute).
-        with('which bar', error_check: false).
+        with('command -v bar', error_check: false).
         and_return(1)
       expect(described_class.which(machine, 'bar')).to be_falsey
     end

data/spec/unit/vagrant-proxyconf/config/key_mixin_spec.rb

@@ -9,7 +9,7 @@ describe VagrantPlugins::ProxyConf::Config::KeyMixin do
     key :bar
 
     # Hack to keep rspec 3 description generation happy
-    def respond_to?(method)
+    def respond_to?(method, include_all = false)
       return false if method == :to_ary
       super
     end

data/spec/unit/vagrant-proxyconf/resources/yum_config_spec.rb

@@ -69,6 +69,20 @@ describe 'resources/yum_config.awk' do
       end
     end
 
+    context "with old proxy conf containing special characters" do
+      let(:old_conf) { 'yum_with_repository_and_proxy_containing_special_chars.conf' }
+
+      it "replaces existing proxy and userinfo" do
+        conf = { proxy: 'http://proxy.example.com:3128/', user: 'foo', pass: 'bar' }
+        expect(configure(conf)).to eq fixture('yum_with_repository_and_proxy.conf')
+      end
+
+      it "disables existing proxy" do
+        conf = { proxy: '', user: 'baz', pass: 'bar' }
+        expect(configure(conf)).to eq fixture('yum_with_repository_and_disabled_proxy.conf')
+      end
+    end
+
     context "without userinfo" do
       let(:old_conf) { 'yum_with_repository_and_proxy_without_userinfo.conf' }