quby 4.0.4 → 5.0.0

data/spec/quby/answers/entities/score_spec.rb

@@ -22,6 +22,10 @@ module Quby::Answers::Entities
     # it works with indifferent access
     subject { answer.score_objects['test'] }
 
+    it 'has working completion' do
+      expect(answer.outcome.completion).to eq("value" => 1.0)
+    end
+
     it 'exposes score schema fields' do
       expect(subject.key).to eq(:test)
       expect(subject.label).to eq('Testscore')

data/spec/quby/answers/services/answer_validations_spec.rb

@@ -148,14 +148,14 @@ module Quby::Answers::Services
     describe '#question_groups' do
       it 'sets the @question_groups attribute to a hash of the question groups' do
         expect(answer.question_groups).to eq({
-          group1: [:v_answer_group_under_minimum, :v_answer_group_under_minimum1],
-          group2: [:v_answer_group_over_minimum, :v_answer_group_over_minimum1],
-          group3: [:v_answer_group_under_maximum, :v_answer_group_under_maximum1],
-          group4: [:v_answer_group_over_maximum, :v_answer_group_over_maximum1],
-          cgroup1: [:v_check_answer_group_under_minimum, :v_check_answer_group_under_minimum1],
-          cgroup2: [:v_check_answer_group_over_minimum, :v_check_answer_group_over_minimum1],
-          cgroup3: [:v_check_answer_group_under_maximum, :v_check_answer_group_under_maximum1],
-          cgroup4: [:v_check_answer_group_over_maximum, :v_check_answer_group_over_maximum1]
+          "group1" => [:v_answer_group_under_minimum, :v_answer_group_under_minimum1],
+          "group2" => [:v_answer_group_over_minimum, :v_answer_group_over_minimum1],
+          "group3" => [:v_answer_group_under_maximum, :v_answer_group_under_maximum1],
+          "group4" => [:v_answer_group_over_maximum, :v_answer_group_over_maximum1],
+          "cgroup1" => [:v_check_answer_group_under_minimum, :v_check_answer_group_under_minimum1],
+          "cgroup2" => [:v_check_answer_group_over_minimum, :v_check_answer_group_over_minimum1],
+          "cgroup3" => [:v_check_answer_group_under_maximum, :v_check_answer_group_under_maximum1],
+          "cgroup4" => [:v_check_answer_group_over_maximum, :v_check_answer_group_over_maximum1]
         })
       end
     end

data/spec/quby/answers/services/score_calculator_spec.rb

@@ -485,26 +485,16 @@ module Quby::Answers::Services
       let(:calculator) { ScoreCalculator.new(questionnaire: questionnaire, values: {}, timestamp: timestamp) }
       let(:table_double) { double.as_null_object }
 
-      before do
-        allow(Quby::LookupTable).to receive(:new).and_return(table_double)
-      end
-
-      it 'instantiates a new Quby::Answers::Entities::LookupTable if the table_hash cache does not know the key' do
+      it 'raises an error if lookup table cannot be found' do
         expect(questionnaire.lookup_tables).to be_empty
-        calculator.table_lookup :test_table, score: 1
-        expect(questionnaire.lookup_tables[:test_table]).to be(table_double)
-      end
-
-      it 'uses the memoized lookuptable if there is a cache hit' do
-        calculator.table_lookup :test_table, score: 1
-        expect(table_double).to receive(:lookup)
-        calculator.table_lookup :test_table, score: 1
+        expect { calculator.table_lookup :test_table, score: 1 }.to raise_error(KeyError)
       end
 
       it 'looks up the given parameters on the given table' do
+        questionnaire.lookup_tables[:test_table] = table_double
         parameters = {score: 1}
-        expect(table_double).to receive(:lookup).with parameters
         calculator.table_lookup :test_table, parameters
+        expect(table_double).to have_received(:lookup).with parameters
       end
 
       context 'with add_lookup_tree inside dsl' do

data/spec/quby/questionnaires/deserializer/questionnaire_spec.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Quby::Questionnaires::Deserializer do
+  it 'sets title' do
+    questionnaire = dsl { title 'Foo' }
+    expect(questionnaire.title).to eq('Foo')
+  end
+
+  it 'sets description' do
+    questionnaire = dsl { description 'This is a questionnaire description' }
+    expect(questionnaire.description).to eq('This is a questionnaire description')
+  end
+
+  it 'sets outcome_description' do
+    questionnaire = dsl { outcome_description 'Outcome description' }
+    expect(questionnaire.outcome_description).to eq('Outcome description')
+  end
+
+  it 'set sbg_key' do
+    questionnaire = dsl { sbg_key 'foo' }
+    expect(questionnaire.sbg_key).to eq('foo')
+  end
+
+  it 'can request outcome regeneration' do
+    timestamp = Time.local(2020, 5, 12, 4, 28, 19)
+    questionnaire = dsl { outcome_regeneration_requested_at timestamp }
+    expect(questionnaire.outcome_regeneration_requested_at).to eq(timestamp)
+  end
+
+  it 'can request answers to be deactivated' do
+    timestamp = Time.local(2020, 5, 12, 4, 28, 19)
+    questionnaire = dsl { deactivate_answers_requested_at timestamp }
+    expect(questionnaire.deactivate_answers_requested_at).to eq(timestamp)
+  end
+
+  describe 'roqua keys' do
+    it 'defaults to key' do
+      questionnaire = dsl("example") {}
+      expect(questionnaire.roqua_keys).to eq(["example"])
+    end
+
+    it 'sets roqua keys' do
+      questionnaire = dsl { roqua_keys :alg_o, :alg_o2 }
+      expect(questionnaire.roqua_keys).to eq(["alg_o", "alg_o2"])
+    end
+  end
+
+  describe 'sbg_domain' do
+    it 'sets sbg_domain' do
+      questionnaire = dsl do
+        sbg_domain '02', from: '2000-01-01', till: '2099-12-31', outcome: '01', sbg_key: 'OQ45-sd', primary: true
+      end
+      expect(questionnaire.sbg_domains).to eq(
+        [
+          {sbg_code: '02', from: '2000-01-01', till: '2099-12-31', outcome: '01', sbg_key: 'OQ45-sd', primary: true}
+        ]
+      )
+    end
+
+    it 'sets multiple sbg_domains with optional attributes' do
+      questionnaire = dsl do
+        sbg_domain '02', outcome: '01', sbg_key: 'OQ45-sd', primary: false
+        sbg_domain '03', outcome: '02', from: '2000-01-01', till: '2099-12-31'
+      end
+      expect(questionnaire.sbg_domains).to eq(
+        [
+          {sbg_code: '02', from: nil, till: nil, outcome: '01', sbg_key: 'OQ45-sd', primary: false},
+          {sbg_code: '03', from: '2000-01-01', till: '2099-12-31', outcome: '02', sbg_key: nil, primary: false}
+        ]
+      )
+    end
+
+    it 'defaults the sbg_key to the sbg_key of the questionnaire' do
+      questionnaire = dsl do
+        sbg_key 'example'
+        sbg_domain '03', from: '2000-01-01', till: '2099-12-31', outcome: '01'
+      end
+      expect(questionnaire.sbg_domains).to eq(
+        [
+          {sbg_code: '03', from: '2000-01-01', till: '2099-12-31', outcome: '01', sbg_key: 'example', primary: false}
+        ]
+      )
+    end
+  end
+
+  it 'does not accept invalid sbg_domains options' do
+    expect { dsl { sbg_domain '02', foo: 'bar' } }.to raise_exception(ArgumentError, "missing keyword: outcome")
+  end
+
+  it 'can be abortable' do
+    questionnaire = dsl { }
+    expect(questionnaire.abortable).to be_falsey
+
+    questionnaire = dsl { abortable }
+    expect(questionnaire.abortable).to be_truthy
+  end
+
+  it 'can allow hotkeys' do
+    questionnaire = dsl { allow_hotkeys }
+    expect(questionnaire.allow_hotkeys).to eq("all")
+  end
+
+  it 'can set license' do
+    questionnaire = dsl { license :free }
+    expect(questionnaire.license).to eq(:free)
+    expect(questionnaire.licensor).to be_nil
+  end
+
+  it 'can set licensor' do
+    questionnaire = dsl { license :free, licensor: 'FOO' }
+    expect(questionnaire.licensor).to eq('FOO')
+  end
+
+  it 'can set language' do
+    questionnaire = dsl { language :en }
+    expect(questionnaire.language).to eq(:en)
+  end
+
+  it 'defaults to Dutch language' do
+    questionnaire = dsl { }
+    expect(questionnaire.language).to eq(:nl)
+  end
+
+  it 'can set respondent_types' do
+    questionnaire = dsl { respondent_types :patient, :parent }
+    expect(questionnaire.respondent_types).to eq([:patient, :parent])
+  end
+
+  it 'can set tags' do
+    questionnaire = dsl { tags :diary }
+    expect(questionnaire.tags.diary).to be_truthy
+    expect(questionnaire.tags.another_tag).to be_falsey
+  end
+
+  it 'builds panels' do
+    questionnaire = dsl { panel { title 'My Title' } }
+    expect(questionnaire.panels.first.title).to eq('My Title')
+  end
+
+  it 'builds line charts' do
+    questionnaire = dsl { line_chart(:tot) { title 'My Title'; range 0..40 } }
+    expect(questionnaire.charts.find(:tot).title).to eq('My Title')
+  end
+
+  it 'builds bar charts' do
+    questionnaire = dsl { bar_chart(:tot) { title 'My Title' } }
+    expect(questionnaire.charts.find(:tot).title).to eq('My Title')
+  end
+
+  it 'builds radar charts' do
+    questionnaire = dsl { radar_chart(:tot) { title 'My Title' } }
+    expect(questionnaire.charts.find(:tot).title).to eq('My Title')
+  end
+
+  it 'sets a depends_on key correctly' do
+    questionnaire = dsl do
+      question :v_1, type: :check_box do
+        option :v_1_a
+      end
+      question :v_2, type: :string, depends_on: [:v_1]
+    end
+    expect(questionnaire.question_hash[:v_2].depends_on).to eq [:v_1_a]
+  end
+
+  it 'sets the parent option key on subquestions correctly' do
+    questionnaire = dsl do
+      question :v_1, type: :check_box do
+        option :v_1a do
+          question :v_2, type: :string
+        end
+        option :v_1b
+      end
+    end
+    expect(questionnaire.question_hash[:v_2].parent_option_key).to eq(:v_1a)
+  end
+
+  describe 'flag' do
+    before do
+      allow_any_instance_of(Quby::Questionnaires::Entities::Questionnaire).to receive(:add_flag)
+    end
+
+    it 'defines flags' do
+      questionnaire = dsl do
+        flag key: :test, description: 'test flag'
+      end
+      expect(questionnaire.flags[:test_test].description).to eq("test flag")
+    end
+  end
+
+  describe '#add_lookup_tree' do
+    it 'can add a lookup tree' do
+      questionnaire = dsl do
+        add_lookup_tree :interpretations,
+          levels: ['score', 'interpretation'],
+          tree: {
+            0..24 => 'low',
+            25..50 => 'high'
+          }
+      end
+
+      expect(questionnaire.lookup_tables[:interpretations].lookup(score: 26)).to eq 'high'
+    end
+  end
+
+  describe '#score_schema' do
+    it 'calls #add_score_schema with the given arguments' do
+      options = [{key: :value, export_key: :tot, label: 'Score'}]
+      questionnaire = dsl do
+        score :totaal, label: 'totaal' do
+          {value: 100}
+        end
+
+        score_schema :totaal, 'Totaal', options
+      end
+
+      expect(questionnaire.score_schemas[:totaal].subscore_schemas[0].export_key).to eq(:tot)
+    end
+  end
+
+  describe '#outcome_table' do
+    it 'calls questionnaire.add_outcome_table with the given arguments' do
+      questionnaire = dsl do
+        outcome_table key: :default, score_keys: [:a], subscore_keys: [:b]
+      end
+      expect(questionnaire.outcome_tables[0].score_keys).to eq([:a])
+      expect(questionnaire.outcome_tables[0].subscore_keys).to eq([:b])
+    end
+  end
+
+  def dsl(key = "test", &block)
+    source = Quby::Compiler::DSL.build(key, "", &block)
+    json = Quby::Compiler::Outputs::QubyFrontendV1Serializer.new(source).to_json
+    described_class.from_json(JSON.parse(json))
+  end
+end

data/spec/quby/questionnaires/dsl_spec.rb

@@ -8,15 +8,6 @@ module Quby::Questionnaires
         definition = repo.find('simple')
         expect(described_class.build_from_definition(definition)).to be_instance_of(Entities::Questionnaire)
       end
-
-      it 'uses a path on instance eval, so we get correct stack traces' do
-        definition = Quby::Questionnaires::Entities::Definition.new(key: 'test',
-                                                                    sourcecode: 'raise("problem")',
-                                                                    path: 'spec/fixtures/raising.rb')
-        expected_backtrace = include(end_with("spec/fixtures/raising.rb:1:in `block in build_from_definition'"))
-        expect { described_class.build_from_definition(definition) }.to \
-          raise_exception(having_attributes(backtrace: expected_backtrace))
-      end
     end
   end
 end

data/spec/quby/questionnaires/entities/fields_spec.rb

@@ -82,8 +82,8 @@ module Quby::Questionnaires::Entities
     end
 
     describe '#description_for_variable' do
-      let(:definition) do
-        %q~
+      let(:questionnaire) do
+        Quby::Questionnaires::DSL.build("test") do
           flag key: :flagtest, description_true: 'it true', description_false: 'it false', description: 'it described'
           textvar key: :textvartest, description: 'tv description'
           question :v_1, type: :radio, title: 'select a few'
@@ -105,7 +105,7 @@ module Quby::Questionnaires::Entities
           score_schema :tot, 'Total', [{key: :value, export_key: 'tot', label: 'Score'},
                                        {key: :interpretation, export_key: 'tot_i', label: 'Interpretation'}]
 
-        ~
+        end
       end
 
       it 'returns question context free titles if the variable is a question' do

data/spec/quby/questionnaires/entities/question_spec.rb

@@ -42,14 +42,6 @@ module Quby::Questionnaires::Entities
     let(:valid_question_options) { {type: :string} }
     subject(:question) { Question.new(:v_1, valid_question_options) }
 
-    it 'validates the key to be a symbol' do
-      questionnaire = Quby::Questionnaires::DSL.build("test2") do
-          question "key", type: :radio
-      end
-      expect(questionnaire.questions.first.valid?).to eq false
-      expect(questionnaire.questions.first.errors.full_messages).to eq ["Key Is not of type Symbol"]
-    end
-
     describe 'sbg_key' do
       it 'can be set by options hash' do
         expect(questionnaire.question_hash[:date].sbg_key).to eq 'foo'

data/spec/quby/questionnaires/entities/questionnaire_spec.rb

@@ -432,30 +432,6 @@ module Quby::Questionnaires::Entities
       end
     end
 
-    describe '#ensure_scores_have_schemas' do
-      let(:score_missing_schema_quest) do
-        Quby::Questionnaires::DSL.build("test") do
-          question :v_1, type: :date, title: 'vraag'
-
-          score(:key, label: 'score') { {value: 'oh no'} }
-          score(:key2, label: 'score2', schema: [{key: :value, label: 'Score', export_key: :key2}]) { {value: 'oh'} }
-          score(:key3, label: 'score3') { {value: 'oh no'} }
-        end
-      end
-
-      it 'does not validate presense of score schemas by default' do
-        expect(score_missing_schema_quest.errors.full_messages).to be_blank
-      end
-
-      describe 'if quby settings require_score_schemas is true' do
-        before { Quby::Settings.require_score_schemas = true }
-        it 'validates every score has a score schema' do
-          expect(score_missing_schema_quest.errors.full_messages).to eq(["Score key is missing a score schema",
-                                                                         "Score key3 is missing a score schema"])
-        end
-      end
-    end
-
     describe '#add_outcome_table' do
       let(:questionnaire) do
         Quby::Questionnaires::DSL.build("test") do
@@ -488,8 +464,8 @@ module Quby::Questionnaires::Entities
           {"fieldKey" => :v_2, "type" => :requires_answer, "explanation" => nil},
           # a float type automatically adds a validation that the data entered must be parseable as a float
           {"fieldKey" => :v_2, "type" => :valid_float, "explanation" => nil},
-          {"fieldKey" => :v_2, "type" => :minimum, "subtype" => :number, "value" => 5},
-          {"fieldKey" => :v_2, "type" => :maximum, "subtype" => :number, "value" => 10}
+          {"fieldKey" => :v_2, "type" => :minimum, "subtype" => :number, "value" => 5, "explanation" => nil},
+          {"fieldKey" => :v_2, "type" => :maximum, "subtype" => :number, "value" => 10, "explanation" => nil}
         ])
       end
 

data/spec/quby/table_backend/range_tree_spec.rb

@@ -1,17 +1,22 @@
 require 'spec_helper'
 
 describe Quby::TableBackend::RangeTree do
-  let(:csv_key) { 'test' }
-  let(:data) { Quby.lookup_table_repo.retrieve(csv_key) }
-  let(:tree) { described_class.from_csv(levels: data.shift, compare: data.shift, data: data) }
-
-  describe '#from_csv' do
-    context 'invalid csv data' do
-      let(:csv_key) { 'bad_range' }
-      it 'fails when csv data contains a range between two equal values' do
-        expect { tree }.to raise_error(RuntimeError, 'Cannot create range between two equal values')
-      end
-    end
+  let(:tree) do
+    described_class.new(
+      levels: ["scale", "gender", "age", "raw", "norm"],
+      tree: {
+        "Inhibitie" => {
+          "male" => {
+            (10.0...11.0) => {
+              (-Float::INFINITY...10.0) => 39.0,
+              (10.0...20.0) => 42.0,
+              (20.0...30.0) => 71.0,
+              (30.0...Float::INFINITY) => 75.0
+            }
+          }
+        }
+      }
+    )
   end
 
   describe '#lookup' do
@@ -68,7 +73,23 @@ describe Quby::TableBackend::RangeTree do
     end
 
     describe 'definition containing range with float values' do
-      let(:csv_key) { 'float_test' }
+      let(:tree) do
+        described_class.new(
+          levels: ["scale", "gender", "age", "raw", "norm"],
+          tree: {
+            "Inhibitie" => {
+              "male" => {
+                (10.0...11.0) => {
+                  (-Float::INFINITY...10.5) => 39.0,
+                  (10.5...20.1) => 42.0,
+                  (20.1...30.7) => 71.0,
+                  (30.7...Float::INFINITY) => 75.0
+                }
+              }
+            }
+          }
+        )
+      end
 
       it 'returns the correct scores' do
         params = {age: 10, raw: 15.8, scale: 'Inhibitie', gender: 'male'}
@@ -80,7 +101,12 @@ describe Quby::TableBackend::RangeTree do
     end
 
     describe 'definition containing float values' do
-      let(:csv_key) { 'test2' }
+      let(:tree) do
+        described_class.new(
+          levels: ["scale", "raw", "norm"],
+          tree: {"Inhibitie" => {15.0=>39.0, 16.0=>42.0, 17.0=>71.0, 18.0=>75.0}}
+        )
+      end
 
       it 'returns the correct scores when using integers in lookup path' do
         params = {scale: 'Inhibitie', raw: 17}
@@ -101,6 +127,13 @@ describe Quby::TableBackend::RangeTree do
       end
     end
 
+    describe 'array leaves' do
+      it 'returns the leaf fully' do
+        tree = described_class.new levels: ['key', 'leaf'], tree: {a: [1, 2, 3], b: [9, 8, 7]}
+        expect(tree.lookup(key: :a)).to eq([1, 2, 3])
+      end
+    end
+
     describe 'parameter validation' do
       it 'raises when parameter keys do not match header keys' do
         params = {foo: :bar}