test_server 0.0.11

data/spec/encoders/null_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Encoders::Null do
+  context '#encode' do
+    it 'encodes string' do
+      encoder = Encoders::Null.new
+      expect(encoder.encode('string')).to eq 'string'
+    end
+  end
+
+  context '#decode' do
+    it 'decodes string' do
+      encoder = Encoders::Null.new
+      expect(encoder.decode( 'string')).to eq 'string'
+    end
+  end
+end

data/spec/error_handler_spec.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ErrorHandler do
+  let(:exception) { StandardError.new }
+
+  context '.create' do
+    it 'requires an exception class, a message and a exit code' do
+      expect {
+        ErrorHandler.create(
+          exception: StandardError,
+          details: 'errors.default.details',
+          summary: 'errors.default.summary',
+          exit_code: 1,
+        )
+      }.not_to raise_error
+    end
+  end
+
+  context '.find' do
+    it 'finds a suitable error handler' do
+      ErrorHandler.create(
+        exception: StandardError,
+        details: 'errors.default.details',
+        summary: 'errors.default.summary',
+        exit_code: 1,
+      )
+
+      expect(ErrorHandler.find(exception)).not_to be_nil
+    end
+
+    it 'returns a default exception if the requested one cannote be found' do
+      expect(ErrorHandler.find(RuntimeError.new).exception).to be(StandardError)
+    end
+  end
+
+  context '#exception' do
+    it 'returns the exception' do
+      handler = ErrorHandler.create(
+        exception: StandardError,
+        details: 'errors.default.details',
+        summary: 'errors.default.summary',
+        exit_code: 1,
+      )
+
+      expect(handler.exception).to eq(StandardError)
+    end
+  end
+
+  context '#execute' do
+    it 'executes the error handler' do
+      handler = ErrorHandler.new(
+        exception: StandardError, 
+        details: 'errors.default.details',
+        summary: 'errors.default.summary',
+        exit_code: 1,
+      )
+      handler.original_message = 'blub'
+
+      TestServer.ui_logger.level = :debug
+
+      result = capture(:stderr) do
+        begin
+          handler.execute
+        rescue SystemExit => e
+          expect(e.status).to eq(1)
+        end
+      end
+
+      expect(result).to include('unexpected')
+      expect(result).to include('blub')
+    end
+
+    it 'renders template + data' do
+      handler = ErrorHandler.new(
+        exception: StandardError, 
+        details: 'errors.internal_error.details',
+        summary: 'errors.internal_error.summary',
+        exit_code: 1,
+      )
+
+      TestServer.ui_logger.level = :debug
+
+      handler.use(message: 'help')
+
+      result = capture(:stderr) do
+        begin
+          handler.execute
+        rescue SystemExit
+        end
+      end
+
+      expect(result).to include('help')
+    end
+
+    it 'ignores data which is not needed' do
+      handler = ErrorHandler.new(
+        exception: StandardError, 
+        details: 'errors.default.details',
+        summary: 'errors.default.summary',
+        exit_code: 1,
+      )
+      handler.original_message = 'blub'
+
+      TestServer.ui_logger.level = :debug
+      handler.use(name: 'asdf')
+
+      result = capture(:stderr) do
+        begin
+          handler.execute
+        rescue SystemExit => e
+          expect(e.status).to eq(1)
+        end
+      end
+
+      expect(result).to include('unexpected')
+      expect(result).to include('blub')
+    end
+  end
+
+  context '#use' do
+    it 'uses data in translation' do
+      handler = ErrorHandler.new(
+        exception: StandardError, 
+        details: 'errors.internal_error.details',
+        summary: 'errors.internal_error.summary',
+        exit_code: 1,
+      )
+
+      handler.use(message: 'help')
+      expect(handler.details).to include('help')
+    end
+  end
+
+  context '#to_json' do
+    it 'returns a json self' do
+      handler = ErrorHandler.new(
+        exception: StandardError, 
+        details: 'errors.internal_error.details',
+        summary: 'errors.internal_error.summary',
+        exit_code: 1,
+      )
+
+      handler.use(message: 'help')
+
+      expect(handler.to_json).to eq(
+        JSON.dump(
+          error_summary: 'Internal error...',
+          error_details: 'Sorry, but I cannot fullfill your request. An internal error occured: "help". Please notify the author of the software about the problem.',
+          result: "failure",
+        )
+      )
+    end
+  end
+end

data/spec/features/fetch_data_via_javascript_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Fetch data via javascript', :js do
+  context '/xhr/string/' do
+    it 'submits requests to url' do
+
+      visit '/xhr/string/'
+
+      within '#form' do
+        fill_in 'url', :with => '§ASDF$$'
+      end
+
+      click_button '#submit'
+      click_on('Search')
+    end
+
+  end
+end

data/spec/features/fetch_test_data_plain_spec.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Fetch plain data' do
+  before :each do
+    config = Class.new do
+      include FeduxOrg::Stdlib::Filesystem
+
+      def root_directory
+        ::File.expand_path('../../../', __FILE__)
+      end
+    end.new
+
+    TestServer.config = config
+    Capybara.app    = TestServer::App::StringController.new
+  end
+
+  it 'downloads the data' do
+    visit('/default/')
+
+    expect(page.status_code).to eq 200
+    expect(page).to have_content('Plain Data')
+  end
+
+  it 'downloads the data with multiplier' do
+    visit('/default/10')
+
+    expect(page.status_code).to eq 200
+    expect(page.source.split(/\n/).size).to eq 10
+  end
+
+  it 'prevents caching' do
+    visit('/default?no_cache')
+
+    expect(page.status_code).to eq 200
+    expect(page.response_headers).to be_key('Cache-Control')
+    expect(page.response_headers['Cache-Control']).to include('no-cache')
+  end
+
+  it 'requires re-validation' do
+    visit('/default?must_revalidate')
+
+    expect(page.status_code).to eq 200
+    expect(page.response_headers).to be_key('Cache-Control')
+    expect(page.response_headers['Cache-Control']).to include('must-revalidate')
+  end
+
+  it 'sets max age' do
+    visit('/default?max_age=500')
+
+    expect(page.status_code).to eq 200
+    expect(page.response_headers).to be_key('Cache-Control')
+    expect(page.response_headers['Cache-Control']).to include('max-age=500')
+  end
+
+  it 'sets everything' do
+    visit('/default?expires=500')
+
+    expect(page.status_code).to eq 200
+    expect(page.response_headers).to be_key('Cache-Control')
+    expect(page.response_headers['Cache-Control']).to include('no-cache')
+    expect(page.response_headers['Cache-Control']).to include('must-revalidate')
+    expect(page.response_headers['Cache-Control']).to include('max-age=500')
+  end
+
+  it 'serves eicar test string to check if virus scanners find that string' do
+    eicar = [ 'X', '5', 'O', '!', 'P', '%', '@', 'A', 'P', '[', '4', "\\", 'P',
+              'Z', 'X', '5', '4', '(', 'P', '^', ')', '7', 'C', 'C', ')', '7',
+              '}', '$', 'E', 'I', 'C', 'A', 'R', '-', 'S', 'T', 'A', 'N', 'D',
+              'A', 'R', 'D', '-', 'A', 'N', 'T', 'I', 'V', 'I', 'R', 'U', 'S',
+              '-', 'T', 'E', 'S', 'T', '-', 'F', 'I', 'L', 'E', '!', '$', 'H',
+              '+', 'H', '*' ]
+
+    visit('/eicar/')
+    expect(page.status_code).to eq 200
+    expect(page).to have_content(eicar.join)
+  end
+
+  it 'supports long running requests' do
+    timeout(3) do
+      visit('/sleep/2')
+    end
+
+    expect(page.status_code).to eq 200
+    expect(page).to have_content('Plain Data')
+  end
+
+  it 'supports random string' do
+    visit('/random/2')
+
+    expect(page.status_code).to eq 200
+    expect(page.source.size).to eq 2
+  end
+
+  it 'supports base64 encoding' do
+    visit('/default?base64')
+
+    expect(page.status_code).to eq 200
+    expect(Base64.decode64(page.source)).to include 'Plain Data'
+  end
+
+  it 'supports base64 stric encoding' do
+    visit('/default?base64_strict')
+
+    expect(page.status_code).to eq 200
+    expect(Base64.strict_decode64(page.source)).to include 'Plain Data'
+  end
+
+end

data/spec/features/fetch_test_data_via_streaming_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Fetch Test Data via Streaming' do
+
+  before :each do
+    config = Class.new do
+      include FeduxOrg::Stdlib::Filesystem
+
+      def root_directory
+        ::File.expand_path('../../../', __FILE__)
+      end
+    end.new
+
+    TestServer.config = config
+    Capybara.app = TestServer::App::StreamingController.new
+  end
+
+  it 'downloads stream' do
+    visit('/default/2')
+
+    expect(page.status_code).to be 200
+    expect(page).to have_content('data')
+  end
+
+  it 'supports base64 encoding' do
+    visit('/default/2?base64')
+
+    expect(page.status_code).to be 200
+    expect(Base64.decode64(page.source.split(/\n/).last)).to include 'data'
+  end
+
+  it 'supports gzip encoding' do
+    visit('/default/2?gzip')
+
+    expect(page.status_code).to be 200
+    expect(Base64.decode64(page.source.split(/\n/).last)).to include "\xC6\xC2\bODLT\x91\xCC \xC32\xC7tG \x85q\xDD\x11\xC8".force_encoding('ASCII-8bit')
+  end
+
+  it 'serves eicar test string to check if virus scanners find that string' do
+    eicar = [ 'X', '5', 'O', '!', 'P', '%', '@', 'A', 'P', '[', '4', "\\", 'P',
+              'Z', 'X', '5', '4', '(', 'P', '^', ')', '7', 'C', 'C', ')', '7',
+              '}', '$', 'E', 'I', 'C', 'A', 'R', '-', 'S', 'T', 'A', 'N', 'D',
+              'A', 'R', 'D', '-', 'A', 'N', 'T', 'I', 'V', 'I', 'R', 'U', 'S',
+              '-', 'T', 'E', 'S', 'T', '-', 'F', 'I', 'L', 'E', '!', '$', 'H',
+              '+', 'H', '*' ]
+
+    visit('/eicar/')
+
+    expect(page.status_code).to be 200
+    expect(page).to have_content(eicar.join)
+  end
+end

data/spec/features/helper_spec.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe WebHelper do
+  before :each do
+    @test_object = Class.new do
+      attr_accessor :params
+
+      include WebHelper
+    end.new
+  end
+
+  context '#generate_string' do
+    it 'generates a string of n lines' do
+      expect(@test_object.generate_string(2)).to eq "Plain Data\nPlain Data\n"
+    end
+  end
+
+  context '#generate_random_string' do
+    it 'generates a random string of length n' do
+      expect(@test_object.generate_random_string(20).size).to eq 20
+    end
+  end
+
+  context '#generate_eicar' do
+    it 'generates eicar test string' do
+      result = [ 'X', '5', 'O', '!', 'P', '%', '@', 'A', 'P', '[', '4', "\\", 'P',
+                 'Z', 'X', '5', '4', '(', 'P', '^', ')', '7', 'C', 'C', ')', '7',
+                 '}', '$', 'E', 'I', 'C', 'A', 'R', '-', 'S', 'T', 'A', 'N', 'D',
+                 'A', 'R', 'D', '-', 'A', 'N', 'T', 'I', 'V', 'I', 'R', 'U', 'S',
+                 '-', 'T', 'E', 'S', 'T', '-', 'F', 'I', 'L', 'E', '!', '$', 'H',
+                 '+', 'H', '*' ]
+
+      expect(@test_object.generate_eicar).to eq(result)
+    end
+  end
+
+  context '#encoding' do
+    it 'supports base64 encoding' do
+      @test_object.params = {
+        'base64' => nil,
+      }
+
+      result = @test_object.encode do
+        'string'
+      end
+
+      expect(result).to eq "c3RyaW5n\n"
+    end
+
+    it 'supports strict base64 encoding' do
+      @test_object.params = {
+        'base64_strict' => nil,
+      }
+
+      result = @test_object.encode do
+        'string'
+      end
+
+      expect(result).to eq "c3RyaW5n"
+    end
+
+    it 'supports gzip encoding' do
+      @test_object.params = {
+        'gzip' => nil,
+      }
+
+      result = @test_object.encode do
+        'string'
+      end
+
+      expect(result).to eq "x\x9C+.)\xCA\xCCK\a\x00\tB\x02\x98".force_encoding('ASCII-8Bit')
+    end
+
+    it 'can combine multiple encodings, based on occurrence (gzip, base64)' do
+      @test_object.params = {
+        'gzip' => nil,
+        'base64' => nil,
+      }
+
+      result = @test_object.encode do
+        'string'
+      end
+
+      expect(result).to eq "eJwrLinKzEsHAAlCApg=\n"
+    end
+
+    it 'can combine multiple encodings, based on occurrence (gzip, base64)' do
+      @test_object.params = {
+        'base64' => nil,
+        'gzip' => nil,
+      }
+
+      expect {
+        result = @test_object.encode do
+          'string'
+        end
+      }.not_to raise_error
+    end
+
+    it 'runs null encoders if no encoder is given' do
+      @test_object.params = {
+      }
+
+      result = @test_object.encode do
+        'string'
+      end
+
+      expect(result).to eq 'string'
+    end
+
+    it 'runs null encoders if unknown encoder is given' do
+      @test_object.params = {
+        'unknown' => nil,
+      }
+
+      result = @test_object.encode do
+        'string'
+      end
+
+      expect(result).to eq 'string'
+    end
+  end
+
+end

data/spec/process_environment_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProcessEnvironment do
+  context '#initialize' do
+    it 'accepts an environment' do
+      env = double('ENV')
+      allow(env).to receive(:to_hash).and_return({})
+
+      expect {
+        ProcessEnvironment.new(env)
+      }.not_to raise_error
+    end
+  end
+
+  context '#fetch' do
+    it 'fetches environment variable' do
+      env = double('ENV')
+      allow(env).to receive(:to_hash).and_return({variable: 'value'})
+
+      env = ProcessEnvironment.new(env)
+      expect(env.fetch(:variable)).to eq('value')
+    end
+
+    it 'returns an empty string if variable cannot be found' do
+      env = double('ENV')
+      allow(env).to receive(:to_hash).and_return({})
+
+      env = ProcessEnvironment.new(env)
+      expect(env.fetch(:variable)).to eq('')
+    end
+  end
+
+  context '#write' do
+    it 'writes to environment' do
+      env = double('ENV')
+      allow(env).to receive(:to_hash).and_return({})
+      expect(env).to receive(:[]=).with('variable', 'value')
+
+      env = ProcessEnvironment.new(env)
+      env.write(:variable, 'value')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+$LOAD_PATH << ::File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+SimpleCov.command_name 'rspec'
+SimpleCov.start
+
+# Pull in all of the gems including those in the `test` group
+require 'bundler'
+Bundler.require :default, :test, :development
+
+require 'test_server'
+
+require File.expand_path('../../app/controllers/application_controller.rb', __FILE__)
+Dir.glob(::File.expand_path('../../app/controllers/*.rb', __FILE__)).each { |f| require f }
+
+# Loading support files
+Dir.glob(::File.expand_path('../support/*.rb', __FILE__)).each { |f| require_relative f }
+
+include TestServer

data/spec/support/capybara.rb

@@ -0,0 +1,16 @@
+module TestServer
+  module SpecHelper
+    module Capybara
+      include ::Capybara::DSL
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include TestServer::SpecHelper::Capybara
+  c.beforc(:all) do
+    Capybara.default_engine = :rack_test
+    Capybara.javascript_engine = :poltergeist
+  end
+end
+

data/spec/support/debugging.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require 'pry'
+require 'debugger'

data/spec/support/encoding.rb

@@ -0,0 +1 @@
+require 'base64'

data/spec/support/environment.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'fedux_org/stdlib/environment'
+
+module TestServer
+  module SpecHelper
+    module Environment
+      include FeduxOrg::Stdlib::Environment
+      alias_method :with_environment, :isolated_environment 
+
+      def mock_stdin(&block)
+        old_stdin = $stdin
+        $stdin = double('stdin')
+
+        block.call
+      ensure
+        $stdin = old_stdin
+      end
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include TestServer::SpecHelper::Environment
+  c.before(:suite) do
+    %w{
+      http_proxy
+      https_proxy
+      HTTP_PROXY
+      HTTPS_PROXY
+    }.each { |var| ENV.delete(var) }
+  end
+end
+

data/spec/support/example.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module TestServer
+  module SpecHelper
+    module Example
+      def example_file(path)
+        File.expand_path("../../examples/#{path}", __FILE__)
+      end
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include TestServer::SpecHelper::Example
+end
+

data/spec/support/filesystem.rb

@@ -0,0 +1,19 @@
+require 'fedux_org/stdlib/filesystem'
+
+module TestServer
+  module SpecHelper
+    module Filesystem
+      include FeduxOrg::Stdlib::Filesystem
+
+      def root_directory
+        ::File.expand_path('../../../', __FILE__)
+      end
+    end
+  end
+end
+
+# encoding: utf-8
+RSpec.configure do |c|
+  c.include TestServer::SpecHelper::Filesystem
+  c.before(:each) { cleanup_working_directory }
+end

data/spec/support/html.rb

@@ -0,0 +1,20 @@
+module TestServer
+  module SpecHelper
+    module Html
+      def pretty_print_page(page)
+        xsl_path = File.expand_path('../pretty_print.xsl', __FILE__)
+
+        xsl = Nokogiri::XSLT(File.read(xsl_path))
+        html = Nokogiri(page.source)
+
+        xsl.apply_to(html).to_s
+      end
+    end
+  end
+end
+
+# encoding: utf-8
+RSpec.configure do |c|
+  c.include TestServer::SpecHelper::Html
+  c.before(:each) { cleanup_working_directory }
+end

data/spec/support/matcher.rb

@@ -0,0 +1,17 @@
+RSpec::Matchers.define :be_a_multiple_of do |expected|
+  match do |actual|
+    actual % expected == 0
+  end
+
+  failure_message_for_should do |actual|
+    "expected that #{actual} would be a precise multiple of #{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected that #{actual} would not be a precise multiple of #{expected}"
+  end
+
+  description do
+    "be a precise multiple of #{expected}"
+  end
+end