mumuki-sqlite-runner 2.2.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e574ef63ec53b93d7841532738042a3be0899079
-  data.tar.gz: a87d92c79f8af4546ef46eb34e6faa7e0d26572c
+SHA256:
+  metadata.gz: 2ff96b8daaf98e39b42e29a2e4a0fda7447ede4b33db3a496bbe09d76b021456
+  data.tar.gz: 124dd0f35e776db7a7ffde818afdb6e3cd4779d8f1c248d0e61e3391dfd5dc08
 SHA512:
-  metadata.gz: 28dca88c0eae83a3d5e34173b47b6702d805e1bc3d3ff70a99d7d546001c157386f91ca9d6e8b93c13b43561576caf0b1d2e0e4329b598d79c73e5ab1f8ca4b4
-  data.tar.gz: aeba550111b462b085d48c9b590822ddd03fdefa874303ccadb13c89867c55120c06612ded7402f871fb3cdaffb95c3d2297e45cd4310c2af36a167ed4e66240
+  metadata.gz: a503486ccbe2dddbbdfdf0274d50574585fa95b1b578e609c874578c1f8369aeaea33acbb58e4ee537c2ba0af2ccb3a3f42935e7a6e2e668dab3eb5ba340c186
+  data.tar.gz: 3c2e5a3d94069b7122dbe584ce81c8e76c2cf0ac6866c3987687f8995fc5e0f7671740c923632ad7e8d2a71cc141dafe406c5a2ee1aca062c95b3ccaf642ff6a

data/lib/checker.rb

@@ -12,25 +12,27 @@ module Sqlite
         when :equals
           success(name, result)
         when :distinct_columns
-          failed(name, result, solution, (I18n.t 'failure.columns'))
+          failed(name, result, solution, 'columns')
         when :distinct_rows
-          failed(name, result, solution, (I18n.t 'failure.rows'))
+          failed(name, result, solution, 'rows')
         else
-          failed(name, result, solution, (I18n.t 'failure.query'))
+          failed(name, result, solution, 'query')
       end
     end
 
     def success(name, result)
-      [name, :passed, render_success(result)]
+      message = I18n.t 'message.success.query'
+      [name, :passed, render_success(result, message)]
     end
 
     def failed(name, result, solution, error)
+      error = I18n.t "message.failure.#{error}"
       [name, :failed, render_error(result, solution, error)]
     end
 
     # Return success page rendered with results
-    def render_success(result)
-      renderer.render_success result
+    def render_success(result, message)
+      renderer.render_success result, message
     end
 
     # Return error page rendered with results & solutions

data/lib/html_renderer.rb

@@ -3,9 +3,10 @@ require 'active_support/inflector'
 module Sqlite
   class HtmlRenderer
 
-    def render_success(result)
-      @header = result[:dataset].header
-      @rows   = result[:dataset].rows
+    def render_success(result, message)
+      @message = message
+      @header  = result[:dataset].header
+      @rows    = result[:dataset].rows
       template_file_success.result binding
     end
 

data/lib/locales/en.yml

@@ -1,8 +1,9 @@
 en:
   dataset: "Dataset %{number}"
-  success:
-    query: 'Correct Query!'
-  failure:
-    columns: 'Columns do not match'
-    rows:    'Rows do not match'
-    query:   'Queries do not match'
+  message:
+    success:
+      query: 'Correct Query!'
+    failure:
+      columns: 'Columns do not match'
+      rows:    'Rows do not match'
+      query:   'Queries do not match'

data/lib/locales/es.yml

@@ -1,8 +1,9 @@
 es:
   dataset: "Set de datos %{number}"
-  success:
-    query: '¡Consulta correcta!'
-  failure:
-    columns: 'Las columnas no coinciden'
-    rows:    'Las filas no coinciden'
-    query:   'Las consultas no coinciden'
+  message:
+    success:
+      query: '¡Consulta correcta!'
+    failure:
+      columns: 'Las columnas no coinciden'
+      rows:    'Las filas no coinciden'
+      query:   'Las consultas no coinciden'

data/lib/parsers/common_test_parser.rb

@@ -0,0 +1,27 @@
+module Sqlite
+  module CommonTestParser
+
+    COMMENT = '-- NONE'
+    attr_reader :result, :final
+    required :parse, 'You need to implement parse method when use CommonTestParse mixin!'
+
+    def initialize(test)
+      @result = parse test
+    end
+
+    def choose(solution)
+      solution
+    end
+
+    protected
+
+    def final_parse(test, override = {})
+      seed = test[:seed].blank? ? '' : test[:seed].strip
+      {
+          seed:     override[:seed]     || seed,
+          expected: override[:expected] || test[:expected].strip
+      }
+    end
+
+  end
+end

data/lib/parsers/dataset_test_parser.rb

@@ -0,0 +1,34 @@
+module Sqlite
+  class DatasetTestParser
+
+    include Sqlite::CommonTestParser
+
+    def initialize(test)
+      @test = test
+      @result = parse test
+    end
+
+    # test = {
+    #   type: dataset,
+    #   seed: INSERT INTO ...,
+    #   expected: |
+    #     id|field
+    #     1|row 1
+    #     ...
+    # }
+    #
+    # return {
+    #   seed: INSERT INTO ...,
+    #   expected: -- NONE
+    # }
+    def parse(test)
+      @solutions = test[:expected].to_s.split("\n").map(&:strip).join("\n")
+      final_parse test, {expected: '-- NONE'}
+    end
+
+    def choose(_solution)
+      @solutions
+    end
+
+  end
+end

data/lib/parsers/final_dataset_test_parser.rb

@@ -0,0 +1,10 @@
+module Sqlite
+  class FinalDatasetTestParser < DatasetTestParser
+
+    def initialize(test)
+      super(test)
+      @final = test[:query] || test[:final]
+    end
+
+  end
+end

data/lib/parsers/invalid_test_parser.rb

@@ -0,0 +1,18 @@
+module Sqlite
+  class InvalidTestParser
+
+    include Sqlite::CommonTestParser
+
+    # return {
+    #   seed: -- NONE,
+    #   expected: -- NONE
+    # }
+    def parse(test)
+      final_parse(test, {
+          seed: COMMENT,
+          expected: COMMENT
+      })
+    end
+
+  end
+end

data/lib/parsers/query_test_parser.rb

@@ -0,0 +1,21 @@
+module Sqlite
+  class QueryTestParser
+
+    include Sqlite::CommonTestParser
+
+    # test = {
+    #   type: query,
+    #   seed: INSERT INTO ...,
+    #   expected: SELECT * FROM ...
+    # }
+    #
+    # return {
+    #   seed: INSERT INTO ...,
+    #   expected: SELECT * FROM ...
+    # }
+    def parse(test)
+      final_parse test
+    end
+
+  end
+end

data/lib/sqlite_runner.rb

@@ -5,12 +5,11 @@ I18n.load_translations_path File.join(__dir__, 'locales', '*.yml')
 
 Mumukit.runner_name = 'sqlite'
 Mumukit.configure do |config|
-  config.docker_image = 'mumuki/mumuki-sqlite-worker'
+  config.docker_image = 'mumuki/mumuki-sqlite-worker:v3-rc1'
   config.content_type = 'html'
   config.structured = true
 end
 
-require_relative './extensions/hash_extension'
 require_relative './version_hook'
 require_relative './test_hook'
 require_relative './metadata_hook'
@@ -18,6 +17,9 @@ require_relative './checker'
 require_relative './multiple_executions_runner'
 require_relative './html_renderer'
 require_relative './dataset'
-require_relative './dataset_solution_parser'
-require_relative './query_solution_parser'
+require_relative './parsers/common_test_parser'
+require_relative './parsers/query_test_parser'
+require_relative './parsers/dataset_test_parser'
+require_relative './parsers/final_dataset_test_parser'
+require_relative './parsers/invalid_test_parser'
 require_relative './errors'

data/lib/test_hook.rb

@@ -9,6 +9,16 @@ class SqliteTestHook < Mumukit::Templates::FileHook
   # Define that worker runs on a freshly-cleaned environment
   isolated
 
+  def initialize(config = nil)
+    super(config)
+    @test_parsers = {
+        query: Sqlite::QueryTestParser,
+        datasets: Sqlite::DatasetTestParser,
+        final_dataset: Sqlite::FinalDatasetTestParser,
+    }
+    @test_parsers.default = Sqlite::InvalidTestParser
+  end
+
   # Just define file extension
   def tempfile_extension
     '.json'
@@ -19,35 +29,36 @@ class SqliteTestHook < Mumukit::Templates::FileHook
     "runsql #{filename}"
   end
 
-  # Define the .json file template from request structure
-  # Input: request = {
-  #   test: (yaml string) teacher's code that define which testing verification student code should pass,
-  #   extra: (sql string) teacher's code that prepare field where student code should run,
-  #   content: (sql string) student code,
-  #   expectations: [] not using for now
+  # Transform Mumuki Request into Docker file style
+  # Request = {
+  #   test: {
+  #     type: (string) query|dataset,
+  #     seed: (string) sql code to populate tables,
+  #     expected: (string) query sentence | resulting table
+  #   },
+  #   extra: (string) sql code to create tables,
+  #   content: (string) student's solution,
+  #   expectations: []    # not using
   # }
   #
   def compile_file_content(request)
-    solution, data = parse_test request.test
-
-    content = {
-        init: request.extra.strip,
-        solution: solution,
-        student: request.content.strip,
-        datasets: data
-    }
-
-    content.to_json
+    tests = parse_tests request.test
+    final = get_final_query
+    {
+        init:    request.extra.strip,
+        student: request.content.strip << final,
+        tests:   tests
+    }.to_json
   end
 
   # Define how output results
   # Expected:
   # {
-  #     "solutions": [
+  #     "expected": [
   #         "name\nTest 1.1\nTest 1.2\nTest 1.3\n",
   #         "name\nTest 2.1\nTest 2.2\nTest 2.3\n"
   #     ],
-  #     "results": [
+  #     "student": [
   #         "id|name\n1|Test 1.1\n2|Test 1.2\n3|Test 1.3\n",
   #         "id|name\n1|Test 2.1\n2|Test 2.2\n3|Test 2.3\n"
   #     ]
@@ -57,8 +68,8 @@ class SqliteTestHook < Mumukit::Templates::FileHook
 
     case status
       when :passed
-        solutions, results = parse_output output
-        framework.test solutions, results
+        expected, student = parse_output output
+        framework.test expected, student
       when :failed
         [output['output'], status]
       else
@@ -69,33 +80,29 @@ class SqliteTestHook < Mumukit::Templates::FileHook
   protected
 
   def parse_output(output)
-    results   = output['results']
-    solutions = output['solutions']
-    unless @solution_parser.nil?
-      solutions = @solution_parser.choose solutions
+    student  = output['student']
+    expected = output['expected']
+    expected.map!.with_index do |expect, i|
+      @expected_parser[i].choose expect
     end
 
-    diff(solutions, results)
+    diff(expected, student)
   end
 
-  def diff(solutions, results)
-    zipped = solutions.zip(results).map do |solution, result|
-
-      diff = Diffy::SplitDiff.new result << "\n", solution << "\n"
-
-      if diff.left.blank?
-        [solution, result]
-      else
-        res = post_process_diff diff.left
-        sol = post_process_diff diff.right
-        [sol, res]
-      end
-
+  def diff(expected, student)
+    zipped = expected.zip(student).map do |expected_i, student_i|
+      diff = Diffy::SplitDiff.new student_i << "\n", expected_i << "\n"
+      choose_left_right(diff, expected_i, student_i).map { |e| post_process_diff e }
     end
-
     zipped.transpose.map { |dataset| post_process_datasets dataset }
   end
 
+  def choose_left_right(diff, expected, student)
+    expected = diff.left  unless diff.left.blank?
+    student  = diff.right unless diff.right.blank?
+    [expected, student]
+  end
+
   def post_process_diff(data)
     data.scan(/^(\s|-|\+)(.+)/)
         .map { |mark, content| mark << '|' << content }
@@ -112,37 +119,33 @@ class SqliteTestHook < Mumukit::Templates::FileHook
     end
   end
 
-  # Test should have one of these formats:
+  # This method receives a list of test cases.
+  # Each one could be like one of these:
   #
-  # Solution by query:
-  # { solution_type: 'query',
-  #   solution_query: 'SELECT * FROM ...',
-  #   examples: [
-  #     { data: "INSERT INTO..." }
-  #   ]
-  # }
+  #   type: query
+  #   seed: INSERT INTO ...
+  #   expected: SELECT * FROM ...
   #
-  # Solution by datasets:
-  # { solution_type: 'datasets',
-  #   examples: [
-  #     { data: "INSERT INTO...",
-  #       solution: "id|field\n1|row1..."
-  #     }
-  #   ]
-  # }
-  def parse_test(test)
-    test = OpenStruct.new YAML.load(test).deep_symbolize_keys
-
-    case test.solution_type.to_sym
-      when :query
-        @solution_parser = Sqlite::QuerySolutionParser.new
-      when :datasets
-        @solution_parser = Sqlite::DatasetSolutionParser.new
-      else
-        raise Sqlite::TestSolutionTypeError
+  #   type: dataset
+  #   seed: INSERT INTO ...
+  #   expected: |
+  #     id|field
+  #     1|row 1
+  #     ...
+  def parse_tests(tests)
+    tests = YAML.load tests
+    @tests = tests.map do | test |
+      test = test.to_struct
+      @test_parsers[test.type.to_sym].new test
     end
 
-    @solution_parser.parse_test test
+    @expected_parser = @tests
+    @tests.map(&:result)
+  end
+
+  def get_final_query
+    parsers = @expected_parser.select { |parser| !parser.final.blank? }
+    parsers.empty? ? '' : parsers.first.final
   end
 
   # Initialize Metatest Framework with Checker & Runner

data/lib/version_hook.rb

@@ -1,3 +1,3 @@
 module SqliteVersionHook
-  VERSION = '2.2.1'
+  VERSION = '3.0.0'
 end

data/lib/view/rows_success.html.erb

@@ -20,7 +20,7 @@
   }
 </style>
 
-<h5><%= I18n.t 'success.query' %></h5>
+<h5><%= message %></h5>
 <table class="table table-bordered sqlite_success">
   <thead>
   <tr>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mumuki-sqlite-runner
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Leandro Di Lorenzo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-12 00:00:00.000000000 Z
+date: 2017-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mumukit
@@ -173,15 +173,17 @@ extra_rdoc_files: []
 files:
 - lib/checker.rb
 - lib/dataset.rb
-- lib/dataset_solution_parser.rb
 - lib/errors.rb
-- lib/extensions/hash_extension.rb
 - lib/html_renderer.rb
 - lib/locales/en.yml
 - lib/locales/es.yml
 - lib/metadata_hook.rb
 - lib/multiple_executions_runner.rb
-- lib/query_solution_parser.rb
+- lib/parsers/common_test_parser.rb
+- lib/parsers/dataset_test_parser.rb
+- lib/parsers/final_dataset_test_parser.rb
+- lib/parsers/invalid_test_parser.rb
+- lib/parsers/query_test_parser.rb
 - lib/sqlite_runner.rb
 - lib/test_hook.rb
 - lib/version_hook.rb
@@ -207,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: SQLite Runner for Mumuki

data/lib/dataset_solution_parser.rb

@@ -1,34 +0,0 @@
-module Sqlite
-  class DatasetSolutionParser
-
-    # If solutions comes in an explicit datasets,
-    # it was stored in instance variable.
-    # Expected input:
-    # OpenStruct#{
-    #   solution_type: 'datasets',
-    #   examples: [
-    #     {
-    #       dataset: "INSERT INTO ...\nINSERT INTO ...",
-    #       solution_dataset: "id|field\n1|row1..."
-    #     }
-    #   ]
-    # }
-    def parse_test(test)
-      data = []
-      @solutions = []
-      solution_query = '-- none'
-
-      test.examples.each do |item|
-        @solutions << item[:solution_dataset].scan(/(?!\|).+(?<!\|)/).join("\n")
-        data.append item[:data]
-      end
-
-      return solution_query, data
-    end
-
-    def choose(_solution)
-      @solutions
-    end
-
-  end
-end

data/lib/extensions/hash_extension.rb

@@ -1,6 +0,0 @@
-
-class Hash
-  def to_yaml
-    super.sub('---', '').strip
-  end
-end

data/lib/query_solution_parser.rb

@@ -1,25 +0,0 @@
-module Sqlite
-  class QuerySolutionParser
-
-    # Expected input:
-    # OpenStruct#{
-    #   solution_type: 'query',
-    #   solution_query: 'select * from motores;',
-    #   examples: [
-    #     { dataset: "INSERT INTO ...\nINSERT INTO ..." }
-    #   ]
-    # }
-    def parse_test(test)
-      data = test.examples.map do |item|
-        item[:data]
-      end
-
-      return test.solution_query, data
-    end
-
-    def choose(solution)
-      solution
-    end
-
-  end
-end