local_pac 0.1.11 → 0.1.13

data/spec/features/lookup_proxy_spec.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'spec_helper_features'
+
+describe 'Fetch proxy pac' do
+  context '/v1/pac' do
+    let(:valid_pac_file) do <<-EOS.strip_heredoc.chomp
+                           function FindProxyForURL(url, host) {
+                             return "DIRECT";
+                           }
+                           EOS
+    end
+
+    let(:pac_file_return_nil) do <<-EOS.strip_heredoc.chomp
+                           function FindProxyForURL(url, host) {
+                             return "";
+                           }
+                           EOS
+    end
+
+    let(:invalid_pac_file) do <<-EOS.strip_heredoc.chomp
+                           function FindProxyForURL(url, host) {
+                           asdfasdf();
+                           }
+                           EOS
+    end
+
+    let(:git_repo) { 'git_repo' }
+
+    before(:each) do
+      git_init(git_repo)
+      create_file(File.join(git_repo, 'file.pac'), valid_pac_file)
+      git_add(git_repo, 'file.pac')
+      git_commit(git_repo)
+    end
+
+    before :each do
+      config = Class.new do
+        include FeduxOrg::Stdlib::Filesystem
+
+        def root_directory
+          File.expand_path('../../../', __FILE__)
+        end
+
+        def local_storage
+          File.join(working_directory, 'git_repo', '.git')
+        end
+      end.new
+
+      LocalPac.config = config
+      Capybara.app = LocalPac::App::LookupController
+    end
+
+    it 'looks up proxy', :focus do
+      visit('/file.pac')
+      within('#search') do
+        fill_in 'url', :with => 'http://www.example.org'
+      end
+      expect(page).to have_content('asdf')
+    end
+
+    it 'shows a result output' do
+      rendered_view = <<-EOS.strip_heredoc
+      EOS
+      response = post('/file.pac', {:url => 'http://example.org'})
+      expect(last_response).to be_ok
+      expect(response.body).to eq('Please enter fully quallified url')
+    end
+
+    it 'handles a nil file as well' do
+      create_file(File.join(git_repo, 'file_nil.pac'), pac_file_return_nil)
+      git_add(git_repo, 'file_nil.pac')
+      git_commit(git_repo)
+
+      rendered_view = <<-EOS.strip_heredoc
+      EOS
+
+      response = post('/file_nil.pac', {:url => 'http://example.org'})
+
+      expect(last_response).to be_ok
+      expect(response.body).to eq(rendered_view)
+    end
+
+    it 'raises an exception on invalid pac file' do
+      create_file(File.join(git_repo, 'invalid.pac'), invalid_pac_file)
+      git_add(git_repo, 'invalid.pac')
+      git_commit(git_repo)
+
+      expect {
+        response = post('/invalid.pac', {:url => 'http://example.org'})
+      }.to raise_error RuntimeError
+    end
+
+    it 'returns a result for an existing proxy pac' do
+      pending
+    end
+
+    it 'returns a error if file does not exist' do
+      pending
+    end
+  end
+end

data/spec/initializer_spec.rb

@@ -10,20 +10,25 @@ describe Initializer do
         :local_storage: #{File.join(working_directory, 'storage', 'cache.git')}
         :executable: #{File.join(working_directory, 'bin', 'local_pac')}
         :pid_file: #{File.join(working_directory, 'run', 'pid')}
+        :sass_cache: #{File.join(working_directory, 'cache', 'sass')}
         :gem_path: []
       EOS
         config_file = create_file('config.yaml', config_string)
 
         config = LocalPac::Config.new(config_file)
         initializer = Initializer.new({}, config)
-        silence(:stderr) do
-          initializer.run
+        result = capture(:stdout) do
+          silence(:stderr) do
+            initializer.run
+          end
         end
 
         expect(path_exists?('log')).to be_true
+        expect(path_exists?('cache/sass')).to be_true
         expect(path_exists?('storage/cache.git')).to be_true
         expect(path_exists?(File.join('storage', 'cache.git', 'hooks', 'pre-receive'))).to be_true
         expect(path_exists?('run')).to be_true
+        expect(result).to include("log_sink: #{File.expand_path(File.join(ENV['HOME'], '.local', 'share', 'local_pac', 'log'))}")
     end
   end
 end

data/spec/proxy_pac/html_div_style_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPac::HTMLDivStyle do
+  it 'produces a table' do
+    data1 = double('DataHTML')
+    allow(data1).to receive(:element).and_return('1st data')
+    allow(data1).to receive(:header).and_return('1st header')
+    allow(data1).to receive(:header_css_class).and_return('header')
+    allow(data1).to receive(:element_css_class).and_return('element')
+
+    data2 = double('DataHTML')
+    allow(data2).to receive(:element).and_return('2nd data')
+    allow(data2).to receive(:header).and_return('2nd header')
+    allow(data2).to receive(:header_css_class).and_return('header')
+    allow(data2).to receive(:element_css_class).and_return('element')
+
+    style = ProxyPac::HTMLDivStyle.new(main_container_css_class: 'main_container', element_container_css_class: 'element_container')
+    style.add_data(data1)
+    style.add_data(data2)
+
+    expected_result = <<-EOS.strip_heredoc.chomp
+       <div class="main_container">
+         <div class="element_container">
+           <div class="header">
+           1st header
+           </div>
+           <div class="element">
+             1st data
+           </div>
+         </div>
+         <div class="element_container">
+           <div class="header">
+           2nd header
+           </div>
+           <div class="element">
+             2nd data
+           </div>
+         </div>
+       </div>
+    EOS
+
+    expect(style.to_s).to eq(expected_result)
+  end
+end

data/spec/proxy_pac/html_table_style_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPac::HTMLTableStyle do
+  it 'produces a table' do
+    data1 = double('DataHTML')
+    allow(data1).to receive(:element).and_return('1st data')
+    allow(data1).to receive(:header).and_return('1st header')
+    allow(data1).to receive(:header_css_class).and_return('header')
+    allow(data1).to receive(:element_css_class).and_return('element')
+
+    data2 = double('DataHTML')
+    allow(data2).to receive(:element).and_return('2nd data')
+    allow(data2).to receive(:header).and_return('2nd header')
+    allow(data2).to receive(:header_css_class).and_return('header')
+    allow(data2).to receive(:element_css_class).and_return('element')
+
+    style = ProxyPac::HTMLTableStyle.new(main_container_css_class: 'main_container', element_container_css_class: 'element_container')
+    style.add_data(data1)
+    style.add_data(data2)
+
+    expected_result = <<-EOS.strip_heredoc.chomp
+       <table class="main_container">
+         <tr class="element_container">
+           <th>
+             <span class="header">
+              1st header
+              </span>
+           </th>
+           <th>
+             <span class="header">
+              2nd header
+              </span>
+           </th>
+         </tr>
+         <tr class="element_container">
+           <td>
+             <span class="element">
+              1st data
+              </span>
+           </td>
+           <td>
+             <span class="element">
+              2nd data
+              </span>
+           </td>
+         </tr>
+       </table>
+    EOS
+
+
+    expect(style.to_s).to eq(expected_result)
+  end
+end

data/spec/proxy_pac/pac_engine_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPac::PACEngine do
+  let(:valid_pac_file) do <<-EOS.strip_heredoc
+                           function FindProxyForURL(url, host) {
+                             return "DIRECT"
+                           }
+  EOS
+  end
+
+  context '#find' do
+    it 'returns a result' do
+      file = double('PacFile')
+      expect(file).to receive(:content).and_return(valid_pac_file)
+
+      parser = ProxyPac::PACEngine.new(file: file)
+      result = parser.find(Addressable::URI.parse('http://example.org'))
+      expect(result).to eq('DIRECT')
+    end
+
+    it 'raises an error if pac file is invalid' do
+      file = double('PacFile')
+      allow(file).to receive(:content).and_return('asdfasdf()')
+
+      parser = ProxyPac::PACEngine.new(file: file)
+
+      expect do
+        parser.find(Addressable::URI.parse('http://example.org'))
+      end.to raise_error Exceptions::PacFileInvalid
+    end
+  end
+end

data/spec/proxy_pac/pac_parser_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPac::PacParser do
+  context '#initialize' do
+    it 'fails if file is missing' do
+      engine = double('pac_engine')
+
+      expect {
+        ProxyPac::PacParser.new(engine: engine)
+      }.to raise_error ArgumentError
+    end
+  end
+
+  context '#find' do
+    it 'finds a proxy for url' do
+      engine = double('pac_engine')
+      expect(engine).to receive(:find).and_return('DIRECT')
+
+      file = double('PacFile')
+
+      stylist = double('Stylist')
+      allow(stylist).to receive(:style_me)
+
+      result_generator = double('PacResult')
+      allow(result_generator).to receive(:new).and_return { result_generator }
+
+      parser = ProxyPac::PacParser.new(file: file, engine: engine, result_generator: result_generator, stylist: stylist)
+      result = parser.find('http://example.org')
+    end
+  end
+end

data/spec/proxy_pac/pac_result_html_stylist_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPac::PacResultHtmlStylist do
+  context '#initialize' do
+    it 'does not require anything' do
+      expect {
+      ProxyPac::PacResultHtmlStylist.new
+      }.not_to raise_error
+    end
+  end
+
+  context '#style_me' do
+    it 'builds html for full string' do
+      result = double('PacResult')
+      allow(result).to receive(:proxy_port).and_return('8080')
+      allow(result).to receive(:proxy).and_return('127.0.0.1')
+      allow(result).to receive(:request_type).and_return('PROXY')
+      allow(result).to receive(:styled_content=).with("<span class=\"lp_request_type\">PROXY</span> <span class=\"lp_proxy\">127.0.0.1</span>:<span class=\"lp_proxy_port\">8080</span>")
+
+      stylist = ProxyPac::PacResultHtmlStylist.new
+      stylist.style_me(result)
+    end
+
+    it 'builds html for string without port' do
+      result = double('PacResult')
+      allow(result).to receive(:proxy_port).and_return(nil)
+      allow(result).to receive(:proxy).and_return('127.0.0.1')
+      allow(result).to receive(:request_type).and_return('PROXY')
+      allow(result).to receive(:styled_content=).with("<span class=\"lp_request_type\">PROXY</span> <span class=\"lp_proxy\">127.0.0.1</span>")
+
+      stylist = ProxyPac::PacResultHtmlStylist.new
+      stylist.style_me(result)
+    end
+  end
+end

data/spec/proxy_pac/pac_result_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPac::PacResult do
+  context '#initialize' do
+    it 'requires a pac parser result' do
+      ProxyPac::PacResult.new('"DIRECT"')
+    end
+
+    it 'handles a empty string' do
+      expect {
+        ProxyPac::PacResult.new('')
+      }.not_to raise_error
+    end
+  end
+
+  context '#verbatim_content' do
+    it 'returns the verbatim content' do
+      result = ProxyPac::PacResult.new('"DIRECT"')
+      expect(result.verbatim_content).to eq('"DIRECT"')
+    end
+  end
+
+  context '#proxy' do
+    it 'extracts proxy-hostname from string' do
+      result = ProxyPac::PacResult.new('"PROXY 127.0.0.1:8080"')
+      expect(result.proxy).to eq('127.0.0.1')
+    end
+
+    it 'extracts proxy-hostname from short string' do
+      result = ProxyPac::PacResult.new('"PROXY 127.0.0.1"')
+      expect(result.proxy).to eq('127.0.0.1')
+    end
+  end
+
+  context '#proxy_port' do
+    it 'extracts proxy-port from string' do
+      result = ProxyPac::PacResult.new('"PROXY 127.0.0.1:8080"')
+      expect(result.proxy_port).to eq('8080')
+    end
+  end
+
+  context '#request_type' do
+    it 'extracts request type from string' do
+      result = ProxyPac::PacResult.new('"PROXY 127.0.0.1:8080"')
+      expect(result.request_type).to eq('PROXY')
+    end
+
+    it 'extracts request type from short string' do
+      result = ProxyPac::PacResult.new('"DIRECT"')
+      expect(result.request_type).to eq('DIRECT')
+    end
+  end
+end

data/spec/proxy_pac_result_parser_spec.rb

@@ -0,0 +1,15 @@
+## encoding: utf-8
+#require 'spec_helper'
+#
+#describe ProxyPacResultParser do
+#  context '#parse' do
+#    it 'parses string and returns html' do
+#      string = 'PROXY 127.0.0.1:3128'
+#      string = '<span class="lp_request_type">PROXY</span> <span class="lp_proxy">127.0.0.1</span>:<span class="lp_proxy_port">3128</span>'
+#
+#      parser = ProxyPacResultParser.new
+#      result = parser.parse string
+#      expect(result).to eq(string)
+#    end
+#  end
+#end

data/spec/server_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Server do
+  context '#initialize' do
+    it 'requires listen statement' do
+      expect {
+        Server.new('tcp://locahost:8000')
+      }.not_to raise_error
+    end
+
+    it 'fails on invalid listen statement' do
+      expect {
+        Server.new(nil)
+      }.to raise_error Exceptions::ServerListenStatementInvalid
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -14,6 +14,8 @@ Bundler.require :default, :test, :development
 
 require 'local_pac/spec_helper'
 
+# Loading support files
 Dir.glob(File.expand_path('../support/*.rb', __FILE__)).each { |f| require_relative f }
 
+# Avoid writing "describe LocalPac::MyClass do [..]" but "describe MyClass do [..]"
 include LocalPac

data/spec/spec_helper_features.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require_relative File.expand_path('../../app/controllers/application_controller.rb', __FILE__)
+Dir.glob(File.expand_path('../../app/controllers/*.rb', __FILE__)).each { |f| require_relative f }

data/spec/support/capybara.rb

@@ -0,0 +1,6 @@
+require 'capybara/rspec'
+RSpec.configure do |c|
+  c.include Capybara::DSL
+end
+
+Capybara.javascript_driver = :poltergeist