cucumber-varnishtest 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39d4bcc496c7bb96948d20cc14ec16d763e8f29e
+  data.tar.gz: 24bd3493559ddf26b32b65280c0099368b583ebb
+SHA512:
+  metadata.gz: b36a2bb13b4a6ccd29db36f5fe2a76c3d55154101da16a5bb669a1469751dd786e10ec1d9122437e3b03b07412623b258858876047ce4bd16d705958e3b9d091
+  data.tar.gz: aef22699953e61133528e4fea1c321e3fafe7529cc2c2b8c0936c031a831a2afdfe48a64ee883da5d6361f94262bd0dc836e05d5d8ae3e168137d90053eeeadd

data/.gitignore

@@ -0,0 +1,12 @@
+# This is the .varnishtest file that is
+# generated via Cucumber.
+generated.varnishtest
+
+# This is the output of failed
+# varnishtest runs
+varnishtest.err
+varnishtest.out
+
+pkg
+
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'cucumber'

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Nick Stielau
+
+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,135 @@
+# Varnishtest Cucumber
+
+This let's you use Gherkin, the language of BDD, to write behavior-level
+checks for your VCL.
+
+## Project status
+This is currently a Proof of Concept.  
+
+I think this is probably the easiest/best way to get started with
+testing your Varnish config, but it might take a bit of extended as
+you test out your use-cases.  
+
+Definitely fork and don't rely on this code not changing, though ;)
+
+I'm working on getting this packaged as a ruby gem to further simplify
+the setup for getting testable VCLs.  Once it's packaged and versioned
+it should be in a sustainable, usable place.
+
+## To run
+
+To run, simply run `cucumber` from this directory.
+
+You can use your own VCL and write your own features in a .feature file.
+
+```
+±  |master ✗| → cucumber
+Feature: Static Server Headers
+
+  Scenario: Simple Single Request          # features/varnishtest.feature:3
+    Given varnish running with example.vcl # features/step_definitions/varnish_steps.rb:4
+    When we GET /images.png                # features/step_definitions/varnish_steps.rb:9
+    Then the response code should be 200   # features/step_definitions/varnish_steps.rb:29
+    And it should pass varnishtest         # features/step_definitions/varnish_steps.rb:25
+
+  Scenario: Checking Response Headers                              # features/varnishtest.feature:9
+    Given varnish running with example.vcl                         # features/step_definitions/varnish_steps.rb:4
+    When we GET /images.png                                        # features/step_definitions/varnish_steps.rb:9
+    Then the response header X-Served-By should be "My App Server" # features/step_definitions/varnish_steps.rb:21
+    And it should pass varnishtest                                 # features/step_definitions/varnish_steps.rb:25
+
+  Scenario: POST should never be cached    # features/varnishtest.feature:15
+    Given varnish running with example.vcl # features/step_definitions/varnish_steps.rb:4
+    When we POST /form                     # features/step_definitions/varnish_steps.rb:9
+    Then there should be 1 passed requests # features/step_definitions/varnish_steps.rb:49
+    And it should pass varnishtest         # features/step_definitions/varnish_steps.rb:25
+
+  Scenario: Multiple Requests without warming # features/varnishtest.feature:21
+    Given varnish running with example.vcl    # features/step_definitions/varnish_steps.rb:4
+    When we GET /images.png                   # features/step_definitions/varnish_steps.rb:9
+    And we GET /images2.png                   # features/step_definitions/varnish_steps.rb:9
+    And we GET /images2.png                   # features/step_definitions/varnish_steps.rb:9
+    Then there should be 2 cache misses       # features/step_definitions/varnish_steps.rb:41
+    Then there should be 1 cache hit          # features/step_definitions/varnish_steps.rb:37
+    And it should pass varnishtest            # features/step_definitions/varnish_steps.rb:25
+
+  Scenario: Check Dynamic header                                     # features/varnishtest.feature:30
+    Given varnish running with example.vcl                           # features/step_definitions/varnish_steps.rb:4
+    When we GET /monalisa.png                                        # features/step_definitions/varnish_steps.rb:9
+    Then the response header X-Requested-URL should be /monalisa.png # features/step_definitions/varnish_steps.rb:21
+    And it should pass varnishtest                                   # features/step_definitions/varnish_steps.rb:25
+
+5 scenarios (5 passed)
+23 steps (23 passed)
+0m7.467s
+```
+
+## Installation
+
+Check out [this example](https://github.com/nstielau/cucumber-varnishtest-example).
+
+Add the following line to your Gemfile, preferably in the test or cucumber group:
+
+```
+gem 'cucumber-varnishtest', :require => false
+```
+
+Then add the following line to your env.rb to make the step definitions available in your features:
+
+```
+require 'cucumber/varnishtest'
+```
+
+## How to use your own VCL
+
+Simply put the .vcl file in this directory, and specify in your
+`Given` clause of your Scenario:
+
+```
+Scenario: Multiple Requests without warming
+  Given varnish running with MyCustomConfig.vcl <==== YOUR VCL FILE
+  When we request /images.png
+  Then it should pass varnishtest
+```
+
+## Dependencies
+
+Make sure you have 'varnishtest' installed!
+
+```
+# On OSX
+$ brew install varnish
+$ varnishtest -h
+usage: varnishtest [options] file ...
+    -b size                      # Set internal buffer size (default: 512K)
+    -D name=val                  # Define macro
+    -i                           # Find varnishd in build tree
+    -j jobs                      # Run this many tests in parallel
+    -k                           # Continue on test failure
+    -L                           # Always leave temporary vtc.*
+    -l                           # Leave temporary vtc.* if test fails
+    -n iterations                # Run tests this many times
+    -q                           # Quiet mode: report only failures
+    -t duration                  # Time tests out after this long
+    -v                           # Verbose mode: always report test log
+    -W                           # Enable the witness facility for locking
+```
+
+Install cucumber
+
+```
+gem install bundler
+bundle install
+bundle exec cucumber --version
+```
+
+## References
+
+Read more about varnish test at
+* http://www.clock.co.uk/blog/getting-started-with-varnishtest
+* http://blog.zenika.com/2012/08/27/introducing-varnishtest/
+
+## Thanks
+
+Thanks to
+* jayzes for examples on how to [package cucumber steps](http://github.com/jayzes/cucumber-api-steps)

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/cucumber-varnishtest.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cucumber/varnishtest/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cucumber-varnishtest"
+  s.version     = Cucumber::Varnishtest::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nick Stielau"]
+  s.email       = ["nick.stielau@gmail.com"]
+  s.homepage    = "https://github.com/nstielau/varnishtest_cucumber"
+  s.summary     = %q{Cucumber steps to easily create and execute varnishtest tests.}
+  s.description = %q{Cucumber steps to easily create and execute varnishtest tests.}
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_dependency              'cucumber',       '>= 2.0.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/example.vcl

@@ -0,0 +1,11 @@
+# This is a really basic vcl file
+
+backend default {
+  .host = "${s1_addr}";
+  .port = "${s1_port}";
+}
+
+sub vcl_deliver {
+  set resp.http.X-Served-By = "My App Server";
+  set resp.http.X-Requested-URL = req.url;
+}

data/features/step_definitions/varnish_steps.rb

@@ -0,0 +1,56 @@
+require './lib/cucumber/varnishtest/context_manager'
+require './lib/cucumber/varnishtest/request'
+
+Given(/^varnish running with (.*)$/) do |vcl_file|
+  # Load  a particular varnish VCL file
+  ContextManager.instance.vcl_file = vcl_file
+end
+
+When(/^we (GET|PATCH|POST|PUT|DELETE) (.*)$/) do |method, path|
+  ContextManager.instance.request path, method
+end
+
+Then(/^the response should be 200$/) do
+  ContextManager.instance.client_expect 'resp.status', 200
+end
+
+Then(/^the response length should be (\d+)$/) do |bytes|
+  ContextManager.instance.client_expect 'resp.bodylen', bytes.to_i
+end
+
+Then(/^the response header (.*) should be (.*)$/) do |header, value|
+  ContextManager.instance.client_expect "resp.http.#{header}", "#{value}"
+end
+
+Then(/^it should pass varnishtest$/) do
+  ContextManager.instance.test!
+end
+
+Then(/^the response code should be (\d+)$/) do |code|
+  ContextManager.instance.client_expect "resp.status", 200
+end
+
+Then(/^the server should receive (\d+) requests$/) do |count|
+  ContextManager.instance.expected_request_count = count
+end
+
+Then(/^there should be (\d+) cache hit[s]*$/) do |count|
+  ContextManager.instance.expected_cache_hits = count
+end
+
+Then(/^there should be (\d+) cache misses$/) do |count|
+  ContextManager.instance.expected_cache_misses = count
+end
+
+Then(/^there should be (\d+) piped request[s]*$/) do |count|
+  ContextManager.instance.expected_piped_requests = count
+end
+
+Then(/^there should be (\d+) passed request[s]*$/) do |count|
+  ContextManager.instance.expected_passed_requests = count
+end
+
+After do |scenario|
+  # Reset the context manager for a fresh scenario
+  ContextManager.reset!
+end

data/features/varnishtest.feature

@@ -0,0 +1,34 @@
+Feature: Static Server Headers
+
+  Scenario: Simple Single Request
+    Given varnish running with example.vcl
+    When we GET /images.png
+    Then the response code should be 200
+    And it should pass varnishtest
+
+  Scenario: Checking Response Headers
+    Given varnish running with example.vcl
+    When we GET /images.png
+    Then the response header X-Served-By should be "My App Server"
+    And it should pass varnishtest
+
+  Scenario: POST should never be cached
+    Given varnish running with example.vcl
+    When we POST /form
+    Then there should be 1 passed requests
+    And it should pass varnishtest
+
+  Scenario: Multiple Requests without warming
+    Given varnish running with example.vcl
+    When we GET /images.png
+    And we GET /images2.png
+    And we GET /images2.png
+    Then there should be 2 cache misses
+    Then there should be 1 cache hit
+    And it should pass varnishtest
+
+  Scenario: Check Dynamic header
+    Given varnish running with example.vcl
+    When we GET /monalisa.png
+    Then the response header X-Requested-URL should be /monalisa.png
+    And it should pass varnishtest

data/lib/cucumber/varnishtest.rb

@@ -0,0 +1 @@
+require 'cucumber/varnishtest/steps'

data/lib/cucumber/varnishtest/context_manager.rb

@@ -0,0 +1,86 @@
+class ContextManager
+  @instance = nil
+
+  VARNISHTEST_FILE = "generated.varnishtest"
+
+  # Server level expectations
+  attr_writer :expected_cache_hits
+  attr_writer :expected_cache_misses
+  attr_writer :expected_request_count
+  attr_writer :expected_piped_requests
+  attr_writer :expected_passed_requests
+
+  def self.instance()
+    # Get instance from class
+    @instance ||= self.new()
+  end
+
+  def self.reset!
+    # Clear out the instance, start fresh
+    @instance = nil
+  end
+
+  def vcl_file=(vcl_file)
+    @vcl_file = vcl_file
+    raise "VCL file '#{vcl_file}' not found." unless File.exist?(vcl_file)
+  end
+
+  def request(path, method)
+    @requests ||= []
+    @requests << VarnishtestRequest.new(path, method)
+  end
+
+  def client_expect(attribute, value)
+    @client_expectations ||= {}
+    @client_expectations[attribute] = value
+  end
+
+  def varnishtest_conf
+    return <<-eos
+    varnishtest "This is my first test"
+
+    server s1 {
+      #{@requests.map{"rxreq\ntxresp -body \"hello world\""}.join("\naccept\n\n")}
+    } -start
+
+    varnish v1 -vcl {
+      #{File.read(@vcl_file)}
+    } -start
+
+    client c1 {
+      #{
+        (@requests || []).map{|req| req.to_varnishtest}.join("\n\n")
+      }
+
+      #{
+        (@client_expectations || []).map do |attribute, value|
+          "expect #{attribute} == #{value}"
+        end.join("\n")
+      }
+    } -run
+
+    #{@expected_cache_hits.nil? ? "" : "varnish v1 -expect cache_hit == #{@expected_cache_hits}"}
+    #{@expected_cache_misses.nil? ? "" : "varnish v1 -expect cache_miss == #{@expected_cache_misses}"}
+    #{@expected_request_count.nil? ? "" : "varnish v1 -expect client_req == #{@expected_request_count}"}
+    #{@expected_piped_requests.nil? ? "" : "varnish v1 -expect s_pipe == #{@expected_piped_requests}"}
+    #{@expected_passed_requests.nil? ? "" : "varnish v1 -expect s_pass == #{@expected_passed_requests}"}
+    eos
+  end
+
+  def test!
+    File.open(VARNISHTEST_FILE, 'w') do |file|
+      file.write(varnishtest_conf)
+    end
+    output = `varnishtest #{VARNISHTEST_FILE}`
+    result = $? == 0
+
+    File.open('varnishtest.out', 'w') do |file|
+      file.write(output)
+    end
+
+    raise [
+      output.split("\n").select{|line| line.match("---- v1")},
+      "See #{VARNISHTEST_FILE} and varnishtest.err debuggin'"
+    ].join("\n\n\n\n") unless result
+  end
+end

data/lib/cucumber/varnishtest/request.rb

@@ -0,0 +1,14 @@
+class VarnishtestRequest
+  def initialize(path, method)
+    @path = path
+    @method = method
+  end
+
+  def to_varnishtest
+    return <<-eos
+    txreq -url "#{@path}" -req #{@method}
+    rxresp
+
+    eos
+  end
+end

data/lib/cucumber/varnishtest/steps.rb

@@ -0,0 +1,56 @@
+require 'cucumber/varnishtest/context_manager'
+require 'cucumber/varnishtest/request'
+
+Given(/^varnish running with (.*)$/) do |vcl_file|
+  # Load  a particular varnish VCL file
+  ContextManager.instance.vcl_file = vcl_file
+end
+
+When(/^we (GET|POST) (.*)$/) do |method, path|
+  ContextManager.instance.request path, method
+end
+
+Then(/^the response should be 200$/) do
+  ContextManager.instance.client_expect 'resp.status', 200
+end
+
+Then(/^the response length should be (\d+)$/) do |bytes|
+  ContextManager.instance.client_expect 'resp.bodylen', bytes.to_i
+end
+
+Then(/^the response header (.*) should be (.*)$/) do |header, value|
+  ContextManager.instance.client_expect "resp.http.#{header}", "#{value}"
+end
+
+Then(/^it should pass varnishtest$/) do
+  ContextManager.instance.test!
+end
+
+Then(/^the response code should be (\d+)$/) do |code|
+  ContextManager.instance.client_expect "resp.status", 200
+end
+
+Then(/^the server should receive (\d+) requests$/) do |count|
+  ContextManager.instance.expected_request_count = count
+end
+
+Then(/^there should be (\d+) cache hit[s]*$/) do |count|
+  ContextManager.instance.expected_cache_hits = count
+end
+
+Then(/^there should be (\d+) cache misses$/) do |count|
+  ContextManager.instance.expected_cache_misses = count
+end
+
+Then(/^there should be (\d+) piped request[s]*$/) do |count|
+  ContextManager.instance.expected_piped_requests = count
+end
+
+Then(/^there should be (\d+) passed request[s]*$/) do |count|
+  ContextManager.instance.expected_passed_requests = count
+end
+
+After do |scenario|
+  # Reset the context manager for a fresh scenario
+  ContextManager.reset!
+end

data/lib/cucumber/varnishtest/version.rb

@@ -0,0 +1,5 @@
+module Cucumber
+  module Varnishtest
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-varnishtest
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nick Stielau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+description: Cucumber steps to easily create and execute varnishtest tests.
+email:
+- nick.stielau@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- cucumber-varnishtest.gemspec
+- example.vcl
+- features/step_definitions/varnish_steps.rb
+- features/support/env.rb
+- features/varnishtest.feature
+- lib/cucumber/varnishtest.rb
+- lib/cucumber/varnishtest/context_manager.rb
+- lib/cucumber/varnishtest/request.rb
+- lib/cucumber/varnishtest/steps.rb
+- lib/cucumber/varnishtest/version.rb
+homepage: https://github.com/nstielau/varnishtest_cucumber
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Cucumber steps to easily create and execute varnishtest tests.
+test_files:
+- features/step_definitions/varnish_steps.rb
+- features/support/env.rb
+- features/varnishtest.feature