faccts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ab5b68cc81737ad2a9de3e64778e6a17f3174e70ef2b361c1deeb8749c6d4ae
+  data.tar.gz: 2b9568a2176536a7f4121304d8009ba76590f105ca12e7f99eef6c5d12d81fcb
+SHA512:
+  metadata.gz: 664e60d3cd0143b32705fbe1851dd9a5bc8a45b6662cd4b14bc36720e675390cbc1a066d01e61c0032ed456d28567daf4f1faec3c6ca7f94089bcfe76b28ce61
+  data.tar.gz: 813a429fd451bcaeb540dd2daf36c07a559ba3dc006fc6832be919bfc583497bf5dc9d5561f0c940221b947b183523071147e4998055f4f6a55f7856459be195

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/faccts

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+require "faccts"
+
+Faccts::BasicAcceptanceTester.new.run!

data/lib/faccts/01_loading_test_specification/file_reader.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Faccts
+  class YAMLFileReader
+    TARGET_FILE_PATH = "./acceptance_tests.yaml"
+
+    def read_file!
+      raise FileNotFoundError unless file_exists?
+
+      target_file_contents
+    end
+
+    class FileNotFoundError < ::StandardError
+      ERROR_MESSAGE = "Cannot find acceptance test specification file '#{TARGET_FILE_PATH}'".freeze
+
+      def initialize(_msg = "")
+        super(ERROR_MESSAGE)
+      end
+    end
+
+    private
+
+    def file_exists?
+      File.exist?(TARGET_FILE_PATH)
+    end
+
+    def target_file_contents
+      File.read(TARGET_FILE_PATH)
+    end
+  end
+end

data/lib/faccts/02_parsing_test_specification/yaml_assertion_specification_parser.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Faccts
+  class YAMLTestParser
+    class YAMLTestAssertionParser
+      class AssertionSpecificationParser
+        def parse(assertion_name_specification)
+          assertion, remaining_specification = extract_assertion_up_to_first_argument(assertion_name_specification)
+
+          return assertion if remaining_specification.nil?
+
+          assertion.combined_with(parse(remaining_specification))
+        end
+
+        def extract_assertion_up_to_first_argument(assert_specification)
+          @specification = assert_specification
+
+          return no_argument_assertion unless specification_contains_argument?
+
+          [extracted_assertion_up_to_first_argument, unextracted_specification]
+        end
+
+        private
+
+        attr_reader :specification
+
+        def no_argument_assertion
+          assertion = Faccts::TestAssertion.new
+
+          assertion.action_name = specification
+          assertion.arguments = []
+
+          assertion
+        end
+
+        def specification_contains_argument?
+          spec_contains_an_open_and_close_wrapper_character?
+        end
+
+        def spec_contains_an_open_and_close_wrapper_character?
+          specification.length > 1 && specification.count(ARGUMENT_WRAPPER_CHAR) > 1
+        end
+
+        def extracted_assertion_up_to_first_argument
+          assertion = Faccts::TestAssertion.new
+
+          assertion.action_name = specification_before_open_wrapper_char + ARGUMENT_NAME_PLACEHOLDER
+          assertion.arguments = [value_between_open_and_close_wrapper_chars]
+
+          assertion
+        end
+
+        def specification_before_open_wrapper_char
+          specification[...open_wrapper_index]
+        end
+
+        def open_wrapper_index
+          specification.index(ARGUMENT_WRAPPER_CHAR)
+        end
+
+        def value_between_open_and_close_wrapper_chars
+          specification[index_after_open_wrapper...close_wrapper_index]
+        end
+
+        def index_after_open_wrapper
+          open_wrapper_index + 1
+        end
+
+        def close_wrapper_index
+          specification_after_open_wrapper = specification[index_after_open_wrapper..]
+
+          index_after_open_wrapper \
+            + specification_after_open_wrapper.index(ARGUMENT_WRAPPER_CHAR)
+        end
+
+        def unextracted_specification
+          specification_after_first_argument
+        end
+
+        def specification_after_first_argument
+          index_after_close_wrapper = close_wrapper_index + 1
+
+          specification[index_after_close_wrapper..]
+        end
+      end
+    end
+  end
+end

data/lib/faccts/02_parsing_test_specification/yaml_test_assertion_parser.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Faccts
+  class YAMLTestParser
+    class YAMLTestAssertionParser
+      ARGUMENT_WRAPPER_CHAR = "\""
+      ARGUMENT_NAME_PLACEHOLDER = "X"
+      ASSERTION_NODE_NAME = "assert"
+
+      def initialize(assertion_specification_parsing_strategy)
+        @assertion_specification_parser = assertion_specification_parsing_strategy
+      end
+
+      def parse(assertion_specification)
+        @assertion_specification = assertion_specification
+
+        generated_assertion = assertion_specification_parser.parse(assertion_name_specification)
+        generated_assertion.name = test_name
+
+        generated_assertion
+      end
+
+      private
+
+      attr_reader :assertion_specification_parser, :assertion_specification
+
+      def assertion_name_specification
+        assertion_specification[test_name][ASSERTION_NODE_NAME]
+      end
+
+      def test_name
+        assertion_specification.keys[0]
+      end
+    end
+  end
+end

data/lib/faccts/02_parsing_test_specification/yaml_test_parser.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Faccts
+  class YAMLTestParser
+    TEST_SUITE_ROOT_NODE_NAME = "tests"
+    ASSERTION_NODE_NAME = "assert"
+
+    def initialize(test_assertion_parser_strategy)
+      @parser = StandardYAMLParser.new
+      @test_assertion_extractor = TestAssertionExtractor.new(test_assertion_parser_strategy)
+    end
+
+    def create_tests!(test_specification_yaml)
+      @test_specification = parser.parse_tests!(test_specification_yaml)
+
+      validate_specification!
+
+      assertions = test_assertions_from_specification
+
+      raise NoTestsGivenError if assertions.empty?
+
+      assertions
+    rescue ::Psych::Exception => e
+      raise InvalidYAMLError, e.message
+    end
+
+    class NoTestsGivenError < ::StandardError
+      ERROR_MESSAGE = "Cannot generate acceptance tests - no tests have been specified!"
+
+      def initialize(assertion_name = "")
+        super(ERROR_MESSAGE % assertion_name)
+      end
+    end
+
+    class InvalidYAMLError < ::StandardError
+      ERROR_MESSAGE = "Cannot parse acceptance tests file"
+      ERROR_TEMPLATE = "#{ERROR_MESSAGE} - %s".freeze
+
+      def initialize(parse_failure_message = "")
+        if parse_failure_message == ""
+          super(ERROR_MESSAGE)
+        else
+          super(ERROR_TEMPLATE % parse_failure_message)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :parser, :test_specification, :test_assertion_extractor
+
+    def validate_specification!
+      raise NoTestsGivenError if test_specification.nil?
+      raise NoTestsGivenError if tests.nil?
+      raise NoTestsGivenError unless tests.respond_to? :keys
+    end
+
+    def test_assertions_from_specification
+      all_test_names
+        .map { |test_name| test_assertion_extractor.from_test_name(tests, test_name) }
+        .compact
+    end
+
+    def all_test_names
+      tests.keys
+    end
+
+    def tests
+      test_specification[TEST_SUITE_ROOT_NODE_NAME]
+    end
+
+    class TestAssertionExtractor
+      def initialize(test_assertion_parser_strategy)
+        @test_assertion_parser = test_assertion_parser_strategy
+      end
+
+      def from_test_name(tests, test_name)
+        @tests = tests
+        @test_name = test_name
+
+        return unless test_contains_assertion?
+        return if assertion_is_empty?
+
+        test_assertion_parser.parse(test_node)
+      end
+
+      def test_contains_assertion?
+        test_assertion_node.respond_to?(:keys) && test_assertion_node.keys.include?(ASSERTION_NODE_NAME)
+      end
+
+      def test_assertion_node
+        tests[test_name]
+      end
+
+      def assertion_is_empty?
+        name_from_assertion_node.nil?
+      end
+
+      def test_node
+        { test_name => test_assertion_node }
+      end
+
+      def name_from_assertion_node
+        tests[test_name][ASSERTION_NODE_NAME]
+      end
+
+      private
+
+      attr_reader :test_assertion_parser, :tests, :test_name
+    end
+
+    class StandardYAMLParser
+      def parse_tests!(test_specification)
+        YAML.load(test_specification)
+      end
+    end
+  end
+end

data/lib/faccts/03_generating_code/rust_code_generator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Faccts
+  class RustCodeGenerator
+    NO_CODE = ""
+
+    def initialize(test_assertion_generator_strategy, fixed_template_fetcher_strategy)
+      @test_assertion_code_generator = test_assertion_generator_strategy
+      @fixed_code_template = RustCodeTemplate.new(fixed_template_fetcher_strategy)
+    end
+
+    def generate_from_test_suite!(test_specification_suite)
+      @test_specification_suite = test_specification_suite
+
+      return NO_CODE if test_specification_suite.empty?
+
+      wrapped_in_fixed_code_template(code_from_test_specification_suite)
+    end
+
+    class RustCodeTemplate
+      RUST_TEMPLATE_INSERT_SYMBOL = "/*{}*/"
+
+      def initialize(fetcher_strategy)
+        @code_template_fetcher = fetcher_strategy
+      end
+
+      def generate_with_values(*values)
+        values.reduce(code_template) do |template, value|
+          insert_value_into_placeholder(template, value)
+        end
+      end
+
+      private
+
+      attr_reader :code_template_fetcher
+
+      def code_template
+        code_template_fetcher.code_template
+      end
+
+      def insert_value_into_placeholder(template, value)
+        template.sub(RUST_TEMPLATE_INSERT_SYMBOL, value)
+      end
+    end
+
+    class BasicRustTestAssertionCallTemplateFetcher
+      def code_template
+        + "    name = \"/*{}*/\";\n" \
+        + "    result = /*{}*/;\n" \
+        + "    result_output = if result == true { \"PASS\" } else { \"FAIL\" };\n" \
+        + "    test_result_output = format!(\"{},{}\", name, result_output);\n" \
+        + "    test_suite_result_output += &test_result_output;\n" \
+        + "    test_suite_result_output += \"\\n\";\n"
+      end
+    end
+
+    class BasicRustMainProgramTemplateFetcher
+      def code_template
+        "use std::fs;\n" \
+          + "mod fixture;\n" \
+          + "\n" \
+          + "use crate::fixture::*;\n" \
+          + "\n" \
+          + "fn main() {\n" \
+          + "    let mut test_suite_result_output = String::from(\"name,result\\n\");\n" \
+          + "    let mut name: &str;\n" \
+          + "    let mut result: bool;\n" \
+          + "    let mut result_output: &str;\n" \
+          + "    let mut test_result_output: String;\n" \
+          + "\n" \
+          + "/*{}*/" \
+          + "\n" \
+          + "    let _ = fs::write(\"./results.faccts\", test_suite_result_output);\n" \
+          + "}\n"
+      end
+    end
+
+    private
+
+    attr_reader :test_assertion_code_generator, :fixed_code_template, :test_specification_suite
+
+    def wrapped_in_fixed_code_template(value)
+      fixed_code_template.generate_with_values(value)
+    end
+
+    def code_from_test_specification_suite
+      generated_test_assertion_list.join
+    end
+
+    def generated_test_assertion_list
+      test_specification_suite.map do |assert_specification|
+        test_assertion_code_generator.generate!(assert_specification)
+      end
+    end
+  end
+end

data/lib/faccts/03_generating_code/rust_name_to_function_call_converter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Faccts
+  class RustCodeGenerator
+    class RustNameToFunctionCallConverter
+      def initialize
+        @character_converter = RustCharacterConverter.new
+      end
+
+      def convert!(test_assertion)
+        @action_name = test_assertion.action_name
+        @arguments = test_assertion.arguments || []
+
+        converted_name = converted_characters(stripped_action_name)
+
+        raise InvalidNameError if all_characters_were_removed?(converted_name)
+
+        "#{converted_name}(#{converted_arguments})"
+      end
+
+      class InvalidNameError < ::StandardError; end
+
+      private
+
+      attr_reader :character_converter, :action_name, :arguments
+
+      def stripped_action_name
+        action_name.strip
+      end
+
+      def converted_characters(name)
+        name.chars.map { |char| character_converter.convert!(char) }.join
+      end
+
+      def all_characters_were_removed?(converted_name)
+        converted_name == ""
+      end
+
+      def converted_arguments
+        return "" unless arguments.length.positive?
+
+        arguments.map { |a| "\"#{a}\"" }.join(", ")
+      end
+
+      class RustCharacterConverter
+        WHITESPACE_CHARACTERS = " \n\t"
+        ALPHANUMERIC_CHARACTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_"
+        SUPPORTED_CHARACTERS = "#{ALPHANUMERIC_CHARACTERS}#{WHITESPACE_CHARACTERS}".freeze
+
+        def convert!(name_character)
+          @input_character = name_character
+
+          return "" unless supported_character?
+          return "_" if whitespace?
+
+          name_character
+        end
+
+        private
+
+        attr_reader :input_character
+
+        def supported_character?
+          SUPPORTED_CHARACTERS.include?(input_character)
+        end
+
+        def whitespace?
+          WHITESPACE_CHARACTERS.include?(input_character)
+        end
+      end
+    end
+  end
+end

data/lib/faccts/03_generating_code/rust_test_assertion_code_generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Faccts
+  class RustCodeGenerator
+    class RustTestAssertionCodeGenerator
+      def initialize(function_call_converter_strategy, template_fetcher_strategy)
+        @function_call_converter = function_call_converter_strategy
+        @code_template = RustCodeTemplate.new(template_fetcher_strategy)
+      end
+
+      def generate!(test_assertion)
+        @test_assertion = test_assertion
+
+        code_template.generate_with_values(*injectable_assertion_values)
+      rescue RustNameToFunctionCallConverter::InvalidNameError
+        raise UnnameableAssertionError, test_assertion.action_name
+      end
+
+      class UnnameableAssertionError < ::StandardError
+        ERROR_TEMPLATE = "Cannot interpret '%s' as a test phase command\n" \
+                         "Please ensure your test phases include alphanumeric characters!"
+
+        def initialize(assertion_name = "")
+          super(ERROR_TEMPLATE % assertion_name)
+        end
+      end
+
+      private
+
+      def injectable_assertion_values
+        [test_assertion.name, test_assertion_as_rust_function].compact
+      end
+
+      def test_assertion_as_rust_function
+        function_call_converter.convert!(test_assertion)
+      end
+
+      attr_reader :function_call_converter, :test_assertion, :code_template, :test_assertion_code_generator
+    end
+  end
+end

data/lib/faccts/04_exporting_results/file_writer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Faccts
+  class RustFileWriter
+    TARGET_FILE_PATH = "./src/main.rs"
+
+    def write_file!(code_to_write)
+      raise FileAlreadyExistsError if file_already_exists?
+
+      @file_contents = code_to_write
+      write_file
+    end
+
+    class FileAlreadyExistsError < ::StandardError
+      ERROR_MESSAGE = "Target generation file '#{TARGET_FILE_PATH}'" \
+        + " already exists.\nI don't want to overwrite it!"
+
+      def initialize(_msg = "")
+        super(ERROR_MESSAGE)
+      end
+    end
+
+    private
+
+    attr_reader :file_contents
+
+    def write_file
+      File.write(TARGET_FILE_PATH, file_contents)
+    end
+
+    def file_already_exists?
+      File.exist?(TARGET_FILE_PATH)
+    end
+  end
+end

data/lib/faccts/05_reporting_feedback/basic_console_output.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Faccts
+  class BasicConsoleOutput
+    PROCESS_COMPLETED_MESSAGE = "Acceptance tests successfully written!"
+
+    def run
+      yield
+      puts PROCESS_COMPLETED_MESSAGE
+    rescue StandardError => e
+      puts e.message
+    end
+  end
+end

data/lib/faccts/entities/test_assertion.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Faccts
+  class TestAssertion
+    attr_accessor :name, :action_name, :arguments
+
+    def combined_with(other)
+      combined_assertion = TestAssertion.new
+
+      combined_assertion.action_name = action_name + other.action_name
+      combined_assertion.arguments = arguments + other.arguments
+
+      combined_assertion
+    end
+  end
+end

data/lib/faccts/integration/acceptance_tester.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Faccts
+  class AcceptanceTester
+    def run!
+      assert_strategies_are_loaded!
+
+      report_feedback do
+        export(
+          code_generated_from(
+            test_suite_data_parsed_from(
+              test_specification
+            )
+          )
+        )
+      end
+    end
+
+    class MissingStrategyError < ::StandardError
+      ERROR_TEMPLATE = "Could not find %s strategy! Please contact your administrator"
+
+      def initialize(msg = "")
+        super(ERROR_TEMPLATE % msg)
+      end
+    end
+
+    class NoTestSpecificationLoadStrategyError < MissingStrategyError
+      def initialize
+        super("test loading")
+      end
+    end
+
+    class NoParsingStrategyError < MissingStrategyError
+      def initialize
+        super("test parsing")
+      end
+    end
+
+    class NoCodeGenerationStrategyError < MissingStrategyError
+      def initialize
+        super("code generation")
+      end
+    end
+
+    class NoTestExportStrategyError < MissingStrategyError
+      def initialize
+        super("test exporting")
+      end
+    end
+
+    class NoFeedbackOutputStrategyError < MissingStrategyError
+      def initialize
+        super("feedback output")
+      end
+    end
+
+    private
+
+    def assert_strategies_are_loaded!
+      required_strategies_table.each do |action, missing_action_error|
+        raise missing_action_error unless respond_to? action
+      end
+    end
+
+    def required_strategies_table
+      {
+        test_specification: NoTestSpecificationLoadStrategyError,
+        test_suite_data_parsed_from: NoParsingStrategyError,
+        code_generated_from: NoCodeGenerationStrategyError,
+        export: NoTestExportStrategyError,
+        report_feedback: NoFeedbackOutputStrategyError
+      }
+    end
+  end
+end

data/lib/faccts/integration/basic_acceptance_tester.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Faccts
+  class BasicAcceptanceTester < AcceptanceTester
+    def initialize
+      @file_reader = YAMLFileReader.new
+      @spec_parser = YAMLTestParser.new(
+        YAMLTestParser::YAMLTestAssertionParser.new(
+          YAMLTestParser::YAMLTestAssertionParser::AssertionSpecificationParser.new
+        )
+      )
+      @code_generator = RustCodeGenerator.new(
+        RustCodeGenerator::RustTestAssertionCodeGenerator.new(
+          RustCodeGenerator::RustNameToFunctionCallConverter.new,
+          RustCodeGenerator::BasicRustTestAssertionCallTemplateFetcher.new
+        ),
+        RustCodeGenerator::BasicRustMainProgramTemplateFetcher.new
+      )
+      @file_writer = RustFileWriter.new
+      @feedback_reporter = BasicConsoleOutput.new
+    end
+
+    def test_specification
+      file_reader.read_file!
+    end
+
+    def test_suite_data_parsed_from(specification)
+      spec_parser.create_tests!(specification)
+    end
+
+    def code_generated_from(test_suite)
+      code_generator.generate_from_test_suite!(test_suite)
+    end
+
+    def export(test_code)
+      file_writer.write_file!(test_code)
+    end
+
+    def report_feedback(&)
+      feedback_reporter.run(&)
+    end
+
+    private
+
+    attr_reader :file_reader, :spec_parser, :code_generator, :file_writer, :feedback_reporter
+  end
+end

data/lib/faccts/version.rb

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

data/lib/faccts.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "faccts/version"
+require "faccts"
+
+module Faccts
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: faccts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- bull313
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Execute automated acceptance tests for your project
+executables:
+- faccts
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- exe/faccts
+- lib/faccts.rb
+- lib/faccts/01_loading_test_specification/file_reader.rb
+- lib/faccts/02_parsing_test_specification/yaml_assertion_specification_parser.rb
+- lib/faccts/02_parsing_test_specification/yaml_test_assertion_parser.rb
+- lib/faccts/02_parsing_test_specification/yaml_test_parser.rb
+- lib/faccts/03_generating_code/rust_code_generator.rb
+- lib/faccts/03_generating_code/rust_name_to_function_call_converter.rb
+- lib/faccts/03_generating_code/rust_test_assertion_code_generator.rb
+- lib/faccts/04_exporting_results/file_writer.rb
+- lib/faccts/05_reporting_feedback/basic_console_output.rb
+- lib/faccts/entities/test_assertion.rb
+- lib/faccts/integration/acceptance_tester.rb
+- lib/faccts/integration/basic_acceptance_tester.rb
+- lib/faccts/version.rb
+homepage: https://github.com/bull313/faccts
+licenses: []
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: FAccTs - Framework for Acceptance Tests
+test_files: []