spec_producer 0.11.0 → 0.13.0

data/lib/spec_producer/producers/controllers_producer.rb

@@ -0,0 +1,31 @@
+module SpecProducer
+  module Producers
+    class ControllersProducer
+      prepend Base
+
+      def resources
+        (ApplicationController.descendants << ApplicationController).
+        reverse.
+        map { |desc| Resource.new(desc, desc.name, 'controller') }
+      end
+
+      def call(resource)
+        resource.obj.action_methods.each do |method_name|
+          builder.pending "##{method_name}"
+        end
+
+        if resource.obj.action_methods.size == 0
+          builder.pending 'controller tests'
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/producers/helpers_producer.rb

@@ -0,0 +1,26 @@
+module SpecProducer
+  module Producers
+    class HelpersProducer
+      prepend Base
+
+      def resources
+      	ActionController::Base.modules_for_helpers(ActionController::Base.all_helpers_from_path 'app/helpers').
+        map { |desc| Resource.new(desc, desc.name, 'helper') }
+      end
+
+      def call(resource)
+        resource.obj.instance_methods.each do |method_name|
+          builder.pending method_name
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/producers/jobs_producer.rb

@@ -0,0 +1,34 @@
+module SpecProducer
+  module Producers
+    class JobsProducer
+      prepend Base
+
+      def resources
+        Dir["app/jobs/**/*.rb"].
+          map { |file| Resource.new(file, File.basename(file, ".rb").camelcase, 'job') }
+      end
+
+      def call(resource)
+        builder.subject('described_class.perform_later(123)')
+
+        builder.context('queues the job') do
+          builder.it("expect(subject).to change(ActiveJob::Base.queue_adapter.enqueued_jobs, :size).by(1)")
+        end
+
+        builder.context('is in proper queue') do
+          builder.it("expect(#{resource.name}.new.queue_name).to eq('default')")
+        end
+
+        builder.pending 'executes perform'
+      end 
+
+      #######
+      private
+      #######
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/producers/mailers_producer.rb

@@ -0,0 +1,24 @@
+module SpecProducer
+  module Producers
+    class MailersProducer
+      prepend Base
+
+      def resources
+        Dir["app/mailers/**/*.rb"].
+          map { |file| Resource.new(file, File.basename(file, ".rb").camelcase, 'mailer') }
+      end
+
+      def call(resource)
+        builder.pending 'mailer tests'
+      end
+
+      #######
+      private
+      #######
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/producers/models_producer.rb

@@ -0,0 +1,89 @@
+require 'active_record'
+
+module SpecProducer
+  module Producers
+    class ModelsProducer
+      prepend Base
+
+      # TODO Rethink this
+      CLASSES_TO_IGNORE = ['ActiveRecord::SchemaMigration', 
+                           'ApplicationRecord',
+                           'Delayed::Backend::ActiveRecord::Job',
+                           'ActiveRecord::InternalMetadata']
+
+      def resources
+        ActiveRecord::Base.descendants.reject do |descendant|
+          should_ignore?(descendant)
+        end.map { |desc| Resource.new(desc, desc.name, 'model') }
+      end
+
+      def call(resource)
+        builder.context('#respond_to?') do
+          respond_to_specs(resource.obj.attribute_names) { |attr| builder.responds_to(attr) }
+          read_only_attr_specs(resource.obj.readonly_attributes) { |attr| builder.responds_to(attr) }
+        end
+
+        if resource.obj.column_names.present?
+          builder.context('DB Columns') do
+            resource.obj.column_names.each do |column_name|
+              builder.it { has_db_column(column_name) }
+            end
+          end
+        end
+
+        if has_validators?(resource.obj)
+          builder.context 'validations' do
+            resource.obj.validators.each do |validator|
+              validator.attributes.each do |attribute|
+                builder.validates_with validator.kind, attribute
+              end
+            end
+          end
+        end
+
+        builder.context 'factories' do
+          builder.it { has_valid_factory(resource.obj.name.underscore) }
+        end
+
+        if resource.obj.reflections.keys.present?
+          builder.context 'Associations' do
+            resource.obj.reflections.each_pair do |_, reflection|
+              builder.it { has_association(reflection) }
+            end
+          end
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def respond_to_specs(attrs = [])
+        return enum_for(:attrs) unless block_given?
+        attrs.each do |attr|
+          yield(attr)
+          yield(":#{attr}=")
+        end
+      end
+
+      def read_only_attr_specs(attrs = [])
+        return enum_for(:attrs) unless block_given?
+        attrs.each do |attr|
+          yield(attr)
+        end
+      end
+
+      def has_validators?(desc)
+        desc.validators.reject { |validator| validator.kind == :associated }.present?
+      end
+
+      def should_ignore?(descendant)
+        CLASSES_TO_IGNORE.include?(descendant.to_s)
+      end
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/producers/registry.rb

@@ -0,0 +1,66 @@
+module SpecProducer
+  module Producers
+    class Registry
+      include Enumerable
+      attr_reader :registrations
+
+      delegate :any?, :empty?, :size, :length, to: :registrations
+
+      def initialize
+        @registrations = Set.new
+      end
+
+      def register(spec_type, klass)
+        registrations << Registration.new(spec_type, klass)
+      end
+
+      def each
+        return enum_for(:registrations) { registrations.size } unless block_given?
+        registrations.each { |registration| yield(registration) }
+      end
+
+      def types
+        map(&:name)
+      end
+      alias_method :registerd_types, :types
+
+      def registered?(symbol)
+        !!find_registration(symbol)
+      end
+
+      def lookup!(symbol)
+        registration = find_registration(symbol)
+
+        if registration
+          registration.call(symbol)
+        else
+          raise ArgumentError, "Unknown spec type #{symbol.inspect}"
+        end
+      end
+
+      private
+      def find_registration(symbol)
+        registrations.find { |r| r.matches?(symbol) }
+      end
+    end
+
+    class Registration
+      attr_reader :name, :klass
+
+      def initialize(name, klass)
+        @name = name
+        @klass = klass
+      end
+
+      def matches?(type_name)
+        type_name == name
+      end
+
+      def call(args)
+        klass.call(args)
+      end
+
+      protected
+    end
+  end
+end

data/lib/spec_producer/producers/routes_producer.rb

@@ -0,0 +1,44 @@
+module SpecProducer
+  module Producers
+    class RoutesProducer
+      prepend Base
+
+      def resources
+        Rails.application.routes.routes.
+        select { |route| route.defaults[:controller].present? && !/^rails/.match(route.defaults[:controller]) }.
+        map { |route| { :path => route.path.spec.to_s.gsub(/\(\.:format\)/, ""), 
+                        :verb => %W{ GET POST PUT PATCH DELETE }.grep(route.verb).first.downcase.to_sym, 
+                        :controller => route.defaults[:controller], 
+                        :action => route.defaults[:action] } }.
+        group_by { |route| route[:controller] }.
+        map { |route_group| Resource.new(route_group, route_group[0], 'routing') }
+      end
+
+      def call(resource)
+        resource.obj[1].each do |route|
+          builder.context("#{route[:verb].upcase} #{route[:path].gsub(/\(.*?\)/, '')} should route to '#{route[:controller]}##{route[:action]}'") do
+
+          route_specifics = { :controller => route[:controller], 
+                              :action => route[:action] }
+
+          route[:path].gsub(/\(.*?\)/, '').scan(/:[a-zA-Z_]+/).flatten.each do |parameter|  
+            route_specifics[parameter.gsub(':','')] = "#{parameter.gsub(':','').upcase}"
+          end
+          
+          route_requested = route[:path].gsub(/\(.*?\)/, '').gsub(/:[a-zA-Z_]+/){ |param| param.gsub(':','').upcase }
+
+          builder.it("expect(:#{route[:verb]} => '#{route_requested}').to route_to(#{route_specifics.map { |k,v| ":#{k} => '#{v}'"}.join(', ')})")
+        end
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/producers/serializers_producer.rb

@@ -0,0 +1,46 @@
+require 'active_model_serializers'
+
+module SpecProducer
+  module Producers
+    class SerializersProducer
+      prepend Base
+
+      # TODO Rethink this
+      CLASSES_TO_IGNORE = [ 'ActiveModel::Serializer::ErrorSerializer' ]
+
+      def resources
+      	ActiveModel::Serializer.descendants.reject do |descendant|
+          should_ignore?(descendant)
+        end.map { |desc| Resource.new(desc, desc.name, 'serializer') }
+      end
+
+      def call(resource)
+        builder.context('should include the expected attribute keys') do
+          builder.subject(builder.initialize_serializer_for_object resource.obj)
+
+          builder.it("expect(subject.attributes.keys).to contain_exactly(#{resource.obj._attributes.map { |x| ":#{x.to_s}" }.join(', ')})")
+        end
+
+        builder.context('to_json should have the proper values') do
+          builder.subject(builder.json_parse_for_serialized_object resource.obj)
+
+          resource.obj._attributes.each do |attribute|
+            builder.it("expect(subject['#{attribute}']).to eq('')")
+          end
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def should_ignore?(descendant)
+        CLASSES_TO_IGNORE.include?(descendant.to_s)
+      end
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/producers/views_producer.rb

@@ -0,0 +1,25 @@
+module SpecProducer
+  module Producers
+    class ViewsProducer
+      prepend Base
+
+      def resources
+        Dir["app/views/**/*.erb"].
+          map { |file| Resource.new(file, file.gsub('app/views/', ''), 'view') }
+      end
+
+      def call(resource)
+        builder.before_render
+        builder.pending 'view content test'
+      end
+
+      #######
+      private
+      #######
+
+      def require_helper_string
+        @require_helper_string ||= Utils::FileUtils.collect_helper_strings
+      end
+    end
+  end
+end

data/lib/spec_producer/railtie.rb

@@ -0,0 +1,13 @@
+require 'rails'
+
+module SpecProducer
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load 'tasks/spec_producer_tasks.rake'
+    end
+
+    initializer 'spec_producer.initialization' do
+      Rails.application.eager_load!
+    end
+  end
+end

data/lib/spec_producer/rspec_builders.rb

@@ -0,0 +1 @@
+require 'spec_producer/rspec_builders/base'

data/lib/spec_producer/rspec_builders/base.rb

@@ -0,0 +1,148 @@
+require_relative 'matchers'
+require_relative 'builder'
+module SpecProducer
+  module RspecBuilders
+    # == Spec \Producer \Rspec \Builders
+    #
+    # Provides all the the methods required to produce an RSpec string in
+    # order to create the corresponding spec files. The base class
+    # includes some methods to create a string like <tt>add</tt> method.
+    #
+    # An example on how to build a spec would be:
+    #   resource = SomeResource.new ...
+    #
+    #   def for_each_column
+    #     resource.column_names.each { |c| yield(c) }
+    #   end
+    #   def for_each_attr
+    #     resource.attributes.each { |a| ield(a) }
+    #   end
+    #
+    #   # Build the spec text
+    #   text = RspecBuilder::Base.build do |b|
+    #     b.write('require \'spec_helper\'')
+    #     b.spec(resource.class.name, 'models') do
+    #       b.subject { build(#{resource.class.name.underscore}) }
+    #       b.context '#respond_to?' do
+    #         for_each_attr do |attr|
+    #           b.responds_to(attr)
+    #         end
+    #       end
+    #       b.context 'DB columns' do
+    #         for_each_column { |c|
+    #           b.responds_to(c)
+    #         }
+    #       end
+    #       b.context 'some other context' do
+    #         b.subject { 'foo' }
+    #         b.it { expect('subject').to eq 'foo' }
+    #         context 'a nested context' do
+    #           b.subject { 'create(:user).profile' }
+    #           b.it { should_be(:present) }
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   # Write the generated text to spec_file
+    #   Utils::FileUtils.try_to_create_spec_file('models', resource.class.name.underscore, text)
+    #
+    #   puts text
+    #
+    # =>  require 'spec_helper'
+    #     describe SomeResource, type: :model do
+    #       subject { builder(:resource) }
+    #       context '#responds_to?' do
+    #         it { is_expected.to respond_to(:attr1) }
+    #         it { is_expected.to respond_to(:attr2) }
+    #       end
+    #
+    #       context 'DB columns' do
+    #         it { is_expected.to have_db_column(:email) }
+    #         it { is_expected.to respond_to(:name) }
+    #       end
+    #
+    #       context 'some other context' do
+    #         subject { 'foo' }
+    #         it { expect(subject).to eq 'foo' }
+    #
+    #         context 'a nested context' do
+    #           subject { create(:user).profile }
+    #           it { expect(subject).to be_present }
+    #         end
+    #       end
+    #     end
+    #
+    # Note that intentation is automatially done based on the current block
+    # we are.
+    class Base
+      include Matchers
+      include Builder
+
+      attr_reader :_text
+      attr_reader :intend
+      private :intend
+
+      def initialize(t = "")
+        @_text = t.to_s
+        @intend = 0
+
+        yield self if block_given?
+      end
+
+      # Adds a string to buffer. by default auto intent is handled here
+      # In order to bypas it we pas false as the current argument. For 
+      # example when we add a new line we don't want to add a n times tabs
+      #
+      def add(text, add_intent = true)
+        add_tabs if add_intent == true
+
+        _text << text
+        self
+      end
+      alias_method :<<, :add
+      alias_method :append, :add
+      alias_method :write, :add
+
+      # Flushes the current buffer to an empty String. Also reset
+      # <tt>intend</tt> count to zero.
+      #
+      def flush!
+        @_text = ""
+        @intend = 0
+      end
+
+      # Adds <tt>@_intend</tt> tabs to the buffer.
+      #
+      def add_tabs
+        intend.times { _text << '  ' }
+      end
+
+      # Adds a new line to the buffer
+      #
+      def new_line
+        add "\n", false
+      end
+
+      def to_s
+        _text
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+      # Increases and decreases the intentation counter. We increase the counter
+      # when we are on nested contexts like nested context block.
+      def increase_intent
+        @intend += 1
+      end
+
+      def decrease_intent
+        @intend -= 1
+      end
+
+    end
+  end
+end