proxy_pac_rb 0.4.2 → 0.5.0

data/spec/environment_spec.rb

@@ -1,161 +1,204 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe ProxyPacRb::Environment do
-  let(:environment) do
-    Environment.new(client_ip: '127.0.0.1', time: Time.now)
+RSpec.describe ProxyPacRb::Environment do
+  let(:client_ip) { '127.0.0.1' }
+  let(:time) { '1970-01-01 00:00:00' }
+  let(:environment) { Environment.new(client_ip: client_ip, time: time) }
+
+  describe '#initialize' do
+    context 'when valid ip address is given' do
+      it { expect { environment }.not_to raise_error }
+    end
+
+    context 'when invalid ip address is given' do
+      let(:client_ip) { 'invalid_ip' }
+      it { expect { environment }.to raise_error IPAddr::InvalidAddressError }
+    end
+
+    context 'when ip address is given as ip address-object' do
+      let(:client_ip) { IPAddr.new('127.0.0.1') }
+      it { expect { environment }.not_to raise_error }
+    end
+
+    context 'when valid time is given' do
+      it { expect { environment }.not_to raise_error }
+    end
+
+    context 'when invalid time is given' do
+      let(:time) { 'invalid_time' }
+      it { expect { environment }.to raise_error ArgumentError }
+    end
+
+    context 'when time is given as time object' do
+      let(:time) { Time.parse('1970-01-01 00:00:00') }
+      it { expect { environment }.not_to raise_error }
+    end
   end
 
   describe '#isResolvable()' do
-    it 'should return true for localhost' do
-      expect(environment.isResolvable('localhost')).to be true
+    context 'when is "localhost"' do
+      it { expect(environment.isResolvable('localhost')).to be true }
     end
 
-    it 'should return false for unexist.domain.localdomain' do
-      expect(environment.isResolvable('unexist.domain.localdomain')).to be false
+    context 'when is "unexist.domain.localdomain"' do
+      it { expect(environment.isResolvable('unexist.domain.localdomain')).to be false }
     end
   end
 
   describe '#isPlainHostName' do
-    it 'returns true for google' do
-      result = environment.isPlainHostName('google')
-      expect(result).to be true
+    context 'when is url contains plain hostname "example"' do
+      let(:result) { environment.isPlainHostName('example') }
+      it { expect(result).to be true }
     end
 
-    it 'returns false for google.com' do
-      result = environment.isPlainHostName('google.com')
-      expect(result).to be false
+    context 'when is url contains hostname with domain "example.com"' do
+      let(:result) { environment.isPlainHostName('example.com') }
+      it { expect(result).to be false }
     end
   end
 
   describe '#dnsDomainIs' do
-    it 'returns true for maps.google.com' do
-      result = environment.dnsDomainIs('maps.google.com', '.google.com')
-      expect(result).to be true
+    context 'when domain matches fqdn' do
+      let(:result) { environment.dnsDomainIs('maps.example.com', '.example.com') }
+      it { expect(result).to be true }
     end
 
-    it 'returns false for maps.ms.com' do
-      result = environment.dnsDomainIs('maps.ms.com', '.google.com')
-      expect(result).to be false
+    context 'when domain does not match fqdn' do
+      let(:result) { environment.dnsDomainIs('maps.example.com', '.example.net') }
+      it { expect(result).to be false }
     end
   end
 
   describe '#localHostOrDomainIs' do
-    it 'returns true for maps.google.com' do
-      result = environment.localHostOrDomainIs('maps.google.com', 'maps.google.com')
-      expect(result).to be true
+    context 'when fqdn matches fqdn' do
+      let(:result) { environment.localHostOrDomainIs('maps.example.com', 'maps.example.com') }
+      it { expect(result).to be true }
+    end
+
+    context 'when plain host is included in fqdn' do
+      let(:result) { environment.localHostOrDomainIs('maps', 'maps.example.com') }
+      it { expect(result).to be true }
     end
 
-    it 'returns true for maps' do
-      result = environment.localHostOrDomainIs('maps', 'maps.google.com')
-      expect(result).to be true
+    context 'when fqdn does not match fqdn' do
+      let(:result) { environment.localHostOrDomainIs('maps.example.net', 'maps.example.com') }
+      it { expect(result).to be false }
     end
 
-    it 'returns false for maps.ms.com' do
-      result = environment.dnsDomainIs('maps.ms.com', '.google.com')
-      expect(result).to be false
+    context 'when plain host is not included in fqdn' do
+      let(:result) { environment.localHostOrDomainIs('text', 'maps.example.com') }
+      it { expect(result).to be false }
     end
   end
 
   describe '#isInNet' do
-    it 'returns true for 127.0.0.1' do
-      result = environment.isInNet('127.0.0.1', '127.0.0.0', '255.255.255.0')
-      expect(result).to be true
+    context 'when ip is included in network' do
+      let(:result) { environment.isInNet('127.0.0.1', '127.0.0.0', '255.255.255.0') }
+      it { expect(result).to be true }
     end
 
-    it 'returns false for 10.0.0.1' do
-      result = environment.isInNet('10.0.0.1', '127.0.0.0', '255.255.255.0')
-      expect(result).to be false
+    context 'when ip is not included in network' do
+      let(:result) { environment.isInNet('10.0.0.1', '127.0.0.0', '255.255.255.0') }
+      it { expect(result).to be false }
     end
 
-    it 'resolves host name' do
-      name =  'google-public-dns-a.google.com'
-      result = environment.isInNet(name, '8.0.0.0', '255.0.0.0')
-      expect(result).to eq true
+    context 'when a resolveable hostname is given' do
+      let(:result) { environment.isInNet('www.example.net', '93.0.0.0', '255.0.0.0') }
+      it { expect(result).to eq true }
     end
 
-    it 'handles not resolvable host names' do
-      name =  'asdf.in.localhost.localdomain'
-      result = environment.isInNet(name, '8.0.0.0', '255.0.0.0')
-      expect(result).to eq false
+    context 'when a non-resolveable hostname is given' do
+      let(:result) { environment.isInNet('www.example.net.localdomain', '93.0.0.0', '255.0.0.0') }
+      it { expect(result).to eq false }
     end
 
-    it 'handles empty strings' do
-      result = environment.isInNet('', '8.0.0.0', '255.0.0.0')
-      expect(result).to eq false
+    context 'when input is nil' do
+      let(:result) { environment.isInNet(nil, '93.0.0.0', '255.0.0.0') }
+      it { expect(result).to eq false }
     end
 
-    it 'handles nil' do
-      result = environment.isInNet(nil, '8.0.0.0', '255.0.0.0')
-      expect(result).to eq false
+    context 'when input is empty string ""' do
+      let(:result) { environment.isInNet('', '93.0.0.0', '255.0.0.0') }
+      it { expect(result).to eq false }
     end
   end
 
   describe '#dnsResolve' do
-    it 'returns the ip address for domain' do
-      ip   = '8.8.8.8'
-      name =  'google-public-dns-a.google.com'
-      expect(environment.dnsResolve(name)).to eq(ip)
+    context 'when a resolveable hostname is given' do
+      let(:result) { environment.dnsResolve('www.example.net') }
+      it { expect(result).to eq '93.184.216.34' }
     end
 
-    it 'return nil for a not resolvable host name' do
-      name =  'not.resolvable.localhost.localdomain'
-      expect(environment.dnsResolve(name)).to eq(nil)
+    context 'when a resolveable hostname is given' do
+      let(:result) { environment.dnsResolve('www.example.net.localdomain') }
+      it { expect(result).to eq nil }
     end
 
-    it 'handles nil values as input' do
-      expect(environment.dnsResolve(nil)).to eq(nil)
+    context 'when input is nil' do
+      let(:result) { environment.dnsResolve(nil) }
+      it { expect(result).to eq nil }
     end
 
-    it 'handles empty string as input' do
-      expect(environment.dnsResolve('')).to eq(nil)
+    context 'when input is empty string ""' do
+      let(:result) { environment.dnsResolve('') }
+      it { expect(result).to eq nil }
     end
 
-    it 'handles garbage as input' do
-      expect(environment.dnsResolve('§§jk:')).to eq(nil)
+    context 'when input is gargabe' do
+      let(:result) { environment.dnsResolve('§§jk:') }
+      it { expect(result).to eq nil }
     end
   end
 
   describe '#dnsDomainLevels' do
-    it 'returns the count of domain levels (dots)' do
-      result = environment.dnsDomainLevels('maps.google.com')
-      expect(result).to eq(2)
+    context 'when contains subdomains' do
+      let(:result) { environment.dnsDomainLevels('maps.example.com') }
+      it { expect(result).to eq 2 }
+    end
+
+    context 'when does not contain subdomains' do
+      let(:result) { environment.dnsDomainLevels('maps') }
+      it { expect(result).to eq 0 }
     end
   end
 
   describe '#shExpMatch' do
-    it 'returns true for maps.google.com' do
-      result = environment.shExpMatch('maps.google.com', '*.com')
-      expect(result).to be true
+    context 'when pattern matches hostname' do
+      let(:result) { environment.shExpMatch('maps.example.com', '*.com') }
+      it { expect(result).to be true }
     end
 
-    it 'returns false for maps.ms.com' do
-      result = environment.shExpMatch('maps.ms.com', '*.de')
-      expect(result).to be false
+    context 'when pattern does not match hostname' do
+      let(:result) { environment.shExpMatch('maps.example.com', '*.de') }
+      it { expect(result).to be false }
     end
   end
 
   describe '#alert' do
-    it 'outputs msg' do
-      result = capture(:stderr) do
-        environment.alert('message')
+    context 'when message is given' do
+      let(:result) do
+        capture(:stderr) do
+          environment.alert('message')
+        end.chomp
       end
 
-      expect(result.chomp).to eq('message')
+      it { expect(result).to eq 'message' }
     end
   end
 
   describe '#prepare' do
-    it 'adds neccessary functions to source file' do
-      string = ''
-      environment.prepare(string)
+    context 'when valid' do
+      let(:string) { '' }
+
+      before(:each) { environment.prepare(string) }
 
       %w(
         myIpAddress
         weekdayRange
         dateRange
         timeRange
-      ).each { |f| expect(string).to include(f) }
+      ).each { |f| it { expect(string).to include(f) } }
     end
   end
 end

data/spec/parser_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe ProxyPacRb::Parser do
+RSpec.describe ProxyPacRb::Parser do
   subject(:proxy_pac) { Parser.new(environment: environment).parse(source) }
 
   let(:environment) { Environment.new }

data/spec/rspec/compare_proxy_pac_files_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'proxy_pac_rb/rspec'
+
+RSpec.describe 'Compare to proxy.pac-files', type: :proxy_pac do
+  subject do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  let(:file_a) do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  let(:file_b) do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  context 'when file "a" is already a ProxyPacFile' do
+    it { expect(proxy_pac).to be_the_same_proxy_pac_file file_b }
+  end
+
+  context 'when file "b" is already a ProxyPacFile' do
+    it { expect(file_b).to be_the_same_proxy_pac_file proxy_pac }
+  end
+
+  context 'when file "a" and file "b" are strings' do
+    context 'when both are eqal' do
+      it { expect(file_a).to be_the_same_proxy_pac_file file_b }
+    end
+
+    context 'when both are not eqal' do
+      let(:file_a) do
+        <<-EOS.strip_heredoc.chomp
+        function FindProxyForURL(url, host) {
+          return "DIRECT";
+        }
+        EOS
+      end
+
+      let(:file_b) do
+        <<-EOS.strip_heredoc.chomp
+        function FindProxyForURL(url, host) {
+          return "PROXY localhost:8080";
+        }
+        EOS
+      end
+
+      it { expect(file_a).not_to be_the_same_proxy_pac_file file_b }
+    end
+  end
+end

data/spec/rspec/parse_proxy_pac_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'proxy_pac_rb/rspec'
+
+RSpec.describe 'Parse proxy.pac', type: :proxy_pac do
+  describe 'Browse url' do
+    subject do
+      <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        if (dnsDomainIs(host, 'localhost')) {
+          return "DIRECT";
+        } else {
+          return "PROXY proxy.example.com:3128";
+        }
+      }
+      EOS
+    end
+
+    context 'http://localhost' do
+      let(:url) { 'http://localhost' }
+      it { expect(url).to be_downloaded_via 'DIRECT' }
+    end
+
+    context 'http://www.example.org' do
+      let(:url) { 'http://www.example.org' }
+      it { expect(url).not_to be_downloaded_via 'DIRECT' }
+    end
+  end
+
+  describe 'Change time' do
+    subject do
+      <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        if (weekdayRange("FRI", "SAT")) {
+          return "PROXY localhost:8080";
+        } else {
+          return "DIRECT";
+        }
+      }
+      EOS
+    end
+
+    let(:url) { 'http://www.example.org' }
+
+    context 'when using default value Thursday, 1970-01-01' do
+      it { expect(url).to be_downloaded_via 'DIRECT' }
+    end
+
+    context 'when time is Thursday, 1970-01-01' do
+      let(:time) { '1970-01-01' }
+      it { expect(url).to be_downloaded_via 'DIRECT' }
+    end
+
+    context 'when time is Friday, 1970-01-02' do
+      let(:time) { '1970-01-02' }
+      it { expect(url).to be_downloaded_via 'PROXY localhost:8080' }
+    end
+  end
+
+  describe 'Change client ip' do
+    subject do
+      <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        if ( myIpAddress() == '127.0.0.2' ) {
+          return "PROXY localhost:8080";
+        } else {
+          return "DIRECT";
+        }
+      }
+      EOS
+    end
+
+    let(:url) { 'http://www.example.org' }
+
+    context 'when using default value for ip, 127.0.0.1' do
+      it { expect(url).to be_downloaded_via 'DIRECT' }
+    end
+
+    context 'when ip is 127.0.0.1' do
+      let(:client_ip) { '127.0.0.1' }
+      it { expect(url).to be_downloaded_via 'DIRECT' }
+    end
+
+    context 'when ip is 127.0.0.2' do
+      let(:client_ip) { '127.0.0.2' }
+      it { expect(url).to be_downloaded_via 'PROXY localhost:8080' }
+    end
+  end
+end

data/spec/rspec/readability_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'proxy_pac_rb/rspec'
+
+RSpec.describe 'Readability', type: :proxy_pac do
+  let(:content) do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  context 'when is file' do
+    let(:root_path) { current_dir }
+
+    subject { 'proxy.pac' }
+
+    context 'when proxy pac exist' do
+      before :each do
+        write_file 'proxy.pac', content
+      end
+
+      it { expect(proxy_pac).to be_readable }
+    end
+
+    context 'when proxy pac does not exist' do
+      it { expect(proxy_pac).not_to be_readable }
+    end
+  end
+
+  context 'when is url' do
+    subject { 'http://www.example.com/proxy.pac' }
+
+    context 'when is readable' do
+      before(:each) { stub_request(:get, subject).to_return(body: content, status: 200) }
+      it { expect(proxy_pac).to be_readable }
+    end
+    context 'when is not readable' do
+      before(:each) { stub_request(:get, subject).to_raise(StandardError) }
+      it { expect(proxy_pac).not_to be_readable }
+    end
+  end
+
+  context 'when is string' do
+    context 'it is always readable' do
+      subject do
+        <<-EOS.strip_heredoc.chomp
+        function FindProxyForURL(url, host) {
+          return "DIRECT";
+        }
+        EOS
+      end
+
+      it { expect(proxy_pac).to be_readable }
+    end
+  end
+end

data/spec/rspec/rspec_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ProxyPacRb do
+  it 'has a version number' do
+    expect(ProxyPacRb::VERSION).not_to be nil
+  end
+end

data/spec/rspec/validitiy_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'proxy_pac_rb/rspec'
+
+RSpec.describe 'Validity', type: :proxy_pac do
+  subject do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  context 'when is valid' do
+    it { expect(proxy_pac).to be_valid }
+  end
+
+  context 'when is not valid' do
+    context 'when is not readable' do
+      subject { 'function Gargabe' }
+
+      it { expect(proxy_pac).not_to be_valid }
+    end
+
+    context 'when contains gargabe' do
+      subject do
+        <<-EOS.strip_heredoc.chomp
+        function FindProxyForURL(url, host) {
+          return $§"% "DIRECT";
+        }
+        EOS
+      end
+
+      it { expect(proxy_pac).not_to be_valid }
+    end
+
+    context 'when undefined variable is referenced' do
+      subject do
+        <<-EOS.strip_heredoc.chomp
+        function FindProxyForURL(url, host) {
+          return asdf;
+        }
+        EOS
+      end
+
+      it { expect(proxy_pac).not_to be_valid }
+    end
+  end
+end

data/spec/support/aruba.rb

@@ -11,38 +11,11 @@ module SpecHelper
     def dirs
       @dirs ||= %w(tmp rspec)
     end
-
-    def absolute_path(*args)
-      in_current_dir { File.expand_path File.join(*args) }
-    end
-
-    def _create_file(*args)
-      super
-
-      self
-    end
-
-    def create_dir(*args)
-      super
-
-      self
-    end
-
-    def touch_file(file_name)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
-        _mkdir(File.dirname(file_name))
-        FileUtils.touch file_name
-      end
-
-      self
-    end
   end
 end
 
 RSpec.configure do |c|
   c.include SpecHelper::Aruba
-
   c.before :each do
     clean_current_dir
     restore_env

data/spec/support/shared_examples/loader.rb

@@ -0,0 +1,27 @@
+RSpec.shared_examples 'a loadable proxy.pac' do
+  it { loader.load(proxy_pac) }
+end
+
+RSpec.shared_examples 'an un-readable proxy.pac' do
+  before(:each) do
+    expect(proxy_pac).to receive(:message=)
+    expect(proxy_pac).to receive(:readable=).with(false)
+    allow(proxy_pac).to receive(:content?).and_return(false)
+  end
+
+  it { loader.load(proxy_pac) }
+end
+
+RSpec.shared_examples 'a readable proxy.pac' do
+  before :each do
+    expect(proxy_pac).to receive(:content=).with(content)
+    allow(proxy_pac).to receive(:content?).and_return(false)
+  end
+
+  before(:each) do
+    expect(proxy_pac).not_to receive(:message=)
+    expect(proxy_pac).to receive(:readable=).with(true)
+  end
+
+  it { loader.load(proxy_pac) }
+end

data/templates/build/middleman/config.rb

@@ -0,0 +1,12 @@
+require 'proxy_pac_rb/rack/proxy_pac_linter'
+use ProxyPacRb::Rack::ProxyPacLinter
+
+require 'proxy_pac_rb/rack/proxy_pac_compressor'
+use ProxyPacRb::Rack::ProxyPacCompressor
+
+page '*.pac', content_type: 'application/x-ns-proxy-autoconfig'
+
+Dir.glob(File.join(source_dir, '**', '*.pac')).each do |f|
+  relative_path = Pathname.new(f).relative_path_from(Pathname.new(source_dir))
+  proxy(format('%s.raw', relative_path), relative_path.to_s, content_type: 'text/plain')
+end

data/templates/build/middleman/script/build

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+bundle exec middleman build --verbose

data/templates/default/.gitignore

@@ -0,0 +1,24 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+# git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the build directory
+/build
+
+# Ignore cache
+/.sass-cache
+/.cache
+
+# Ignore .DS_store file
+.DS_Store
+
+# Temp files
+tmp/
+
+# Logs
+*.log