shoulda_matchmakers 0.1.0

data/lib/model/active_record/matchmakers/delegate_method.rb

@@ -0,0 +1,101 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module DelegateMethod
+
+
+          def delegate_method_matcher_tests
+            delegate_method_occurrences = get_delegate_method_occurrences(@app_class_name)
+            if delegate_method_occurrences.present?
+              generate_delegate_method_matcher_tests(delegate_method_occurrences)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def get_delegate_method_occurrences(app_class_name)
+            delegate_method_occurrences = []
+            app_model_file_path = compose_extended_model_file_path(app_class_name)
+            if File.exists?(app_model_file_path)
+              File.open(app_model_file_path, 'r') do |app_model_file|
+                app_model_file.each_line do |app_model_file_line|
+                  if app_model_file_line =~ /^\s+delegate(?:\s*\(\s*|\s+):[A-Za-z0-9_@]+/
+                    delegate_method_occurrences = delegate_method_occurrences + get_delegate_delegate_method_occurrences(app_model_file_line)
+                  elsif app_model_file_line =~ /^\s+def(?:_instance)?_delegators?(?:\s*\(\s*|\s+):[A-Za-z0-9_@]+/
+                    delegate_method_occurrences = delegate_method_occurrences + get_def_delegate_delegate_method_occurrences(app_model_file_line)
+                  end
+                end
+              end
+            else
+              delegate_method_occurrences = []
+            end
+            delegate_method_occurrences
+          end
+
+          def get_delegate_delegate_method_occurrences(app_model_file_line)
+            delegate_delegate_method_occurrences = []
+            delegated_methods = app_model_file_line.scan(/(?:^\s+delegate(?:\s*\(\s*|\s+)|,\s*)(:[A-Za-z0-9_@]+)/).flatten
+            delegate = app_model_file_line.scan(/,\s*to:\s+(:?[A-Za-z0-9_@]+)/).flatten
+            if delegate.present? && delegated_methods.present?
+              prefix = app_model_file_line.scan(/,\s*prefix:\s+(:?[A-Za-z0-9_@]+)/).flatten
+              arguments = app_model_file_line.scan(/,\s*([A-Za-z0-9_@]+:\s+:?[A-Za-z0-9_@]+)/)
+              arguments = arguments.flatten.reject{ |argument| argument =~ /^to:/ || argument =~ /^prefix:/ }
+              delegated_methods.each do |delegated_method|
+                delegate_method_hash = { delegate: delegate[0], method: delegated_method, prefix: "", arguments: [] }
+                delegate_method_hash[:prefix] = prefix[0] if prefix.present?
+                delegate_method_hash[:arguments] = arguments if arguments.present?
+                delegate_delegate_method_occurrences = append_element(delegate_method_hash, delegate_delegate_method_occurrences)
+              end
+            end
+            delegate_delegate_method_occurrences
+          end
+
+          def get_def_delegate_delegate_method_occurrences(app_model_file_line)
+            def_delegate_delegate_method_occurrences = []
+            delegate = app_model_file_line.scan(/^\s+def(?:_instance)?_delegators?(?:\s*\(\s*|\s+)(:[A-Za-z0-9_@]+)/).flatten
+            delegated_methods = app_model_file_line.scan(/,\s*(:[A-Za-z0-9_@]+)/).flatten
+            if delegate.present? && delegated_methods.present?
+              delegated_methods.each do |delegated_method|
+                delegate_method_hash = { delegate: delegate[0], method: delegated_method, prefix: "", arguments: [] }
+                def_delegate_delegate_method_occurrences = append_element(delegate_method_hash, def_delegate_delegate_method_occurrences)
+              end
+            end
+            def_delegate_delegate_method_occurrences
+          end
+
+          def generate_delegate_method_matcher_tests(delegate_method_occurrences)
+            delegate_method_tests = []
+            delegate_method_occurrences.sort_by!{ |dmo| [dmo[:method], dmo[:delegate], dmo[:prefix], dmo[:arguments]] }
+            delegate_method_occurrences = delegate_method_occurrences.uniq
+            delegate_method_occurrences.each do |delegate_method_occurrence|
+              delegate_method_test = generate_delegate_method_test(delegate_method_occurrence)
+              delegate_method_tests = append_element(delegate_method_test, delegate_method_tests)
+            end
+            format_tests(delegate_method_tests)
+          end
+
+          def generate_delegate_method_test(delegate_method_occurrence)
+            delegate_method_test = "  it { is_expected.to delegate_method(#{ delegate_method_occurrence[:method] }).to(#{ delegate_method_occurrence[:delegate] })"
+            if delegate_method_occurrence[:prefix].present?
+              delegate_method_test.concat(".with_prefix(#{ delegate_method_occurrence[:prefix] })")
+            end
+            if delegate_method_occurrence[:arguments].present?
+              delegate_method_test.concat(".with_arguments(")
+              delegate_method_occurrence[:arguments].each do |delegate_method_argument|
+                delegate_method_test.concat("#{ delegate_method_argument }, ")
+              end
+              delegate_method_test.chomp!(", ").concat(")")
+            end
+            delegate_method_test.concat(" }")
+          end
+
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/have_db_column.rb

@@ -0,0 +1,33 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module HaveDbColumn
+
+
+          def have_db_column_matcher_tests
+            db_columns = @app_class_name.constantize.columns
+            if db_columns.present?
+              generate_have_db_column_matcher_tests(db_columns)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_have_db_column_matcher_tests(db_columns)
+            db_column_tests = []
+            db_columns.each do |db_column|
+              db_column_test = "  it { is_expected.to have_db_column(:#{ db_column.name }).of_type(:#{ db_column.type }) }"
+              db_column_tests = append_element(db_column_test, db_column_tests)
+            end
+            format_tests(db_column_tests)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/have_db_index.rb

@@ -0,0 +1,39 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module HaveDbIndex
+
+          def have_db_index_matcher_tests
+            # IMPLEMENTATION TODO: Determine if it is possible to indexes where 'using=:gin' (or anything not :btree)
+            db_indexes = ::ActiveRecord::Base.connection.indexes(@app_class_name.tableize.gsub("/", "_")).select{ |ndx| ndx.using == :btree }
+            if db_indexes.present?
+              generate_have_db_index_matcher_tests(db_indexes)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_have_db_index_matcher_tests(db_indexes)
+            db_index_tests = []
+            db_indexes.map do |ndx|
+              if ndx.columns.length == 1
+                db_index_test = "  it { is_expected.to have_db_index(:#{ ndx.columns[0] })"
+              else
+                db_index_test = "  it { is_expected.to have_db_index(#{ ndx.columns.map { |c| c.to_sym } })"
+              end
+              db_index_test.concat(".unique") if ndx.unique
+              db_index_test.concat(" }")
+              db_index_tests = append_element(db_index_test, db_index_tests)
+            end
+            format_tests(db_index_tests)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/have_readonly_attribute.rb

@@ -0,0 +1,32 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module HaveReadonlyAttribute
+
+          def have_readonly_attribute_matcher_tests
+            readonly_attributes = @app_class_name.constantize.readonly_attributes
+            if readonly_attributes.present?
+              generate_have_readonly_attribute_matcher_tests(readonly_attributes)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_have_readonly_attribute_matcher_tests(readonly_attributes)
+            readonly_attribute_tests = []
+            readonly_attributes.each do |attribute|
+              readonly_attribute_test = "  it { is_expected.to have_readonly_attribute(:#{ attribute }) }"
+              readonly_attribute_tests = append_element(readonly_attribute_test, readonly_attribute_tests)
+            end
+            format_tests(readonly_attribute_tests)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/have_secure_password.rb

@@ -0,0 +1,32 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module HaveSecurePassword
+
+          def have_secure_password_matcher_tests
+            model_methods = @app_class_name.constantize.methods
+            model_instance_methods = @app_class_name.constantize.instance_methods
+            if model_methods.present? && model_instance_methods.present?
+              generate_have_secure_password_matcher_tests(model_methods, model_instance_methods)
+            else
+              []
+            end
+         end
+
+
+          private
+
+          def generate_have_secure_password_matcher_tests(model_methods, model_instance_methods)
+            secure_password_test = ""
+            if model_instance_methods.include?(:password_digest) && model_methods.exclude?(:devise_parameter_filter)
+              secure_password_test = "  it { is_expected.to have_secure_password }"
+            end
+            secure_password_test
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/serialize.rb

@@ -0,0 +1,67 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module Serialize
+
+
+          def serialize_matcher_tests
+            serialized_attributes = @app_class_name.constantize.serialized_attributes
+            if serialized_attributes.present?
+              generate_serialize_matcher_tests(serialized_attributes)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_serialize_matcher_tests(serialized_attributes)
+            serialize_tests = []
+            serialized_attributes.map do |attribute, cast_type|
+              object_class = cast_type.try(:object_class)
+              if %w(Array Hash Object).include?(object_class.to_s) || (object_class == nil && cast_type.to_s.include?("JSON"))
+                serialize_test = generate_serialize_test(attribute, object_class)
+                serialize_tests = append_element(serialize_test, serialize_tests)
+              else
+                custom_serialize_test = generate_custom_serialize_test(attribute, cast_type, object_class)
+                serialize_tests = append_element(custom_serialize_test, serialize_tests)
+              end
+            end
+            format_tests(serialize_tests)
+          end
+
+          def generate_serialize_test(attribute, object_class)
+            case object_class.to_s
+            when "Array", "Hash"
+              serialize_test = "  it { is_expected.to serialize(:#{ attribute }).as(#{ object_class }) }"
+            when "Object"
+              serialize_test = "  it { is_expected.to serialize(:#{ attribute }) }"
+            else
+              serialize_test = "  it { is_expected.to serialize(:#{ attribute }).as(JSON) }"
+            end
+            serialize_test
+          end
+
+          def generate_custom_serialize_test(attribute, cast_type, object_class)
+            if object_class == nil
+              custom_serializer_class = cast_type.to_s
+              custom_serializer_class = custom_serializer_class.gsub(/#\</, "").gsub(/:.*\z/, "") if cast_type.to_s.include?("#<")
+              custom_serialize_test = "  it { is_expected.to serialize(:#{ attribute }).as(#{ custom_serializer_class }) }"
+            else
+              custom_serializer_class = object_class.to_s
+              custom_serializer_class = custom_serializer_class.gsub(/#\</, "").gsub(/:.*\z/, "") if object_class.to_s.include?("#<")
+              custom_serialize_test = "  it { is_expected.to serialize(:#{ attribute }).as_instance_of(#{ custom_serializer_class }) }"
+            end
+            if custom_serialize_test.length > @working_generated_code_line_length
+              custom_serialize_test = custom_serialize_test.sub("  it { ", "  it do\n    ").sub(").as", ").\n      as").sub("}) }", "})\n  end")
+            end
+            custom_serialize_test
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/validations.rb

@@ -0,0 +1,169 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module Validations
+
+
+          def validator_matcher_tests(validation_type)
+            validators = extract_validators(@app_class_name, validation_type)
+            if validators.present?
+              generate_validation_matcher_tests(validators)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_validation_matcher_tests(validators)
+            validation_tests = []
+            validators.map do |validator|
+              if conditional_options_exist(validator.options)
+                conditional_validation_tests = generate_conditional_validation_tests(validator)
+                validation_tests = validation_tests + conditional_validation_tests
+              else
+                validation_test = generate_validation_test(validator, validator.options)
+                validation_tests = append_element(validation_test, validation_tests)
+              end
+            end
+            format_tests(validation_tests)
+          end
+
+          def generate_validation_test(validator, validator_options)
+            validation_test = "  it { is_expected.to validate_#{ validator.kind.to_s }_of(:#{ validator.attributes.first.to_s })"
+            if (validator.kind == :exclusion || validator.kind == :inclusion) && custom_exclusion_inclusion_test_required(validator_options)
+              validation_test.sub!("  it {", "  xit {")
+              custom_exclusion_inclusion_test_comment = get_custom_exclusion_inclusion_test_comment(validator_options)
+              validation_test.prepend(custom_exclusion_inclusion_test_comment).concat(" }")
+            else
+              if validator.kind == :exclusion || validator.kind == :inclusion
+                refined_validator_options = refine_exclusion_inclusion_non_conditional_option(validator_options)
+              else
+                refined_validator_options = validator_options
+              end
+              validator_options_string = get_options_string(refined_validator_options)
+              validation_test.concat(validator_options_string + " }")
+              if validation_test.length > @working_generated_code_line_length
+                validation_test = generate_validation_test_multiple_lines(validator, validator_options_string)
+              end
+            end
+            validation_test
+          end
+
+          def generate_validation_test_multiple_lines(validator, validator_options_string)
+            validation_test = "  it do\n    is_expected.to validate_#{ validator.kind.to_s }_of(:#{ validator.attributes.first })"
+            validator_options_string = validator_options_string.gsub(".", ".\n      ")
+            validation_test.concat(validator_options_string).concat("\n  end")
+          end
+
+          def generate_conditional_validation_tests(validator)
+            conditional_validation_tests = []
+            validator_options = parse_validator_options(validator.options.dup)
+            if (validator.kind == :exclusion || validator.kind == :inclusion) && validator_options[:non_conditional_options].present?
+              validator_options[:non_conditional_options] = refine_exclusion_inclusion_non_conditional_option(validator_options[:non_conditional_options])
+            end
+            if all_option_values_are_symbols(validator_options[:if_option_values]) &&
+                all_option_values_are_symbols(validator_options[:unless_option_values])
+              conditional_validating_test = generate_conditional_validating_test(validator, validator_options)
+              conditional_validation_tests = append_element(conditional_validating_test, conditional_validation_tests)
+              conditional_non_validating_tests = generate_conditional_non_validating_tests(validator, validator_options)
+              conditional_validation_tests = conditional_validation_tests + conditional_non_validating_tests
+            # else
+              # Skip tests due to non-symbol conditions (see below)
+            end
+            conditional_validation_tests
+          end
+
+          def generate_conditional_validating_test(validator, validator_options)
+            conditional_validating_test = compose_conditional_validating_context_string(validator_options)
+            validating_permutation = get_validating_true_false_permutation(validator_options)
+            conditional_validating_test.concat(compose_conditional_before_strings(validator_options, validating_permutation))
+            validating_test = generate_validation_test(validator, validator_options[:non_conditional_options])
+            validating_test = adjust_conditional_test_indentation(validating_test)
+            conditional_validating_test.concat(validating_test).concat("\n  end").prepend("# Conditional validating test\n#\n")
+          end
+
+          def generate_conditional_non_validating_tests(validator, validator_options)
+            conditional_non_validating_tests = []
+            possible_conditional_permutations = get_possible_true_false_permutations(validator_options)
+            validating_permutation = get_validating_true_false_permutation(validator_options)
+            non_validating_permutations = possible_conditional_permutations - [validating_permutation]
+            non_validating_permutations.each do |non_validating_permutation|
+              conditional_non_validating_test = generate_conditional_non_validating_test(validator, validator_options, non_validating_permutation)
+              conditional_non_validating_tests << conditional_non_validating_test
+            end
+            if validator.options.key?(:unless)
+              conditional_non_validating_tests[0] = conditional_non_validating_tests[0].prepend("# For more natural readability of 'is_expected.not_to' context lines, 'unless' is represented by 'if not'\n# and 'unless not' is represented by 'if'.\n#\n")
+            end
+            conditional_non_validating_tests[0] = conditional_non_validating_tests[0].prepend("# Conditional non-validating test(s)\n#\n")
+            conditional_non_validating_tests
+          end
+
+          def generate_conditional_non_validating_test(validator, validator_options, non_validating_permutation)
+            conditional_non_validating_test = compose_conditional_non_validating_context_string(validator_options, non_validating_permutation)
+            conditional_non_validating_test.concat(compose_conditional_before_strings(validator_options, non_validating_permutation))
+            non_validating_test = generate_validation_test(validator, validator_options[:non_conditional_options])
+            non_validating_test.sub!("is_expected.to","is_expected.not_to")
+            non_validating_test = adjust_conditional_test_indentation(non_validating_test)
+            conditional_non_validating_test.concat(non_validating_test)
+            conditional_non_validating_test.concat("\n  end")
+          end
+
+          def custom_exclusion_inclusion_test_required(exclusion_inclusion_option)
+            exclusion_inclusion_enumerable = exclusion_inclusion_option[:in] || exclusion_inclusion_option[:within]
+            if exclusion_inclusion_enumerable.is_a?(Array) || exclusion_inclusion_enumerable.is_a?(Range)
+              false
+            else
+              true
+            end
+          end
+
+          def get_custom_exclusion_inclusion_test_comment(exclusion_inclusion_option)
+            exclusion_inclusion_enumerable = exclusion_inclusion_option[:in] || exclusion_inclusion_option[:within]
+            # CONFIRMATION TODO: Confirm whether or not enumerable could be a 'Proc' that isn't a 'lambda'
+            custom_exclusion_inclusion_test_comment = if exclusion_inclusion_enumerable.lambda?
+                                                        "# Note: Your 'in:/within:' configuration option value is a 'Lambda'." +
+                                                        " You will need to implement a customized test.\n"
+                                                      elsif exclusion_inclusion_enumerable.respond_to?(:call)
+                                                        "# Note: Your 'in:/within:' configuration option value is a 'Proc'." +
+                                                        " You will need to implement a customized test.\n"
+                                                      else
+                                                        "# Alert: Invalid 'in:/within:' enumerable object type: '#{ exclusion_enumerable.class.name.to_s }'\n" +
+                                                        "#        Valid exclusion 'in:/within:' enumerable object types: 'Array', 'Range'" +
+                                                        " (or a proc, lambda or symbol which returns an enumerable)\n"
+                                                      end
+            custom_exclusion_inclusion_test_comment.concat("# Remove the 'x' from 'xit' once test customization has been implemented.\n")
+          end
+
+          def refine_exclusion_inclusion_non_conditional_option(exclusion_inclusion_option)
+            refined_exclusion_inclusion_option = {}
+            exclusion_inclusion_enumerable = exclusion_inclusion_option[:in] || exclusion_inclusion_option[:within]
+            if exclusion_inclusion_enumerable.is_a?(Array)
+              refined_exclusion_inclusion_option = { in_array: exclusion_inclusion_enumerable }
+            elsif exclusion_inclusion_enumerable.is_a?(Range)
+              refined_exclusion_inclusion_option = { in_range: exclusion_inclusion_enumerable }
+            end
+            refined_exclusion_inclusion_option
+          end
+
+        end
+      end
+    end
+  end
+end
+
+# else
+  # Skip tests due to non-symbol conditions (see below)
+  # validator.attributes.map do |attribute|
+  #   skip = true
+  #   presence_test = generate_presence_test_single_line(validator_options, attribute, skip)
+  #   if presence_test[0].length > 100 || validator_options.count > 1
+  #     presence_test = generate_presence_test_multiple_lines(validator_options, attribute, skip)
+  #   end
+  #   presence_test_comment = "  # This test is currently skipped due to if: and/or unless: conditions that aren't symbols.\n"
+  #   presence_test_comment.concat("  # Provide ")
+  #   presence_test.prepend(presence_test_comment)
+  #   presence_tests << presence_test
+  # end