screenplay 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dbb612ed6af3abe140b84a1f5ff9f260c7d9b682
+  data.tar.gz: 6a7606ad77ba8dd2999d676b92d8b580b85759cb
+SHA512:
+  metadata.gz: 1ae0e7d50879140a9f208e3ff93bdc3c27fa0b20ff01b2bd70df4529fe1aafab406c7d846be6e5c0f03a8a8bb32656d7539069de6b46c3bee2ea570bad1853e4
+  data.tar.gz: 4f3c5df6e4d8221f1b9950b9f76e1ff7164774e0098341680f3d5fe943fcc66fb8ae40c827061c73fdac718ce6c7bcfcf7ffad375796ac84664ac38b1755218d

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gem 'rest-client', '~> 1.7.2'
+gem 'highline', '~> 1.6.21'
+
+

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Taco Jan Osinga
+
+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/bin/screenplay

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
+require 'screenplay'
+require 'optparse'
+
+$SCREENPLAY_OPTIONS = {}
+
+$ARGV_PARSER = OptionParser.new { | opts |
+	opts.banner = 'Usage: screenplay command [-c|--config FILE] [-a|--actors DIR] [-s|--scenarios DIR] [-v|--verbose] [-h|--human-friendly]'
+	opts.separator('')
+
+	opts.separator('Available commands:')
+	opts.separator('- play: Plays all scenarios.')
+	opts.separator('- actors: Lists all known actors.')
+	opts.separator('- scenarios: Lists all found scenarios.')
+	opts.separator('')
+
+	opts.separator('Specific options:')
+	opts.on('-c FILE', '--config FILE', 'Filename of the configuration file.') { | f | $SCREENPLAY_CONFIGFILE = f }
+	opts.on('-a DIR', '--actors DIR', 'Directory where custom actors can be found. By default in the ./actors directory near the config file.') { | d | $SCREENPLAY_ACTORS_DIR = d }
+	opts.on('-s DIR', '--scenarios DIR', 'Directory where the scenarios can be found. By default in the ./scenarios director near the config file.') { | d | $SCREENPLAY_SCENARIOS_DIR = d }
+	opts.on('-d', '--debug', 'Shows full stack trace on when failed. Especially usefull when developing new actors or other information.') { $SCREENPLAY_OPTIONS[:debug] = true }
+	opts.on('-q', '--quiet', 'Doesn\'t show the output of the scenes.') { $SCREENPLAY_OPTIONS[:quiet] = true }
+	opts.on('-h', '--human-friendly', 'Formats outputted JSON.') { $SCREENPLAY_OPTIONS[:human_friendly] = true }
+	opts.separator('')
+}
+command = $ARGV_PARSER.parse![0] rescue ''
+
+def usage
+	STDOUT << $ARGV_PARSER.help
+end
+
+def play
+	Screenplay.prepare
+	begin
+		Screenplay.play($SCREENPLAY_OPTIONS)
+	rescue Exception => e
+		raise if $SCREENPLAY_OPTIONS[:debug]
+		abort(e.message)
+	end
+end
+
+def actors
+	Screenplay.prepare
+	Screenplay::Cast.each { | actor | puts actor.name }
+end
+
+def scenarios
+	Screenplay.prepare
+	Screenplay::Scenarios.each { | scenario | puts scenario.name }
+end
+
+case command
+	when 'play' then play
+	when 'actors' then actors
+	when 'scenarios' then scenarios
+	else usage
+end
+

data/lib/screenplay.rb

@@ -0,0 +1,59 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+
+require 'json'
+
+require 'screenplay/datatype-extensions'
+require 'screenplay/configuration'
+require 'screenplay/cast'
+require 'screenplay/actor'
+require 'screenplay/scenarios'
+
+module Screenplay
+	extend self
+
+	def prepare
+		Configuration.load
+		Cast.autoload
+		Scenarios.autoload
+	end
+
+	def play(options = {})
+		options[:quiet] ||= false
+		options[:human_friendly] ||= false
+
+		raise Exception.new('ERROR: Couldn\'t find any scenarios to play.') if Scenarios.size == 0
+
+		# First check if we know all needed actors
+		each_scene { | scenario_name, actor_name  |
+			raise UnknownActorException.new(scenario_name, actor_name) if Cast.get(actor_name).nil?
+		}
+
+		each_scene { | scenario, actor_name, params, input, index |
+			puts "##### #{scenario.name} - #{actor_name}: #####" unless (options[:quiet])
+			begin
+				output = Cast.get(actor_name).play(params, input)
+			rescue Exception => e
+				raise ScenarioFailedException.new(scenario, index, actor_name, e.message)
+			end
+			output.symbolize_keys!
+			unless (options[:quiet])
+				output_str = options[:human_friendly] ? JSON.pretty_generate(output) : output.to_s
+				puts "output = #{output_str}"
+				puts ''
+			end
+			output
+		}
+	end
+
+	def each_scene
+		Scenarios.each { | scenario |
+			input = {}
+			index = 1
+			scenario.each { | actor_name, params |
+				input = yield scenario, actor_name, params, input, index
+				index += 1
+			}
+		}
+	end
+
+end

data/lib/screenplay/actor.rb

@@ -0,0 +1,46 @@
+require 'screenplay/cast'
+require 'screenplay/configuration'
+
+module Screenplay
+
+	class MethodNotImplemented < Exception
+
+		def initialize(name)
+			super("Method #{name} is not implemented.")
+		end
+
+	end
+
+
+	class UnknownActorException < Exception
+
+		def initialize(scenario, name)
+			super("The scenario #{scenario} uses unknown actor #{name}.")
+		end
+
+	end
+
+	class Actor
+
+		attr_reader :name
+
+		def initialize(name)
+			@name = name.to_sym
+			configure(Configuration[@name] || {})
+		end
+
+		def self.descendants
+			ObjectSpace.each_object(Class).select { | klass | klass < self }
+		end
+
+		def configure(config = {})
+			# Not needed to override this, but might be useful
+		end
+
+		def play(params, input)
+			raise MethodNotImplemented.new('play')
+		end
+
+	end
+
+end

data/lib/screenplay/actors/api.rb

@@ -0,0 +1,64 @@
+require 'rest_client'
+require File.join(File.dirname(__FILE__), '..', 'actor')
+
+module Screenplay
+
+	class WrongResponseCodeException < Exception
+		def initialize(expected, actual)
+			super("Expected HTTP response code #{expected}, but received #{actual}.")
+		end
+	end
+
+	class ApiActor < Actor
+
+		attr_reader :cookies
+
+		def configure(config)
+			@url = config[:url].to_s
+			@url += '/' unless @url.end_with?('/')
+			@request_headers = config[:request_headers] || {}
+			@cookies = nil
+		end
+
+		def play(params, input)
+			raise Exception.new('Missing configuration api.url') if @url == '/'
+			path = params[:path]
+			method = params[:method].downcase.to_sym rescue :get
+			expects = (params[:expect] || 200).to_i
+			data = params[:data] || {} rescue {}
+			data = input if (data.is_a?(String)) && (data == '$input')
+			data.stringify_keys!
+			headers = @request_headers
+			headers[:cookie] = @cookies unless @cookies.nil?
+			url = @url + path.to_s.replace_vars(input)
+			if ([:get, :head, :delete].include?(method))
+				headers[:params] = data
+				data = {}
+			end
+
+			begin
+				response = RestClient::Request.execute({
+					url: url,
+					method: method,
+					headers: headers,
+					payload: data
+				})
+			rescue => e
+				response = e.response
+			end
+
+			if response.code != expects
+				raise WrongResponseCodeException.new(expects, response.code)
+			end
+
+			unless response.nil?
+				output = JSON.parse(response.body) rescue {}
+				@cookies = response.headers[:set_cookie][0] rescue nil
+			end
+
+			return output || {}
+		end
+
+	end
+
+end

data/lib/screenplay/actors/cache.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', 'actor')
+
+module Screenplay
+
+	class CacheActor < Actor
+
+		attr_reader :cache
+
+		def play(params = {}, input = {})
+			@cache ||= {}
+			output = {}
+			params.each { | action, values |
+				output = input.dup if action == :merge
+
+				if action == :clear
+					@cache.clear
+				elsif action == :set
+					values.each { | input_key, cache_key |
+						@cache[cache_key.to_sym] = (input_key == '$input'.to_sym) ? input : input[input_key]
+					}
+				elsif (action == :merge || action == :get)
+					values.each { | cache_key, input_key |
+						output[input_key.to_sym] = @cache[cache_key.to_sym]
+					}
+				end
+			}
+			return output
+		end
+
+	end
+
+end

data/lib/screenplay/actors/data.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '..', 'actor')
+
+module Screenplay
+
+	class DataActor < Actor
+
+		def play(params, input)
+			input.merge!(params)
+			return input
+		end
+
+	end
+
+end

data/lib/screenplay/actors/prompt.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), '..', 'actor')
+require 'highline/import'
+
+module Screenplay
+
+	class PromptActor < Actor
+
+		def play(params, input)
+			output = input
+			params.each { | key, title |
+				output[key] = ask(title.replace_vars(input) + ': ') #{ | q | q.echo = true }
+			}
+			return output
+		end
+
+	end
+
+end

data/lib/screenplay/actors/test.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), '..', 'actor')
+
+module Screenplay
+
+	class TestFailedException < Exception
+		def initialize(test, a, b)
+			super("#{test} on #{a.to_s} failed. Expected: #{b.to_s}.")
+		end
+	end
+
+	class UnknownTestException < Exception
+		def initialize(test)
+			super("Unknown test #{test}")
+		end
+	end
+
+	class UnsupportedTypeTestException < Exception
+		def initialize(test, a)
+			super("Unsupported data type for test #{test}: #{a.to_s}")
+		end
+	end
+
+	class UnknownInputKeyException < Exception
+		def initialize(test, key)
+			super("Couldn't find #{key} in the input for test #{test}.")
+		end
+	end
+
+	class TestActor < Actor
+
+		def play(params, input)
+			params.each { | key, values |
+				values.each { | test, b |
+					expects = !test.to_s.start_with?('not-')
+					test = test.to_s[4..-1] unless expects
+					method = "test_#{test}".to_sym
+					raise UnknownTestException.new(test) if !respond_to?(method)
+					raise UnknownInputKeyException.new(test, key) unless input.include?(key.to_sym)
+					a = input[key.to_sym]
+					raise TestFailedException.new(test, a, b) unless (public_send(method, a, b) == expects)
+				}
+			}
+			return input
+		end
+
+		def test_lt(a, b)
+			a < b
+		end
+
+		def test_lte(a, b)
+			a <= b
+		end
+
+		def test_eq(a, b)
+			a === b
+		end
+
+		def test_gte(a, b)
+			a >= b
+		end
+
+		def test_gt(a, b)
+			a > b
+		end
+
+		def test_in(a, b)
+			if (b.is_a?(String))
+				b.index(a) != nil
+			elsif (b.is_a?(Array))
+				b.to_a.include?(a)
+			elsif (b.is_a?(Hash))
+				b.include?(a.to_sym)
+			else
+				raise UnsupportedTypeTestException.new(:in, b)
+			end
+		end
+
+		def test_size(a, b)
+			if (a.respond_to?(:size))
+				a.size == b
+			else
+				raise UnsupportedTypeTestException.new(:size, a)
+			end
+		end
+
+		def test_regexp(a, b)
+			b = Regexp.new(b.to_s) if b.is_a?(String) || b.is_a?(Symbol)
+			raise UnsupportedTypeTestException.new(:regexp, b) unless b.is_a?(Regexp)
+			raise UnsupportedTypeTestException.new(:regexp, a) unless a.is_a?(String)
+			!a.match(b).nil?
+		end
+	end
+
+end

data/lib/screenplay/cast.rb

@@ -0,0 +1,49 @@
+module Screenplay
+
+	# The Cast module is a singleton which is available for actors to register themselves and make themselves available.
+	module Cast
+		extend self
+
+		@actors = []
+
+		include Enumerable
+
+		def register(actor)
+			raise Exception.new("Actor #{actor.name} is already registered.") if @actors.include?(actor.name)
+			@actors.push(actor)
+			@actors.sort_by!{ | actor | actor.name }
+		end
+
+		def each
+			@actors.each { | actor | yield actor }
+		end
+
+		def get(actor_name)
+			@actors.each { | actor |
+				return actor if actor.name == actor_name.to_sym
+			}
+			return nil
+		end
+
+		def autoload
+			# Require all standard actors
+			Dir[File.dirname(__FILE__) + '/actors/*.rb'].each { | filename |
+				require filename
+			}
+			## Require custom actors
+			@actors_path = $SCREENPLAY_ACTORS_DIR || Configuration[:general][:actors_dir] rescue  File.join(Configuration.path, 'actors')
+			Dir[@actors_path + '/**/*.rb'].each { | filename |
+				require filename
+			}
+
+			## Create an instance of each actor and register it to the cast
+			Actor.descendants.each { | klass |
+				name = klass.name.match(/(\w+)(Actor)?$/)[0].gsub(/Actor$/, '').snake_case
+				register(klass.new(name))
+			}
+		end
+
+
+	end
+
+end

data/lib/screenplay/configuration.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+require 'screenplay/datatype-extensions'
+
+module Screenplay
+
+	module Configuration
+		extend self
+
+		include Enumerable
+
+		@config = {}
+
+		def each
+			@config.each { | k, v | yield k, v }
+		end
+
+		def [](key)
+			@config[key]
+		end
+
+		def load(reload = false)
+			return unless @config.empty? || reload
+			@filename = $SCREENPLAY_CONFIGFILE || './config.yml'
+			@config = YAML.load_file(@filename) if File.exists?(@filename)
+			@config.symbolize_keys!
+		end
+
+		def path
+			File.dirname(@filename) || './'
+		end
+
+		def to_h
+			@config.to_h
+		end
+
+	end
+
+end

data/lib/screenplay/datatype-extensions.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+# The classes in this file extend common datatypes with some extra functionality.
+
+# The Boolean module is used to mixin in the TrueClass and FalseClass for easy comparison.
+# This way fields can be given the Boolean datatype instead of a TrueClass or a FalseClass.
+module Boolean
+end
+
+
+# Adds the Boolean module into the TrueClass as mixin
+class TrueClass
+	include Boolean
+end
+
+
+# Adds the Boolean module into the FalseClass as mixin
+class FalseClass
+	include Boolean
+end
+
+
+# Adds a few extra methods to the standard Hash
+class Hash
+
+	# Removes all nil values from the hash. If the value is an array or hash, it will do this recursively.
+	def remove_nil_values!
+		self.delete_if { |_, v| v.nil? }
+		self.each { |_, v| v.remove_nil_values! if (v.is_a?(Hash) || v.is_a?(Array)) }
+	end
+
+	# Changes all keys to symbols. If the value is an array or hash, it will do this recursively.
+	def symbolize_keys!(recursive = true)
+		self.keys.each { | key |
+			if !key.is_a?(Symbol)
+				val = self.delete(key)
+				val.symbolize_keys! if (recursive && (val.is_a?(Hash) || val.is_a?(Array)))
+				self[(key.to_sym rescue key) || key] = val
+			end
+			self[key.to_sym].symbolize_keys! if (recursive && (self[key.to_sym].is_a?(Hash) || self[key.to_sym].is_a?(Array)))
+		}
+	end
+
+	# Changes all keys to strings.  If the value is an array or hash, it will do this recursively.
+	def stringify_keys!(recursive = true)
+		self.keys.each do |key|
+			if !key.is_a?(String)
+				val = self.delete(key)
+				val.stringify_keys! if (recursive && (val.is_a?(Hash) || val.is_a?(Array)))
+				self[(key.to_s rescue key) || key] = val
+			end
+		end
+	end
+
+end
+
+
+# Adds a few extra methods to the standard Hash
+class Array
+
+	# Removes all nil values from the hash. If the value is an array or hash, it will do this recursively.
+	def remove_nil_values!
+		self.compact!
+		self.each { |val| val.remove_nil_values! if (val.is_a?(Hash) || val.is_a?(Array)) }
+	end
+
+	# Changes all keys to symbols. If the value is an array or hash, it will do this recursively.
+	def symbolize_keys!(recursive = true)
+		self.map! { |val| val.symbolize_keys! if (recursive && (val.is_a?(Hash) || val.is_a?(Array))); val }
+	end
+
+	# Changes all keys to strings. If the value is an array or hash, it will do this recursively.
+	def stringify_keys!(recursive = true)
+		self.map! { |val| val.stringify_keys! if (recursive && (val.is_a?(Hash) || val.is_a?(Array))); val }
+	end
+
+end
+
+
+# Adds a few extra methods to the standard String
+class String
+
+	# Returns true if a string is numeric.
+	def numeric?
+		self.to_i.to_s == self
+	end
+
+	# Strips single or double quotes at the start and end of the given string.
+	def strip_quotes
+		gsub(/\A['"]+|['"]+\Z/, '')
+	end
+
+	# Normalizes a string, remove diacritics (accents)
+	def normalize
+		tr(
+			"ÀÁÂÃÄÅàáâãäåĀāĂ㥹ÇçĆćĈĉĊċČčÐðĎďĐđÈÉÊËèéêëĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħÌÍÎÏìíîïĨĩĪīĬĭĮįİıĴĵĶķĸĹĺĻļĽľĿŀŁłÑñŃńŅņŇňʼnŊŋÒÓÔÕÖØòóôõöøŌōŎŏŐőŔŕŖŗŘřŚśŜŝŞşŠšſŢţŤťŦŧÙÚÛÜùúûüŨũŪūŬŭŮůŰűŲųŴŵÝýÿŶŷŸŹźŻżŽž",
+			"AAAAAAaaaaaaAaAaAaCcCcCcCcCcDdDdDdEEEEeeeeEeEeEeEeEeGgGgGgGgHhHhIIIIiiiiIiIiIiIiIiJjKkkLlLlLlLlLlNnNnNnNnnNnOOOOOOooooooOoOoOoRrRrRrSsSsSsSssTtTtTtUUUUuuuuUuUuUuUuUuUuWwYyyYyYZzZzZz")
+	end
+
+	def truncate(max_length, ellipses = '...')
+		(self.length > max_length) ? self.to_s[0..max_length].gsub(/[^\w]\w+\s*$/, '...') : self.to_s
+	end
+
+	def replace_vars!(input)
+		input = {} unless input.is_a?(Hash)
+		return if input.empty?
+		matches = {}
+		input.each { | k, v | matches['#{' + k.to_s + '}'] = v.to_s }
+		self.gsub!(/\#({\w+})/, matches)
+	end
+
+	def replace_vars(input)
+		result = self.dup
+		result.replace_vars!(input)
+		return result
+	end
+
+	def snake_case
+		self.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr('-', '_').downcase
+	end
+
+	def camel_case
+		self.split('_').collect(&:capitalize).join
+	end
+
+end

data/lib/screenplay/scenario.rb

@@ -0,0 +1,37 @@
+require 'yaml'
+
+module Screenplay
+
+	class ScenarioFailedException < Exception
+		def initialize(scenario, index, actor_name, message)
+			super("FAILED: Scenario #{scenario.name}, scene #{index} of #{scenario.size}, actor #{actor_name}: #{message}")
+		end
+	end
+
+	class Scenario
+
+		include Enumerable
+
+		attr_reader :name
+
+		def initialize(name, filename)
+			@name = name
+			@actions = YAML.load_file(filename)
+			@actions.symbolize_keys!
+		end
+
+		def each
+			@actions.each { | action |
+				actor = action.keys[0]
+				data = action[actor]
+				yield actor, data
+			}
+		end
+
+		def size
+			@actions.size
+		end
+
+	end
+
+end

data/lib/screenplay/scenarios.rb

@@ -0,0 +1,38 @@
+require 'screenplay/scenario'
+
+module Screenplay
+
+	module Scenarios
+		extend self
+
+		include Enumerable
+
+		@scenarios = []
+
+		def register(filename)
+			name = filename.gsub(@path, '').gsub(/^\//, '') unless @path.empty?
+			@scenarios.push(Scenario.new(name, filename))
+			@scenarios.sort_by{ | actor | actor.name }
+		end
+
+		def autoload
+			@path = $SCREENPLAY_SCENARIOS_DIR || Configuration[:general][:scenarios_dir] rescue File.join(Configuration.path, 'scenarios')
+			load_path(@path)
+		end
+
+		def load_path(path)
+			yml_files = File.join(path, '**', '*.yml')
+			Dir[yml_files].each { | filename | register(filename) }
+		end
+
+		def size
+			@scenarios.size
+		end
+
+		def each
+			@scenarios.each { | k | yield k }
+		end
+
+	end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: screenplay
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Taco Jan Osinga
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Screenplay helps with testing data driven applications like RESTful API's
+  by writing scenario's in Yaml.
+email: info@osingasoftware.nl
+executables:
+- screenplay
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- bin/screenplay
+- lib/screenplay.rb
+- lib/screenplay/actor.rb
+- lib/screenplay/actors/api.rb
+- lib/screenplay/actors/cache.rb
+- lib/screenplay/actors/data.rb
+- lib/screenplay/actors/prompt.rb
+- lib/screenplay/actors/test.rb
+- lib/screenplay/cast.rb
+- lib/screenplay/configuration.rb
+- lib/screenplay/datatype-extensions.rb
+- lib/screenplay/scenario.rb
+- lib/screenplay/scenarios.rb
+homepage: https://github.com/tjosinga/screenplay
+licenses:
+- MIT
+metadata: {}
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Screenplay
+test_files: []