brine-dsl 0.5.0

data/features/assertions/is_including.feature

@@ -0,0 +1,29 @@
+Feature: Including
+  It can be asserted that a value is a superset of another value.
+
+  Scenario: Equals
+    Given a file named "features/includes.feature" with:
+      """
+Feature: Includes
+  Scenario: Basic object membership
+    When the response body is assigned:
+      \"\"\"
+      {"foo":"bar",
+      "baz": 1,
+      "other": "blah"}
+      \"\"\"
+    Then the value of the response body is including:
+      \"\"\"
+      {"baz":1}
+      \"\"\"
+    And the value of the response body is not including:
+      \"\"\"
+      {"missing":"value"}
+      \"\"\"
+      """
+    When I run `cucumber features/includes.feature`
+    Then the output should contain:
+      """
+      1 passed
+      """
+    And it should pass

data/features/assertions/is_matching.feature

@@ -0,0 +1,35 @@
+Feature: Matching
+  It can be asserted that a value matches another string or regex
+
+  Scenario: Assorted positive and negative assertions.
+    Given a file named "features/is_matching.feature" with:
+      """
+
+Feature: Assert value matchiness
+  Scenario: String in response body matched against a regex
+    When the response body is assigned:
+      \"\"\"
+      http://www.github.com?var=val
+      \"\"\"
+    Then the value of the response body is matching `/github/`
+    And the value of the response body is matching `/git.*\?.*=/`
+    And the value of the response body is not matching `/gh/`
+    And the value of the response body is not matching `/^github/`
+
+  Scenario: Regex in response body matched against a string
+    When the response body is assigned:
+      \"\"\"
+      /(.+)\1/
+      \"\"\"
+    Then the value of the response body is matching `blahblah`
+    And the value of the response body is matching `boo`
+    And the value of the response body is not matching `blah blah`
+    And the value of the response body is not matching `blah`
+
+      """
+    When I run `cucumber --strict features/is_matching.feature`
+    Then the output should contain:
+      """
+      2 passed
+      """
+    And it should pass

data/features/deprecations/replaced_with.feature

@@ -0,0 +1,35 @@
+Feature: Deprecation Messaging
+
+  Scenario: Deprecation Message is Displayed
+    Given a file named "features/deprecation.feature" with:
+    """
+Feature: Deprecation Messaging
+  Scenario: Multine String
+    When the response body is:
+      \"\"\"
+      Anything
+      \"\"\"
+    Then the response body as JSON is:
+      \"\"\"
+      ""Anything""
+      \"\"\"
+  Scenario: Multine Object
+    When the response body is:
+      \"\"\"
+      {"isObj": true}
+      \"\"\"
+    Then the response body as JSON is:
+      \"\"\"
+      '{"isObj":true}'
+      \"\"\"
+      """
+    When I run `cucumber features/deprecation.feature`
+    Then the output should contain:
+      """
+      2 passed
+      """
+    And the output should contain:
+      """
+      DEPRECATION:
+      """
+    And it should pass

data/features/request_construction/basic.feature

@@ -0,0 +1,29 @@
+Feature: Basic Request Construction
+  A simple request with a specified method and path can be sent.
+
+  Scenario Outline: Varying Methods
+    Given a file named "features/basic_requests.feature" with:
+
+      """
+Feature: Sending a method
+  Scenario: Basic URL
+    Given expected <method> sent to `/profile`
+
+    When a <method> is sent to `/profile`
+    Then expected calls are verified
+      """
+
+    When I run `cucumber features/basic_requests.feature`
+    Then the output should contain:
+      """
+      1 passed
+      """
+    And it should pass
+
+    Examples:
+      | method |
+      | GET    |
+      | POST   |
+      | PATCH  |
+      | DELETE |
+      | PUT    |

data/features/request_construction/body.feature

@@ -0,0 +1,26 @@
+Feature: Assigning a Request Body
+
+  Scenario: Request With Body
+    Given a file named "features/request_body.feature" with:
+      """
+Feature: Passing a body
+  Scenario: Basic URL
+    Given expected request body:
+    \"\"\"
+    {"request":1}
+    \"\"\"
+    And expected PUT sent to `/store`
+
+    When the request body is assigned:
+    \"\"\"
+    {"request":1}
+    \"\"\"
+    When a PUT is sent to `/store`
+    Then expected calls are verified
+      """
+    When I run `cucumber features/request_body.feature`
+    Then the output should contain:
+      """
+      5 passed
+      """
+    And it should pass

data/features/request_construction/clearing.feature

@@ -0,0 +1,46 @@
+Feature: Cleared After Sent
+  After a request is sent, any values that were added to that request
+are cleared and will not be present in subsequent requests.
+
+  Scenario: Request is Cleared Before Second Send
+    Given a file named "features/request_clearing.feature" with:
+
+      """
+Feature: Clearing the request.
+  Scenario: Request body is cleared.
+    Given expected request body:
+      \"\"\"
+      {"request":1}
+      \"\"\"
+    And expected PUT sent to `/profile`
+    Given expected request body:
+      \"\"\"
+      \"\"\"
+    And expected PUT sent to `/store`
+
+    When the request body is assigned:
+    \"\"\"
+    {"request":1}
+    \"\"\"
+    And a PUT is sent to `/profile`
+    And a PUT is sent to `/store`
+
+    Then expected calls are verified
+
+  Scenario: Request parameter
+    Given expected GET sent to `/query?foo=bar`
+    And expected GET sent to `/resource`
+
+    Given the request query parameter `foo` is assigned `bar`
+    And a GET is sent to `/query`
+
+    When a GET is sent to `/resource`
+    Then expected calls are verified
+      """
+
+    When I run `cucumber features/request_clearing.feature`
+    Then the output should contain:
+      """
+      2 passed
+      """
+    And it should pass

data/features/request_construction/headers.feature

@@ -0,0 +1,94 @@
+Feature: Adding Headers
+
+  Scenario: Headers are added to requests.
+    Given a file named "features/headers.feature" with:
+
+      """
+Feature: Request headers can be specified.
+  Scenario: A new header with a single value is added to request.
+    Given expected request headers:
+      \"\"\"
+      {"foo":"bar"}
+      \"\"\"
+    And expected GET sent to `/query`
+
+    When the request header `foo` is assigned `bar`
+    And a GET is sent to `/query`
+
+    Then expected calls are verified
+
+  Scenario: Default headers are present in requests.
+    Given expected request headers:
+      \"\"\"
+      {"Content-Type": "application/json"}
+      \"\"\"
+    And expected GET sent to `/query`
+
+    When a GET is sent to `/query`
+
+    Then expected calls are verified
+
+  Scenario: Default headers can be overridden.
+    Given expected request headers:
+      \"\"\"
+      {"Content-Type": "text/plain"}
+      \"\"\"
+    And expected GET sent to `/query`    
+
+    When the request header `Content-Type` is assigned `text/plain`
+    And a GET is sent to `/query`
+
+    Then expected calls are verified
+
+  Scenario: Array header values are added to requests.
+    Given expected request headers:
+      \"\"\"
+      {"X-Array": "1, 2, 3"}
+      \"\"\"
+    And expected GET sent to `/query`
+
+    When the request header `X-Array` is assigned `[1, 2, 3]`
+    And a GET is sent to `/query`
+
+    Then expected calls are verified
+
+  Scenario: The last set value for a given header wins.
+    Given expected request headers:
+      \"\"\"
+      {"foo":"baz"}
+      \"\"\"
+    And expected GET sent to `/query`
+
+    When the request header `foo` is assigned `bar`
+    And the request header `foo` is assigned `baz`
+    And a GET is sent to `/query`
+
+    Then expected calls are verified
+
+  Scenario Outline: Header is added regardless of HTTP method.
+    Given expected request headers:
+      \"\"\"
+      {"foo":"bar"}
+      \"\"\"
+    And expected <method> sent to `/query`
+
+    When the request header `foo` is assigned `bar`
+    And a <method> is sent to `/query`
+
+    Then expected calls are verified
+
+  Examples:
+    | method  |
+    | POST    |
+    | PUT     |
+    | DELETE  |
+    | HEAD    |
+    | OPTIONS |
+      """
+
+    When I run `cucumber features/headers.feature`
+    Then the output should contain:
+      """
+      10 passed
+      """
+    And it should pass

data/features/request_construction/params.feature

@@ -0,0 +1,60 @@
+@wip
+Feature: Adding Query Parameters
+
+  Scenario: Query parameters are added to requests.
+    Given a file named "features/params.feature" with:
+
+      """
+Feature: Request query parameters can be specified.
+  Scenario: A single parameter is appended to the URL.
+    Given expected GET sent to `/query?foo=bar`
+
+    When the request query parameter `foo` is assigned `bar`
+    And a GET is sent to `/query`
+
+    Then expected calls are verified
+
+  Scenario: Multiple parameters are appended to the URL with proper formatting.
+    Given expected GET sent to `/query?foo=bar&baz=1`
+
+    When the request query parameter `foo` is assigned `bar`
+    And the request query parameter `baz` is assigned `1`
+    And a GET is sent to `/query`
+
+    Then expected calls are verified
+
+  Scenario Outline: Values are encoded appropriately.
+    Given expected GET sent to `/query?foo=<encoded>`
+
+    When the request query parameter `foo` is assigned `<input>`
+    And a GET is sent to `/query`
+
+    Then expected calls are verified
+  Examples:
+    | input         | encoded                  |
+    | bar & grill   | bar+%26+grill            |
+    | + +           | %2B+%2B                  |
+    | (imbalance))  | %28imbalance%29%29       |
+
+  Scenario Outline: Parametes are added regardless of HTTP method.
+    Given expected <method> sent to `/query?foo=bar`
+
+    When the request query parameter `foo` is assigned `bar`
+    And a <method> is sent to `/query`
+
+    Then expected calls are verified
+  Examples:
+    | method  |
+    | POST    |
+    | PUT     |
+    | DELETE  |
+    | HEAD    |
+    | OPTIONS |
+      """
+
+    When I run `cucumber features/params.feature`
+    Then the output should contain:
+      """
+      10 passed
+      """
+    And it should pass

data/features/resource_cleanup/cleanup.feature

@@ -0,0 +1,86 @@
+Feature: Resource Cleanup
+  Resources created during testing can be marked for deletion.
+
+  Scenario: Initial Success
+    Given a file named "features/cleanup.feature" with:
+
+      """
+Feature: Resource Cleanup
+
+  Scenario: Successful Basic Deletion
+    Given expected DELETE sent to `/some/path`
+
+    When a resource is created at `/some/path`
+      """
+
+    When I run `cucumber --strict features/cleanup.feature`
+    Then the output should match %r<delete http://www.example.com/some/path>
+    And the output should not contain:
+      """
+      ERROR
+      """
+    And it should pass
+
+  Scenario: Returned 4xx
+    Given a file named "features/cleanup_failure.feature" with:
+
+      """
+Feature: Resource Cleanup
+
+  Scenario: Failed Deletion
+    Given expected response status of `409`
+    And expected DELETE sent to `/some/path`
+
+    When a resource is created at `/some/path`
+      """
+
+    When I run `cucumber --strict features/cleanup_failure.feature`
+    Then the output should match %r<(?:.*delete http://www.example.com/some/path.*){3}>
+    And the output should contain:
+      """
+      ERROR
+      """
+    And it should pass
+
+  Scenario: Success Upon Retry
+    Given a file named "features/cleanup_retried.feature" with:
+
+      """
+Feature: Resource Cleanup
+
+  Scenario: Success Upon Retry
+    Given expected response status sequence of `[504, 200]`
+    And expected DELETE sent to `/some/path`
+
+    When a resource is created at `/some/path`
+      """
+
+    When I run `cucumber --strict -o ../../out.log features/cleanup_retried.feature`
+    Then the output should match %r<(?:.*delete http://www.example.com/some/path.*){2}>
+    And the output should not contain:
+      """
+      ERROR
+      """
+    And it should pass
+
+
+  Scenario: Unreached Success
+    Given a file named "features/cleanup_unreached.feature" with:
+
+      """
+Feature: Resource Cleanup
+
+  Scenario: Unreached Success
+    Given expected response status sequence of `[504, 504, 504, 200]`
+    And expected DELETE sent to `/some/path`
+
+    When a resource is created at `/some/path`
+      """
+
+    When I run `cucumber --strict -o ../../out.log features/cleanup_unreached.feature`
+    Then the output should match %r<(?:.*delete http://www.example.com/some/path.*){3}>
+    And the output should contain:
+      """
+      ERROR
+      """
+    And it should pass    

data/features/selectors/all.feature

@@ -0,0 +1,55 @@
+Feature: All Elements
+  Assertions can be done against all elements of a structure.
+
+  Scenario: Assorted positive and negative assertions.
+    Given a file named "features/all.feature" with:
+      """
+
+Feature: Allow selection of all structure elements
+  Scenario: List in response body
+    When the response body is assigned:
+      \"\"\"
+      ["a", "bb", "ccc"]
+      \"\"\"
+    Then the value of the response body has elements which are all matching `/\w+/`
+
+  Scenario: Spread nested lists
+    When the response body is assigned:
+      \"\"\"
+      [{"val": "foo"},{"val": "foo"}]
+      \"\"\"
+    Then the value of the response body children `..val` has elements which are all equal to `foo`
+
+      """
+    When I run `cucumber --strict features/all.feature`
+    Then the output should contain:
+      """
+      4 passed
+      """
+    And it should pass
+
+  Scenario: Failing tests since negation isn't available yet.
+    Given a file named "features/all.feature" with:
+      """
+
+Feature: Allow selection of all structure elements
+  Scenario: List in response body
+    When the response body is assigned:
+      \"\"\"
+      ["a", "bb", "ccc"]
+      \"\"\"
+    Then the value of the response body has elements which are all matching `/^\w$/`
+
+  Scenario: Spread nested lists
+    When the response body is assigned:
+      \"\"\"
+      [{"val": "foo"},{"val": "fob"}]
+      \"\"\"
+    Then the value of the response body children `..val` has elements which are all equal to `foo`
+
+      """
+    When I run `cucumber --strict features/all.feature`
+    Then the output should contain:
+      """
+      2 failed
+      """

data/features/selectors/any.feature

@@ -0,0 +1,48 @@
+Feature: Any Element
+  Assertions can be done against any element of a structure.
+
+  Scenario: Assorted positive and negative assertions.
+    Given a file named "features/any.feature" with:
+      """
+
+Feature: Allow selection of any structure element
+  Scenario: List in response body
+    When the response body is assigned:
+      \"\"\"
+      ["a", "b", "c"]
+      \"\"\"
+    Then the value of the response body does have any element that is equal to `a`
+    And the value of the response body does not have any element that is equal to `d`
+
+  Scenario: Nested list in response body
+    When the response body is assigned:
+      \"\"\"
+      {"letters": ["a", "b", "c"]}
+      \"\"\"
+    Then the value of the response body child `letters` does have any element that is equal to `a`
+    And the value of the response body child `letters` does not have any element that is equal to `d`
+
+  Scenario: Map matches entries
+    When the response body is assigned:
+      \"\"\"
+      {"a": 1, "b": 2}
+      \"\"\"
+    #Equality will match keys
+    Then the value of the response body does have any element that is equal to `a`
+    And the value of the response body does not have any element that is equal to `d`
+
+  Scenario: Spread nested lists
+    When the response body is assigned:
+      \"\"\"
+      [{"val":"foo"},{"val":"bar"}]
+      \"\"\"
+    Then the value of the response body children `..val` does have any element that is equal to `foo`
+    And the value of the response body children `..val` does not have any element that is equal to `other`
+
+      """
+    When I run `cucumber --strict features/any.feature`
+    Then the output should contain:
+      """
+      4 passed
+      """
+    And it should pass

data/features/step_definitions/test_steps.rb

@@ -0,0 +1,5 @@
+# the output should contain: is useful for seeing failures
+# TODO: Swap this out with standard aruba step
+Then(/^it should pass$/) do
+  expect(last_command_started).to be_successfully_executed
+end

data/features/support/env.rb

@@ -0,0 +1,10 @@
+require 'aruba/cucumber'
+
+Before do
+  write_file 'features/support/env.rb',
+             <<-END
+             require 'brine'
+             require 'brine/test_steps'
+             World(brine_mix)
+             END
+end

data/lib/brine/cleaner_upper.rb

@@ -0,0 +1,62 @@
+# cleaner_upper.rb -- clean up resources created during test run
+#
+# Will issue DELETE call for all tracked URLs which will normally be triggered in a hook.
+#
+# The present approach for this is to explicitly track created resources to which
+# DELETE calls will be sent. Cleaning up of resources will be given some further attention
+# in the future, but this functionality should be preserved.
+
+class DeleteCommand
+  attr_accessor :client, :path
+
+  def initialize(client, path,
+                 oks:[200,204],
+                 attempts: 3)
+    @client = client
+    @path = path
+    @oks = oks
+    @attempts = attempts
+  end
+
+  def cleanup
+    while @attempts > 0
+      begin
+        resp=@client.delete(@path)
+        return true if @oks.include?(resp.status)
+      rescue ex
+        puts "WARNING: #{ex}"
+      end
+      @attempts -= 1
+    end
+    puts "ERROR: Could not DELETE #{@path}"
+    false
+  end
+end
+
+module CleanerUpper
+
+  # HTTP client object used to issue DELETE calls
+  # must support #delete(path)
+  # to be injected by calling code
+  def set_cleaning_client(client)
+    @client = client
+  end
+
+  # Record resource to be cleaned
+  def track_created_resource(path)
+    created_resources << DeleteCommand.new(@client, path)
+  end
+
+  # Clean recorded resources
+  # Expected to be called after test run
+  def cleanup_created_resources
+    created_resources.reverse.each{|it| it.cleanup}
+  end
+
+  private
+
+  # Lazily initialized array of resources to remove
+  def created_resources
+    @created_resources ||= []
+  end
+end

data/lib/brine/coercer.rb

@@ -0,0 +1,18 @@
+## coercer.rb::
+
+class Coercer
+  def initialize
+    @map = Hash.new(->(l, r){[l, r]})
+    @map[[String, Time]] = ->(l, r){[Time.parse(l), r]}
+  end
+
+  def coerce(l, r)
+    @map[[l.class, r.class]].call(l, r)
+  end
+end
+
+module Coercion
+  def coercer
+    @coercer ||= Coercer.new
+  end
+end

data/lib/brine/hooks.rb

@@ -0,0 +1,4 @@
+# Call CleanerUpper after test run
+After do
+  cleanup_created_resources
+end

data/lib/brine/mustache_binder.rb

@@ -0,0 +1,25 @@
+require 'mustache'
+
+# Provides a binding environment and template expansion functions that use that
+# environment
+module MustacheBinder
+
+  # getter for mutable hash which serves as binding environment
+  def binding
+    @binding ||= {}
+  end
+
+  # assign `value' to `key' within binding
+  # defined in a method to allow observability/interception
+  def bind(key, value)
+    puts "Assigning #{value} to #{key}" if ENV['BRINE_LOG_BINDING']
+    binding[key] = value
+  end
+
+  # return value as expanded Mustache template using binding environment
+  # Mustache in...no Mustache out
+  def shave_value(val)
+    Mustache.render(val, binding)
+  end
+
+end