test_generator 1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e7909cf0b3c6a8fdf7e19e25ffd386e52ffdbce97924609d33d7c9b26046d6f9
+  data.tar.gz: 2a103ab5ac36e823cda0bd6d312523440765c8d0983a92d194e16e08e9ab3a0c
+SHA512:
+  metadata.gz: 5421450d717d4fe6044cb9d2dbf79ab389e1a16322123d4c40fec91fe49e19155053acacf566beaf4929fd6e187f1a1ffc570d059551218476ff56a6dceac4a8
+  data.tar.gz: bbf3b9d80c25c4c69a85d991cb092401b1f415bf841fa9e56058bcafcb52367a661754e9cdf2c9f9482d25535e4d083897839e9d5c47bff971ace4f34896fbd6

data/lib/ext/string.rb

@@ -0,0 +1,47 @@
+class String
+  # strings de cada classe de equivalência para testes
+  INT_STRING = "3"
+  EMAIL_STRING = "genaina@email.com"
+  FLOAT_STRING = "3.14"
+  PHONE_STRING = "(61) 98999-9999"
+  DATE_STRING = "12/01/1997"
+
+  CUSTOM_METHODS = %w(is_i? is_email? is_float? is_phone? is_date?)
+
+  EQUIVALENCE_CLASSES = {
+    "is_i?" => "INTEGER",
+    "is_email?" => "EMAIL",
+    "is_float?" => "FLOAT",
+    "is_phone?" => "PHONE",
+    "is_date?" => "DATE",
+  }
+
+  STRINGS_EQUIVALENCE_CLASSES = {
+      "is_i?" => String::INT_STRING,
+      "is_email?" => String::EMAIL_STRING,
+      "is_float?" => String::FLOAT_STRING,
+      "is_phone?" => String::PHONE_STRING,
+      "is_date?" => String::DATE_STRING,
+  }
+
+  def is_i?
+    /\A[-+]?\d+\z/ === self
+  end
+
+  def is_email?
+    /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i === self
+  end
+
+  def is_float?
+    self.to_f.to_s === self
+  end
+
+  def is_phone?
+    /^\([1-9]{2}\) (?:[2-8]|9[1-9])[0-9]{3}\-[0-9]{4}$/ === self ||
+        /^\([1-9]{2}\)(?:[2-8]|9[1-9])[0-9]{3}\-[0-9]{4}$/ === self
+  end
+
+  def is_date?
+
+  end
+end

data/lib/generators/equivalence_class_generator.rb

@@ -0,0 +1,64 @@
+require 'rails/generators/base'
+class EquivalenceClassGenerator < Rails::Generators::Base
+  def create_equivalence_class_tests
+    require 'json'
+    require 'reflector'
+    class_name = args[0]
+    file_name = class_name.downcase
+    puts "criando testes unitarios para #{class_name}..."
+    is_controller = /.*Controller$/.match?(class_name)
+    class_type = "model"
+
+    template = %Q{require 'rails_helper'
+
+RSpec.describe #{class_name}, :type => :#{class_type} do
+}
+    equivalence_class_counter = {}
+    File.readlines("#{Rails.root}/tmp/#{class_name}.rb").each do |line|
+      json_string = JSON.parse(line.strip)
+      puts "\nReflecting..."
+      reflector = Reflect::Reflector.new
+      klass = json_string["klass"]
+      meth = json_string["method"]
+      cs = json_string["current_state"]
+      args = json_string["args"]
+      class_and_method_name = "#{klass}::#{meth}"
+
+      equivalence_class_counter[meth] ||= {}
+      args.each do |arg|
+        String::CUSTOM_METHODS.each do |equivalence_class_method|
+          respond_to_eq_class = arg.send(equivalence_class_method) # testa pra ver se responde à alguma classe de equivalencia
+          if respond_to_eq_class # se responder à classe, adiciona 1 ao contador daquela classe
+            if equivalence_class_counter[meth][equivalence_class_method].nil?
+              equivalence_class_counter[meth][equivalence_class_method] = 1
+            else
+              equivalence_class_counter[meth][equivalence_class_method] += 1
+            end
+          end
+        end
+      end
+
+    end
+
+    equivalence_class_counter.each do |method,stats| # pega o hash com os métodos e as estatísticas de cada
+      probabily_class =  stats.max_by{|k,v| v}
+      template_aux = %Q{
+  describe '##{method}_equivalence_class' do
+    # #{probabily_class.last} entries with this class
+    it "arguments should belong to #{String::EQUIVALENCE_CLASSES[probabily_class.first]} equivalence class" do
+      expect(#{class_name.capitalize}).to receive(:#{method}).with("#{String::STRINGS_EQUIVALENCE_CLASSES[probabily_class.first]}")
+      User.find_by_email_address("#{String::STRINGS_EQUIVALENCE_CLASSES[probabily_class.first]}")
+    end
+  end
+      }
+      template.concat(template_aux)
+    end
+    puts equivalence_class_counter
+
+    template.concat(%Q{
+end
+                    })
+
+    create_file "spec/#{class_type}s/#{file_name}_equiv_spec.rb", template
+  end
+end

data/lib/generators/unit_test_generator.rb

@@ -0,0 +1,120 @@
+require 'rails/generators/base'
+class UnitTestGenerator < Rails::Generators::Base
+  def create_unit_tests
+    require 'json'
+    require 'reflector'
+    class_name = args[0]
+    file_name = class_name.downcase
+    puts "criando testes unitarios para #{class_name}..."
+    is_controller = /.*Controller$/.match?(class_name)
+    class_type = "model"
+    first_line = File.open("#{Rails.root}/tmp/#{class_name}.rb", &:readline)
+    sample_object = JSON.parse(first_line)["current_state"]
+
+    executed_methods = []
+    executed_arguments = {}
+    if is_controller
+      class_type = "controller"
+      template = %Q{require 'rails_helper'
+
+RSpec.describe #{class_name}, :type => :#{class_type} do
+}
+      File.readlines("#{Rails.root}/tmp/#{class_name}.rb").each do |line|
+        json_string = JSON.parse(line.strip)
+        puts "\nReflecting..."
+        reflector = Reflect::Reflector.new
+        klass = json_string["klass"]
+        meth = json_string["method"]
+        cs = json_string["current_state"]
+        args = json_string["args"]
+        class_and_method_name = "#{klass}::#{meth}"
+        if executed_methods.include?(class_and_method_name)
+          if executed_arguments[class_and_method_name.to_sym].include?(args)
+            # do nothing, same test
+          else
+            # same test with other arguments
+            executed_arguments[class_and_method_name.to_sym].push(args)
+          end
+        else # other test for other method
+          executed_methods.push(class_and_method_name)
+          executed_arguments[class_and_method_name.to_sym] = []
+          puts "Executando #{klass}::#{meth} com argumentos #{args} no objeto #{sample_object}"
+          reflection = reflector.reflect(klass, meth, sample_object, args)
+          puts "Resultado: #{reflection}"
+          print "\n"
+
+          template_aux = %Q{
+  describe 'GET #{meth}' do
+    it 'returns a successful response' do
+      get :#{meth}
+      expect(response).to be_successful
+    end
+
+    it 'renders the #{meth} template' do
+      get :#{meth}
+      expect(response).to render_template("#{meth}")
+    end
+  end
+      }
+          template.concat(template_aux)
+        end
+      end
+
+      template.concat(%Q{
+end
+                    })
+    else
+      template = %Q{require 'rails_helper'
+
+RSpec.describe #{class_name}, :type => :#{class_type} do
+  let(:#{file_name}) { #{class_name}.new(#{sample_object}) }
+
+  it "is valid with valid attributes" do
+    expect(#{file_name}).to be_valid
+  end
+}
+      File.readlines("#{Rails.root}/tmp/#{class_name}.rb").each do |line|
+        json_string = JSON.parse(line.strip)
+        puts "\nReflecting..."
+        reflector = Reflect::Reflector.new
+        klass = json_string["klass"]
+        meth = json_string["method"]
+        cs = json_string["current_state"]
+        args = json_string["args"]
+        class_and_method_name = "#{klass}::#{meth}"
+        if executed_methods.include?(class_and_method_name)
+          if executed_arguments[class_and_method_name.to_sym].include?(args)
+            # do nothing, same test
+          else
+            # same test with other arguments
+            executed_arguments[class_and_method_name.to_sym].push(args)
+          end
+        else # other test for other method
+          executed_methods.push(class_and_method_name)
+          executed_arguments[class_and_method_name.to_sym] = []
+          puts "Executando #{klass}::#{meth} com argumentos #{args} no objeto #{sample_object}"
+          reflection = reflector.reflect(klass, meth, sample_object, args)
+          puts "Resultado: #{reflection}"
+          print "\n"
+
+          template_aux = %Q{
+  describe '##{meth}' do
+    it "should return valid string for method #{meth}" do
+      expect(#{class_name.downcase}.#{meth}(#{args.join(', ')})).to eq "#{reflection}"
+    end
+  end
+      }
+          template.concat(template_aux)
+        end
+      end
+
+      template.concat(%Q{
+end
+                    })
+    end
+
+    create_file "spec/#{class_type}s/#{file_name.sub('controller', '_controller')}_spec.rb", template
+
+    puts "Testes criados."
+  end
+end

data/lib/reflector.rb

@@ -0,0 +1,16 @@
+module Reflect
+  class Reflector
+    def reflect(klass, method, attributes, args)
+      if attributes.nil?
+        @instance = Object.const_get(klass).new
+      else
+        @instance = Object.const_get(klass).new(attributes)
+      end
+      if Object.const_get(klass).respond_to?(method) # class method
+        Object.const_get(klass).send(method, *args)
+      else
+        @instance.send(method, *args)
+      end
+    end
+  end
+end

data/lib/templates/aspects.rb

@@ -0,0 +1,58 @@
+require 'aquarium'
+include Aquarium::Aspects
+
+# Load Rails constants
+Rails.application.eager_load!
+
+# Get Rails models and controllers classes
+controllers = ApplicationController.subclasses
+models = ApplicationRecord.subclasses
+
+puts "Aspects initialized"
+
+Aspect.new(:around,
+           calls_to: :all_methods,
+           for_types: models + controllers,
+           method_options: [:exclude_ancestor_methods, :class]) do |jp, obj, *args|
+  begin
+    # Get class
+    klass = jp.target_type.name.constantize
+    # puts klass
+
+    # List all klass public instance methods
+    if models.include? klass
+      public_instance_methods = (klass.public_instance_methods - Object.public_instance_methods).sort
+      # puts public_instance_methods
+    end
+
+    # Get method
+    method = jp.method_name.to_sym
+    # puts method
+
+    # Get object current state
+    if models.include? klass
+      if obj.class == Class
+      else
+        current_state = obj.attributes
+      end
+      # puts current_state
+    end
+
+    # Create temp file
+    file_name ="#{Rails.root}/tmp/#{klass.to_s}.rb"
+
+    file = File.new(file_name, 'a')
+
+    str = "{ \"klass\": \"#{klass}\", \"method\": \"#{method}\", \"args\": #{args.inspect}, \"current_state\": #{current_state.to_json} }"
+
+    unless File.open(file_name).each_line.any? { |line| line.include?(str)}
+      file.puts str
+    end
+
+    jp.proceed
+  ensure
+    if file
+      file.close
+    end
+  end
+end

data/lib/test_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/base'
+
+module TestGenerator
+  class InstallGenerator < Rails::Generators::Base
+    desc "Creates a aspects initializer file."
+    def create_aspect_initialize_file
+      template = File.read('./templates/aspects.rb')
+      create_file "config/initializers/aspects.rb", template
+
+      puts "Aspects Initializer created."
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: test_generator
+version: !ruby/object:Gem::Version
+  version: '1.1'
+platform: ruby
+authors:
+- Nicholas Marques
+- Rafael Fernandes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: cucumber-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aquarium
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem will track everything users do in the system and map it into
+  controllers and model methods beeing called, and generate tests for them
+email:
+- nnmarques97@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ext/string.rb
+- lib/generators/equivalence_class_generator.rb
+- lib/generators/unit_test_generator.rb
+- lib/reflector.rb
+- lib/templates/aspects.rb
+- lib/test_generator.rb
+homepage: https://github.com/NickNish09/TestGenerator
+licenses: []
+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: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Auto generate tests based on system usage and BDD.
+test_files: []