proxy_tester 0.0.1

data/spec/actions/initialize_application_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Actions::InitializeApplication do
+  context '#run' do
+    it 'creates all files/directories neccessary to run local_pac' do
+      config_string = <<-EOS.strip_heredoc
+        :user_file: #{File.join(working_directory, 'config', 'user_file.csv')}
+        :config_file: #{File.join(working_directory, 'config', 'config.yaml')}
+        :test_cases_directory: #{File.join(working_directory, 'test_cases.d')}
+        :examples_directory: #{File.join(working_directory, 'test_cases.d/examples')}
+      EOS
+
+      config_file = create_file('config_spec.yaml', config_string)
+
+      config = ProxyTester::Config.new(config_file)
+
+      initializer = Actions::InitializeApplication.new({
+          create_user_file: true,
+          create_config_file: true,
+          create_test_cases_directory: true,
+          pre_seed: true
+      }, config)
+
+      result = capture(:stdout) do
+        silence(:stderr) do
+          initializer.run
+        end
+      end
+
+      expect(path_exists?('config/user_file.csv')).to be_true
+      expect(path_exists?('config/config.yaml')).to be_true
+      expect(path_exists?('test_cases.d')).to be_true
+      expect(path_exists?('test_cases.d/examples/support')).to be_true
+      expect(path_exists?('test_cases.d/examples/example_spec.rb')).to be_true
+      expect(path_exists?('test_cases.d/examples/spec_helper.rb')).to be_true
+      expect(result).to include('config_file:')
+    end
+  end
+end

data/spec/actions/show_config_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Actions::ShowConfig do
+  context '#initialize' do
+    it 'has no special requirements' do
+      expect {
+        Actions::ShowConfig.new
+      }.not_to raise_error
+    end
+  end
+
+  context '#run' do
+    it 'gathers all relevant information and prints them to stdout' do
+      result = capture(:stdout) do
+        Actions::ShowConfig.new.run
+      end
+
+      expect(result).to include('user_file')
+    end
+  end
+end

data/spec/capybara_proxy_pac_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe CapybaraProxyPac do
+  let(:valid_pac_file1) do <<-EOS.strip_heredoc.chomp
+                           function FindProxyForURL(url, host) {
+                             return "PROXY localhost:3128";
+                           }
+  EOS
+  end
+
+  context 'all' do
+    it 'handles exceptions for file not found' do
+      pac = CapybaraProxyPac.new
+      expect { pac.pac_file = 'asdf' }.to raise_error Exceptions::PacFileNotFound
+    end
+  end
+
+  context '#host' do
+    it 'returns host for url' do
+      file = create_file 'proxy.pac', valid_pac_file1
+
+      pac = CapybaraProxyPac.new
+      pac.pac_file = file
+      pac.url = 'http://www.heise.de'
+
+      expect(pac.host).to eq('localhost')
+    end
+  end
+
+  context '#port' do
+    it 'returns port for url' do
+      file = create_file 'proxy.pac', valid_pac_file1
+
+      pac = CapybaraProxyPac.new
+      pac.pac_file = file
+      pac.url = 'http://www.heise.de'
+
+      expect(pac.port).to eq('3128')
+    end
+  end
+end

data/spec/capybara_proxy_spec.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe CapybaraProxy do
+  context '#initialize' do
+    it 'accepts no arguments' do
+      expect {
+        CapybaraProxy.new
+      }.not_to raise_error
+    end
+  end
+
+  context '#type=' do
+    it 'sets the proxy type to none' do
+      proxy = CapybaraProxy.new
+      proxy.type = :none
+
+      expect(proxy.type).to eq 'none'
+    end
+
+    it 'sets the proxy type to http' do
+      proxy = CapybaraProxy.new
+      proxy.type = :http
+
+      expect(proxy.type).to eq 'http'
+    end
+
+    it 'sets the proxy type socks5' do
+      proxy = CapybaraProxy.new
+      proxy.type = :socks5
+
+      expect(proxy.type).to eq 'socks5'
+    end
+
+    it 'raises an exception for invalid proxy type' do
+      proxy = CapybaraProxy.new
+      expect {
+        proxy.type = :asdf
+      }.to raise_error Exceptions::ProxyTypeInvalid
+    end
+
+    it 'results in an phantomjs argument' do
+      proxy = CapybaraProxy.new
+      proxy.host = 'host'
+      proxy.port = 3128
+      proxy.type = :socks5
+
+      expect(proxy.as_phantomjs_arguments).to eq(
+        [
+          '--proxy=host:3128',
+          '--proxy-type=socks5',
+        ]
+      )
+    end
+  end
+
+  context '#to_a' do
+    it 'accepts no arguments' do
+      proxy = CapybaraProxy.new
+      proxy.host = 'host'
+      proxy.port = 3128
+
+      proxy.user = double('user')
+      allow(proxy.user).to receive(:to_string).and_return('user:password')
+
+      expect(proxy.as_phantomjs_arguments).to eq(
+        [
+          '--proxy=host:3128',
+          '--proxy-auth=user:password',
+        ]
+      )
+
+    end
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyTester::Config do
+  let(:config_file) { create_file('config_.yaml') }
+
+  context '#initialize' do
+    it 'requires a file name' do
+      ProxyTester::Config.new(config_file)
+    end
+  end
+
+  context '#to_s' do
+    it 'outputs a nice config overview' do
+      config = ProxyTester::Config.new(config_file)
+      expect(config.to_s).to include ::File.join('.config', 'proxy_tester', 'config.yaml')
+    end
+  end
+
+  context '#lock' do
+    it 'raises and exception if changed afterward' do
+      config = ProxyTester::Config.new(config_file)
+      config.lock
+
+      expect {
+        config.config_file = 'asdf'
+      }.to raise_error Exceptions::ConfigLocked
+    end
+  end
+
+  context '#config_file' do
+    it 'returns value of config file' do
+      config_file = create_file 'config.yaml', <<-EOS.strip_heredoc
+      ---
+      :config_file: '/asdf/config'
+      EOS
+
+      config = ProxyTester::Config.new(config_file)
+      expect(config.config_file).to eq('/asdf/config')
+    end
+
+    it 'returns default value if no config file is available' do
+      config = ProxyTester::Config.new(config_file)
+      file = ::File.join(ENV['HOME'], '.config', 'proxy_tester','config.yaml')
+
+      expect(config.config_file).to eq(file)
+    end
+  end
+
+  context '#user_file' do
+    it 'returns value of user file' do
+      config_file = create_file 'user.csv', <<-EOS.strip_heredoc
+      :user_file: '/asdf/user'
+      EOS
+
+      config = ProxyTester::Config.new(config_file)
+      expect(config.user_file).to eq('/asdf/user')
+    end
+
+    it 'returns default value if no user file is available' do
+      config = ProxyTester::Config.new(config_file)
+      file = ::File.join(ENV['HOME'], '.config', 'proxy_tester','user.csv')
+
+      expect(config.user_file).to eq(file)
+    end
+  end
+
+  context '#test_cases_directory' do
+    it 'returns value of user file' do
+      config_file = create_file 'user.csv', <<-EOS.strip_heredoc
+      :test_cases_directory: '/asdf/cases'
+      EOS
+
+      config = ProxyTester::Config.new(config_file)
+      expect(config.test_cases_directory).to eq('/asdf/cases')
+    end
+
+    it 'returns default value if no user file is available' do
+      config = ProxyTester::Config.new(config_file)
+      file = ::File.join(ENV['HOME'], '.config', 'proxy_tester','test_cases.d')
+
+      expect(config.test_cases_directory).to eq(file)
+    end
+  end
+
+end

data/spec/data_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyTester::Data do
+  context '#instance_binding' do
+    it 'let you lookup variables' do
+      config = Class.new(Module) do
+        def pid_file
+          '/path/pid_file'
+        end
+      end.new
+
+      data = ProxyTester::Data.new(config)
+      # rubocop:disable Eval
+      result = eval('lookup("pid_file")', data.instance_binding)
+      # rubocop:enable Eval
+      expect(result).to eq('/path/pid_file')
+    end
+  end
+
+  context '#lookup' do
+    it 'let you lookup variables' do
+      config = Class.new(Module) do
+        def pid_file
+          '/path/pid_file'
+        end
+      end.new
+
+      data = ProxyTester::Data.new(config)
+      result = data.lookup('pid_file')
+      expect(result).to eq('/path/pid_file')
+    end
+  end
+end

data/spec/environment_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Environment do
+  context '#initialize' do
+    it 'requires no arguments' do
+      expect {
+        Environment.new
+      }.not_to raise_error
+    end
+  end
+
+  context '#request_password' do
+    it 'asks for password' do
+      stderr = double(stderr)
+      expect(stderr).to receive(:printf).with('Please enter password: ')
+
+      stdin = double('stdin')
+      expect(stdin).to receive(:readline).and_return('passwd')
+
+      env = Environment.new(stdin, stderr)
+      expect(env.password).to eq('passwd')
+    end
+  end
+end

data/spec/erb_generator_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ErbGenerator do
+  context '#compile' do
+    it 'needs a source and a target' do
+      data = double('binding')
+      allow(data).to receive(:instance_binding) do
+        Class.new do
+          def pid_file
+            '/path/pid_file'
+          end
+
+          def instance_binding
+            binding
+          end
+        end.new.instance_binding
+      end
+
+      source = double('source')
+      allow(source).to receive(:encoding)
+      allow(source).to receive(:read).and_return('Path <%= pid_file %>')
+
+      destination = double('destination')
+      expect(destination).to receive(:puts).with('Path /path/pid_file')
+
+      gen = ErbGenerator.new(data)
+      gen.compile(source, destination)
+    end
+  end
+end

data/spec/examples/proxy.pac

@@ -0,0 +1,7 @@
+function FindProxyForURL(url, host) {
+  if (url == "http://example.com") {
+    return "PROXY localhost2:8080";
+  } else {
+    return "DIRECT";
+  }
+}

data/spec/factories.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+FactoryGirl.define do
+  factory :user do
+    name 'user'
+    password 'pw'
+  end
+end

data/spec/features/check_ssl_sites_spec.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Check ssl sites' do
+  it 'works with www.heise.de' do
+
+  end
+end

data/spec/git_file_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe GitFile do
+  context 'initialize' do
+    it 'requires a path' do
+      expect {
+        GitFile.new('dir/path.txt')
+      }.not_to raise_error
+    end
+
+    it 'accepts content' do
+      expect {
+        GitFile.new('dir/path.txt', 'content')
+      }.not_to raise_error
+    end
+  end
+
+  context '#name' do
+    it 'has a name' do
+      file = GitFile.new('file.txt')
+      expect(file.name).to eq(:file)
+    end
+  end
+
+  context '#extension?' do
+    it 'checks if extension is the same' do
+      file = GitFile.new('path.txt')
+      expect(file).to be_extension('.txt')
+    end
+  end
+
+  context '#content' do
+    it 'returns the content of file' do
+      file = GitFile.new('file.txt', 'content')
+      expect(file.content).to eq('content')
+    end
+  end
+
+  context '#nil?' do
+    it 'is always false' do
+      file = GitFile.new('file.txt')
+      expect(file.nil?).to be_false
+    end
+  end
+end

data/spec/git_repository_spec.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe GitRepository do
+  context '#initialize' do
+    it 'requires a storage path' do
+      file_creator = double('file_creator')
+      null_file    = double('null_file')
+
+      Rugged::Repository.init_at(File.join(working_directory, 'git_repo'))
+
+      expect {
+        GitRepository.new(File.join(working_directory, 'git_repo'), file_creator, null_file)
+      }.not_to raise_error
+    end
+  end
+
+  context '#find_file' do
+    it 'returns a file if exists in repository' do
+      repo_path = File.join(working_directory, 'git_repo')
+      Rugged::Repository.init_at(repo_path)
+
+      file = double('file')
+      allow(file).to receive(:name).and_return(:file)
+
+      file_creator = double('file_creator')
+      allow(file_creator).to receive(:new).with('file.txt', 'asdf').and_return(file)
+
+      null_file    = double('null_file')
+
+      repo = GitRepository.new(repo_path, file_creator, null_file)
+      repo.add_content('file.txt', 'asdf')
+      f = repo.find_file(:file)
+
+      expect(f).to be(file)
+    end
+
+    it 'returns a null file if does not exist in repository' do
+      repo_path = File.join(working_directory, 'git_repo')
+      Rugged::Repository.init_at(repo_path)
+
+      file_creator = double('file_creator')
+      null_file    = double('null_file')
+
+      repo = GitRepository.new(repo_path, file_creator, null_file)
+      f = repo.find_file(:file)
+
+      expect(f).to be(null_file)
+    end
+
+    it 'handles uninitialized repositories' do
+      repo_path = File.join(working_directory, 'git_repo')
+      Rugged::Repository.init_at(repo_path)
+
+      file_creator = double('file_creator')
+      null_file    = double('null_file')
+
+      repo = GitRepository.new(repo_path, file_creator, null_file)
+      f = repo.find_file(:file)
+
+      expect(f).to be(null_file)
+    end
+  end
+
+  context '#each_file' do
+    it 'iterates over all found files' do
+      repo_path = File.join(working_directory, 'git_repo')
+      Rugged::Repository.init_at(repo_path)
+
+      file = double('file')
+      allow(file).to receive(:name).and_return(:file1)
+
+      file_creator = double('file_creator')
+      allow(file_creator).to receive(:new).with('file1.pac', 'asdf1').and_return(file)
+
+      null_file    = double('null_file')
+
+      repo = GitRepository.new(repo_path, file_creator, null_file)
+      repo.add_content('file1.pac', 'asdf1')
+
+      result = []
+      repo.each_file { |f| result << f.name }
+
+      expect(result).to eq([:file1])
+    end
+  end
+
+  context '.clone' do
+    it 'clones existing repository' do
+      repo_path = File.join(working_directory, 'git_repo.git')
+      repo = GitRepository.create(repo_path)
+      repo.add_content('file1.pac', 'asdf1')
+
+      clone_path = File.join(working_directory, 'git_repo_clone')
+
+      clone = GitRepository.clone(repo_path, clone_path)
+      expect(clone.all_files.first.name).to eq(:file1)
+    end
+
+    it 'creates cloned bare repository' do
+      repo_path = File.join(working_directory, 'git_repo.git')
+      repo = GitRepository.create(repo_path)
+      repo.add_content('file1.pac', 'asdf1')
+
+      clone_path = File.join(working_directory, 'git_repo_clone')
+      GitRepository.clone(repo_path, clone_path, bare: true)
+
+      expect(Rugged::Repository.new(clone_path).bare?).to be true
+    end
+  end
+end

data/spec/main_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyTester do
+  context '.load_user_database' do
+    it 'loads the database' do
+      user_file = create_file 'users.csv', <<-EOS.strip_heredoc
+      "name","password"
+      "user1","password1"
+      EOS
+
+      config_file = create_file 'config.yaml', <<-EOS.strip_heredoc
+      user_file: #{user_file}
+      EOS
+
+      ProxyTester.config = ProxyTester::Config.new(config_file)
+      ProxyTester.load_user_database
+
+      expect {
+        User.find_by!(name: 'user1')
+      }.not_to raise_error
+    end
+
+  end
+end

data/spec/pac_result_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe PacResult do
+  it 'parses pac result' do
+    result = PacResult.new('PROXY localhost:3128')
+
+    expect(result.proxy).to eq('localhost')
+    expect(result.proxy_port).to eq('3128')
+    expect(result.request_type).to eq('PROXY')
+  end
+
+  it 'parses pac result' do
+    result = PacResult.new('DIRECT')
+
+    expect(result.proxy).to eq(nil)
+    expect(result.proxy_port).to eq(nil)
+    expect(result.request_type).to eq('DIRECT')
+  end
+end