quby 4.0.3 → 5.0.0.pre1

data/spec/quby/questionnaires/services/definition_validator_spec.rb

@@ -1,793 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby::Questionnaires::Services
-  describe DefinitionValidator do
-    let(:questionnaire) { Quby::Questionnaires::DSL.build('test', 'title "Test"') }
-
-    def make_definition(definition = 'title "Test"')
-      Quby::Questionnaires::Entities::Definition.new(key: 'test', sourcecode: definition, path: 'fake definition test')
-    end
-
-    describe "fields#answer_keys and fields#input_keys need to be symbols" do
-      before do
-        allow(Quby::Questionnaires::DSL).to receive(:build_from_definition).and_return(questionnaire)
-      end
-
-      it 'passes when answer_keys and input_keys are symbols' do
-        valid_definition = make_definition
-        questionnaire.fields.answer_keys << :v_foo
-        questionnaire.fields.input_keys << :v_foo_a1
-        valid_definition.valid?
-        expect(valid_definition.errors).to be_empty
-      end
-
-      it 'fails when an answer_keys is not a symbol' do
-        invalid_definition = make_definition
-        questionnaire.fields.answer_keys << 'v_foo'
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Answer key v_foo is not a symbol")
-      end
-
-      it 'fails when an input_keys is not a symbol' do
-        invalid_definition = make_definition
-        questionnaire.fields.input_keys << 'v_foo_a1'
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Input key v_foo_a1 is not a symbol")
-      end
-    end
-
-    describe "questionnaire needs a title" do
-      it "throws an error if the questionnaire does not have a title" do
-        invalid_definition = make_definition("")
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Questionnaire title is missing.")
-      end
-
-      it "throws an error if the title is empty" do
-        invalid_definition = make_definition(<<-END)
-          title ""
-        END
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Questionnaire title is missing.")
-      end
-    end
-
-    describe 'questions with activemodel validation errors' do
-      it "throws an error if the question to be hidden does not exist" do
-        invalid_definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :string, show_values: :error do
-            title "Testvraag"
-          end
-        END
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Question v_1 is invalid: Show values option invalid: error.")
-      end
-    end
-
-    describe ":hides_questions" do
-      it "throws an error if the question to be hidden does not exist" do
-        invalid_definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, hides_questions: [:v_2]
-          end
-        END
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Question v_1 option a1 hides_questions references nonexistent question v_2")
-      end
-
-      it "throws an error if the question to be hidden is a subquestion" do
-        invalid_definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, hides_questions: [:v_1_a1_sq] do
-              question :v_1_a1_sq, type: :string
-            end
-          end
-        END
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Question v_1 option a1 hides_questions references subquestion v_1_a1_sq")
-      end
-
-      it 'does not throw an error when the question to be hidden exists' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, hides_questions: [:v_2]
-          end
-
-          question :v_2, type: :textarea do
-            title "Testvraag"
-          end
-        END
-        expect(definition.valid?).to be_truthy
-      end
-    end
-
-    describe ":shows_questions" do
-      it "throws an error if the question to be shown does not exist" do
-        invalid_definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, shows_questions: [:v_2]
-          end
-        END
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Question v_1 option a1 shows_questions references nonexistent question v_2")
-      end
-
-      it "throws an error if the question to be shown is a subquestion" do
-        invalid_definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, shows_questions: [:v_1_a1_sq] do
-              question :v_1_a1_sq, type: :string
-            end
-          end
-        END
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Question v_1 option a1 shows_questions references subquestion v_1_a1_sq")
-      end
-
-      it 'does not throw an error when the question to be shown exists' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, shows_questions: [:v_2]
-          end
-
-          question :v_2, type: :textarea do
-            title 'Testvraag'
-          end
-        END
-        expect(definition.valid?).to be_truthy
-      end
-    end
-
-    describe ":default_invisible" do
-      it 'throws an error if a subquestion has default_invisible set' do
-        invalid_definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Testvraag"
-            option :a1
-            option :a2, shows_questions: [:v_1_a1_sq] do
-              question :v_1_a1_sq, type: :string, default_invisible: true
-            end
-          end
-        END
-        invalid_definition.valid?
-        expect(invalid_definition.errors[:sourcecode].first[:message])
-          .to include("Question v_1_a1_sq is a subquestion with default_invisible")
-      end
-
-      it 'does not throw an error if a non-subquestion has default_invisible set' do
-        valid_definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :string default_invisible: true
-        END
-        valid_definition.valid?
-        expect(valid_definition.errors[:sourcecode].first[:message]).to be_truthy
-      end
-    end
-
-    describe ":validates_question_key_format" do
-      it "validates length of the question keys" do
-        long_key = make_definition(<<-END)
-          title "Test"
-          question :questionthree, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, description: 'some_description'
-          end
-        END
-        valid_key = make_definition(<<-END)
-          title "Test"
-          question :v_12345678901, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, description: 'some_description'
-          end
-        END
-        expect(long_key.valid?).to be_falsey
-        expect(valid_key.valid?).to be_truthy
-      end
-
-      it "validates that question key starts with a `v_`" do
-        invalid_key = make_definition(<<-END)
-          title "Test"
-          question :one, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, description: 'some_description', hides_questions: [:two]
-          end
-        END
-        valid_key = make_definition(<<-END)
-          title "Test"
-          question :v_2, type: :radio do
-            title "Testvraag"
-            option :a1, value: 0, description: 'some_description'
-          end
-        END
-        expect(invalid_key.valid?).to be_falsey
-        expect(valid_key.valid?).to be_truthy
-      end
-
-      it "validates check_box question options start with `v_`" do
-        invalid_keys = make_definition(<<-END)
-          title "Test"
-          question :v_4, type: :check_box do
-            title "Testvraag met een check_box"
-            option :q1, description: 'some_description'
-          end
-        END
-        valid_keys = make_definition(<<-END)
-          title "Test"
-          question :v_4, type: :check_box do
-            title "Testvraag met een check_box"
-            option :v_q1, description: 'some_description'
-            inner_title 'blaat'
-            option :v_q2, description: 'more_description'
-          end
-        END
-        expect(invalid_keys.valid?).to be_falsey
-        expect(valid_keys.valid?).to be_truthy
-      end
-
-      it "validates check_box question options length" do
-        invalid_keys = make_definition(<<-END)
-          title "Test"
-          question :v_4, type: :check_box do
-            title "Testvraag met een check_box"
-            option :v_q1_has_a_very_long_key, description: 'some_description'
-          end
-        END
-        valid_keys = make_definition(<<-END)
-          title "Test"
-          question :v_4, type: :check_box do
-            title "Testvraag met een check_box"
-            option :v_q1, description: 'some_description'
-          end
-        END
-        expect(invalid_keys.valid?).to be_falsey
-        expect(valid_keys.valid?).to be_truthy
-      end
-
-      it "validates question date keys" do
-        invalid_keys = make_definition(<<-END)
-          title "Test"
-          question :v_6, type: :date, year_key: :invalid_key, month_key: :v_62, day_key: :v_63 do
-            title "Testvraag met een datum"
-          end
-        END
-        valid_keys = make_definition(<<-END)
-          title "Test"
-          question :v_6, type: :date, year_key: :v_61, month_key: :v_62, day_key: :v_63 do
-            title "Testvraag met een datum"
-          end
-        END
-        expect(invalid_keys.valid?).to be_falsey
-        expect(valid_keys.valid?).to be_truthy
-      end
-    end
-
-    describe 'subquestion validation' do
-      it 'does not accept subquestions in question of type select' do
-        select_type_without_subquestions = make_definition(<<-END)
-          title "Test"
-          question :v_7, type: :select do
-            title "Vraag met hidden options"
-            option :a1, :value => 1, :description => "Keuze1"
-            option :a2, :value => 2, :description => "Keuze2"
-          end
-        END
-        select_type_with_subquestions = make_definition(<<-END)
-          title "Test"
-          question :v_8, type: :select do
-            title "Vraag met hidden options"
-            option :a3, :value => 1, :description => "Keuze1"
-            option :a4, :value => 2, :description => "Keuze2"
-            option :a5, :value => 7, :description => "Anders, namelijk:"
-            question :v_8a, :type => :radio do
-              option :a7a, :value => 11, :description => "Keuze 3"
-              option :a7b, :value => 12, :description => "Keuze 4"
-            end
-          end
-        END
-
-        expect(select_type_with_subquestions.valid?).to be_falsey
-        expect(select_type_without_subquestions.valid?).to be_truthy
-      end
-    end
-
-    describe 'score key validation' do
-      it 'accepts score keys that are the correct length' do
-        valid_definition = make_definition(<<-END)
-          title "Test"
-          score 'ok_key_length', label: 'some_label',
-            schema: [{key: :wait_what_this_key_is_very_long, label: 'Score', export_key: :wat}] do
-            { wait_what_this_key_is_very_long: 42 }
-          end
-        END
-        expect(valid_definition).to be_valid
-      end
-
-      it 'reject score keys that are too long' do
-        invalid_definition = make_definition(<<-END)
-          title "Test"
-          score 'score_whose_key_is_longer_than_max', label: 'some_label',
-            schema: [{key: :t_score, label: 'Score', export_key: :wat}] do
-            { t_score: 42 }
-          end
-        END
-        expect(invalid_definition).not_to be_valid
-      end
-
-      it 'reject score key if already defined' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_6, type: :radio, title: 'foo'
-          score 'foo_score', label: 'some_label',
-            schema: [{key: :t_score, label: 'Score', export_key: :wat}] do
-            { t_score: 42 }
-          end
-          score 'foo_score', label: 'some_label',
-            schema: [{key: :t_score, label: 'Score', export_key: :wat}] do
-            { t_score: 43 }
-          end
-        END
-        expect(definition).not_to be_valid
-      end
-    end
-
-    describe 'score label validation' do
-      it 'accepts the label option' do
-        score_definition = make_definition(<<-END)
-          title "Test"
-          score 'score_key', label: 'score_label',
-            schema: [{key: :value, label: 'Score', export_key: :sc1}] do {value: 42} end
-        END
-        expect(score_definition).to be_valid
-      end
-
-      it 'rejects score definitions without the label option' do
-        score_definition = make_definition(<<-END)
-          title "Test"
-          score 'score_key',
-            schema: [{key: :value, label: 'Score', export_key: :sc1}] do {value: 42} end
-        END
-        expect(score_definition).not_to be_valid
-      end
-    end
-
-    describe 'title validations' do
-      context ':title and :context_free_title do not exist' do
-        it 'fails' do
-          definition = make_definition(<<-END)
-            title "Test"
-            question :v_6, type: :radio
-          END
-          expect(definition.valid?).to be false
-        end
-
-        it 'does not fail with :allow_blank_titles option' do
-          definition = make_definition(<<-END)
-            title "Test"
-            question :v_6, type: :radio, allow_blank_titles: true do
-            end
-          END
-          expect(definition.valid?).to be true
-        end
-
-        it 'does not fail on table question' do
-          definition = make_definition(<<-END)
-            title "Test"
-            table columns: 4 do
-            end
-          END
-          expect(definition.valid?).to be true
-        end
-      end
-
-      context ':title or :context_free_title exist' do
-        it 'does not fail when :title exists' do
-          definition = make_definition(<<-END)
-            title "Test"
-            question :v_6, type: :radio do
-              title 'foo'
-            end
-          END
-          expect(definition.valid?).to be true
-        end
-
-        it 'does not fail when :context_free_title exists' do
-          definition = make_definition(<<-END)
-            title "Test"
-            question :v_6, type: :radio do
-              context_free_title 'bar'
-            end
-          END
-          expect(definition.valid?).to be true
-        end
-      end
-
-      context 'default question options' do
-        it 'is valid when no title exist and default question options set to true' do
-          definition = make_definition(<<-END)
-            title "Test"
-            default_question_options allow_blank_titles: true
-            question :v_6, type: :radio do
-              context_free_title 'bar'
-            end
-          END
-          expect(definition).to be_valid
-        end
-      end
-
-      context 'subquestions' do
-        it 'acts the same on subquestions' do
-          definition = make_definition(<<-END)
-            title "Test"
-            default_question_options allow_blank_titles: true
-            question :v_22a, :type => :check_box do
-              option :v_22_a01, :description => "Niet genoeg informatie"
-            end
-          END
-          expect(definition).to be_valid
-        end
-
-        it 'acts the same on title_question' do
-          definition = make_definition(<<-END)
-            title "Test"
-            default_question_options allow_blank_titles: true
-            question :v_100a, :type => :radio, :presentation => :horizontal, :required => false do
-              title "  100a."
-              title_question :v_100a_01, :type => :string, :title => ''
-              option :a1, :value => 0, :description => "Optie 1"
-              option :a2, :value => 1, :description => "Optie 2"
-              option :a3, :value => 2, :description => "Optie 3"
-            end
-          END
-          expect(definition).to be_valid
-        end
-      end
-
-      context 'spaces before question number' do
-        it 'is valid when title starts with 0 or 1 spaces before question number' do
-          definition = make_definition(<<-END)
-            title "Test"
-            question :v_1, type: :string do
-              title "1\\\\. Title"
-            end
-          END
-          expect(definition).to be_valid
-        end
-
-        it 'is invalid when title starts with more than 1 space before question number' do
-          definition = make_definition(<<-END)
-            title "Test"
-            question :v_1, type: :string do
-              title "  1\\\\. Title"
-            end
-          END
-          expect(definition).to be_invalid
-        end
-      end
-    end
-
-    describe 'subquestions inside a table' do
-      it 'accepts title_questions' do
-        expect(make_definition(<<-END).valid?).to be_truthy
-          title "Test"
-          panel do
-            table do
-              question :v_1, type: :radio do
-                title "Question"
-                title_question :v_2, :type => :string, :title => "Title Question", :depends_on => [:v_1_a1]
-                option :a1, value: 1, description: "Option 1"
-                option :a2, value: 2, description: "Option 2"
-              end
-            end
-          end
-        END
-      end
-
-      it 'does not accept subquestions in questions inside a table' do
-        expect(make_definition(<<-END).valid?).to be_falsey
-          title "Test"
-          panel do
-            table do
-              question :v_1, type: :radio do
-                title "Question"
-                option :a1, value: 1, description: "Option 1"
-                option :a2, value: 2, description: "Option 2" do
-                  question :v_2, type: :string, title: 'Subquestion'
-                end
-              end
-            end
-          end
-        END
-      end
-    end
-
-    describe 'flags' do
-      it 'does not accept shows_questions arrays with unknown keys' do
-        expect(make_definition(<<-END).valid?).to be_falsey
-          title "Test"
-          flag key: 'a', description: 'a flag', shows_questions: [:v_22]
-        END
-      end
-
-      it 'does not accept hides_questions arrays with unknown keys' do
-        expect(make_definition(<<-END).valid?).to be_falsey
-          title "Test"
-          flag key: 'a', description: 'a flag', hides_questions: [:v_22]
-        END
-      end
-
-      it 'accepts shows_questions arrays with known keys' do
-        expect(make_definition(<<-END).valid?).to be_truthy
-          title "Test"
-          flag key: 'a', description: 'a flag', shows_questions: [:v_22]
-          question :v_22, type: :string do
-            title 'Question'
-          end
-        END
-      end
-
-      it 'accepts hides_questions arrays with known keys' do
-        expect(make_definition(<<-END).valid?).to be_truthy
-          title "Test"
-          flag key: 'a', description: 'a flag', hides_questions: [:v_22]
-          question :v_22, type: :string do
-            title 'Question'
-          end
-        END
-      end
-
-      it 'accepts depends_on with known flags' do
-        definition = make_definition <<-END
-          title 'Test'
-          flag key: :test, description_true: 'Test flag', description_false: 'Test flag uit'
-          flag key: :test2, description_true: 'Test flag 2', description_false: 'Test flag 2 uit', depends_on: :test_test
-        END
-        definition.valid?
-        expect(definition.errors.full_messages).to be_blank
-      end
-
-      it 'does not accept a flag depending on a non existing flag key' do
-        definition = make_definition <<-END
-          title 'Test'
-          flag key: :test, description_true: 'Test flag', description_false: 'Test flag uit', depends_on: :nonexistent
-        END
-        definition.valid?
-        expect(definition.errors[:sourcecode].first[:message]).to include "Flag test_test depends_on nonexistent flag 'nonexistent'"
-      end
-    end
-
-    describe 'respondent_types' do
-      it 'is optional' do
-        expect(make_definition(<<-END).valid?).to be_truthy
-          title "Test"
-        END
-      end
-
-      it 'accepts valid respondent_types' do
-        expect(make_definition(<<-END).valid?).to be_truthy
-          title "Test"
-          respondent_types :patient, :parent
-        END
-      end
-
-      it 'does not accept invalid respondent_types' do
-        expect(make_definition(<<-END).valid?).to be_falsey
-          title "Test"
-          respondent_types :santa_claus
-        END
-      end
-    end
-
-    describe 'outcome_tables' do
-      it 'checks if outcome tables are valid' do
-        expect(make_definition(<<-END).valid?).to be_truthy
-          title "Test"
-          score(:key, label: 'score', schema: [{key: :value, label: 'Score', export_key: :key}]) do {value: 'oh1'} end
-          score(:key2, label: 'score2', schema: [{key: :value, label: 'Score 2', export_key: :key2}]) do {value: 'oh2'} end
-
-          outcome_table key: :test_outcome_table,
-                        score_keys: %i[key key2],
-                        subscore_keys: [:value]
-        END
-      end
-
-      it 'fails if there is an error in outcome tables' do
-        definition = make_definition(<<-END)
-          title "Test"
-          score(:key, label: 'score', schema: [{key: :value, label: 'Score', export_key: :key}]) do {value: 'oh1'} end
-          score(:key2, label: 'score2', schema: [{key: :value, label: 'Score 2', export_key: :key2}]) do {value: 'oh2'} end
-
-          outcome_table key: :test_outcome_table,
-                        score_keys: %i[key unknown_key_1 unknown_key_2],
-                        subscore_keys: [:value]
-        END
-        expect(definition.valid?).to be_falsey
-        expect(definition.errors.full_messages.first).to include('Score keys :unknown_key_1 not found in score schemas')
-      end
-    end
-    describe '#validate_values_unique' do
-      it 'fails on duplicate option values' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :scale do
-            title 'Ah'
-            option :a1, value: 0
-            option :a2, value: 0
-          end
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to \
-            include('v_1:a2: Another option with value 0 is already defined.')
-      end
-
-      it 'does not complain about checkbox questions' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :check_box do
-            title "Testvraag met een check_box"
-            option :v_1a1, description: 'some_description'
-            option :v_1a2, description: 'more_description'
-          end
-        END
-        expect(definition.valid?).to be true
-      end
-
-      it 'skips validation if question was passed allow_duplicate_option_values: true' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :scale, allow_duplicate_option_values: true do
-            title 'Ah'
-            option :a1, value: 0
-            option :a2, value: 0
-          end
-        END
-        expect(definition.valid?).to be true
-      end
-
-      it 'skips placeholder options' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :select do
-            title 'Ah'
-            option :a1, placeholder: true
-            option :a2, placeholder: true
-          end
-        END
-        expect(definition.valid?).to be true
-      end
-
-      it 'skips inner titles' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :radio do
-            title "Wat is de hoogst genoten opleiding die u hebt afgerond?"
-            option :a0,  value:  0, description: "Geen"
-            inner_title "Basisonderwijs:"
-            option :a1,  value:  1, description: "Basisonderwijs"
-            option :a2,  value:  2, description: "(SBO) Speciale School voor Basisonderwijs"
-            option :a3,  value:  3, description: "(SO) Speciaal Onderwijs"
-            inner_title "Voortgezet onderwijs:"
-          end
-        END
-        expect(definition.valid?).to be true
-      end
-
-      it 'checks if all options have values' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :scale do
-            title 'Ah'
-            option :a1
-          end
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to \
-            include('v_1:a1: Has no option value defined.')
-      end
-    end
-
-    describe '#validate_placeholder_options_nil_values' do
-      it 'validates placeholder options do not have values' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :select do
-            title 'Ah'
-            option :a1, placeholder: true, value: 32
-          end
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to \
-            include('v_1:a1: Placeholder options should not have values defined.')
-      end
-    end
-
-    describe '#validate_markdown' do
-      it 'validates question titles' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :string, title: 'a <b> tag'
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to include('That tag isn\'t allowed here')
-      end
-
-      it 'validates question description' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :string, title: 'fine', description: 'a <b> tag'
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to include('That tag isn\'t allowed here')
-      end
-
-      it 'validates option description' do
-        definition = make_definition(<<-END)
-          title "Test"
-          question :v_1, type: :select, title: 'fine' do
-            option :a1, value: 32, description: 'a <b> tag'
-          end
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to include('That tag isn\'t allowed here')
-      end
-    end
-
-    describe '#validate_raw_content_items' do
-      it 'validates html fields' do
-        definition = make_definition(<<-END)
-          title "Test"
-          panel do
-            html "A <b> tag"
-          end
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to include('That tag isn\'t allowed here')
-      end
-
-      it 'allows video elements' do
-        definition = make_definition(<<-END)
-          title "Test"
-          panel do
-            html "A <video></video> tag"
-          end
-        END
-        expect(definition.valid?).to be true
-      end
-
-      it 'validates items with raw_content' do
-        definition = make_definition(<<-END)
-          title "Test"
-          panel do
-            question :v_1, type: :float, title: 'q', raw_content: "<p>a <b> tag</p>"
-          end
-        END
-        expect(definition.valid?).to be false
-        expect(definition.errors.full_messages.first).to include('That tag isn\'t allowed here')
-      end
-    end
-  end
-end