web_tsunami 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a151d3928ef65c636d341b5c00c4aab1f51314f7bb809e845f1281782b172db
-  data.tar.gz: '08597d6fcdb0157c1636033ebc92c2a0a0accd66d023ae6d609817f60d371756'
+  metadata.gz: 5684946d08e860b309d812707e690d91f45698140d5a22b1d8fe963f85203f25
+  data.tar.gz: dd58e555fc6c6dc89c3e1205299fec88c3879635ea36f4e78baa49a5f00993e5
 SHA512:
-  metadata.gz: 4f987ec8a711515c8bf5c8045b8fb074b8e4617af5c802e66cf0900b2e5df89eaeb286b78a529ef9508d7629ed365bbe73384bb722308a77dd26084d2ddce361
-  data.tar.gz: e9e2e9d3c9c975b3f6f2b6ce3ea2657da4bd806819944b34ea7824621e85700637b340a2dab3388af74723d1391080e45da8b766488fbc9d1a41d0369bfcb521
+  metadata.gz: 1a29b20791f56ba1e87b4168777fd9a362a6bc06c3548bd5bc1a7a2d44b4d765153fb24ca732fea99172d0a2d2ffbdbad08aec7d0063cc018fa5309e740c647f
+  data.tar.gz: 3991dbf3d1b3d72c2aa40f734a153a8ed40f4bfbc903afdd6f3780c4b81ef918b0ed4033ee5f3521837342987ff16cd1a5f2a5f2d5a68990039c0a2d67356189

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Changelog of Web Tsunami
 
-## Unreleased
+## 0.2.0 (2024-01-25)
+
+* Add methods post, put, patch and delete
+* Improve README with an advanced example
+
+## 0.1.0 (2024-01-19)
 
 * Fix non compatible changes of Typhoeus
 

data/README.md

@@ -1,3 +1,5 @@
+<img align="right" width="120px" src="./web_tsunami.png">
+
 # Web Tsunami
 
 Write tailor-made scenarios for load testing web apps
@@ -5,16 +7,31 @@ Write tailor-made scenarios for load testing web apps
 ## Why
 
 Many good tools already exist for a very long time such as ApacheBench and Siege.
-But, sometimes load testing a web app requires to write a custom scenario.
+The goal is not to replace them.
+But sometimes, load testing a web app requires to write a custom scenario.
+My initial requirement was to send requests with unique parameters.
+To the best of my knowledge, no tool could do this.
+
 The goal is to focus only on the scenario without thinking about forking, threads and non blocking IOs.
 Fortunately there is [Typhoeus](https://github.com/typhoeus/typhoeus) to send parallel HTTP requests.
 
+## How
+
 Web Tsunami is a tiny class that forks every seconds and sends as many requests as expected.
+It provide the methods `get`, `post`, `put`, `patch` and `delete`.
+They all accept the same arguments : `get(url, options = {}, &block)`.
+The `options` is given to Typhoeus as is.
+It can contain headers and the request body.
+See [Typhoeus usage](https://github.com/typhoeus/typhoeus/#usage) for more details.
+
+## Examples
 
-## Example
+Let's start with a very trivial scenario and I will show you an advanced one after :
 
 ```ruby
-class Example < WebTsunami::Scenario
+require "web_tsunami"
+
+class SearchTsunami < WebTsunami::Scenario
   def run
     get("http://site.example") do
       # Block is executed once the response has been received
@@ -22,7 +39,7 @@ class Example < WebTsunami::Scenario
       get("http://site.example/search?query=stress+test") do |response|
         # Do whatever you need with the response object or ignore it
         sleep(10)
-        get("http://site.example/search?query=stress+test&page=2") do
+        get("http://site.example/search?query=stress+test&page=#{rand(100)}") do
           sleep(5)
           get("http://site.example/stress/test")
         end
@@ -33,11 +50,75 @@ end
 
 # Simulates 100 concurrent visitors every second for 10 minutes
 # It's a total of 60K unique visitors for an average of 23'220 rpm.
-Example.start(concurrency: 100, duration: 60 * 10)
+SearchTsunami.start(concurrency: 100, duration: 60 * 10)
+```
+
+In this scenario, a visitor comes on the index page, then search for _stress test_, then go on a random page of the search result, and finally found the stress test page.
+It introduces a unique parameters which is the page number.
+It's nice, but it could have almost be done with Siege.
+Let me show you a more advanced scenario.
+
+```ruby
+require "web_tsunami"
+require "json"
+
+class RegistrationTsunami < WebTsunami::Scenario
+  # Simulate a visitor coming on the index page,
+  # then going to the registration form,
+  # and finally submitting the form.
+  def run
+    get("http://site.example/") do |response|
+      get("http://site.example/account/new") do |response|
+        post("http://site.example/account", post_account_options(response)) do |response|
+          # Then visiting the dashboard, and so on.
+        end
+      end
+    end
+  end
+
+  private
+
+  def post_account_options(response)
+    # In order to not be blocked by the Cross-Site Request Forgery, the request must contain :
+    #   1. Cookie header
+    #   2. authenticity_token form param
+    {
+      headers: build_post_headers(response),
+      body: JSON.generate(
+        authenticity_token: extract_csrf_token(response.body),
+        user: {
+          name: name = rand.to_s[2..-1],
+          email: "#{name}@domain.test",
+          password: name,
+        }
+      ),
+    }
+  end
+
+  def build_post_headers(response)
+    {
+      "Origin" => response.request&.base_url,
+      "Content-Type" => "application/json",
+      "Cookie" => response.headers["Set-Cookie"],
+      # To Simulate a post XmlHttpRequest from JavaScript, you should provide these headers :
+      # "X-CSRF-Token" => extract_csrf_token(response.body),
+      # "X-Requested-With" => "XMLHttpRequest"
+    }
+  end
+
+  CSRF_REGEX = /<meta name="csrf-token" content="([^"]+)"/
+
+  def extract_csrf_token(html)
+    html.match(CSRF_REGEX)[1]
+  end
+end
+
+# Simulates 100 concurrent visitors every second for 10 minutes
+RegistrationTsunami.start(concurrency: 100, duration: 10)
 ```
 
-In this example, the same requests are always sent.
-But you can provide dynamic query strings, use variables and some randomness.
+This is more complex because it handles CSRF and every submitted forms are unique.
+Indeed emails must be unique, so it's not possible to send the same data everytime.
 
 ## Output and result
 

data/lib/web_tsunami/version.rb

@@ -1,3 +1,3 @@
 module WebTsunami
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/web_tsunami.rb

@@ -13,7 +13,6 @@ module WebTsunami
     end
 
     def initialize(concurrency)
-      @sleeps = {}
       @concurrency = concurrency
     end
 
@@ -21,8 +20,29 @@ module WebTsunami
       @requests ||= Typhoeus::Hydra.new
     end
 
-    def get(url, &block)
-      requests.queue(req = Typhoeus::Request.new(url, request_options))
+    def get(url, options = {}, &block)
+      request(:get, url, options, &block)
+    end
+
+    def post(url, options = {}, &block)
+      request(:post, url, options, &block)
+    end
+
+    def put(url, options = {}, &block)
+      request(:put, url, options, &block)
+    end
+
+    def patch(url, options = {}, &block)
+      request(:patch, url, options, &block)
+    end
+
+    def delete(url, options = {}, &block)
+      request(:delete, url, options, &block)
+    end
+
+    def request(method, url, options, &block)
+      req = Typhoeus::Request.new(url, {method: method}.merge(options))
+      requests.queue(req)
       req.on_complete do |response|
         if response.timed_out?
           puts "Timeout #{url}"
@@ -44,9 +64,5 @@ module WebTsunami
       raise NotImplementedError
     end
 
-    def request_options
-      {}
-    end
-
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: web_tsunami
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexis Bernard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-19 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -36,10 +36,10 @@ files:
 - Gemfile.lock
 - LICENSE.txt
 - README.md
-- example.rb
 - lib/web_tsunami.rb
 - lib/web_tsunami/version.rb
 - web_tsunami.gemspec
+- web_tsunami.png
 homepage: https://github.com/BaseSecrete/web_tsunami
 licenses:
 - MIT

data/example.rb

@@ -1,28 +0,0 @@
-$LOAD_PATH << File.dirname(__FILE__)
-
-require 'web_tsunami'
-
-# Triggers the following requests concurently:
-# http://www.google.com
-# http://www.google.com/search?q=ruby
-# http://www.google.com/search?q=ruby&start=10
-
-class GoogleTsunami < WebTsunami::Scenario
-  def run
-    get('http://www.google.com') do
-      puts 'http://www.google.com'
-      get('http://www.google.com/search?q=ruby') do
-        puts 'http://www.google.com/search?q=ruby'
-        get('http://www.google.com/search?q=ruby&start=10') do
-          puts 'http://www.google.com/search?q=ruby&start=10'
-        end
-      end
-    end
-  end
-end
-
-# Set concurrency and duration in seconds and start your script.
-# These numbers are voluntary low because I don't want any trouble with Google.
-# But don't hesitate to set a higher concurrency and a duration of almost 5 minutes
-# in order to get a reliable benchmark.
-GoogleTsunami.start(concurrency: 2, duration: 10)