rspeed 0.0.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37630f2559997e8c9d0a8128030d60d58a47b419197bae4e5af03bd882961108
-  data.tar.gz: ce15fb8fe3bd8617819e7b9735a1300e31fdac020d6b907ebef9abedfe0bee52
+  metadata.gz: c2d2d14366ee70f0cf449f6fbf6bc6c7cedd57edc8497b646721afa4b098720a
+  data.tar.gz: 0ac5789e67ba474055620780a0311525bbe29c801b2c09344218888b33de55ac
 SHA512:
-  metadata.gz: 2ee677e609df2a543b75c14259ab1d878fdbf6f853e00bffb196b14fc76fb0f4f026df9ea7c2ce9ec56744a497418b271dc6c5e5ccb053a62a6c110d3e794613
-  data.tar.gz: 92f1c09d0f251d4b5e7bffed57120c3d9fa56b16278dd8b5de2dd225218d1993d62db5f3a57b0b30a8bd47bccaada5a90969c713bb63a45590bb3c4d3c10bea9
+  metadata.gz: 00adb24277015b707cfbd1d5ea0f2cd9b220701344654a107471ab6683ea4876830a34cb34262a42b425078a5dab85efaee16cb2252da1027b807a3409eb22ac
+  data.tar.gz: aa4932a206cd9a5ab93e4b4217099ebad1a110b8ee9d48c6c0dd9addaf9073d561249480cfe1f74137f484c27a649b05afc4720fde679abb825ef43ba59feb4a

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## master
+
+- None;
+
+## v0.5.0
+
+#### Fix
+
+- Add env `RSPEED_NAME` to specify the application name and avoid result conflicts between multiple runs;
+- No more depends on pipe sequence to generate ou aggregate the resul;
+- rake `rspeed:install`;
+
+#### Update
+
+- The result of the pipes are no more saved on Redis. It's now calculated based on result key `rspeed`;
+
+## v0.4.0
+
+- Now we make diff to discover removed and added examples;
+
+## v0.3.0
+
+- Removed and added files now is considered on run;
+
+## v0.2.0
+
+- Splits specs by examples over files;
+
+## v0.1.0
+
+- First release;
+
 ## v0.0.1
 
 - RubyGems namespace reservation.

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Washington Botelho
+Copyright (c) 2017-2020 Washington Botelho
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,11 +1,94 @@
 # RSpeed
 
-[![Build Status](https://travis-ci.org/wbotelhos/normalizy.svg)](https://travis-ci.org/wbotelhos/normalizy)
-[![Gem Version](https://badge.fury.io/rb/normalizy.svg)](https://badge.fury.io/rb/normalizy)
-[![LiberPay](https://img.shields.io/badge/donate-%3C3-brightgreen.svg)](https://liberapay.com/wbotelhos)
+[![CI](https://github.com/wbotelhos/rspeed/workflows/CI/badge.svg)](https://github.com/wbotelhos/rspeed/actions)
+[![Gem Version](https://badge.fury.io/rb/rspeed.svg)](https://badge.fury.io/rb/rspeed)
+[![Maintainability](https://api.codeclimate.com/v1/badges/f312587b4f126bb13e85/maintainability)](https://codeclimate.com/github/wbotelhos/rspeed/maintainability)
+[![Coverage](https://codecov.io/gh/wbotelhos/rspeed/branch/main/graph/badge.svg)](https://codecov.io/gh/wbotelhos/rspeed)
+[![Sponsor](https://img.shields.io/badge/sponsor-%3C3-green)](https://www.patreon.com/wbotelhos)
 
+RSpeed splits your specs to you run parallels tests.
 
+## Install
 
-## Love it!
+Add the following code on your `Gemfile` and run `bundle install`:
 
-Via [PayPal](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=X8HEP2878NDEG&item_name=rspeed) or [LiberPay](https://liberapay.com/wbotelhos). Thanks! (:
+```ruby
+gem 'rspeed'
+```
+
+## Setup
+
+We need to extract the rake that executes the split via `rspeed:run`.
+
+```ruby
+rake rspeed:install
+```
+
+## Usage
+
+- `RSPEED_NAME`: You app name to avoid data override
+- `RSPEED_PIPE`: Current pipe
+- `RSPEED_PIPES`: Quantity of pipes
+- `RSPEED_RESULT_KEY`: The key that keeps the final result of all pipes
+- `RSPEED_TMP_KEY`: The temporary key that keeps the partial result of the pipes
+- `RSPEED`: Enables RSpeed
+
+```sh
+RSPEED=true RSPEED_NAME=authorizy RSPEED_PIPE=1 RSPEED_PIPES=3 bundle exec rake rspeed:run
+```
+
+## How it Works
+
+### First run
+
+1. Since we have no statistics on the first time, we run all specs and collect it;
+
+```json
+{ "file": "./spec/models/1_spec.rb", "time": 0.01 }
+{ "file": "./spec/models/2_spec.rb", "time": 0.02 }
+{ "file": "./spec/models/3_spec.rb", "time": 0.001 }
+{ "file": "./spec/models/4_spec.rb", "time": 1 }
+```
+
+### Second and next runs
+
+1. Previous statistics is balanced by times and distributed between pipes:
+
+```json
+{ "file": "./spec/models/4_spec.rb", "time": 1 }
+```
+
+```json
+{ "file": "./spec/models/2_spec.rb", "time": 0.02 }
+```
+
+```json
+{ "file": "./spec/models/3_spec.rb", "time": 0.001 }
+{ "file": "./spec/models/1_spec.rb", "time": 0.01 }
+```
+
+2. Run the current pipe `1`:
+
+```json
+{ "file": "./spec/models/4_spec.rb", "time": 1 }
+```
+
+- Collects statistics and temporary save it;
+
+4. Run the current pipe `2`:
+
+```json
+{ "file": "./spec/models/2_spec.rb", "time": 0.02 }
+```
+
+- Collects statistics and temporary save it;
+
+5. Run the current pipe `3`:
+
+```json
+{ "file": "./spec/models/3_spec.rb", "time": 0.001 }
+{ "file": "./spec/models/1_spec.rb", "time": 0.01 }
+```
+
+- Collects statistics and temporary save it;
+- Sum all the last statistics and save it for the next run;

data/lib/generators/rspeed/install_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RSpeed
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+
+    desc 'Creates RSpeed task'
+
+    def create_initializer
+      copy_file 'lib/tasks/rspeed.rake', 'lib/tasks/rspeed.rake'
+    end
+  end
+end

data/lib/generators/rspeed/templates/lib/tasks/rspeed.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rspeed'
+
+namespace :rspeed do
+  task run: :environment do
+    ::RSpeed::Runner.run ->(command) { sh command }
+  end
+end

data/lib/rspeed.rb

@@ -1,4 +1,13 @@
 # frozen_string_literal: true
 
 module RSpeed
+  require 'csv'
+
+  require 'rspeed/env'
+  require 'rspeed/extension'
+  require 'rspeed/observer'
+  require 'rspeed/redis'
+  require 'rspeed/runner'
+  require 'rspeed/splitter'
+  require 'rspeed/variable'
 end

data/lib/rspeed/env.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Env
+    module_function
+
+    def db
+      ENV['RSPEED_DB']&.to_i
+    end
+
+    def host
+      ENV['RSPEED_HOST']
+    end
+
+    def name
+      ENV['RSPEED_NAME']
+    end
+
+    def pipe
+      ENV.fetch('RSPEED_PIPE', 1).to_i
+    end
+
+    def pipes
+      RSpeed::Redis.result? ? ENV.fetch('RSPEED_PIPES', 1).to_i : 1
+    end
+
+    def port
+      ENV['RSPEED_PORT']&.to_i
+    end
+
+    def result_key
+      ENV.fetch('RESPEED_RESULT_KEY', RSpeed::Variable.result)
+    end
+
+    def rspeed
+      ENV['RSPEED'] == 'true'
+    end
+
+    def tmp_key
+      ENV.fetch('RESPEED_TMP_KEY', RSpeed::Variable.tmp)
+    end
+  end
+end

data/lib/rspeed/extension.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+if RSpeed::Env.rspeed
+  require 'rspec'
+
+  RSpec.configure do |config|
+    config.before(:suite) { RSpeed::Observer.before_suite }
+    config.before { |example| RSpeed::Observer.before(example) }
+    config.after { |example| RSpeed::Observer.after(example) }
+    config.after(:suite) { RSpeed::Observer.after_suite }
+  end
+end

data/lib/rspeed/observer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Observer
+    module_function
+
+    def after(example)
+      file_path   = example.metadata[:file_path]
+      line_number = example.metadata[:line_number]
+      spent_time  = example.clock.now - example.metadata[:start_at]
+
+      File.open(RSpeed::Variable::CSV, 'a') do |file|
+        file.write("#{spent_time},#{file_path}:#{line_number}\n")
+      end
+    end
+
+    def after_suite(splitter = ::RSpeed::Splitter.new)
+      RSpeed::Redis.set(RSpeed::Variable.pipe_name, true)
+
+      splitter.append
+
+      return unless RSpeed::Redis.specs_finished?
+
+      splitter.rename
+
+      RSpeed::Redis.clean_pipes_flag
+    end
+
+    def before(example)
+      example.update_inherited_metadata(start_at: example.clock.now)
+    end
+
+    def before_suite
+      truncate_csv_file
+
+      RSpeed::Redis.destroy(RSpeed::Variable.tmp) unless RSpeed::Redis.specs_initiated?
+    end
+
+    def truncate_csv_file
+      File.open(RSpeed::Variable::CSV, 'w') { |file| file.truncate(0) }
+    end
+  end
+end

data/lib/rspeed/redis.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Redis
+    require 'redis'
+
+    module_function
+
+    def clean_pipes_flag
+      destroy(RSpeed::Variable::PIPES_PATTERN)
+    end
+
+    def client
+      @client ||= ::Redis.new(db: RSpeed::Env.db, host: RSpeed::Env.host, port: RSpeed::Env.port)
+    end
+
+    def destroy(pattern = RSpeed::Variable::DEFAULT_PATTERN)
+      keys(pattern).each { |key| client.del(key) }
+    end
+
+    def get(key)
+      client.get(key)
+    end
+
+    def keys(pattern = RSpeed::Variable::DEFAULT_PATTERN)
+      cursor = 0
+      result = []
+
+      loop do
+        cursor, results = client.scan(cursor, match: pattern)
+        result += results
+
+        break if cursor.to_i.zero?
+      end
+
+      result
+    end
+
+    def result?
+      keys(RSpeed::Env.result_key).any?
+    end
+
+    def set(key, value)
+      client.set(key, value)
+    end
+
+    def specs_finished?
+      RSpeed::Redis.keys(RSpeed::Variable::PIPES_PATTERN).size == RSpeed::Env.pipes
+    end
+
+    def specs_initiated?
+      RSpeed::Redis.keys(RSpeed::Variable::PIPES_PATTERN).any?
+    end
+  end
+end

data/lib/rspeed/runner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Runner
+    module_function
+
+    def run(shell, splitter: ::RSpeed::Splitter.new)
+      return if splitter.redundant_run?
+
+      shell.call(['bundle exec rspec', splitter.pipe_files].compact.join(' '))
+    end
+  end
+end

data/lib/rspeed/splitter.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RSpeed
+  class Splitter
+    require 'json'
+
+    def initialize(specs_path: './spec/**/*_spec.rb')
+      @specs_path = specs_path
+    end
+
+    def actual_examples
+      @actual_examples ||= begin
+        [].tap do |examples|
+          Dir[@specs_path].sort.each do |file|
+            data     = File.open(file).read
+            lines    = data.split("\n")
+
+            lines&.each&.with_index do |item, index|
+              examples << "#{file}:#{index + 1}" if /^it/.match?(item.gsub(/\s+/, ''))
+            end
+          end
+
+          stream(:actual_examples, examples)
+        end
+      end
+    end
+
+    def append(files = CSV.read(RSpeed::Variable::CSV))
+      files.each do |time, file|
+        redis.lpush(RSpeed::Env.tmp_key, { file: file, time: time.to_f }.to_json)
+      end
+    end
+
+    def diff
+      actual_data = rspeed_data.select { |item| actual_examples.include?(item[:file]) }
+      added_data  = added_examples.map { |item| { file: item, time: 0 } }
+
+      removed_examples # called just for stream for now
+
+      actual_data + added_data
+    end
+
+    def first_pipe?
+      RSpeed::Env.pipe == 1
+    end
+
+    def get(pattern)
+      @get ||= begin
+        return redis.lrange(pattern, 0, -1) if [RSpeed::Variable.result, RSpeed::Variable.tmp].include?(pattern)
+
+        RSpeed::Redis.keys(pattern).map { |key| ::JSON.parse(redis.get(key)) }
+      end
+    end
+
+    def pipe_files
+      return unless RSpeed::Redis.result?
+
+      split[RSpeed::Variable.key(RSpeed::Env.pipe)][:files].map { |item| item[:file] }.join(' ')
+    end
+
+    def redundant_run?
+      !first_pipe? && !exists?(RSpeed::Env.result_key)
+    end
+
+    def rename
+      redis.rename(RSpeed::Env.tmp_key, RSpeed::Env.result_key)
+    end
+
+    def split(data = diff)
+      json = {}
+
+      RSpeed::Env.pipes.times do |index|
+        json[RSpeed::Variable.key(index + 1)] ||= []
+        json[RSpeed::Variable.key(index + 1)] = { total: 0, files: [], number: index + 1 }
+      end
+
+      sorted_data = data.sort_by { |item| item[:time] }.reverse
+
+      sorted_data.each do |record|
+        selected_pipe_data = json.min_by { |pipe| pipe[1][:total] }
+        selected_pipe      = json[RSpeed::Variable.key(selected_pipe_data[1][:number])]
+        time               = record[:time].to_f
+
+        selected_pipe[:total] += time
+        selected_pipe[:files] << { file: record[:file], time: time }
+      end
+
+      json
+    end
+
+    private
+
+    def added_examples
+      @added_examples ||= begin
+        (actual_examples - rspeed_examples).tap { |examples| stream(:added_examples, examples) }
+      end
+    end
+
+    # TODO: exists? does not work: undefined method `>' for false:FalseClass
+    def exists?(key)
+      redis.keys.include?(key)
+    end
+
+    def redis
+      @redis ||= ::RSpeed::Redis.client
+    end
+
+    def removed_examples
+      @removed_examples ||= begin
+        (rspeed_examples - actual_examples).tap { |examples| stream(:removed_examples, examples) }
+      end
+    end
+
+    def removed_time
+      removed_examples.sum { |item| item[0].to_f }
+    end
+
+    def rspeed_data
+      @rspeed_data ||= get(RSpeed::Env.result_key).map { |item| JSON.parse(item, symbolize_names: true) }
+    end
+
+    def rspeed_examples
+      rspeed_data.map { |item| item[:file] }
+    end
+
+    def stream(type, data)
+      puts "PIPE: #{RSpeed::Env.pipe} with #{type}: #{data}"
+    end
+  end
+end