urushiol 1.0.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmQ3Yjg3YjQ3ZjY0MjZjODBmODc1ZTE2NDA2YTlhYWUwNDA1MmIwMg==
+  data.tar.gz: !binary |-
+    NGVmNDk0OTA3ODE0OWNjYjkwYWY3NmZiZWM4MWZkMTE5ZWY3ZmJhZg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZTYyOTMwZDE0MTAxMzE2NDJhYmJlNTYxMDEwOTQ0YjcxOWM0YWVmYmMzMmFj
+    ZDA0YTI5YjhkNjU1ZjRhYjJmYTU0MTlhZjQ3M2QyMDlhOGI4MzkxNzE3NzI0
+    YzRlZmEwZDVkMjZmMmUzZWQ4Njc1NjNlOGM4MzE5ODUwMzAyNmU=
+  data.tar.gz: !binary |-
+    MTdiMzA3MzcyMjA1MzBiNWI3NWQ3NTljYjY1NjNiMzUzZTc5ZjBhZjQ5MWY2
+    MWJhNjA2ZjcxNjE1YTBkOWFiNWM2ZTFmM2UxNjVhNDJhYzY0NmZlZjI0ZDdm
+    ZjBlNzFjNzZkYjExYWY1ZWM3NzYxYWVhOGEyYzIzZDFhZWYxNDg=

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 TV4
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+Urushiol - /ʊˈruːʃi.ɒl/ v0.5 BETA
+========
+
+Test framework written in Ruby to test varnish-cache routing and caching logic.
+
+>The sap of the lacquer tree, today bearing the technical description of "urushiol-based lacquer," has traditionally been used in Japan. As the substance is poisonous to the touch until it dries, the creation of lacquerware has long been practiced only by skilled dedicated artisans.
+
+Urushiol was born out of necessity. When we decided to migrate our reverse proxy routing from Apache to Varnish we noticed that this would not be a trivial matter.
+As the migration came to a halt due to unexpected routing errors we decided that, having a proper way of testing our configs would not be a bad idea. 
+Urushiol is the product of that idea.
+
+####Get up and running with Urushiol.
+To start with there are some dependencies that must be satisfied. 
+* Varnish (a.t.m only supports 3.0.4) must be installed on the host computer. 
+* Ruby (tested on 1.9.3) must be installed on the host computer
+
+Then there is just the matter of writing the tests. The project come bundled with some examples but lets look at the basics a bit more in depth.
+
+Navigate to the project folder where you will se a folder: `Testing-Framework/` inside there you will se a `lib/` catalog and some `.rb` files that all follow the pattern `0Xtest.rb` these are the function-tests.
+You should run each one of them to make sure that the framework actually work, if it doesn't I redirect you back to the dependencies.
+You run Urushiol tests by for example typing `ruby 01test.rb` in your shell. You should be presented with `#     top  TEST /tmp/test.vtc passed (0.003)`
+each and every time.
+
+####Writing your own tests.
+Now to write your own tests. It is assumed that you have a varnish `.vcl` file that you want to test.
+Each test is written in ruby and requires `varnishtest_base.rb` which can be found in the `lib` folder within `Testing-Framework` like so: `require './lib/varnishtest_base'` for the functiontests.
+From here on you have all the power of Urushiol at your fingertips.
+
+Start out with instanciating a testcase like so:
+
+`testcase = Urushiol::VarnishTestBase.new("vcl test")`
+
+and that's it now you have a testcase you can run by calling `testcase.run`. At the moment that will be pretty uneventfull so lets load up a vcl-fil and mock some backends.
+Urushiol has functionallity to do this on the fly. Simply `modified_vcl_file = testcase.mock_backends( vcl_file_path )`.
+The `mock_backends` methods does a lot of things but in essence it takes the vcl's filepath and mocks upp servers to act as its backends and modifies the backends in the file to point to the given servers.
+Now it's quite easy to test them as they will return statuscode 200 and the backend name as the body.
+The method returns a modified version of the vclfile that has the backends rerouted to the mock_servers.
+
+You can create your own servers with the `mock_server` method but that is covered extencivly in the function-tests.
+
+To create a mock varnish one runs the `mock_varnish` method. To configure it one gives it a block of stuff to do. In this case we want to give it a vcl file; the modified vcl file.
+
+```ruby
+testcase.mock_varnish "v1" do |varnish|
+  varnish.vcl modified_vcl_file
+end
+```
+
+This starts a mock varnish with the given configfile and it works just as a real varnish would, because it is a real varnish instance.
+
+So now we have servers, and a varnish instance that points at the servers now all we need are some clients that asks varnish for stuff and tests its behaviour.
+
+Say that we have a backend named `SuperBackend` in our vcl file and some logic that states that if your client's request's http.host == `superbackend.tv4.se` one should be passed through to the superbackend.
+This behaviour we can now test:
+
+```ruby
+testcase.client_testcase "c1" do |test|
+  test.txreq do |req|
+    req.host "superbackend.tv4.se"
+  end
+  test.rxresp
+  test.expect "resp.status == 200"
+  test.expect "resp.body == SuperBackend"
+end
+```
+
+I find this pretty selfexplanatory but here goes, we mock a client_testcase and define a request to transmit (`txreq`).
+While creating the request we modify the header to have the given host. We then grab the respons and expect it to have status 200 and the backendname as a body.
+
+now we are ready to go, this was a short demonstartion of what you CAN do. But there is more to Urushiol than this. Play around and look at the code.
+
+The whole test would look something like this:
+
+```ruby
+require './lib/varnishtest_base'
+
+testcase = Urushiol::VarnishTestBase.new("vcl test")
+
+vcl_file_path = '../new.vcl'
+
+modified_vcl_file = testcase.mock_backends( vcl_file_path )
+
+testcase.mock_varnish "v1" do |varnish|
+  varnish.vcl modified_vcl_file
+end
+
+testcase.client_testcase "c1" do |test|
+  test.txreq do |req|
+    req.host "superbackend.tv4.se"
+  end
+  test.rxresp
+  test.expect "resp.status == 200"
+  test.expect "resp.body == SuperBackend"
+end
+
+testcase.run
+```
+
+
+
+
+
+

data/bin/urushiol

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+require 'urushiol'
+require 'test_case'
+require 'pathname'
+require 'meta/help'
+require 'meta/version'
+
+def run_testfile file_ref
+  test = TestCase.new file_ref
+
+  puts "\nRunning test #{Pathname.new(file_ref).basename} :  "
+
+  test.instance_eval("def run \n #{IO.read(file_ref)} \nend")
+  test.run
+end
+
+def run_typed_testfiles test_files, vcl_file, type
+  test_head = IO.readlines("#{root_path}meta/#{type}_top.uru").join('').sub(";file_ref;", vcl_file)
+
+  test_files.each do |test_file|
+    test = TestCase.new test_file
+
+    puts "\nRunning test #{Pathname.new(test_file).basename} :"
+
+    test.instance_eval("def run \n#{test_head}\n#{IO.read(test_file)} \nend")
+
+    test.run
+  end
+end
+
+def create_test_file test_name
+  out_file = File.new("#{test_name}.uru", "w")
+  out_file << IO.readlines("#{root_path}meta/test_skeleton.uru").join('')
+  out_file.close
+
+  puts "#{test_name}.uru successfully created."
+end
+
+def root_path
+  File.dirname(__FILE__).to_s+"/../"
+end
+
+def pre_run_check(argv_index)
+  ARGV.each do |testfile|
+    if File.exists? testfile
+      yield testfile
+    end
+  end
+end
+
+if ARGV.empty?
+  puts "Welcome to Urushiol. The easy test framework for varnish vcl files.
+Append -h flag for usage information."
+
+elsif (ARGV.include?("--version") || ARGV.include?("-v"))
+  puts "Version : #{Urushiol::VERSION}"
+
+elsif (ARGV.include?("--help") || ARGV.include?("-h"))
+  puts Urushiol::HELP
+
+elsif (ARGV.include?("--live") || ARGV.include?("-l"))
+  live_flag = "--live" if ARGV.include?("--live")
+  live_flag = "-l" if ARGV.include?("-l")
+
+
+
+  vclfile    = ARGV[ARGV.find_index(live_flag)+1]
+  test_files = ARGV[(ARGV.find_index(live_flag)+2)...ARGV.length]
+  run_typed_testfiles(test_files, vclfile, "live")
+
+
+elsif (ARGV.include?("--mock") || ARGV.include?("-m"))
+
+  mock_flag = "--mock" if ARGV.include?("--mock")
+  mock_flag = "-m" if ARGV.include?("-m")
+
+  vclfile    = ARGV[ARGV.find_index(mock_flag)+1]
+  test_files = ARGV[(ARGV.find_index(mock_flag)+2)...ARGV.length]
+  run_typed_testfiles(test_files, File.absolute_path(vclfile), "mock")
+
+
+elsif ARGV.first.downcase == "integritycheck"
+  Dir.glob("#{root_path}test/**/*").each do |testfile|
+    run_testfile testfile
+  end
+elsif ARGV.first == "generate"
+  if ARGV[1] != nil
+    create_test_file(ARGV[1])
+  else
+    puts "Please specify a name for your test."
+  end
+elsif File.exists? ARGV.first
+  ARGV.each do |testfile|
+    if File.exists? testfile
+      run_testfile testfile
+    end
+  end
+else
+  puts "Urushiol did not recognize \"#{ARGV.join(" ")} \" as argument(s)."
+end
+
+
+
+
+
+
+

data/lib/client_test_base.rb

@@ -0,0 +1,41 @@
+require 'txreq'
+
+module Urushiol
+  class ClientTestBase
+    class << self
+      def wait(name = "c")
+        "\nclient #{name} -wait"
+      end
+    end
+    def initialize (name,config = "")
+      @client_test = "\nclient #{name} #{config}{"
+    end
+
+    def txreq(&block)
+      req = Txreq.new
+      yield req if block_given?
+      @client_test << req.get_source
+    end
+
+    def rxresp
+      @client_test << "\nrxresp"
+    end
+
+    def expect(criteria)
+      @client_test << "\nexpect #{criteria.strip}"
+    end
+
+    def run
+      @client_test << "\n} -run\n"
+    end
+
+    def test_source
+      if @client_test.end_with?("\n} -run\n")
+        @client_test
+      else
+        run
+        @client_test
+      end
+    end
+  end
+end

data/lib/meta/help.rb

@@ -0,0 +1,17 @@
+module Urushiol
+  HELP = "Usage: urushiol [-v] [-h] [-l] [-m] [<args>]
+
+    If no flags are specified <args> should be test file(s).
+
+    -v, --version                    Print the version and exit.
+    -h, --help                       Print this help.
+    -l, --live                       Runs tests on live vcl file; backends
+                                     will be real servers. <args> should be
+                                     path to vcl file and path to test file(s).
+    -m, --mock                       Runs tests on mocked vcl file; backends
+                                     will be mocked servers that return 200 as
+                                     status code and the backend name as body.
+                                     <args> should be path to vcl file and path
+                                     to test file(s).
+    "
+end

data/lib/meta/version.rb

@@ -0,0 +1,3 @@
+module Urushiol
+  VERSION = '1.0.3'
+end

data/lib/server.rb

@@ -0,0 +1,42 @@
+require 'txresp'
+
+module Urushiol
+  class Server
+    class << self
+      def wait(name)
+        "\nserver #{name} -wait"
+      end
+    end
+
+    def initialize (name)
+      @server_string = "\nserver #{name} {"
+    end
+
+    def txresp
+      resp = Txresp.new
+      yield resp if block_given?
+      @server_string << resp.get_source
+    end
+
+    def rxreq
+      @server_string << "\nrxreq"
+    end
+
+    def expect(criteria)
+      @server_string << "\nexpect #{criteria}"
+    end
+
+    def start
+      @server_string << "\n} -start"
+    end
+
+    def server_source
+      if @server_string.end_with?("\n} -start")
+        @server_string
+      else
+        start
+        @server_string
+      end
+    end
+  end
+end

data/lib/test_case.rb

@@ -0,0 +1,10 @@
+# A empty testcase
+class TestCase
+  def initialize test_file
+    @testcase = Urushiol::VarnishTestBase.new("#{test_file}")
+  end
+
+  def testcase
+    @testcase
+  end
+end

data/lib/txreq.rb

@@ -0,0 +1,28 @@
+module Urushiol
+  class Txreq
+
+    def initialize
+      @req = "\ntxreq"
+    end
+
+    def url(url)
+      @req << " -url #{url.strip}"
+    end
+
+    def protocol(proto)
+      @req << " -proto #{proto.strip}"
+    end
+
+    def host(host)
+      @req << " -hdr \"Host: #{host.strip}\""
+    end
+
+    def request(type)
+      @req << " -req #{type.strip.upcase}"
+    end
+
+    def get_source
+      @req
+    end
+  end
+end

data/lib/txresp.rb

@@ -0,0 +1,32 @@
+module Urushiol
+  class Txresp
+
+    def initialize
+      @resp = "\ntxresp"
+    end
+
+    def message(msg)
+      @resp << " -msg #{msg}"
+    end
+
+    def protocol(proto)
+      @resp << " -proto #{proto}"
+    end
+
+    def status_code(status)
+      @resp << " -status #{status}"
+    end
+
+    def header(hdr)
+      @resp << " -hdr \"#{hdr}\""
+    end
+
+    def body(body)
+      @resp << " -body \"#{body}\""
+    end
+
+    def get_source
+      @resp
+    end
+  end
+end

data/lib/urushiol.rb

@@ -0,0 +1,89 @@
+require 'vtc'
+require 'vcl'
+require 'client_test_base'
+require 'server'
+require 'varnish'
+
+module Urushiol
+  class VarnishTestBase
+    def initialize (name,vcl_file_ref=nil)
+      @vtc_obj    = Vtc.new(name)
+      @vcl_source = vcl_file_ref
+    end
+
+    def mock_varnish(name)
+      varnish = Varnish.new(name)
+      yield varnish if block_given?
+      @vtc_obj.append_config(varnish.varnish_source)
+    end
+
+    def mock_backends(source=@vcl_source)
+      if source != nil
+        @vtc_obj.mock_backends(Vcl.new(source).get_conf)
+      else
+        puts "\nCan't mock backends if no VCL file is specified.\n"
+      end
+    end
+
+    def server(&block)
+      if block_given?
+        @vtc_obj.append_config(yield Server)
+      end
+    end
+
+    def define_tests(tests)
+      @vtc_obj.mock_clients_and_tests(tests)
+    end
+
+    def client_testcase(name="c",config="",&block)
+      test = ClientTestBase.new(name,config)
+      yield test if block_given?
+      @vtc_obj.append_config(test.test_source)
+    end
+
+    def mock_server(name,&block)
+      server = Server.new(name)
+      yield server if block_given?
+      @vtc_obj.append_config(server.server_source)
+    end
+
+    def create_test_file(vtc)
+      File.open('/tmp/test.vtc', "wb") { |f| f.write(vtc.get_spec) }
+    end
+
+    def override_vcl_file(vcl_file)
+      File.open('/tmp/test.vcl', "wb") { |f| f.write(Vcl.new(vcl_file).get_conf) }
+    end
+
+    def get_vcl
+      @vcl_source
+    end
+
+    def delay(time)
+      @vtc_obj.append_config("\ndelay #{time}")
+    end
+
+    def run
+      create_test_file(@vtc_obj)
+      varnishd_check = `which varnishd` ;  result=$?.success?
+      if result == true
+        output=`varnishtest /tmp/test.vtc` ;  result=$?.success?
+        if result == false
+          puts output
+          puts "\nVarnishtests returned errors, see stack trace above."
+          exit 1
+        else
+          puts "Test completed successfully without errors."
+        end
+        cleanup
+      else
+        puts "Varnish does not seem to be installed on your computer. Urushiol can't run without Varnish"
+      end
+
+    end
+
+    def cleanup
+      #system("rm /tmp/test.vtc")
+    end
+  end
+end

data/lib/varnish.rb

@@ -0,0 +1,46 @@
+module Urushiol
+  class Varnish
+    def initialize (name)
+      @varnish_string = "\n# Start a varnish instance called \"#{name}\"\n"
+      @varnish_string << "varnish #{name}"
+    end
+
+    def args(args_string)
+      @varnish_string << " -arg \"#{args_string}\""
+    end
+
+    def vcl_file(file_path)
+      args "-f #{file_path}"
+    end
+
+    def server_address(ip_adress,port)
+      args "-a #{ip_adress}:#{port}"
+    end
+
+    def mock_server_address
+      server_address("127.0.0.1","8080")
+    end
+
+    def vcl(vcl_string)
+      @varnish_string << " -vcl {\n#{vcl_string}\n}"
+    end
+
+    def vcl_backend(vcl_backend_string)
+      @varnish_string << " -vcl+backend {\n#{vcl_backend_string}\n}"
+    end
+
+    def start
+      @varnish_string << " -start"
+    end
+
+    def varnish_source
+      if @varnish_string.end_with?(" -start")
+        @varnish_string
+      else
+        start
+        @varnish_string
+      end
+
+    end
+  end
+end

data/lib/vcl.rb

@@ -0,0 +1,21 @@
+module Urushiol
+  class Vcl
+
+    def initialize (vcl_file_ref)
+      @vcl = ""
+      parse(vcl_file_ref)
+    end
+
+    def parse (vcl_file_ref)
+      file = File.open(vcl_file_ref)
+      file.each do |line|
+        @vcl << line
+      end
+    end
+
+    def get_conf
+      @vcl
+    end
+
+  end
+end

data/lib/vtc.rb

@@ -0,0 +1,45 @@
+module Urushiol
+  class Vtc
+
+    def initialize(name)
+      @vtc = ""
+    end
+
+    def mock_backends(vcl)
+      if vcl != nil
+        backends = vcl.scan(/^backend (\w*)\W+/).flatten
+
+        #Mock servers in vtc-file
+        backends.each do |backend|
+          index = backends.index(backend)
+          @vtc << "server s#{index} -repeat 10000 {
+              # Receive a request
+              rxreq
+              # Send a standard response
+              txresp -hdr \"Connection: close\" -body \"#{backend}\"
+            } -start \n"
+
+          #mock backends in vcl-file
+          vcl.gsub!(/(?m)backend #{backend} \{(.*?)\}/,
+                     "backend #{backend} {\n  .host = \"${s#{index}_addr}\";\n  .port = \"${s#{index}_port}\";\n}")
+        end
+        @test_vcl = vcl
+      else
+        puts("no vcl-file given")
+      end
+    end
+
+    def append_config(tests)
+      @vtc << tests
+    end
+
+    def mock_varnish
+      @vtc << "# Start a varnish instance called \"v1\" from vcl and override backends with mock server adresses
+              varnish v1 -arg \"-f /tmp/test.vcl\" -start \n"
+    end
+
+    def get_spec
+      @vtc
+    end
+  end
+end

data/meta/live_top.uru

@@ -0,0 +1,7 @@
+#Reference the vclfile to be tested
+vcl_file_ref = ';file_ref;'
+
+#Mock varnish and give it a vcl file to run
+testcase.mock_varnish("v1") do |varnish|
+  varnish.vcl_file vcl_file_ref
+end

data/meta/mock_top.uru

@@ -0,0 +1,10 @@
+#Reference the vclfile to be tested
+vcl_file_ref = ';file_ref;'
+
+#Automock backends stated in the vclfile
+vcl_file     = testcase.mock_backends(vcl_file_ref)
+
+#Mock varnish and give it a vcl file to run
+testcase.mock_varnish("v1") do |varnish|
+  varnish.vcl vcl_file
+end

data/meta/test_skeleton.uru

@@ -0,0 +1,30 @@
+# Welcome to Urushio! We have created a testcase instance for you.
+# Access it by calling methods on the variable "testcase", like so:
+#
+#  testcase.mock_server "s1" do |server|
+#    server.rxreq
+#    server.txresp
+#  end
+#
+#  testcase.run
+#
+# If you have any questions regarding functionality we redirect you to our Github page:
+# https://github.com/TV4/Urushiol
+#
+# Run this test by running `urushiol NameOfTestHere.uru` in your shell.
+
+testcase.mock_server("s1") do |server|
+  server.rxreq
+  server.txresp
+end
+
+testcase.client_testcase("c1","-connect ${s1_sock} ") do |test|
+  test.txreq
+  test.rxresp
+end
+
+testcase.server do |server|
+  server.wait("s1")
+end
+
+testcase.run

data/test/01test.rb

@@ -0,0 +1,15 @@
+testcase.mock_server("s1") do |server|
+  server.rxreq
+  server.txresp
+end
+
+testcase.client_testcase("c1","-connect ${s1_sock} ") do |test|
+  test.txreq
+  test.rxresp
+end
+
+testcase.server do |server|
+  server.wait("s1")
+end
+
+testcase.run

data/test/02test.rb

@@ -0,0 +1,27 @@
+testcase.mock_server("s1") do |server|
+  server.rxreq
+  server.expect "req.proto == HTTP/1.1"
+  server.expect "req.url == \"/\""
+  server.txresp do |resp|
+    resp.message "Ok"
+    resp.status_code "200"
+    resp.protocol "HTTP/1.1"
+  end
+end
+
+testcase.client_testcase("c1","-connect ${s1_sock} ") do |test|
+  test.txreq do |req|
+    req.url "/"
+    req.protocol "HTTP/1.1"
+  end
+  test.rxresp
+  test.expect "resp.proto == HTTP/1.1"
+  test.expect "resp.status == 200"
+  test.expect "resp.msg == Ok"
+end
+
+testcase.server do |server|
+  server.wait("s1")
+end
+
+testcase.run

data/test/03test.rb

@@ -0,0 +1,29 @@
+testcase.mock_server("s1") do |server|
+  server.rxreq
+  server.expect "req.request == PUT"
+  server.expect "req.proto == HTTP/1.0"
+  server.expect "req.url == \"/foo\""
+  server.txresp do |resp|
+    resp.message "Foo"
+    resp.status_code "201"
+    resp.protocol "HTTP/1.2"
+  end
+end
+
+testcase.client_testcase("c1","-connect ${s1_sock} ") do |test|
+  test.txreq do |req|
+    req.url "/foo"
+    req.protocol "HTTP/1.0"
+    req.request "PUT"
+  end
+  test.rxresp
+  test.expect "resp.proto == HTTP/1.2"
+  test.expect "resp.status == 201"
+  test.expect "resp.msg == Foo"
+end
+
+testcase.server do |server|
+  server.wait("s1")
+end
+
+testcase.run

data/test/04test.rb

@@ -0,0 +1,31 @@
+testcase.mock_server "s1" do |server|
+  server.rxreq
+  server.txresp do |resp|
+    resp.header "Connection: close"
+    resp.body "012345"
+  end
+end
+
+testcase.mock_varnish "v1"  do |varnish|
+  varnish.vcl_backend 'backend b2 {
+		.host = "${s1_addr}";
+		.port = "${s1_port}";
+	}
+  sub vcl_recv {
+    set req.backend = b2;
+    return(lookup);
+}'
+end
+
+
+testcase.client_testcase do |test|
+  test.txreq do |req|
+    req.url "/"
+  end
+  test.rxresp
+  test.expect "resp.status == 200"
+  test.expect "resp.body == \"012345\""
+end
+
+
+testcase.run

data/urushiol.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require 'meta/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'urushiol'
+  s.version     =  Urushiol::VERSION
+  s.date        =  Date.today.to_s
+  s.required_ruby_version = ">=1.9.2"
+  s.authors     = ["TV4","Karl Litterfeldt"]
+  s.email       = "karl.litterfeldt@tv4.se"
+  s.license     = "MIT-LICENSE"
+
+  s.homepage    = "http://www.tv4.se"
+  s.summary     = %q{Test framework written in Ruby to test varnish-cache routing and caching logic.}
+  s.description = %q{Urushiol was born out of necessity. When we decided to migrate our reverse proxy routing from Apache to Varnish we noticed that this would not be a trivial matter. As the migration came to a halt due to unexpected routing errors we decided that, having a proper way of testing our configs would not be a bad idea. Urushiol is the product of that idea.}
+
+  s.files       = Dir.glob("lib/**/*") + Dir.glob("test/**/*") + Dir.glob("meta/**/*") + Dir.glob("bin/**/*") + %w(urushiol.gemspec LICENSE README.md)
+  s.executables   = %w(urushiol)
+  s.require_paths = ["lib"]
+
+
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: urushiol
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+platform: ruby
+authors:
+- TV4
+- Karl Litterfeldt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-30 00:00:00.000000000 Z
+dependencies: []
+description: Urushiol was born out of necessity. When we decided to migrate our reverse
+  proxy routing from Apache to Varnish we noticed that this would not be a trivial
+  matter. As the migration came to a halt due to unexpected routing errors we decided
+  that, having a proper way of testing our configs would not be a bad idea. Urushiol
+  is the product of that idea.
+email: karl.litterfeldt@tv4.se
+executables:
+- urushiol
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/client_test_base.rb
+- lib/meta/help.rb
+- lib/meta/version.rb
+- lib/server.rb
+- lib/test_case.rb
+- lib/txreq.rb
+- lib/txresp.rb
+- lib/urushiol.rb
+- lib/varnish.rb
+- lib/vcl.rb
+- lib/vtc.rb
+- test/01test.rb
+- test/02test.rb
+- test/03test.rb
+- test/04test.rb
+- meta/live_top.uru
+- meta/mock_top.uru
+- meta/test_skeleton.uru
+- bin/urushiol
+- urushiol.gemspec
+- LICENSE
+- README.md
+homepage: http://www.tv4.se
+licenses:
+- MIT-LICENSE
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: Test framework written in Ruby to test varnish-cache routing and caching
+  logic.
+test_files: []
+has_rdoc: