foot_traffic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f953b3b31b7d172bed8c19c4516f568969fca74c4677ad58f11f73200d11ef7b
+  data.tar.gz: bc6bd3f2bff7b92f7edc61aebf616c832cb49581f8197b50d9361552f277c4a5
+SHA512:
+  metadata.gz: 5dc2c473dcbee1f5d4978f3b34d2bb087f3f5ed4cb7fe8e31fd9e98d5f976aa6429b3aa3c7337917bf3135df0e7cf4a9614288d6d8976d8e37a4ccead172d354
+  data.tar.gz: 5c039f20cf7d9ee37da0a70a958d4b78f7f154a7334f9455c96745017399d35ca4aba379e114625ab67a2fbd559750ae151a1b0d668281fd1d7c5140a5672497

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in foot_traffic.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    foot_traffic (0.1.0)
+      ferrum (~> 0.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    cliver (0.3.2)
+    concurrent-ruby (1.1.6)
+    diff-lcs (1.3)
+    ferrum (0.8)
+      addressable (~> 2.6)
+      cliver (~> 0.3)
+      concurrent-ruby (~> 1.1)
+      websocket-driver (>= 0.6, < 0.8)
+    public_suffix (4.0.5)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    websocket-driver (0.7.1)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  foot_traffic!
+  rake (~> 12.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Andy B
+
+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,243 @@
+# Foot Traffic :dancers: :dancing_men:
+
+A natural companion to to an amazing [Ferrum](https://github.com/rubycdp/ferrum) gem that controls a fleet of Chrome windows and tabs and simulates real user interaction with your web applications from any Ruby scripts. Works naturally with your system Chrome or Chromium, no extra magic like Selenium or WebDrivers needed.
+
+```rb
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start do |window|
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com/paris" }
+end
+```
+
+![FootTraffic in action](docs/in_action.gif)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'foot_traffic'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install foot_traffic
+
+## Powered by Ferrum :heart:
+
+At [Le Wagon](https://www.lewagon.com) we love Ferrum and use it as a Selenium replacement to run system tests for our learning platforms. We highly recommend you do the same, and here's why
+
+> Ferrum connects to the browser by CDP protocol and there's no Selenium/WebDriver/ChromeDriver dependency. The emphasis was made on a raw CDP protocol because Chrome allows you to do so many things that are barely supported by WebDriver because it should have consistent design with other browsers.—[Ferrum on GitHub](https://github.com/rubycdp/ferrum)
+
+Pure Ruby + pure Chrome—what's not to like?
+
+## Tutorial
+
+In a simplest case, all you need is to `require "foot_traffic"`, put in the `using FootTraffic` to enable Ferrum [refinements](https://docs.ruby-lang.org/en/master/syntax/refinements_rdoc.html) and proceed with opening a session block. It yields a `window` object that is an instance of `Ferrum::Context` ([source](https://github.com/rubycdp/ferrum/blob/master/lib/ferrum/context.rb)). You can create a "tab" instance with a `new_tab` method and control it through Ferrum [methods](https://github.com/rubycdp/ferrum#examples) that are designed to be close to [Puppeteer](https://github.com/puppeteer/puppeteer/).
+
+```rb
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start do |window|
+  window.new_tab.goto "https://www.lewagon.com"
+  window.new_tab.goto "https://www.lewagon.com/berlin"
+
+  paris = window.new_tab
+  paris.goto "https://www.lewagon.com/paris"
+  paris.at_css('[href="/paris/apply"]').click
+  paris.at_css("#apply_first_name").focus.type("Alan")
+  paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+end
+```
+
+In this case, all the instructions to the browser will run in a _single thread_ of execution, so you will see a browser performing actions consequetively.
+
+As Ferrum is thread-safe by design, you can execute the same scenario in parallel. `tab_thread` method opens a block that yields the instance of `Ferrum::Page` ([source](https://github.com/rubycdp/ferrum/blob/master/lib/ferrum/page.rb)).
+
+```rb
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start do |window|
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  window.tab_thread do |paris|
+    paris.goto "https://www.lewagon.com/paris"
+    paris.at_css('[href="/paris/apply"]').click
+    paris.at_css("#apply_first_name").focus.type("Alan")
+    paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+  end
+end
+```
+
+Now, all the tabs will run **in parallel** (with limits to Ruby concurrency model, of course). After the session block finishes execution, browser will stay open indefinitely—until you `Ctrl-C` the original script. That might be useful if you want to use Chrome Developer Tools on open pages.
+
+If your script does not end with a session block and you want to continue running your code—set the duration time for the session.
+
+```rb
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start(duration: 10) do |window|
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  window.tab_thread do |paris|
+    paris.goto "https://www.lewagon.com/paris"
+    paris.at_css('[href="/paris/apply"]').click
+    paris.at_css("#apply_first_name").focus.type("Alan")
+    paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+  end
+end
+```
+
+Now the block will exit after 10 seconds.
+
+If you don't want to guess the time for pages to stay open—you can use the `quit` parameter of session. Note that in that case, you need to wait for all your threads to exit. As a convenience, `session` block yields a second argument that is a primitive implementation of a thread pool.
+
+```rb
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start(quit: true) do |window, pool|
+  pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  pool << window.tab_thread do |paris|
+    paris.goto "https://www.lewagon.com/paris"
+    paris.at_css('[href="/paris/apply"]').click
+    paris.at_css("#apply_first_name").focus.type("Alan")
+    paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+  end
+  pool.wait
+end
+```
+
+Now, the session block will exit as soon as the last action in the last tab completes—your script can run further!
+
+If you want to see how your website handles multiple concurrent visits—you can use the `clone` parameter that will open as many Chrome windows as you want and run the tab scenario in each of them.
+
+As this puts the strain on your system's resources, it makes sense to also use some of the Ferrum's [options](https://github.com/rubycdp/ferrum#customization) to set higher timeouts for Chrome startup and page loads. `slowmo` parameter might be particularly useful for simulating real user behavior, as it will add a small wait before executing each action, including sending keyboard keys.
+
+```rb
+require "foot_traffic"
+using FootTraffic
+
+opts = {
+  process_timeout: 10,
+  timeout: 100,
+  slowmo: 0.1,
+  window_size: [1024, 768]
+}
+
+FootTraffic::Session.start(options: opts, quit: true, clones: 10) do |window, pool|
+  pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  pool << window.tab_thread { |paris|
+    paris.goto "https://www.lewagon.com/paris"
+    paris.at_css('[href="/paris/apply"]').click
+    paris.at_css("#apply_first_name").focus.type("Alan")
+    paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+  }
+  pool.wait
+end
+```
+
+You can also set the `headless` option to `true` to perform script in headless mode. If you open too many concurrent tabs, or the number of clones too high—your system will run out of memory. To prevent that, Foot Traffic will raise the
+`FootTraffic::ResourceOverloadError` once `ThreadError`, `RuntimeError`, `Errno::EMFILE`, or `Errno::ECONNRESET` start propagating.
+
+```rb
+require "foot_traffic"
+using FootTraffic
+
+opts = {
+  headless: true,
+  process_timeout: 10,
+  timeout: 100,
+  slowmo: 0.1,
+  window_size: [1024, 768]
+}
+
+begin
+  FootTraffic::Session.start(options: opts, quit: true, clones: 10) do |window, pool|
+    pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+    pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+    pool << window.tab_thread { |paris|
+      paris.goto "https://www.lewagon.com/paris"
+      paris.at_css('[href="/paris/apply"]').click
+      paris.at_css("#apply_first_name").focus.type("Alan")
+      paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+    }
+    pool.wait
+  end
+rescue FootTraffic::ResourceOverloadError
+  puts "Oops..."
+  exit(1)
+end
+```
+
+You can also control cookies for each tab. Keep in mind that in this case you don't want all your actions to run entirely concurrently, as the values of cookies may leak between tabs. Here's an example on how to avoid it:
+
+```rb
+require "concurrent" # concurrent-ruby
+
+tokens = [] # imaginary array of auth tokens
+
+cookies = Concurrent::Hash.new
+
+opts = {
+  headless: false, # Headless or not
+  timeout: 300, # How long to wait for new tab to open, set for high value
+  slowmo: 0.1, # How fast do you want bots to type
+  window_size: [1200, 800]
+}
+
+FootTraffic::Session.start(options: opts, quit: true) do |window, pool|
+  tokens.each do |token|
+    sleep(1) # Need to sleep so we can propely save cookies
+    pool << window.with_tab { |tab|
+      tab.goto("https://example.com/sign_in/#{token}")
+      cookies[token] = tab.cookies["_example_session"].value
+    }
+  end
+  pool.wait
+end
+
+FootTraffic::Session.start(options: opts) do |window|
+  tokens.each do |token|
+    sleep(1) # Wait to properly load cookies
+    window.with_tab do |tab|
+      tab.cookies.clear
+      tab.cookies.set(
+        name: "_example_session",
+        domain: "example.lewagon.co",
+        value: cookies[token]
+      )
+      tab.goto("https://example.com/protected_route")
+    end
+  end
+end
+```
+
+Check out the [examples](https://github.com/lewagon/foot_traffic/tree/master/examples) folder to study some of the scripts above.
+
+## 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/lewagon/foot_traffic.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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 "foot_traffic"
+
+# 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(__FILE__)

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/examples/clones.rb

@@ -0,0 +1,27 @@
+require "foot_traffic"
+using FootTraffic
+
+opts = {
+  headless: true,
+  process_timeout: 10,
+  timeout: 100,
+  slowmo: 0.1,
+  window_size: [1024, 768]
+}
+
+begin
+  FootTraffic::Session.start(options: opts, quit: true, clones: 100) do |window, pool|
+    pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+    pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+    pool << window.tab_thread { |paris|
+      paris.goto "https://www.lewagon.com/paris"
+      paris.at_css('[href="/paris/apply"]').click
+      paris.at_css("#apply_first_name").focus.type("Alan")
+      paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+    }
+    pool.wait
+  end
+rescue FootTraffic::ResourceOverloadError
+  puts "Oops..."
+  exit(1)
+end

data/examples/cookies.rb

@@ -0,0 +1,38 @@
+require "concurrent" # concurrent-ruby
+
+tokens = [] # imaginary array of auth tokens
+
+cookies = Concurrent::Hash.new
+
+opts = {
+  headless: false, # Headless or not
+  timeout: 300, # How long to wait for new tab to open, set for high value
+  slowmo: 0.1, # How fast do you want bots to type
+  window_size: [1200, 800]
+}
+
+FootTraffic::Session.start(options: opts, quit: true) do |window, pool|
+  tokens.each do |token|
+    sleep(1) # Need to sleep so we can propely save cookies
+    pool << window.with_tab { |tab|
+      tab.goto("https://example.com/sign_in/#{token}")
+      cookies[token] = tab.cookies["_example_session"].value
+    }
+  end
+  pool.wait
+end
+
+FootTraffic::Session.start(options: opts) do |window|
+  tokens.each do |token|
+    sleep(1) # Wait to properly load cookies
+    window.with_tab do |tab|
+      tab.cookies.clear
+      tab.cookies.set(
+        name: "_example_session",
+        domain: "example.lewagon.co",
+        value: cookies[token]
+      )
+      tab.goto("https://example.com/protected_route")
+    end
+  end
+end

data/examples/multi_threaded.rb

@@ -0,0 +1,13 @@
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start do |window|
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  window.tab_thread do |paris|
+    paris.goto "https://www.lewagon.com/paris"
+    paris.at_css('[href="/paris/apply"]').click
+    paris.at_css("#apply_first_name").focus.type("Alan")
+    paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+  end
+end

data/examples/multi_threaded_pool.rb

@@ -0,0 +1,14 @@
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start(quit: true) do |window, pool|
+  pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  pool << window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  pool << window.tab_thread { |paris|
+    paris.goto "https://www.lewagon.com/paris"
+    paris.at_css('[href="/paris/apply"]').click
+    paris.at_css("#apply_first_name").focus.type("Alan")
+    paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+  }
+  pool.wait
+end

data/examples/simple.rb

@@ -0,0 +1,8 @@
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start do |window|
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com" }
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com/berlin" }
+  window.tab_thread { |tab| tab.goto "https://www.lewagon.com/paris" }
+end

data/examples/single_threaded.rb

@@ -0,0 +1,13 @@
+require "foot_traffic"
+using FootTraffic
+
+FootTraffic::Session.start do |window|
+  window.new_tab.goto "https://www.lewagon.com"
+  window.new_tab.goto "https://www.lewagon.com/berlin"
+
+  paris = window.new_tab
+  paris.goto "https://www.lewagon.com/paris"
+  paris.at_css('[href="/paris/apply"]').click
+  paris.at_css("#apply_first_name").focus.type("Alan")
+  paris.at_css("#apply_last_name").focus.type("Turing", :Tab)
+end

data/foot_traffic.gemspec

@@ -0,0 +1,30 @@
+require_relative "lib/foot_traffic/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "foot_traffic"
+  spec.version = FootTraffic::VERSION
+  spec.authors = ["Andy B"]
+  spec.email = ["andrey@lewagon.org"]
+
+  spec.summary = "Control a fleet of Chromes from a Ruby script. Built on Ferrum."
+  spec.description = "Foot Traffic allows to simulate real web users for load testing, debugging, or feature discovery"
+  spec.homepage = "https://github.com/lewagon/foot_traffic"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/lewagon/foot_traffic"
+  spec.metadata["changelog_uri"] = "https://github.com/lewagon/foot_traffic/CHANGELOG"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ferrum", "~> 0.8"
+  spec.add_development_dependency "rspec", "~> 3.2"
+end

data/lib/foot_traffic.rb

@@ -0,0 +1,6 @@
+require "foot_traffic/version"
+require "foot_traffic/session"
+
+module FootTraffic
+  class ResourceOverloadError < StandardError; end
+end

data/lib/foot_traffic/refinements.rb

@@ -0,0 +1,20 @@
+require "ferrum"
+
+module FootTraffic
+  refine Ferrum::Context do
+    def new_tab
+      create_page
+    end
+
+    def in_thread(&block)
+      Thread.new do
+        block.call(create_page)
+      rescue ThreadError, RuntimeError, Errno::EMFILE, Errno::ECONNRESET
+        raise ResourceOverloadError
+      end
+    end
+
+    alias_method :with_tab, :in_thread
+    alias_method :tab_thread, :in_thread
+  end
+end

data/lib/foot_traffic/session.rb

@@ -0,0 +1,55 @@
+require_relative "refinements"
+require "ferrum"
+
+module FootTraffic
+  class ThreadPool
+    def initialize
+      @threads = []
+    end
+
+    def <<(thread)
+      @threads << thread
+    end
+
+    def wait
+      @threads.map(&:join)
+    end
+  end
+
+  class Session
+    def self.start(options: {}, duration: nil, clones: 1, quit: false, &block)
+      new(options).start(duration: duration, clones: clones, quit: quit, &block)
+    end
+
+    def initialize(opts)
+      opts[:headless] ||= false
+      @browser ||= Ferrum::Browser.new(opts)
+    end
+
+    def start(duration: nil, clones: 1, quit: false, &block)
+      main = Thread.new {
+        threads = []
+        clones.times do
+          threads << Thread.new {
+            window = @browser.contexts.create
+            block.call(window, ThreadPool.new)
+          }
+        end
+        threads.map(&:join)
+      }
+
+      # A sleeping thread to keep Ferrum open for a given period of time
+      unless quit
+        wait = Thread.new {
+          duration.nil? ? sleep : sleep(duration)
+        }
+        wait.join
+      end
+
+      main.join
+      @browser.quit
+    rescue ThreadError, RuntimeError, Errno::EMFILE, Errno::ECONNRESET
+      raise ResourceOverloadError
+    end
+  end
+end

data/lib/foot_traffic/version.rb

@@ -0,0 +1,3 @@
+module FootTraffic
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: foot_traffic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andy B
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ferrum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Foot Traffic allows to simulate real web users for load testing, debugging,
+  or feature discovery
+email:
+- andrey@lewagon.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/in_action.gif
+- examples/clones.rb
+- examples/cookies.rb
+- examples/multi_threaded.rb
+- examples/multi_threaded_pool.rb
+- examples/simple.rb
+- examples/single_threaded.rb
+- foot_traffic.gemspec
+- lib/foot_traffic.rb
+- lib/foot_traffic/refinements.rb
+- lib/foot_traffic/session.rb
+- lib/foot_traffic/version.rb
+homepage: https://github.com/lewagon/foot_traffic
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/lewagon/foot_traffic
+  source_code_uri: https://github.com/lewagon/foot_traffic
+  changelog_uri: https://github.com/lewagon/foot_traffic/CHANGELOG
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Control a fleet of Chromes from a Ruby script. Built on Ferrum.
+test_files: []