playwright 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43eed1125904ba3c14998084d8710997300317fb
+  data.tar.gz: c8dda6b2906319bec40992e7a037db060d6f5d08
+SHA512:
+  metadata.gz: 072fc084887b5066ecaadb3af1373e237adb833ecc30d35a1658dc9c18a1e2129432cec6f631fe9a31193c15458d933e3bc11d85342bb68543bca2c37051cfb4
+  data.tar.gz: 44eb5495d51b4bba2af0cef01f7778f3e801f924d7622faa787ec24e89ce55eaa02b0dcacdcc1510b3fce630ba3aa14c67402f579e04e6ab055fc18ebbc14ac7

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2
+after_success: bundle exec codeclimate-test-reporter

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in playwright.gemspec
+gemspec
+
+gem 'simplecov', require: false
+gem 'codeclimate-test-reporter', require: false

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2016 Baylor Rae'
+
+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,125 @@
+# Playwright
+
+[![Build Status](https://travis-ci.org/BaylorRae/playwright.svg?branch=master)](https://travis-ci.org/BaylorRae/playwright) [![Code Climate](https://codeclimate.com/github/BaylorRae/playwright/badges/gpa.svg)](https://codeclimate.com/github/BaylorRae/playwright) [![Test Coverage](https://codeclimate.com/github/BaylorRae/playwright/badges/coverage.svg)](https://codeclimate.com/github/BaylorRae/playwright/coverage)
+
+Playwright is a foundational piece for building a test framework. It allows
+test cases to be written as a play with all the moving parts to be categorized
+as a `Stage`, `Scene`, `Props` or `Actor`.
+
+### What are `Stage`, `Scene` or `Actor`?
+
+Each test contains a single `Stage` which encapsulates one or many `Scene`s and
+`Props`. There should only be one stage created in a test as it is the context
+that everything should go through.
+
+Once you have a `Stage` the next step is to create the `Scene`s that help build
+the test or "story". A `Scene` is a service layer between your test and page
+object models. It also groups two `Actor`s together that will "interact" as the
+test runs. A `Stage` has multiple `Scene`s as there are generally more than one
+action in a test.
+
+An `Actor` will likely be a user in your system but it can be anything that
+interacts another object type.
+
+## Example
+
+Let's imagine we have an platform with **sellers**, **buyers** and **fulfillment
+agencies**. We need to create a test around fulfilling an order. You can teach
+Playwright how to group actors together as **buyer** will only interact with
+**seller** and **seller** will only interact with the **fulfillment agency**.
+
+```ruby
+stage = FulfillmentStage.new
+
+# scenes
+stage.scenes  #=> [PurchaseProduct, FulfillOrder]
+stage.purchase_product #=> PurchaseProduct
+stage.fulfill_order    #=> FulfillOrder
+
+# actors
+stage.actors #=> [:buyer, :seller, :fulfillment_agency]
+stage.buyer   #=> User(username: 'buyer')
+stage.seller  #=> User(username: 'seller')
+stage.fulfillment_agency #=> FulfillmentAgency
+
+# props
+stage.products #=> [Product, Product, ...]
+stage.orders #=> [Order, Order, ...]
+stage.fulfillments #=> [OrderFulfillment, OrderFulfillment, ...]
+```
+
+The above code example is defined from the following.
+
+```ruby
+class FulfillmentStage < Playwright::Stage
+  actors do
+    actor(:buyer)   { User.find_by(username: 'buyer') }
+    actor(:seller)  { User.find_by(username: 'seller') }
+    actor(:fulfillment_agency) { FulfillmentAgency.find_by(name: 'agency-1') }
+  end
+
+  scenes do
+    scene :purchase_product, from: :buyer, to: :seller
+    scene :fulfill_order, from: :seller, to: :fulfillment_agency
+  end
+
+  prop_collection(:products) { |p| p.id }
+  prop_collection(:orders) { |o| o.invoice_number }
+  prop_collection(:fulfillments) { |f| f.id }
+end
+
+class PurchaseProduct < Playwright::Scene
+  sender_accessor :buyer
+
+  def purchase_product(product)
+    LoginHelper.login_as(buyer)
+    ProductPage.purchase(product.id)
+    stage.orders.find_or_add(product.orders.last)
+  end
+end
+
+class FulfillOrder < Playwright::Scene
+  sender_accessor :seller
+  receiver_accessor :fulfillment_agency
+
+  def fulfill(order)
+    LoginHelper.login_as(seller)
+    OrderPage.fulfill_order(order.invoice_number)
+
+    LoginHelper.login_as(fulfillment_agency)
+    FulfillmentPage.ship_order(order.invoice_number)
+    stage.fulfillments.find_or_add(order.fulfillments.last)
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'playwright'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install playwright
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/baylorrae/playwright.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "playwright"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

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

data/lib/playwright.rb

@@ -0,0 +1,11 @@
+require 'playwright/version'
+
+module Playwright
+  autoload :Stage, 'playwright/stage'
+  autoload :Scene, 'playwright/scene'
+  autoload :Props, 'playwright/props'
+  autoload :Narrator, 'playwright/narrator'
+  autoload :ActorNotRegistered, 'playwright/errors'
+  autoload :SceneNotRegistered, 'playwright/errors'
+  autoload :ClassMethods, 'playwright/extensions'
+end

data/lib/playwright/dsl/actor_dsl.rb

@@ -0,0 +1,31 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Playwright
+  module DSL
+    # Defines an actor in a stage. The block is only evaluated once when the
+    # method is called the first time.
+    #
+    #   class ExampleStage < Playwright::Stage
+    #     actors do
+    #       actor(:actor_name) { User.first! }
+    #     end
+    #   end
+    class ActorDSL < BasicObject
+      attr_reader :actors
+
+      def initialize
+        @actors = ::ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def self.find(&block) # :nodoc:
+        dsl = new
+        dsl.instance_eval(&block)
+        dsl.actors
+      end
+
+      def actor(name, &block)
+        @actors[name] = block
+      end
+    end
+  end
+end

data/lib/playwright/dsl/scene_dsl.rb

@@ -0,0 +1,49 @@
+require 'active_support/inflector'
+require 'active_support/hash_with_indifferent_access'
+
+module Playwright
+  module DSL
+    # Defines an actor in a stage. The block is only evaluated once when the
+    # method is called the first time.
+    #
+    #   class ExampleStage < Playwright::Stage
+    #     actors do
+    #       actor(:buyer) { User.first! }
+    #       actor(:seller) { User.first! }
+    #     end
+    #
+    #     scenes do
+    #       scene PurchaseProduct, from: :buyer, to: :seller
+    #     end
+    #   end
+    class SceneDSL
+      attr_reader :scenes
+      SceneWithActors = Struct.new(:klass, :from, :to) do
+        def init(narrator, stage)
+          klass.new(stage, narrator.get_actor(from), narrator.get_actor(to))
+        end
+      end
+
+      def initialize # :nodoc:
+        @scenes = ::ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def self.find(&block) # :nodoc:
+        dsl = new
+        dsl.instance_eval(&block)
+        dsl.scenes
+      end
+
+      def scene(klass, options)
+        if klass.kind_of?(Class)
+          accessor = klass.name.demodulize.underscore
+        else
+          accessor = klass.to_s
+          klass = accessor.camelize.constantize
+        end
+
+        @scenes[accessor] = SceneWithActors.new(klass, options[:from], options[:to])
+      end
+    end
+  end
+end

data/lib/playwright/errors.rb

@@ -0,0 +1,4 @@
+module Playwright
+  class ActorNotRegistered < StandardError; end
+  class SceneNotRegistered < StandardError; end
+end

data/lib/playwright/extensions.rb

@@ -0,0 +1,13 @@
+module Playwright
+    module ClassMethods # :nodoc:
+      def self.extended(base)
+        base.class_eval do
+          @narrators = []
+        end
+      end
+
+      def narrators
+        @narrators ||= superclass.narrators.dup
+      end
+    end
+end

data/lib/playwright/narrator.rb

@@ -0,0 +1,80 @@
+require 'playwright/dsl/actor_dsl'
+require 'playwright/dsl/scene_dsl'
+
+module Playwright
+  class Narrator
+    include DSL
+
+    attr_reader :owner_class
+
+    def self.find_or_create(owner_class)
+      # get narrator from existing class
+      if owner_class.respond_to?(:narrators) && narrator = owner_class.narrators.first
+
+        # child classes should have their own narrator
+        if narrator.owner_class != owner_class
+          narrator = narrator.dup
+          narrator.owner_class = owner_class
+        end
+      else
+        narrator = new(owner_class)
+      end
+
+      return narrator
+    end
+
+    def initialize(owner_class) # :nodoc:
+      self.owner_class = owner_class
+      @actors = {}
+    end
+
+    def owner_class=(owner_class) # :nodoc:
+      @owner_class = owner_class
+      owner_class.class_eval do
+        extend ClassMethods
+      end
+
+      owner_class.narrators << self
+    end
+
+    def add_actors(&block) # :nodoc:
+      @actors = ActorDSL.find(&block)
+    end
+
+    def add_scenes(&block) # :nodoc
+      @scenes = SceneDSL.find(&block)
+    end
+
+    def actors
+      return @loaded_actors if @loaded_actors
+      @loaded_actors = @actors.each do |key, value|
+        @actors[key] = value.call
+      end
+    end
+
+    def has_actor?(name)
+      actors.has_key?(name)
+    end
+
+    def get_actor(name)
+      raise ActorNotRegistered unless has_actor?(name)
+      actors[name]
+    end
+
+    def scenes(stage)
+      return @loaded_scenes if @loaded_scenes
+      @loaded_scenes = @scenes.each do |key, value|
+        @scenes[key] = value.init(self, stage)
+      end
+    end
+
+    def has_scene?(stage, name)
+      scenes(stage).has_key?(name)
+    end
+
+    def get_scene(stage, name)
+      raise SceneNotRegistered unless has_scene?(stage, name)
+      scenes(stage)[name]
+    end
+  end
+end

data/lib/playwright/props.rb

@@ -0,0 +1,38 @@
+module Playwright
+  # == Playwright::Props
+  #
+  # Props are a collection of items that are used during the test. They are
+  # accessible through the Stage and can be a unique list which is filtered
+  # with the +find_or_add+ method. You can specify a lambda to specify how it
+  # compares existing items.
+  #
+  #     first_product = Product.first
+  #     products = Playwright::Props.new(Proc.new { |p| p.id })
+  #
+  #     2.times { products.find_or_add(first_product) }
+  #
+  #     products #=> [first_product]
+  class Props < Array
+    attr_accessor :include_query # :nodoc:
+
+    # Creates a new prop collection with an optional lambda to determine if it
+    # has already been added from +find_or_add+
+    def initialize(include_query = nil)
+      @include_query = include_query
+    end
+
+    # Finds the first item in the array or adds it to the end.
+    def find_or_add(item)
+      self << item unless include?(item) || include_from_query?(item)
+      item
+    end
+
+    private
+
+    def include_from_query?(item)
+      return if include_query.nil?
+      item_value = include_query.call(item)
+      any? { |v| include_query.call(v) == item_value }
+    end
+  end
+end

data/lib/playwright/scene.rb

@@ -0,0 +1,61 @@
+module Playwright
+  # == Playwright::Scene
+  #
+  # Scene is the service layer between your test and page object models. It
+  # allows common interactions to be duplicated in tests without letting the
+  # tests know too much about the page.
+  #
+  #     class PurchaseProduct < Playwright::Scene
+  #       sender_accessor :buyer
+  #     
+  #       def purchase_product(product)
+  #         LoginHelper.login_as(buyer)
+  #         ProductPage.purchase(product.id)
+  #         stage.orders.find_or_add(product.orders.last)
+  #       end
+  #     end
+  class Scene
+    attr_reader :stage
+    attr_accessor :sender, :receiver
+
+    def initialize(stage, sender, receiver)
+      @stage = stage
+      @sender = sender
+      @receiver = receiver
+    end
+
+    # Aliases the +sender+ method to better describe who the action is coming
+    # from.
+    #
+    #   class OrderScene < Playwright::Scene
+    #     sender_accessor :buyer
+    #
+    #     def purchase_product(product)
+    #       LoginHelper.login_as(buyer)
+    #     end
+    #   end
+    def self.sender_accessor(name)
+      define_method(name, instance_method(:sender))
+    end
+
+
+    # Aliases the +receiver+ method to better describe who is receiving the
+    # action.
+    #
+    #   class OrderScene < Playwright::Scene
+    #     receiver_accessor :seller
+    #
+    #     def deliver_order(order)
+    #       LoginHelper.login_as(seller)
+    #     end
+    #   end
+    def self.receiver_accessor(name)
+      define_method(name, instance_method(:receiver))
+    end
+
+    def ==(other) # :nodoc:
+      return false unless other.is_a?(Scene)
+      stage == other.stage && sender == other.sender && receiver == other.receiver
+    end
+  end
+end

data/lib/playwright/stage.rb

@@ -0,0 +1,103 @@
+module Playwright
+  # == Playwright::Stage
+  #
+  # Stage encapsulates the Actors, Scenes and Props for a test.
+  #
+  # === Actors
+  #
+  # Every stage needs actors. Actors added to the stage are available as
+  # instance methods and can be assigned a sender or receiver to a Scene.
+  #
+  #     class ActorStage < Playwright::Stage
+  #       actors do
+  #         actor(:actor_1) { User.first! }
+  #       end
+  #     end
+  #
+  #     stage = ActorStage.new
+  #     stage.actor_1 #=> User
+  #
+  # === Scenes
+  #
+  # Scenes are the service layer in your tests. They are the middleware between
+  # the test and the page object models.
+  #
+  #     class SceneStage < Playwright::Stage
+  #       actors do
+  #         actor(:actor_1) { User.first! }
+  #         actor(:actor_2) { User.second! }
+  #         actor(:actor_3) { User.last! }
+  #       end
+  #
+  #       scenes do
+  #         scene Scene1, from: :actor_1, to: actor_2
+  #         scene Scene2, from: :actor_2, to: actor_3
+  #       end
+  #     end
+  #
+  #     stage = SceneStage.new
+  #
+  #     # current scene with actors
+  #     scene = stage.current_scene
+  #     scene.sender #=> stage.actor_1
+  #     scene.receiver #=> stage.actor_2
+  #
+  #     # next scene with actors
+  #     scene = stage.next_scene
+  #     scene.sender #=> stage.actor_2
+  #     scene.receiver #=> stage.actor_3
+  #
+  # === Full Example
+  #
+  #     class FulfillmentStage < Playwright::Stage
+  #       actors do
+  #         actor(:buyer)   { User.find_by(username: 'buyer') }
+  #         actor(:seller)  { User.find_by(username: 'seller') }
+  #         actor(:fulfillment_agency) { FulfillmentAgency.find_by(name: 'agency-1') }
+  #       end
+  #     
+  #       scenes do
+  #         scene PurchaseProduct, from: :buyer, to: :seller
+  #         scene FulfillOrder, from: :seller, to: :fulfillment_agency
+  #       end
+  #     
+  #       prop_collection(:products) { |p| p.id }
+  #       prop_collection(:orders) { |o| o.invoice_number }
+  #       prop_collection(:fulfillments) { |f| f.id }
+  #     end
+  class Stage
+
+    def method_missing(name, *args, &block)
+      narrator = self.class.narrator
+      return narrator.get_actor(name) if narrator.has_actor?(name)
+      return narrator.get_scene(self, name) if narrator.has_scene?(self, name)
+      super
+    end
+
+    def actors
+      self.class.narrator.actors
+    end
+
+    def scenes
+      self.class.narrator.scenes(self)
+    end
+
+    def self.actors(&block)
+      narrator.add_actors(&block)
+    end
+
+    def self.scenes(&block)
+      narrator.add_scenes(&block)
+    end
+
+    def self.prop_collection(name, &block)
+      define_method name do
+        Props.new(block)
+      end
+    end
+
+    def self.narrator
+      Narrator.find_or_create(self)
+    end
+  end
+end

data/lib/playwright/version.rb

@@ -0,0 +1,3 @@
+module Playwright
+  VERSION = '0.1.0'.freeze
+end

data/playwright.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'playwright/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "playwright"
+  spec.version       = Playwright::VERSION
+  spec.authors       = ["Baylor Rae'"]
+  spec.email         = ["baylor@fastmail.com"]
+
+  spec.summary       = %q{Playwright is a foundational piece for building a test framework.}
+  spec.description   = %q{Playwright is a foundational piece for building a test framework.}
+  spec.homepage      = "https://github.com/baylorrae/playwright"
+  spec.license       = "MIT"
+
+  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_dependency "activesupport", "~> 5.0"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: playwright
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Baylor Rae'
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Playwright is a foundational piece for building a test framework.
+email:
+- baylor@fastmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/playwright.rb
+- lib/playwright/dsl/actor_dsl.rb
+- lib/playwright/dsl/scene_dsl.rb
+- lib/playwright/errors.rb
+- lib/playwright/extensions.rb
+- lib/playwright/narrator.rb
+- lib/playwright/props.rb
+- lib/playwright/scene.rb
+- lib/playwright/stage.rb
+- lib/playwright/version.rb
+- playwright.gemspec
+homepage: https://github.com/baylorrae/playwright
+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.5.2
+signing_key: 
+specification_version: 4
+summary: Playwright is a foundational piece for building a test framework.
+test_files: []