decidim-forms 0.22.0 → 0.23.0

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

@@ -75,7 +75,7 @@ shared_examples_for "has questionnaire" do
         click_link "Back"
 
         expect(page).to have_content("STEP 1 OF 2")
-        expect(page).to have_field("questionnaire_answers_0", with: "My first answer")
+        expect(page).to have_field("questionnaire_responses_0", with: "My first answer")
       end
 
       it "finishes the submission when answering the last questionnaire" do
@@ -257,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
@@ -308,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" }
@@ -335,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" }
@@ -344,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
 
@@ -401,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
 
@@ -411,7 +411,7 @@ 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
 
@@ -509,11 +509,11 @@ shared_examples_for "has questionnaire" do
           questionnaire: questionnaire,
           question_type: "sorting",
           options: [
-            { "body" => "idiotas" },
-            { "body" => "trates" },
-            { "body" => "No" },
-            { "body" => "por" },
-            { "body" => "nos" }
+            { "body" => { "en" => "chocolate" } },
+            { "body" => { "en" => "like" } },
+            { "body" => { "en" => "We" } },
+            { "body" => { "en" => "dark" } },
+            { "body" => { "en" => "all" } }
           ]
         )
       end
@@ -523,25 +523,25 @@ shared_examples_for "has questionnaire" do
 
         expect(page).to have_selector(".sortable-check-box-collection input[type=checkbox]", count: 5)
 
-        expect(page).to have_content("idiotas\ntrates\nNo\npor\nnos")
+        expect(page).to have_content("chocolate\nlike\nWe\ndark\nall")
 
-        check "No"
-        check "nos"
-        check "trates"
-        check "por"
-        check "idiotas"
+        check "We"
+        check "all"
+        check "like"
+        check "dark"
+        check "chocolate"
 
-        expect(page).to have_content("1. No\n2. nos\n3. trates\n4. por\n5. idiotas")
+        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 "No"
-        check "nos"
-        check "trates"
-        check "por"
-        check "idiotas"
+        check "We"
+        check "all"
+        check "like"
+        check "dark"
+        check "chocolate"
 
         check "questionnaire_tos_agreement"
 
@@ -552,14 +552,46 @@ shared_examples_for "has questionnaire" do
         end
 
         expect(Decidim::Forms::Answer.first.choices.pluck(:position, :body)).to eq(
-          [[0, "No"], [1, "nos"], [2, "trates"], [3, "por"], [4, "idiotas"]]
+          [[0, "We"], [1, "all"], [2, "like"], [3, "dark"], [4, "chocolate"]]
         )
       end
 
       it "displays errors on incomplete sortings" do
         visit questionnaire_public_path
 
-        check "No"
+        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" }
 
@@ -568,6 +600,7 @@ shared_examples_for "has questionnaire" do
         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
 
@@ -757,6 +790,26 @@ shared_examples_for "has questionnaire" do
         end
       end
 
+      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 }
 
@@ -780,26 +833,554 @@ shared_examples_for "has questionnaire" do
           expect(checkboxes.map { |c| c[:checked] }).to eq(["true", "true", "true", nil, nil, "true"])
         end
       end
+    end
 
-      context "when the question is mandatory and the answer is not complete" do
-        let!(:mandatory) { true }
+    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
 
-        it "shows an error" do
+      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
 
-          checkboxes = page.all(".check-box-collection input[type=checkbox]")
-          check checkboxes[0][:id]
+        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
 
-          check "questionnaire_tos_agreement"
-          accept_confirm { click_button "Submit" }
+          it "is displayed only if all conditions are fulfilled" do
+            expect_question_to_be_visible(false)
 
-          within ".alert.flash" do
-            expect(page).to have_content("There was a problem answering")
+            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
 
-          expect(page).to have_content("Choices are not complete")
+        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