vanilli-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6e60458d2a143b7ab40102bb484447123451bc4
+  data.tar.gz: a3cee75a0c3765f16505c2456c50b42f5d87c1d3
+SHA512:
+  metadata.gz: a6e8b5484f7db8964cf147da31b57c0240fafbc63eba528351c91c8b33335be45651a1392ed1272aed7f550a420a129c4c32a911ce34d1e47bf7178e97c910c5
+  data.tar.gz: db24cf62f4c37f3a924dbd4db64ca558b0a9c7c30eeb72da1281d20e2e0bd5dd1aafb1a07051cff8147a8b2023eecb89d4b82b6b65b2eaf6ba4ad713d1e320b8

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+*.iml
+.idea
+*.gem

data/.rubocop.yml

@@ -0,0 +1,8 @@
+LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2013-2015, MixRadio
+All rights reserved.
+  
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:  
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.  
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.  
+3. Neither the name of Alistair Dutton nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.  
+  
+THIS SOFTWARE IS PROVIDED BY ALISTAIR DUTTON ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL ALISTAIR DUTTON BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,63 @@
+# vanilli-ruby
+Ruby bindings for use with [vanilli](https://github.com/mixradio/vanilli).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vanilli-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vanilli-ruby
+
+## Usage
+Two classes are provided `VanilliServer` and `VanilliClient`.
+
+### VanilliClient
+This class provides a client API for interacting with a running vanilli server. The API has
+deliberately been kept as close as possible to the canonical javascript API with a few "rubifications"
+(snake case on method names for example). However, the API is close enough that providing extra
+documentation here is counter-productive - please see the [javascript documentation](https://github.com/mixradio/vanilli/wiki/API).
+
+Instantiating the client is straightforward:
+
+```ruby
+require 'vanilli/client'
+
+vanilli = VanilliClient.new
+
+vanilli.stub(...)
+#etc.
+```
+
+### VanilliServer
+Of course, to be able to make use of the client one needs a vanilli server running to connect to. This
+can be achieved in a number of ways:
+
+* Start vanilli via its CLI
+```sh
+npm install -g vanilli
+vanilli --port 9000
+```
+
+* Start vanilli from javascript
+i.e. use the javascript API perhaps from some grunt/gulp/npm based task.
+
+* Use VanilliServer provided with this ruby gem
+This just acts as a wrapper around the vanilli CLI. Therefore you *MUST* have vanilli installed to your
+path for this to work. Once installed, start something like this:
+
+```ruby
+vanilli_server = VanilliServer.new(port: 9000,
+                                  log_level: "debug",
+                                  static_root: "/your/web/app/assets",
+                                  static_include: ['**/*.html', '**/*.js', '**/*.css*', '/robots.txt'])
+                .start
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rubocop/rake_task'
+
+desc 'Run RuboCop on the lib directory'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.patterns = ['lib/**/*.rb']
+end
+
+task default: :rubocop

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'vanilli/server'
+require 'vanilli/client'
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/vanilli/client.rb

@@ -0,0 +1,180 @@
+require 'rest-client'
+require 'json'
+
+private def unwrap_regex(thing)
+  if thing.is_a?(Regexp)
+    return { regex: thing.source }
+  else
+    return thing
+  end
+end
+
+private def fail_body_with_no_contenttype(body, content_type)
+  fail 'Body was specified for but content-type was missing.' if body && !content_type
+end
+
+private def map_over_hash(h, f)
+  if h.nil?
+    return nil
+  else
+    return h.map { |key, value| { key => send(f, value) } }.reduce(:merge)
+  end
+end
+
+private def strip_nils(h)
+  h.delete_if { |_k, v| v.nil? }
+end
+
+private def stringify_non_json_content(content_blob)
+  body = content_blob[:body]
+
+  if (body.is_a? Hash) && (content_blob[:contentType] != 'application/json')
+    return content_blob.merge(body: body.to_json)
+  else
+    return content_blob
+  end
+end
+
+# Provides ruby bindings for the vanilli client. API is a
+# "rubified" (i.e. snake-case for camel-case) version of the
+# default javascript API provided with vanilli.
+class VanilliClient
+  # Represents a single stub as will be registered with
+  # the vanilli server.
+  class Stub
+    attr_writer :expect
+
+    def initialize(criteria:, priority:)
+      @criteria = criteria
+      @priority = priority
+    end
+
+    # Construct the response for the stub
+    def respond_with(status, body: nil, content_type: nil, headers: nil, times: 1)
+      fail 'Status code is missing.' if status.nil?
+      fail_body_with_no_contenttype(body, content_type)
+
+      @response = stringify_non_json_content(strip_nils(status: status,
+                                                        contentType: content_type,
+                                                        body: body,
+                                                        headers: headers))
+      @times = times
+
+      self
+    end
+
+    # Vanilli will wait the specified number of milliseconds
+    # before responding with the stub response.
+    def wait(milliseconds:)
+      @response[:wait] = milliseconds
+      self
+    end
+
+    # The body of the matching request(s) will be logged by vanilli
+    # under the specified capture id.
+    def capture(capture_id)
+      @capture_id = capture_id
+      self
+    end
+
+    # Converts the stub to JSON for sending to vanilli.
+    def to_json
+      strip_nils(criteria: strip_nils(@criteria),
+                 priority: @priority,
+                 response: strip_nils(@response),
+                 times: @times,
+                 captureId: @capture_id,
+                 expect: @expect).to_json
+    end
+  end
+
+  # Create a new Stub that will be matched
+  # against the specified criteria.
+  def on_request(method, url, content_type: nil, body: nil, query: nil, headers: nil, priority: nil)
+    fail 'Url is missing.' unless url
+    fail_body_with_no_contenttype(body, content_type)
+
+    Stub.new(criteria: stringify_non_json_content(method: method,
+                                                  url: unwrap_regex(url),
+                                                  contentType: content_type,
+                                                  body: body,
+                                                  query: map_over_hash(query, :unwrap_regex),
+                                                  headers: map_over_hash(headers, :unwrap_regex)),
+             priority: priority)
+  end
+
+  # Creates a Stub for a GET request that will be
+  # matched against the specified criteria.
+  def on_get(url, query: nil, headers: nil, priority: nil)
+    on_request('GET', url, query: query, headers: headers, priority: priority)
+  end
+
+  # Creates a Stub for a POST request that will be
+  # matched against the specified criteria.
+  def on_post(url, query: nil, headers: nil, priority: nil, content_type: nil, body: nil)
+    on_request('POST', url, query: query, headers: headers, priority: priority, content_type: content_type, body: body)
+  end
+
+  # Creates a Stub for a PUT request that will be
+  # matched against the specified criteria.
+  def on_put(url, query: nil, headers: nil, priority: nil, content_type: nil, body: nil)
+    on_request('PUT', url, query: query, headers: headers, priority: priority, content_type: content_type, body: body)
+  end
+
+  # Creates a Stub for a DELETE request that will be
+  # matched against the specified criteria.
+  def on_delete(url, query: nil, headers: nil, priority: nil)
+    on_request('DELETE', url, query: query, headers: headers, priority: priority)
+  end
+
+  # Registers the specified Stub(s) with the vanilli server.
+  def stub(*stubs)
+    stubs.each do |stub|
+      begin
+        RestClient.post 'http://localhost:9000/_vanilli/stubs', stub.to_json, content_type: :json, accept: :json
+      rescue => e
+        raise e.response
+      end
+    end
+  end
+
+  # Registers the specified Stub as an expectation on the
+  # vanilli server.
+  def expect(expectation)
+    expectation.expect = true
+    stub(expectation)
+  end
+
+  # Clears the vanilli server of all stubs.
+  def clear
+    RestClient.delete 'http://localhost:9000/_vanilli/stubs'
+  rescue => e
+    raise e.response
+  end
+
+  # Verifies that all vanilli expectations have been met. If
+  # not, an error is thrown.
+  def verify
+    begin
+      res = JSON.parse(RestClient.get 'http://localhost:9000/_vanilli/verify')
+    rescue => e
+      raise e.response
+    end
+
+    fail 'VERIFICATION FAILED: ' + res['errors'].join('\n') if res['errors'].length > 0
+  end
+
+  # Pulls back details of all requests that were logged against the
+  # specified capture id.
+  def get_captures(capture_id)
+    JSON.parse(RestClient.get 'http://localhost:9000/_vanilli/captures/' + capture_id)
+  rescue => e
+    raise e.response
+  end
+
+  # Pulls back details of the last request that was logged against the
+  # specified capture id.
+  def get_capture(capture_id)
+    get_captures(capture_id).last
+  end
+end

data/lib/vanilli/server.rb

@@ -0,0 +1,45 @@
+require 'rest-client'
+
+# Provides hooks for starting and stopping a vanilli server. Relies on the vanilli CLI
+# API and therefore requires vanilli to be installed.
+class VanilliServer
+  def initialize(port:, static_root: nil, static_include: [], static_exclude: [], static_default: 'index.html', log_level: 'warn')
+    @static_root = static_root
+    @static_default = static_default
+    @static_include = static_include.join(',')
+    @static_exclude = static_exclude.join(',')
+    @port = port
+    @log_level = log_level
+  end
+
+  # Shells out to start vanilli
+  def start(cwd: '.')
+    @pid = spawn("vanilli --port #{@port} \
+                    --logLevel=#{@log_level} \
+                    --staticRoot=#{@static_root} \
+                    --staticDefault=#{@static_default} \
+                    --staticInclude=#{@static_include} \
+                    --staticExclude=#{@static_exclude}", chdir: cwd)
+
+    Timeout.timeout(3) do
+      begin
+        RestClient.get "http://localhost:#{@port}/_vanilli/ping"
+      rescue
+        sleep 0.1
+        retry
+      end
+    end
+
+    self
+  end
+
+  # Stops the vanilli server by killing the
+  # process started when shelling out to start vanilli
+  def stop
+    if @pid
+      Process.kill('KILL', @pid)
+      Process.wait @pid
+    end
+    @pid = nil
+  end
+end

data/vanilli-ruby.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "vanilli-ruby"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Alistair Dutton"]
+  spec.email         = ["kelveden@gmail.com"]
+
+  spec.summary       = "Ruby bindings for vanilli"
+  spec.description   = "Provides a ruby API for starting a vanilli server and interacting with it."
+  spec.homepage      = "https://github.com/mixradio/vanilli-ruby"
+  spec.license       = "BSD-3-Clause"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.4"
+  spec.add_development_dependency "rubocop", "~> 0.31"
+  spec.add_runtime_dependency "rest-client", "~> 1.8"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: vanilli-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alistair Dutton
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Provides a ruby API for starting a vanilli server and interacting with
+  it.
+email:
+- kelveden@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/vanilli/client.rb
+- lib/vanilli/server.rb
+- vanilli-ruby.gemspec
+homepage: https://github.com/mixradio/vanilli-ruby
+licenses:
+- BSD-3-Clause
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for vanilli
+test_files: []