decidim-forms 0.19.1 → 0.23.0

data/config/locales/zh-TW.yml

@@ -0,0 +1 @@
+zh-TW:

data/db/migrate/20190315203056_add_session_token_to_decidim_forms_answers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class AddSessionTokenToDecidimFormsAnswers < ActiveRecord::Migration[5.2]
+  class Answer < ApplicationRecord
+    self.table_name = :decidim_forms_answers
+  end
+
+  def change
+    add_column :decidim_forms_answers, :session_token, :string, null: false, default: ""
+    add_index :decidim_forms_answers, :session_token
+
+    Answer.find_each do |answer|
+      answer.session_token = Digest::MD5.hexdigest("#{answer.decidim_user_id}-#{Rails.application.secrets.secret_key_base}")
+      answer.save!
+    end
+  end
+end

data/db/migrate/20190930094710_add_ip_hash_to_decidim_form_answers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddIpHashToDecidimFormAnswers < ActiveRecord::Migration[5.2]
+  class Answer < ApplicationRecord
+    self.table_name = :decidim_forms_answers
+  end
+
+  def change
+    add_column :decidim_forms_answers, :ip_hash, :string
+    add_index :decidim_forms_answers, :ip_hash
+  end
+end

data/db/migrate/20200130194123_create_decidim_forms_display_conditions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateDecidimFormsDisplayConditions < ActiveRecord::Migration[5.1]
+  def up
+    create_table :decidim_forms_display_conditions do |t|
+      t.bigint :decidim_question_id, index: { name: "decidim_forms_display_condition_question" }, null: false
+      t.bigint :decidim_condition_question_id, index: { name: "decidim_forms_display_condition_condition_question" }, null: false
+      t.bigint :decidim_answer_option_id, index: { name: "decidim_forms_display_condition_answer_option" }
+      t.integer :condition_type, default: 0, null: false
+      t.jsonb :condition_value
+      t.boolean :mandatory, default: false
+
+      t.timestamps
+    end
+  end
+
+  def down
+    drop_table :decidim_forms_display_conditions
+  end
+end

data/db/migrate/20200225123810_create_decidim_forms_question_matrix_rows.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class CreateDecidimFormsQuestionMatrixRows < ActiveRecord::Migration[5.2]
+  def change
+    create_table :decidim_forms_question_matrix_rows do |t|
+      t.references :decidim_question, index: { name: "index_decidim_forms_question_matrix_questionnaire_id" }
+      t.integer :position, index: true
+      t.jsonb :body
+    end
+  end
+end

data/db/migrate/20200304152939_add_matrix_row_id_to_decidim_forms_answer_choices.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class AddMatrixRowIdToDecidimFormsAnswerChoices < ActiveRecord::Migration[5.2]
+  class AnswerChoice < ApplicationRecord
+    self.table_name = :decidim_forms_answer_choices
+  end
+
+  def change
+    add_column :decidim_forms_answer_choices, :decidim_question_matrix_row_id, :integer
+  end
+end

data/lib/decidim/api/questionnaire_entity_interface.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # This interface should be implemented by any Type that can be linked to a questionnaire
+    # The only requirement is to have an ID and the Type name be the class.name + Type
+    QuestionnaireEntityInterface = GraphQL::InterfaceType.define do
+      name "QuestionnaireEntityInterface"
+      description "An interface that can be used in objects with questionnaires"
+
+      field :id, !types.ID, "ID of this entity"
+
+      resolve_type ->(obj, _ctx) {
+        "#{obj.class.name}Type".constantize
+      }
+    end
+  end
+end

data/lib/decidim/exporters/form_pdf.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "wicked_pdf"
+
+module Decidim
+  module Exporters
+    # Inherits from abstract PDF exporter. This class is used to set
+    # the parameters used to create a PDF when exporting Survey Answers.
+    #
+    class FormPDF < PDF
+      # i18n-tasks-use t('decidim.admin.exports.formats.FormPDF')
+
+      def controller
+        @controller ||= FormPDFControllerHelper.new
+      end
+
+      def template
+        "decidim/forms/admin/questionnaires/answers/export/pdf.html.erb"
+      end
+
+      def layout
+        "decidim/forms/admin/questionnaires/questionnaire_answers.html.erb"
+      end
+
+      def locals
+        {
+          questionnaire: collection.first.first.questionnaire,
+          collection: collection.map { |answer| Decidim::Forms::Admin::QuestionnaireParticipantPresenter.new(participant: answer.first) }
+        }
+      end
+    end
+  end
+end

data/lib/decidim/exporters/form_pdf_controller_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    # A dummy controller to render views while exporting questionnaires
+    class FormPDFControllerHelper < ActionController::Base
+      helper Decidim::TranslationsHelper
+      helper Decidim::Forms::Admin::QuestionnaireAnswersHelper
+    end
+  end
+end

data/lib/decidim/forms.rb

@@ -3,6 +3,7 @@
 require "decidim/forms/admin"
 require "decidim/forms/engine"
 require "decidim/forms/admin_engine"
+require "decidim/forms/api"
 
 module Decidim
   # This namespace holds the logic of the `Forms`.
@@ -10,4 +11,9 @@ module Decidim
     autoload :UserAnswersSerializer, "decidim/forms/user_answers_serializer"
     autoload :DataPortabilityUserAnswersSerializer, "decidim/forms/data_portability_user_answers_serializer"
   end
+
+  module Exporters
+    autoload :FormPDF, "decidim/exporters/form_pdf"
+    autoload :FormPDFControllerHelper, "decidim/exporters/form_pdf_controller_helper"
+  end
 end

data/lib/decidim/forms/admin_engine.rb

@@ -10,7 +10,7 @@ module Decidim
       paths["lib/tasks"] = nil
 
       initializer "decidim_forms.admin_assets" do |app|
-        app.config.assets.precompile += %w(admin/decidim_forms_manifest.js)
+        app.config.assets.precompile += %w(admin/decidim_forms_manifest.js admin/decidim_forms_manifest.css)
       end
 
       def load_seed

data/lib/decidim/forms/api.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    autoload :QuestionnaireEntityInterface, "decidim/api/questionnaire_entity_interface"
+  end
+end

data/lib/decidim/forms/test.rb

@@ -2,3 +2,9 @@
 
 require "decidim/forms/test/shared_examples/has_questionnaire"
 require "decidim/forms/test/shared_examples/manage_questionnaires"
+require "decidim/forms/test/shared_examples/manage_questionnaire_answers"
+
+if defined? Decidim::Templates
+  require "decidim/templates/test/shared_examples/uses_questionnaire_templates"
+  require "decidim/templates/test/factories"
+end

data/lib/decidim/forms/test/factories.rb

@@ -13,27 +13,75 @@ FactoryBot.define do
     end
     tos { generate_localized_title }
     questionnaire_for { build(:participatory_process) }
+
+    trait :with_questions do
+      questions do
+        qs = %w(short_answer long_answer).collect do |text_question_type|
+          build(:questionnaire_question, question_type: text_question_type)
+        end
+        qs << build(:questionnaire_question, :with_answer_options, question_type: :single_option)
+        qs
+      end
+    end
+
+    trait :empty do
+      title { {} }
+      description { {} }
+      tos { {} }
+    end
   end
 
   factory :questionnaire_question, class: "Decidim::Forms::Question" do
     transient do
-      answer_options { [] }
+      options { [] }
+      rows { [] }
     end
 
     body { generate_localized_title }
+    description do
+      Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+        generate_localized_title
+      end
+    end
     mandatory { false }
     position { 0 }
     question_type { Decidim::Forms::Question::TYPES.first }
     questionnaire
 
     before(:create) do |question, evaluator|
-      evaluator.answer_options.each do |answer_option|
-        question.answer_options.build(
-          body: answer_option["body"],
-          free_text: answer_option["free_text"]
-        )
+      if question.answer_options.empty?
+        evaluator.options.each do |option|
+          question.answer_options.build(
+            body: option["body"],
+            free_text: option["free_text"]
+          )
+        end
+      end
+
+      if question.matrix_rows.empty?
+        evaluator.rows.each do |row|
+          question.matrix_rows.build(
+            body: row["body"]
+          )
+        end
       end
     end
+
+    trait :with_answer_options do
+      answer_options do
+        Array.new(3).collect { build(:answer_option) }
+      end
+    end
+
+    trait :conditioned do
+      display_conditions do
+        Array.new(3).collect { build(:display_condition) }
+      end
+    end
+
+    trait :separator do
+      question_type { :separator }
+    end
   end
 
   factory :answer, class: "Decidim::Forms::Answer" do
@@ -41,15 +89,41 @@ FactoryBot.define do
     questionnaire
     question { create(:questionnaire_question, questionnaire: questionnaire) }
     user { create(:user, organization: questionnaire.questionnaire_for.organization) }
+    session_token { Digest::MD5.hexdigest(user.id.to_s) }
   end
 
   factory :answer_option, class: "Decidim::Forms::AnswerOption" do
     question { create(:questionnaire_question) }
     body { generate_localized_title }
+    free_text { false }
   end
 
   factory :answer_choice, class: "Decidim::Forms::AnswerChoice" do
     answer
     answer_option { create(:answer_option, question: answer.question) }
+    matrix_row { create(:question_matrix_row, question: answer.question) }
+  end
+
+  factory :question_matrix_row, class: "Decidim::Forms::QuestionMatrixRow" do
+    question { create(:questionnaire_question) }
+    body { generate_localized_title }
+    position { 0 }
+  end
+
+  factory :display_condition, class: "Decidim::Forms::DisplayCondition" do
+    condition_question { create(:questionnaire_question) }
+    question { create(:questionnaire_question, position: 1) }
+    condition_type { :answered }
+    mandatory { true }
+
+    trait :equal do
+      condition_type { :equal }
+      answer_option { create(:answer_option, question: condition_question) }
+    end
+
+    trait :match do
+      condition_type { :match }
+      condition_value { generate_localized_title }
+    end
   end
 end

data/lib/decidim/forms/test/shared_examples/has_questionnaire.rb

@@ -35,7 +35,9 @@ shared_examples_for "has questionnaire" do
 
       check "questionnaire_tos_agreement"
 
-      accept_confirm { click_button "Submit" }
+      accept_confirm do
+        click_button "Submit"
+      end
 
       within ".success.flash" do
         expect(page).to have_content("successfully")
@@ -47,6 +49,73 @@ shared_examples_for "has questionnaire" do
       expect(page).to have_no_i18n_content(question.body)
     end
 
+    context "with multiple steps" do
+      let!(:separator) { create(:questionnaire_question, questionnaire: questionnaire, position: 1, question_type: :separator) }
+      let!(:question2) { create(:questionnaire_question, questionnaire: questionnaire, position: 2) }
+
+      before do
+        visit questionnaire_public_path
+      end
+
+      it "allows answering the first questionnaire" do
+        expect(page).to have_content("STEP 1 OF 2")
+
+        within ".answer-questionnaire__submit" do
+          expect(page).to have_no_content("Back")
+        end
+
+        answer_first_questionnaire
+
+        expect(page).to have_no_selector(".success.flash")
+      end
+
+      it "allows revisiting previously-answered questionnaires with my answers" do
+        answer_first_questionnaire
+
+        click_link "Back"
+
+        expect(page).to have_content("STEP 1 OF 2")
+        expect(page).to have_field("questionnaire_responses_0", with: "My first answer")
+      end
+
+      it "finishes the submission when answering the last questionnaire" do
+        answer_first_questionnaire
+
+        check "questionnaire_tos_agreement"
+        accept_confirm { click_button "Submit" }
+
+        within ".success.flash" do
+          expect(page).to have_content("successfully")
+        end
+
+        visit questionnaire_public_path
+
+        expect(page).to have_content("You have already answered this form.")
+      end
+
+      def answer_first_questionnaire
+        expect(page).to have_no_selector("#questionnaire_tos_agreement")
+
+        fill_in question.body["en"], with: "My first answer"
+        within ".answer-questionnaire__submit" do
+          click_link "Continue"
+        end
+        expect(page).to have_content("STEP 2 OF 2")
+      end
+    end
+
+    it "requires confirmation when exiting mid-answering" do
+      visit questionnaire_public_path
+
+      fill_in question.body["en"], with: "My first answer"
+
+      dismiss_page_unload do
+        page.find(".logo-wrapper a").click
+      end
+
+      expect(page).to have_current_path questionnaire_public_path
+    end
+
     context "when the questionnaire has already been answered by someone else" do
       let!(:question) do
         create(
@@ -54,7 +123,7 @@ shared_examples_for "has questionnaire" do
           questionnaire: questionnaire,
           question_type: "single_option",
           position: 0,
-          answer_options: [
+          options: [
             { "body" => Decidim::Faker::Localized.sentence },
             { "body" => Decidim::Faker::Localized.sentence }
           ]
@@ -163,7 +232,7 @@ shared_examples_for "has questionnaire" do
           question_type: "single_option",
           position: 0,
           mandatory: true,
-          answer_options: [
+          options: [
             { "body" => Decidim::Faker::Localized.sentence },
             { "body" => Decidim::Faker::Localized.sentence }
           ]
@@ -188,7 +257,7 @@ shared_examples_for "has questionnaire" do
     end
 
     context "when a question has a rich text description" do
-      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, position: 0, description: "<b>This question is important</b>") }
+      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, position: 0, description: { en: "<b>This question is important</b>" }) }
 
       it "properly interprets HTML descriptions" do
         visit questionnaire_public_path
@@ -205,7 +274,8 @@ shared_examples_for "has questionnaire" do
           :questionnaire_question,
           questionnaire: questionnaire,
           question_type: question_type,
-          answer_options: [
+          position: 1,
+          options: [
             { "body" => answer_option_bodies[0] },
             { "body" => answer_option_bodies[1] },
             { "body" => answer_option_bodies[2], "free_text" => true }
@@ -219,7 +289,8 @@ shared_examples_for "has questionnaire" do
           questionnaire: questionnaire,
           question_type: "multiple_option",
           max_choices: 2,
-          answer_options: [
+          position: 2,
+          options: [
             { "body" => Decidim::Faker::Localized.sentence },
             { "body" => Decidim::Faker::Localized.sentence },
             { "body" => Decidim::Faker::Localized.sentence }
@@ -237,16 +308,16 @@ shared_examples_for "has questionnaire" do
         it "renders them as radio buttons with attached text fields disabled by default" do
           expect(page).to have_selector(".radio-button-collection input[type=radio]", count: 3)
 
-          expect(page).to have_field("questionnaire_answers_0_choices_2_custom_body", disabled: true, count: 1)
+          expect(page).to have_field("questionnaire_responses_0_choices_2_custom_body", disabled: true, count: 1)
 
           choose answer_option_bodies[2]["en"]
 
-          expect(page).to have_field("questionnaire_answers_0_choices_2_custom_body", disabled: false, count: 1)
+          expect(page).to have_field("questionnaire_responses_0_choices_2_custom_body", disabled: false, count: 1)
         end
 
         it "saves the free text in a separate field if submission correct" do
           choose answer_option_bodies[2]["en"]
-          fill_in "questionnaire_answers_0_choices_2_custom_body", with: "Cacatua"
+          fill_in "questionnaire_responses_0_choices_2_custom_body", with: "Cacatua"
 
           check "questionnaire_tos_agreement"
           accept_confirm { click_button "Submit" }
@@ -264,7 +335,7 @@ shared_examples_for "has questionnaire" do
           check other_question.answer_options.third.body["en"]
 
           choose answer_option_bodies[2]["en"]
-          fill_in "questionnaire_answers_0_choices_2_custom_body", with: "Cacatua"
+          fill_in "questionnaire_responses_0_choices_2_custom_body", with: "Cacatua"
 
           check "questionnaire_tos_agreement"
           accept_confirm { click_button "Submit" }
@@ -273,7 +344,7 @@ shared_examples_for "has questionnaire" do
             expect(page).to have_content("There was a problem answering")
           end
 
-          expect(page).to have_field("questionnaire_answers_0_choices_2_custom_body", with: "Cacatua")
+          expect(page).to have_field("questionnaire_responses_0_choices_2_custom_body", with: "Cacatua")
         end
       end
 
@@ -283,16 +354,16 @@ shared_examples_for "has questionnaire" do
         it "renders them as check boxes with attached text fields disabled by default" do
           expect(page.first(".check-box-collection")).to have_selector("input[type=checkbox]", count: 3)
 
-          expect(page).to have_field("questionnaire_answers_0_choices_2_custom_body", disabled: true, count: 1)
+          expect(page).to have_field("questionnaire_responses_0_choices_2_custom_body", disabled: true, count: 1)
 
           check answer_option_bodies[2]["en"]
 
-          expect(page).to have_field("questionnaire_answers_0_choices_2_custom_body", disabled: false, count: 1)
+          expect(page).to have_field("questionnaire_responses_0_choices_2_custom_body", disabled: false, count: 1)
         end
 
         it "saves the free text in a separate field if submission correct" do
           check answer_option_bodies[2]["en"]
-          fill_in "questionnaire_answers_0_choices_2_custom_body", with: "Cacatua"
+          fill_in "questionnaire_responses_0_choices_2_custom_body", with: "Cacatua"
 
           check "questionnaire_tos_agreement"
           accept_confirm { click_button "Submit" }
@@ -305,12 +376,12 @@ shared_examples_for "has questionnaire" do
         end
 
         it "preserves the previous custom body if submission not correct" do
-          check "questionnaire_answers_1_choices_0_body"
-          check "questionnaire_answers_1_choices_1_body"
-          check "questionnaire_answers_1_choices_2_body"
+          check "questionnaire_responses_1_choices_0_body"
+          check "questionnaire_responses_1_choices_1_body"
+          check "questionnaire_responses_1_choices_2_body"
 
           check answer_option_bodies[2]["en"]
-          fill_in "questionnaire_answers_0_choices_2_custom_body", with: "Cacatua"
+          fill_in "questionnaire_responses_0_choices_2_custom_body", with: "Cacatua"
 
           check "questionnaire_tos_agreement"
           accept_confirm { click_button "Submit" }
@@ -319,7 +390,7 @@ shared_examples_for "has questionnaire" do
             expect(page).to have_content("There was a problem answering")
           end
 
-          expect(page).to have_field("questionnaire_answers_0_choices_2_custom_body", with: "Cacatua")
+          expect(page).to have_field("questionnaire_responses_0_choices_2_custom_body", with: "Cacatua")
         end
       end
     end
@@ -330,7 +401,7 @@ shared_examples_for "has questionnaire" do
       it "renders the answer as a textarea" do
         visit questionnaire_public_path
 
-        expect(page).to have_selector("textarea#questionnaire_answers_0")
+        expect(page).to have_selector("textarea#questionnaire_responses_0")
       end
     end
 
@@ -340,13 +411,13 @@ shared_examples_for "has questionnaire" do
       it "renders the answer as a text field" do
         visit questionnaire_public_path
 
-        expect(page).to have_selector("input[type=text]#questionnaire_answers_0")
+        expect(page).to have_selector("input[type=text]#questionnaire_responses_0")
       end
     end
 
     context "when question type is single option" do
       let(:answer_options) { Array.new(2) { { "body" => Decidim::Faker::Localized.sentence } } }
-      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, question_type: "single_option", answer_options: answer_options) }
+      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, question_type: "single_option", options: answer_options) }
 
       it "renders answers as a collection of radio buttons" do
         visit questionnaire_public_path
@@ -372,7 +443,7 @@ shared_examples_for "has questionnaire" do
 
     context "when question type is multiple option" do
       let(:answer_options) { Array.new(3) { { "body" => Decidim::Faker::Localized.sentence } } }
-      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, question_type: "multiple_option", answer_options: answer_options) }
+      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, question_type: "multiple_option", options: answer_options) }
 
       it "renders answers as a collection of radio buttons" do
         visit questionnaire_public_path
@@ -409,6 +480,8 @@ shared_examples_for "has questionnaire" do
         check answer_options[1]["body"][:en]
         check answer_options[2]["body"][:en]
 
+        expect(page).to have_content("too many choices")
+
         check "questionnaire_tos_agreement"
 
         accept_confirm { click_button "Submit" }
@@ -429,17 +502,46 @@ shared_examples_for "has questionnaire" do
       end
     end
 
-    context "when question type is multiple option" do
-      let(:answer_options) { Array.new(2) { { "body" => Decidim::Faker::Localized.sentence } } }
-      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, question_type: "multiple_option", answer_options: answer_options) }
+    context "when question type is sorting" do
+      let!(:question) do
+        create(
+          :questionnaire_question,
+          questionnaire: questionnaire,
+          question_type: "sorting",
+          options: [
+            { "body" => { "en" => "chocolate" } },
+            { "body" => { "en" => "like" } },
+            { "body" => { "en" => "We" } },
+            { "body" => { "en" => "dark" } },
+            { "body" => { "en" => "all" } }
+          ]
+        )
+      end
 
-      it "renders the question answers as a collection of radio buttons" do
+      it "renders the question answers as a collection of check boxes sortable on click" do
         visit questionnaire_public_path
 
-        expect(page).to have_selector(".check-box-collection input[type=checkbox]", count: 2)
+        expect(page).to have_selector(".sortable-check-box-collection input[type=checkbox]", count: 5)
 
-        check answer_options[0]["body"][:en]
-        check answer_options[1]["body"][:en]
+        expect(page).to have_content("chocolate\nlike\nWe\ndark\nall")
+
+        check "We"
+        check "all"
+        check "like"
+        check "dark"
+        check "chocolate"
+
+        expect(page).to have_content("1. We\n2. all\n3. like\n4. dark\n5. chocolate")
+      end
+
+      it "properly saves valid sortings" do
+        visit questionnaire_public_path
+
+        check "We"
+        check "all"
+        check "like"
+        check "dark"
+        check "chocolate"
 
         check "questionnaire_tos_agreement"
 
@@ -449,53 +551,175 @@ shared_examples_for "has questionnaire" do
           expect(page).to have_content("successfully")
         end
 
+        expect(Decidim::Forms::Answer.first.choices.pluck(:position, :body)).to eq(
+          [[0, "We"], [1, "all"], [2, "like"], [3, "dark"], [4, "chocolate"]]
+        )
+      end
+
+      it "displays errors on incomplete sortings" do
         visit questionnaire_public_path
 
-        expect(page).to have_content("You have already answered this form.")
-        expect(page).to have_no_i18n_content(question.body)
+        check "We"
+
+        accept_confirm { click_button "Submit" }
+
+        within ".alert.flash" do
+          expect(page).to have_content("problem")
+        end
+
+        expect(page).to have_content("are not complete")
+      end
+
+      it "displays maintains sorting order if errors" do
+        visit questionnaire_public_path
+
+        check "We"
+        check "dark"
+        check "chocolate"
+
+        accept_confirm { click_button "Submit" }
+
+        within ".alert.flash" do
+          expect(page).to have_content("problem")
+        end
+
+        # Check the next round to ensure a re-submission conserves status
+        expect(page).to have_content("are not complete")
+        expect(page).to have_content("1. We\n2. dark\n3. chocolate\nlike\nall")
+
+        checkboxes = page.all("input[type=checkbox]")
+
+        checkboxes[0].uncheck
+        check "We"
+        check "all"
+
+        accept_confirm { click_button "Submit" }
+
+        within ".alert.flash" do
+          expect(page).to have_content("problem")
+        end
+
+        expect(page).to have_content("are not complete")
+        expect(page).to have_content("1. dark\n2. chocolate\n3. We\n4. all\nlike")
       end
     end
 
-    context "when question type is sorting" do
+    context "when question type is matrix_single" do
+      let(:matrix_rows) { Array.new(2) { { "body" => Decidim::Faker::Localized.sentence } } }
+      let(:answer_options) { Array.new(2) { { "body" => Decidim::Faker::Localized.sentence } } }
+      let(:mandatory) { false }
+
       let!(:question) do
         create(
           :questionnaire_question,
           questionnaire: questionnaire,
-          question_type: "sorting",
-          answer_options: [
-            { "body" => "idiotas" },
-            { "body" => "trates" },
-            { "body" => "No" },
-            { "body" => "por" },
-            { "body" => "nos" }
-          ]
+          question_type: "matrix_single",
+          rows: matrix_rows,
+          options: answer_options,
+          mandatory: mandatory
         )
       end
 
-      it "renders the question answers as a collection of check boxes sortable on click" do
+      it "renders the question answers as a collection of radio buttons" do
         visit questionnaire_public_path
 
-        expect(page).to have_selector(".sortable-check-box-collection input[type=checkbox]", count: 5)
+        expect(page).to have_selector(".radio-button-collection input[type=radio]", count: 4)
+
+        expect(page).to have_content(matrix_rows.map { |row| row["body"]["en"] }.join("\n"))
+        expect(page).to have_content(answer_options.map { |option| option["body"]["en"] }.join(" "))
+
+        radio_buttons = page.all(".radio-button-collection input[type=radio]")
+
+        choose radio_buttons.first[:id]
+        choose radio_buttons.last[:id]
 
-        expect(page).to have_content("idiotas\ntrates\nNo\npor\nnos")
+        check "questionnaire_tos_agreement"
 
-        check "No"
-        check "nos"
-        check "trates"
-        check "por"
-        check "idiotas"
+        accept_confirm { click_button "Submit" }
 
-        expect(page).to have_content("1. No\n2. nos\n3. trates\n4. por\n5. idiotas")
+        within ".success.flash" do
+          expect(page).to have_content("successfully")
+        end
+
+        visit questionnaire_public_path
+
+        expect(page).to have_content("You have already answered this form.")
+        expect(page).to have_no_i18n_content(question.body)
+
+        first_choice, last_choice = Decidim::Forms::Answer.last.choices.pluck(:decidim_answer_option_id, :decidim_question_matrix_row_id)
+
+        expect(first_choice).to eq([question.answer_options.first.id, question.matrix_rows.first.id])
+        expect(last_choice).to eq([question.answer_options.last.id, question.matrix_rows.last.id])
       end
 
-      it "properly saves valid sortings" do
+      it "preserves the chosen answers if submission not correct" do
+        visit questionnaire_public_path
+
+        radio_buttons = page.all(".radio-button-collection input[type=radio]")
+        choose radio_buttons[1][:id]
+
+        accept_confirm { click_button "Submit" }
+
+        within ".alert.flash" do
+          expect(page).to have_content("There was a problem answering")
+        end
+
+        radio_buttons = page.all(".radio-button-collection input[type=radio]")
+        expect(radio_buttons.map { |b| b[:checked] }).to eq([nil, "true", nil, nil])
+      end
+
+      context "when the question is mandatory and the answer is not complete" do
+        let!(:mandatory) { true }
+
+        it "shows an error if the question is mandatory and the answer is not complete" do
+          visit questionnaire_public_path
+
+          radio_buttons = page.all(".radio-button-collection input[type=radio]")
+          choose radio_buttons[0][:id]
+
+          check "questionnaire_tos_agreement"
+          accept_confirm { click_button "Submit" }
+
+          within ".alert.flash" do
+            expect(page).to have_content("There was a problem answering")
+          end
+
+          expect(page).to have_content("Choices are not complete")
+        end
+      end
+    end
+
+    context "when question type is matrix_multiple" do
+      let(:matrix_rows) { Array.new(2) { { "body" => Decidim::Faker::Localized.sentence } } }
+      let(:answer_options) { Array.new(3) { { "body" => Decidim::Faker::Localized.sentence } } }
+      let(:max_choices) { nil }
+      let(:mandatory) { false }
+
+      let!(:question) do
+        create(
+          :questionnaire_question,
+          questionnaire: questionnaire,
+          question_type: "matrix_multiple",
+          rows: matrix_rows,
+          options: answer_options,
+          max_choices: max_choices,
+          mandatory: mandatory
+        )
+      end
+
+      it "renders the question answers as a collection of check boxes" do
         visit questionnaire_public_path
 
-        check "No"
-        check "nos"
-        check "trates"
-        check "por"
-        check "idiotas"
+        expect(page).to have_selector(".check-box-collection input[type=checkbox]", count: 6)
+
+        expect(page).to have_content(matrix_rows.map { |row| row["body"]["en"] }.join("\n"))
+        expect(page).to have_content(answer_options.map { |option| option["body"]["en"] }.join(" "))
+
+        checkboxes = page.all(".check-box-collection input[type=checkbox]")
+
+        check checkboxes[0][:id]
+        check checkboxes[1][:id]
+        check checkboxes[3][:id]
 
         check "questionnaire_tos_agreement"
 
@@ -505,24 +729,658 @@ shared_examples_for "has questionnaire" do
           expect(page).to have_content("successfully")
         end
 
-        expect(Decidim::Forms::Answer.first.choices.pluck(:position, :body)).to eq(
-          [[0, "No"], [1, "nos"], [2, "trates"], [3, "por"], [4, "idiotas"]]
-        )
+        visit questionnaire_public_path
+
+        expect(page).to have_content("You have already answered this form.")
+        expect(page).to have_no_i18n_content(question.body)
+
+        first_choice, second_choice, third_choice = Decidim::Forms::Answer.last.choices.pluck(:decidim_answer_option_id, :decidim_question_matrix_row_id)
+
+        expect(first_choice).to eq([question.answer_options.first.id, question.matrix_rows.first.id])
+        expect(second_choice).to eq([question.answer_options.second.id, question.matrix_rows.first.id])
+        expect(third_choice).to eq([question.answer_options.first.id, question.matrix_rows.last.id])
       end
 
-      it "displays errors on incomplete sortings" do
-        visit questionnaire_public_path
+      context "when the question hax max_choices defined" do
+        let!(:max_choices) { 2 }
 
-        check "No"
+        it "respects the max number of choices" do
+          visit questionnaire_public_path
 
-        accept_confirm { click_button "Submit" }
+          expect(page).to have_content("Max choices: 2")
 
-        within ".alert.flash" do
-          expect(page).to have_content("problem")
+          checkboxes = page.all(".check-box-collection input[type=checkbox]")
+
+          check checkboxes[0][:id]
+          check checkboxes[1][:id]
+          check checkboxes[2][:id]
+
+          expect(page).to have_content("too many choices")
+
+          check checkboxes[3][:id]
+          check checkboxes[4][:id]
+
+          expect(page).to have_content("too many choices")
+
+          check checkboxes[5][:id]
+
+          uncheck checkboxes[0][:id]
+
+          expect(page).to have_content("too many choices")
+
+          check "questionnaire_tos_agreement"
+
+          accept_confirm { click_button "Submit" }
+
+          within ".alert.flash" do
+            expect(page).to have_content("There was a problem answering")
+          end
+
+          expect(page).to have_content("are too many")
+
+          checkboxes = page.all(".check-box-collection input[type=checkbox]")
+
+          uncheck checkboxes[5][:id]
+
+          accept_confirm { click_button "Submit" }
+
+          within ".success.flash" do
+            expect(page).to have_content("successfully")
+          end
         end
+      end
 
-        expect(page).to have_content("are not complete")
+      context "when the question is mandatory and the answer is not complete" do
+        let!(:mandatory) { true }
+
+        it "shows an error" do
+          visit questionnaire_public_path
+
+          checkboxes = page.all(".check-box-collection input[type=checkbox]")
+          check checkboxes[0][:id]
+
+          check "questionnaire_tos_agreement"
+          accept_confirm { click_button "Submit" }
+
+          within ".alert.flash" do
+            expect(page).to have_content("There was a problem answering")
+          end
+
+          expect(page).to have_content("Choices are not complete")
+        end
       end
+
+      context "when the submission is not correct" do
+        let!(:max_choices) { 2 }
+
+        it "preserves the chosen answers" do
+          visit questionnaire_public_path
+
+          checkboxes = page.all(".check-box-collection input[type=checkbox]")
+          check checkboxes[0][:id]
+          check checkboxes[1][:id]
+          check checkboxes[2][:id]
+          check checkboxes[5][:id]
+
+          check "questionnaire_tos_agreement"
+          accept_confirm { click_button "Submit" }
+
+          within ".alert.flash" do
+            expect(page).to have_content("There was a problem answering")
+          end
+
+          checkboxes = page.all(".check-box-collection input[type=checkbox]")
+          expect(checkboxes.map { |c| c[:checked] }).to eq(["true", "true", "true", nil, nil, "true"])
+        end
+      end
+    end
+
+    describe "display conditions" do
+      let(:answer_options) do
+        3.times.to_a.map do |x|
+          {
+            "body" => Decidim::Faker::Localized.sentence,
+            "free_text" => x == 2
+          }
+        end
+      end
+      let(:condition_question_options) { [] }
+      let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, position: 2) }
+      let!(:conditioned_question_id) { "#questionnaire_responses_1" }
+      let!(:condition_question) do
+        create(:questionnaire_question,
+               questionnaire: questionnaire,
+               question_type: condition_question_type,
+               position: 1,
+               options: condition_question_options)
+      end
+
+      context "when a question has a display condition" do
+        context "when condition is of type 'answered'" do
+          let!(:display_condition) do
+            create(:display_condition,
+                   condition_type: "answered",
+                   question: question,
+                   condition_question: condition_question)
+          end
+
+          before do
+            visit questionnaire_public_path
+          end
+
+          context "when the condition_question type is short answer" do
+            let!(:condition_question_type) { "short_answer" }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              fill_in "questionnaire_responses_0", with: "Cacatua"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: ""
+              change_focus
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is long answer" do
+            let!(:condition_question_type) { "long_answer" }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              fill_in "questionnaire_responses_0", with: "Cacatua"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: ""
+              change_focus
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is single option" do
+            let!(:condition_question_type) { "single_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              choose condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+
+              choose condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is multiple option" do
+            let!(:condition_question_type) { "multiple_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+
+              uncheck condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+            end
+          end
+        end
+
+        context "when a question has a display condition of type 'not_answered'" do
+          let!(:display_condition) do
+            create(:display_condition,
+                   condition_type: "not_answered",
+                   question: question,
+                   condition_question: condition_question)
+          end
+
+          before do
+            visit questionnaire_public_path
+          end
+
+          context "when the condition_question type is short answer" do
+            let!(:condition_question_type) { "short_answer" }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: "Cacatua"
+              change_focus
+
+              expect_question_to_be_visible(false)
+
+              fill_in "questionnaire_responses_0", with: ""
+              change_focus
+
+              expect_question_to_be_visible(true)
+            end
+          end
+
+          context "when the condition_question type is long answer" do
+            let!(:condition_question_type) { "long_answer" }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: "Cacatua"
+              change_focus
+
+              expect_question_to_be_visible(false)
+
+              fill_in "questionnaire_responses_0", with: ""
+              change_focus
+
+              expect_question_to_be_visible(true)
+            end
+          end
+
+          context "when the condition_question type is single option" do
+            let!(:condition_question_type) { "single_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(true)
+
+              choose condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is multiple option" do
+            let!(:condition_question_type) { "multiple_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(true)
+
+              check condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(false)
+
+              uncheck condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+            end
+          end
+        end
+
+        context "when a question has a display condition of type 'equal'" do
+          let!(:display_condition) do
+            create(:display_condition,
+                   condition_type: "equal",
+                   question: question,
+                   condition_question: condition_question,
+                   answer_option: condition_question.answer_options.first)
+          end
+
+          before do
+            visit questionnaire_public_path
+          end
+
+          context "when the condition_question type is single option" do
+            let!(:condition_question_type) { "single_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              choose condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+
+              choose condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is multiple option" do
+            let!(:condition_question_type) { "multiple_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+
+              uncheck condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+            end
+          end
+        end
+
+        context "when a question has a display condition of type 'not_equal'" do
+          let!(:display_condition) do
+            create(:display_condition,
+                   condition_type: "not_equal",
+                   question: question,
+                   condition_question: condition_question,
+                   answer_option: condition_question.answer_options.first)
+          end
+
+          before do
+            visit questionnaire_public_path
+          end
+
+          context "when the condition_question type is single option" do
+            let!(:condition_question_type) { "single_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              choose condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(true)
+
+              choose condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is multiple option" do
+            let!(:condition_question_type) { "multiple_option" }
+            let!(:condition_question_options) { answer_options }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(true)
+
+              uncheck condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.second.body["en"]
+
+              expect_question_to_be_visible(true)
+            end
+          end
+        end
+
+        context "when a question has a display condition of type 'match'" do
+          let!(:condition_value) { { en: "something" } }
+          let!(:display_condition) do
+            create(:display_condition,
+                   condition_type: "match",
+                   question: question,
+                   condition_question: condition_question,
+                   condition_value: condition_value)
+          end
+
+          before do
+            visit questionnaire_public_path
+          end
+
+          context "when the condition_question type is short answer" do
+            let!(:condition_question_type) { "short_answer" }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              fill_in "questionnaire_responses_0", with: "Aren't we all expecting #{condition_value[:en]}?"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: "Now upcase #{condition_value[:en].upcase}!"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: "Cacatua"
+              change_focus
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is long answer" do
+            let!(:condition_question_type) { "long_answer" }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              fill_in "questionnaire_responses_0", with: "Aren't we all expecting #{condition_value[:en]}?"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: "Now upcase #{condition_value[:en].upcase}!"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              fill_in "questionnaire_responses_0", with: "Cacatua"
+              change_focus
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is single option" do
+            let!(:condition_question_type) { "single_option" }
+            let!(:condition_question_options) { answer_options }
+            let!(:condition_value) { { en: condition_question.answer_options.first.body["en"].split.second.upcase } }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              choose condition_question.answer_options.first.body["en"]
+
+              expect_question_to_be_visible(true)
+            end
+          end
+
+          context "when the condition_question type is single option with free text" do
+            let!(:condition_question_type) { "single_option" }
+            let!(:condition_question_options) { answer_options }
+            let!(:condition_value) { { en: "forty two" } }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              choose condition_question.answer_options.third.body["en"]
+              fill_in "questionnaire_responses_0_choices_2_custom_body", with: "The answer is #{condition_value[:en]}"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              choose condition_question.answer_options.first.body["en"]
+              expect_question_to_be_visible(false)
+
+              choose condition_question.answer_options.third.body["en"]
+              fill_in "questionnaire_responses_0_choices_2_custom_body", with: "oh no not 42 again"
+              change_focus
+
+              expect_question_to_be_visible(false)
+            end
+          end
+
+          context "when the condition_question type is multiple option" do
+            let!(:condition_question_type) { "multiple_option" }
+            let!(:condition_question_options) { answer_options }
+            let!(:condition_value) { { en: "forty two" } }
+
+            it "shows the question only if the condition is fulfilled" do
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.third.body["en"]
+              fill_in "questionnaire_responses_0_choices_2_custom_body", with: "The answer is #{condition_value[:en]}"
+              change_focus
+
+              expect_question_to_be_visible(true)
+
+              check condition_question.answer_options.first.body["en"]
+              expect_question_to_be_visible(true)
+
+              uncheck condition_question.answer_options.third.body["en"]
+              expect_question_to_be_visible(false)
+
+              check condition_question.answer_options.third.body["en"]
+              fill_in "questionnaire_responses_0_choices_2_custom_body", with: "oh no not 42 again"
+              change_focus
+
+              expect_question_to_be_visible(false)
+            end
+          end
+        end
+      end
+
+      context "when a question has multiple display conditions" do
+        before do
+          visit questionnaire_public_path
+        end
+
+        context "when all conditions are mandatory" do
+          let!(:condition_question_type) { "single_option" }
+          let!(:condition_question_options) { answer_options }
+          let!(:display_conditions) do
+            [
+              create(:display_condition,
+                     condition_type: "answered",
+                     question: question,
+                     condition_question: condition_question,
+                     mandatory: true),
+              create(:display_condition,
+                     condition_type: "not_equal",
+                     question: question,
+                     condition_question: condition_question,
+                     mandatory: true,
+                     answer_option: condition_question.answer_options.second)
+            ]
+          end
+
+          it "is displayed only if all conditions are fulfilled" do
+            expect_question_to_be_visible(false)
+
+            choose condition_question.answer_options.second.body["en"]
+
+            expect_question_to_be_visible(false)
+
+            choose condition_question.answer_options.first.body["en"]
+
+            expect_question_to_be_visible(true)
+          end
+        end
+
+        context "when all conditions are non-mandatory" do
+          let!(:condition_question_type) { "multiple_option" }
+          let!(:condition_question_options) { answer_options }
+          let!(:display_conditions) do
+            [
+              create(:display_condition,
+                     condition_type: "equal",
+                     question: question,
+                     condition_question: condition_question,
+                     mandatory: false,
+                     answer_option: condition_question.answer_options.first),
+              create(:display_condition,
+                     condition_type: "not_equal",
+                     question: question,
+                     condition_question: condition_question,
+                     mandatory: false,
+                     answer_option: condition_question.answer_options.third)
+            ]
+          end
+
+          it "is displayed if any of the conditions is fulfilled" do
+            expect_question_to_be_visible(false)
+
+            check condition_question.answer_options.first.body["en"]
+
+            expect_question_to_be_visible(true)
+
+            uncheck condition_question.answer_options.first.body["en"]
+            check condition_question.answer_options.second.body["en"]
+
+            expect_question_to_be_visible(true)
+
+            check condition_question.answer_options.first.body["en"]
+
+            expect_question_to_be_visible(true)
+          end
+        end
+
+        context "when a mandatory question has conditions that have not been fulfilled" do
+          let!(:condition_question_type) { "short_answer" }
+          let!(:question) { create(:questionnaire_question, questionnaire: questionnaire, position: 2, mandatory: true) }
+          let!(:display_conditions) do
+            [
+              create(:display_condition,
+                     condition_type: "match",
+                     question: question,
+                     condition_question: condition_question,
+                     condition_value: { en: "hey", es: "ey", ca: "ei" },
+                     mandatory: true)
+            ]
+          end
+
+          it "doesn't throw error" do
+            visit questionnaire_public_path
+
+            fill_in condition_question.body["en"], with: "My first answer"
+
+            check "questionnaire_tos_agreement"
+
+            accept_confirm { click_button "Submit" }
+
+            within ".success.flash" do
+              expect(page).to have_content("successfully")
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def expect_question_to_be_visible(visible)
+      expect(page).to have_css(conditioned_question_id, visible: visible)
+    end
+
+    def change_focus
+      check "questionnaire_tos_agreement"
     end
   end
 end