lavin 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed47d43b5e5f91e1af2c3e319fa03d3588aee9826215394038359e559773a173
-  data.tar.gz: 17261c42f46a7c4e1ecff28adbd92434c5ec66ac28d4c208d6195a55bf49f69d
+  metadata.gz: 52a0a48c405e0aff4b816ff7bf91b27e8407929a838db819f8777d222b4f7674
+  data.tar.gz: 4acb3c0a928acd45ecbd8137089433e69cdc8235919a0db6fefefb40418bfd82
 SHA512:
-  metadata.gz: 747a493c85dd8fe99c5da92d9fc8380248f80a7b0483bfe42ba3f48fc8a06c89ecc45dfa02f424304b75d28709dfd7c35bc9137a658b22cb449dab91a4bb13ff
-  data.tar.gz: 304de7aa069cb83a61f3530bec34df37349e4572cdc4eb23ec20b86daa4a75606f207248f7b4efe5f3338d8f4166ba94c71ee33e856bc22e6cb36720585627cf
+  metadata.gz: e2fe666e13f22d13dc4f085e8ab7e78c2242a973bd9b0d58054e0b4ada2cc17d1ca924e4103a3c55408bd88c4d1cd3efa8b3449cee7fd8a5d36794392218779c
+  data.tar.gz: b1f7f478a288492082a4f02462d345ce42703316638b3d6aee7848a92a539b22b750105e5e70fdf2ffe662ac26ed68a4f6a32c63154b18ba4faf96dee917b16b

data/lib/lavin/client.rb

@@ -5,6 +5,13 @@ require 'async/http/internet'
 module Lavin
   class Client
     class Error < Lavin::Error; end
+
+    class ServerError < Error
+      def initialize(status)
+        super("Server responded with status: #{status}")
+      end
+    end
+
     class NoCurrentAsyncTaskError < Error
       def initialize(msg = nil)
         super(msg || "Trying to create a client outside of an Async task")
@@ -17,7 +24,7 @@ module Lavin
     }.freeze
 
     attr_reader :internet, :base_url
-    attr_accessor :request_count, :cookie
+    attr_accessor :request_count, :cookie, :report_statistics
 
     def initialize(base_url = nil)
       raise NoCurrentAsyncTaskError unless Async::Task.current?
@@ -26,6 +33,7 @@ module Lavin
       @base_url = base_url
       @request_count = 0
       @cookie = nil
+      @report_statistics = true
     end
 
     def close
@@ -41,7 +49,7 @@ module Lavin
 
       status, headers, body = process(response)
 
-      Statistics.register_request(method:, url:, status:, duration:)
+      Statistics.register_request(method:, url:, status:, duration:) if report_statistics
 
       {status:, headers:, body: body}
     end

data/lib/lavin/error.rb

@@ -2,4 +2,8 @@
 
 module Lavin
   class Error < StandardError; end
+
+  class RecoverableError < Error; end
+
+  class IrrecoverableError < Error; end
 end

data/lib/lavin/failure.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'lavin/error'
+
+module Lavin
+  module Failure
+    def failure(msg)
+      raise RecoverableError, msg
+    end
+
+    def failure!(msg)
+      raise IrrecoverableError, msg
+    end
+  end
+end

data/lib/lavin/hook.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lavin
+  class Hook
+    attr_reader :user, :block, :type
+
+    def initialize(user:, type: :before, &block)
+      @user = user
+      @block = block
+      @type = type
+    end
+
+    def run(context: nil)
+      call(context:)
+      Runner.yield
+    end
+
+    def call(context:)
+      report_statistics = context.client.report_statistics
+      context.client.report_statistics = false
+      context.instance_exec(&block)
+    rescue RecoverableError
+    rescue => error
+      puts "Caught #{error.class} in #{type} hook: #{error.message}"
+      puts error.backtrace unless error.is_a? IrrecoverableError
+      throw :failure
+    ensure
+      context.client.report_statistics = report_statistics
+    end
+  end
+end

data/lib/lavin/http_client.rb

@@ -9,7 +9,7 @@ module Lavin
 
     def initialize(**kwargs)
       super(**kwargs)
-      @client = Client.new(config[:base_url])
+      @client = kwargs.fetch(:client) { Client.new(config[:base_url]) }
     end
 
     def cleanup
@@ -17,27 +17,35 @@ module Lavin
     end
 
     def get(url, headers: {})
-      client.request(:get, url:, headers:)
+      request(:get, url:, headers:)
     end
 
     def head(url, headers: {})
-      client.request(:head, url:, headers:)
+      request(:head, url:, headers:)
     end
 
     def post(url, headers: {}, body: nil)
-      client.request(:post, url:, headers:, body:)
+      request(:post, url:, headers:, body:)
     end
 
     def put(url, headers: {}, body: nil)
-      client.request(:put, url:, headers:, body:)
+      request(:put, url:, headers:, body:)
     end
 
     def patch(url, headers: {}, body: nil)
-      client.request(:patch, url:, headers:, body:)
+      request(:patch, url:, headers:, body:)
     end
 
     def delete(url, headers: {})
-      client.request(:delete, url:, headers:)
+      request(:delete, url:, headers:)
+    end
+
+    private
+
+    def request(method, url:, headers:, body: nil)
+      client.request(method, url:, headers:, body:).tap do |response|
+        raise Lavin::Client::ServerError, response[:status] if response[:status] > 499
+      end
     end
   end
 end

data/lib/lavin/runner.rb

@@ -57,14 +57,14 @@ module Lavin
       rescue StandardError => error
         puts "Failed to run in thread: #{error.message}"
         thread.join
-        thread = nil
+        self.thread = nil
         raise
       end
 
       def stop
-        Statistics.stop
         thread&.kill
         self.thread = nil
+        Statistics.stop
       end
 
       def running?

data/lib/lavin/statistics.rb

@@ -28,6 +28,10 @@ module Lavin
         data[:total_requests]
       end
 
+      def total_steps
+        data[:step_summary][:count]
+      end
+
       def duration
         return data[:duration] if data[:duration]
 
@@ -42,8 +46,14 @@ module Lavin
         data[:requests][key] << result
       end
 
-      def register_step
-        # TODO
+      def register_step(user:, step_name:, failure: nil)
+        data[:step_summary][:count] += 1
+        data[:step_summary][:success] += 1 unless failure
+        data[:step_summary][:failure] += 1 if failure
+        key = [user, step_name]
+        data[:steps][key][:success] += 1 unless failure
+        data[:steps][key][:failure] += 1 if failure
+        data[:failures][failure.to_s] += 1 if failure
       end
 
       def stats
@@ -53,9 +63,11 @@ module Lavin
         requests = data[:requests].map do |(method, url), requests|
           durations = []
           statuses = []
+          failed_requests = 0
           requests.each do |request|
             durations << request[:duration]
             statuses << request[:status]
+            failed_requests += 1 if request[:failure]
           end
           min_duration = durations.min
           max_duration = durations.max
@@ -66,9 +78,10 @@ module Lavin
             url: url,
             requests: requests.size,
             statuses: statuses.tally,
-            avg_duration: avg_duration,
-            min_duration: min_duration,
-            max_duration: max_duration,
+            failed_requests:,
+            avg_duration:,
+            min_duration:,
+            max_duration:
           }
         end
 
@@ -76,7 +89,10 @@ module Lavin
           duration: duration,
           total_requests: total_requests,
           rate: duration ? format("%.2f", total_requests / duration) : 0,
-          requests: requests
+          step_summary: data[:step_summary],
+          steps: data[:steps],
+          requests: requests,
+          failures: data[:failures]
         ).tap do |stats|
           # FIXME remove!
           puts "Calculated stats in #{Time.now - time}s"
@@ -88,12 +104,24 @@ module Lavin
 
         show_summary(values)
 
+        show_steps(values) do |(user, step), hash|
+          format(
+            "%-48<user_step>s %8<success>d %8<failure>d",
+            user_step: "#{user}.#{step}",
+            **hash
+          )
+        end
+
         show_table(values) do |request_values|
           format(
             "%-6<method>s %-100<url>s %6<requests>d %12<avg_duration>fs %12<min_duration>fs %12<max_duration>fs",
             **request_values
           )
         end
+
+        show_failures(values) do |message, count|
+          format("%-64<message>s %6<count>d", message:, count:)
+        end
       end
 
       private
@@ -116,8 +144,14 @@ module Lavin
           start: nil,
           duration: nil,
           total_requests: 0,
-          steps: [],
-          requests: Hash.new { |h, k| h[k] = [] }
+          step_summary: {
+            count: 0,
+            success: 0,
+            failure: 0
+          },
+          steps: Hash.new { |h, k| h[k] = {success: 0, failure: 0} },
+          requests: Hash.new { |h, k| h[k] = [] },
+          failures: Hash.new { |h, k| h[k] = 0 }
         }
       end
 
@@ -127,14 +161,29 @@ module Lavin
           Lavin results:
           Test ran for #{values.duration}s
           Total number of requests: #{values.total_requests}
-          Rate: #{format("%.2f", values.total_requests/values.duration)} rps
+          Rate: #{format("%.2f", values.total_requests / values.duration)} rps
 
+          Total number of steps: #{values.total_steps}
+          Step success rate: #{format("%.2f %%", 100 * values.successful_steps.to_f / values.total_steps)}
         RESULT
       end
 
+      def show_steps(values)
+        puts format(
+          "\n%-48<user_step>s %8<success>s %8<failure>s",
+          user_step: "Steps",
+          success: "Success",
+          failure: "Failure"
+        )
+        divider = "-" * 66
+        puts divider
+        values.each_step { |step_values| puts yield step_values }
+        puts divider
+      end
+
       def show_table(values)
         puts format(
-          "%-6<method>s %-100<url>s %-6<requests>s %12<avg_duration>s %12<min_duration>s %12<max_duration>s",
+          "\n%-6<method>s %-100<url>s %-6<requests>s %12<avg_duration>s %12<min_duration>s %12<max_duration>s",
           method: "Method",
           url: "URL",
           requests: "Requests",
@@ -148,6 +197,14 @@ module Lavin
         values.each_request { |request_values| puts yield request_values }
         puts divider
       end
+
+      def show_failures(values)
+        puts format("\n%-64<message>s %6<count>s", message: "Failures", count: "Count")
+        divider = "-" * 71
+        puts divider
+        values.each_failure { |failures| puts yield failures }
+        puts divider
+      end
     end
   end
 end

data/lib/lavin/stats.rb

@@ -2,13 +2,16 @@
 
 module Lavin
   class Stats
-    attr_reader :duration, :total_requests, :rate, :requests
+    attr_reader :duration, :total_requests, :rate, :requests, :step_summary, :steps, :failures
 
-    def initialize(duration:, total_requests:, rate:, requests: [])
+    def initialize(duration:, total_requests:, rate:, requests: [], step_summary: {}, steps: [], failures: [])
       @duration = duration
       @total_requests = total_requests
       @rate = rate
       @requests = requests
+      @step_summary = step_summary
+      @steps = steps
+      @failures = failures
     end
 
     def empty?
@@ -20,12 +23,35 @@ module Lavin
         duration:,
         total_requests:,
         rate:,
-        requests:
+        requests:,
+        step_summary:,
+        steps:,
+        failures:
       }
     end
 
+    def total_steps
+      @step_summary[:count]
+    end
+
+    def successful_steps
+      @step_summary[:success]
+    end
+
+    def failed_steps
+      @step_summary[:failure]
+    end
+
+    def each_step(&block)
+      steps.each(&block)
+    end
+
     def each_request(&block)
       requests.each(&block)
     end
+
+    def each_failure(&block)
+      failures.each(&block)
+    end
   end
 end

data/lib/lavin/step.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require 'lavin/error'
+
 module Lavin
   class Step
-    attr_reader :user, :block, :repeat
+    attr_reader :name, :user, :block, :repeat
 
-    def initialize(repeat: 1, &block)
+    def initialize(name:, user:, repeat: 1, &block)
+      @name = name
+      @user = user
       @repeat = repeat
       @block = block
     end
@@ -18,11 +22,12 @@ module Lavin
 
     def call(context:)
       context.instance_exec(&block)
-      # Report Success!
+      Statistics.register_step(user: user.name, step_name: name)
+    rescue IrrecoverableError => error
+      Statistics.register_step(user: user.name, step_name: name, failure: error.message)
+      throw :failure
     rescue => error
-      puts "Caught an error - #{error.class}: #{error.message}"
-      puts error.backtrace
-      # Report Failure!
+      Statistics.register_step(user: user.name, step_name: name, failure: error.message)
     end
   end
 end

data/lib/lavin/user.rb

@@ -4,6 +4,7 @@ require "set"
 require "lavin/user_config"
 require "lavin/worker"
 require "lavin/http_client"
+require "lavin/failure"
 
 module Lavin
   class User
@@ -12,6 +13,7 @@ module Lavin
       subclass.include UserConfig
       subclass.include Worker
       subclass.include HttpClient
+      subclass.include Failure
       all_personas << subclass
     end
 

data/lib/lavin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lavin
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/lavin/web_server.rb

@@ -40,6 +40,11 @@ module Lavin
       redirect to('/statistics')
     end
 
+    post '/stop' do
+      Lavin::Runner.stop
+      redirect to('/statistics')
+    end
+
     get '/statistics' do
       stats = Statistics.stats
       running = Lavin::Runner.running?
@@ -50,6 +55,16 @@ module Lavin
       end
     end
 
+    get '/failures' do
+      stats = Statistics.stats
+      running = Lavin::Runner.running?
+      if stats.empty? && !running
+        redirect to('/')
+      else
+        erb :failures, locals: {stats:, running:}
+      end
+    end
+
     get '/edit' do
       persona = find_persona
       raise Sinatra::NotFound unless persona

data/lib/lavin/worker.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'lavin/step'
+require 'lavin/hook'
 
 module Lavin
   module Worker
@@ -8,21 +9,22 @@ module Lavin
       def before(&block)
         return @before unless block
 
-        @before = block
+        @before = Hook.new(user: self, type: :before, &block)
       end
 
       def after(&block)
         return @after unless block
 
-        @after = block
+        @after = Hook.new(user: self, type: :after, &block)
       end
 
       def steps
         @steps ||= []
       end
 
-      def step(**options, &block)
-        steps << Step.new(**options, &block)
+      def step(name: nil, **options, &block)
+        name ||= "Step##{steps.size + 1}"
+        steps << Step.new(user: self, name:, **options, &block)
       end
     end
 
@@ -38,11 +40,15 @@ module Lavin
     end
 
     def run
-      self.class.before.call.then { Runner.yield } if self.class.before
+      catch(:failure) do
+        self.class.before.run(context: self).then { Runner.yield } if self.class.before
 
-      run_step until finished?
+        run_step until finished?
+      end
 
-      self.class.after.call.then { Runner.yield } if self.class.after
+      catch(:failure) do
+        self.class.after.run(context: self).then { Runner.yield } if self.class.after
+      end
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lavin
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sammy Henningsson
@@ -29,7 +29,7 @@ cert_chain:
   DVzXaUnsmwP+jQ1PkDa5q8ibBzMd2c6Hmm87UDqPxZtML0bF9SjrpbyLMjwtXaMA
   WDPp0ajpdUZ9GPHsrVNYXiOfQIqcmlmpYVsH1o7vuneUIcIDMrnMDChh
   -----END CERTIFICATE-----
-date: 2022-10-30 00:00:00.000000000 Z
+date: 2022-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -113,6 +113,8 @@ files:
 - lib/lavin.rb
 - lib/lavin/client.rb
 - lib/lavin/error.rb
+- lib/lavin/failure.rb
+- lib/lavin/hook.rb
 - lib/lavin/http_client.rb
 - lib/lavin/runner.rb
 - lib/lavin/statistics.rb