decidim 0.0.2 → 0.0.3

data/decidim-proposals/spec/commands/decidim/proposals/create_proposal_spec.rb

@@ -1,65 +1,12 @@
 # frozen_string_literal: true
 require "spec_helper"
+require_relative "../../../shared/create_proposal_examples"
 
 module Decidim
   module Proposals
     describe CreateProposal do
-      describe "call" do
-        let(:organization) { create(:organization) }
-        let(:participatory_process) { create :participatory_process, organization: organization }
-        let(:feature) { create(:feature, participatory_process: participatory_process) }
-        let(:form_params) do
-          {
-            title: "Proposal title",
-            body: "Proposal body",
-            feature: feature
-          }
-        end
-
-        let(:author) do
-          create(:user, organization: organization)
-        end
-
-        let(:form) do
-          ProposalForm.from_params(
-            form_params
-          ).with_context(
-            current_organization: organization,
-            current_feature: feature,
-            current_process: participatory_process
-          )
-        end
-
-        let(:command) { described_class.new(form, author) }
-
-        describe "when the form is not valid" do
-          before do
-            expect(form).to receive(:invalid?).and_return(true)
-          end
-
-          it "broadcasts invalid" do
-            expect { command.call }.to broadcast(:invalid)
-          end
-
-          it "doesn't create a proposal" do
-            expect do
-              command.call
-            end.to_not change { Proposal.count }
-          end
-        end
-
-        describe "when the form is valid" do
-          it "broadcasts ok" do
-            expect { command.call }.to broadcast(:ok)
-          end
-
-          it "creates a new proposal" do
-            expect do
-              command.call
-            end.to change { Proposal.count }.by(1)
-          end
-        end
-      end
+      let(:form_klass) { ProposalForm }
+      it_behaves_like "create a proposal", true
     end
   end
 end

data/decidim-proposals/spec/controllers/decidim/admin/proposal_answers_controller_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Proposals
+    module Admin
+      describe ProposalAnswersController, type: :controller do
+        let(:feature) { proposal.feature }
+        let(:proposal) { create(:proposal) }
+        let(:user) { create(:user, :confirmed, :admin, organization: feature.organization) }
+
+        routes do
+          Decidim::Proposals::AdminEngine.routes
+        end
+
+        before do
+          @request.env["decidim.current_organization"] = feature.organization
+          @request.env["decidim.current_participatory_process"] = feature.participatory_process
+          @request.env["decidim.current_feature"] = feature
+          sign_in user
+        end
+
+        let(:params) do
+          {
+            id: proposal.id,
+            proposal_id: proposal.id,
+            feature_id: feature.id,
+            participatory_process_id: feature.participatory_process.id,
+            state: "rejected"
+          }
+        end
+
+        describe "PUT update" do
+          context "when the command fails" do
+            it "renders the edit template" do
+              put :update, params: params
+
+              expect(response).to render_template(:edit)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-proposals/spec/controllers/decidim/proposal_votes_controller_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Proposals
+    describe ProposalVotesController, type: :controller do
+      let(:proposal) { create(:proposal, feature: feature) }
+      let(:user) { create(:user, :confirmed, organization: feature.organization) }
+
+      routes do
+        Decidim::Proposals::Engine.routes
+      end
+
+      before do
+        @request.env["decidim.current_organization"] = feature.organization
+        @request.env["decidim.current_participatory_process"] = feature.participatory_process
+        @request.env["decidim.current_feature"] = feature
+        sign_in user
+      end
+
+      let(:params) do
+        {
+          proposal_id: proposal.id,
+          feature_id: feature.id,
+          participatory_process_id: feature.participatory_process.id
+        }
+      end
+
+      describe "POST create" do
+        context "with votes enabled" do
+          let(:feature) do
+            create(:proposal_feature, :with_votes_enabled)
+          end
+
+          it "allows voting" do
+            expect do
+              post :create, format: :js, params: params
+            end.to change { ProposalVote.count }.by(1)
+
+            expect(ProposalVote.last.author).to eq(user)
+            expect(ProposalVote.last.proposal).to eq(proposal)
+          end
+        end
+
+        context "with votes disabled" do
+          let(:feature) do
+            create(:proposal_feature)
+          end
+
+          it "doesn't allow voting" do
+            expect do
+              post :create, format: :js, params: params
+            end.not_to change { ProposalVote.count }
+
+            expect(flash[:alert]).not_to be_empty
+            expect(response).to have_http_status(302)
+          end
+        end
+
+        context "with votes enabled but votes blocked" do
+          let(:feature) do
+            create(:proposal_feature, :with_votes_blocked)
+          end
+
+          it "doesn't allow voting" do
+            expect do
+              post :create, format: :js, params: params
+            end.not_to change { ProposalVote.count }
+
+            expect(flash[:alert]).not_to be_empty
+            expect(response).to have_http_status(302)
+          end
+        end
+      end
+
+      describe "destroy" do
+        before do
+          create(:proposal_vote, proposal: proposal, author: user)
+        end
+
+        context "with vote limit enabled" do
+          let(:feature) do
+            create(:proposal_feature, :with_votes_enabled, :with_vote_limit)
+          end
+
+          it "deletes the vote" do
+            expect do
+              delete :destroy, format: :js, params: params
+            end.to change { ProposalVote.count }.by(-1)
+
+            expect(ProposalVote.count).to eq(0)
+          end
+        end
+
+        context "with vote limit disabled" do
+          let(:feature) do
+            create(:proposal_feature, :with_votes_enabled)
+          end
+
+          it "does not allow deleting a vote" do
+            expect do
+              delete :destroy, format: :js, params: params
+            end.not_to change { ProposalVote.count }
+
+            expect(flash[:alert]).not_to be_empty
+            expect(response).to have_http_status(302)
+            expect(ProposalVote.count).to eq(1)
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-proposals/spec/controllers/decidim/proposals_controller_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Proposals
+    describe ProposalsController, type: :controller do
+      let(:user) { create(:user, :confirmed, organization: feature.organization) }
+
+      routes do
+        Decidim::Proposals::Engine.routes
+      end
+
+      before do
+        @request.env["decidim.current_organization"] = feature.organization
+        @request.env["decidim.current_participatory_process"] = feature.participatory_process
+        @request.env["decidim.current_feature"] = feature
+        sign_in user
+      end
+
+      let(:params) do
+        {
+          feature_id: feature.id,
+          participatory_process_id: feature.participatory_process.id
+        }
+      end
+
+      describe "POST create" do
+        context "when creation is not enabled" do
+          let(:feature) { create(:proposal_feature) }
+
+          it "raises an error" do
+            expect(CreateProposal).not_to receive(:call)
+
+            post :create, params: params
+
+            expect(flash[:alert]).not_to be_empty
+            expect(response).to have_http_status(302)
+          end
+        end
+
+        context "when creation is enabled" do
+          let(:feature) { create(:proposal_feature, :with_creation_enabled) }
+
+          it "creates a proposal" do
+            expect(CreateProposal).to receive(:call)
+
+            post :create, params: params
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-proposals/spec/factories.rb

@@ -1,23 +1 @@
-require "decidim/core/test/factories"
-require "decidim/admin/test/factories"
-require "decidim/comments/test/factories"
-
-FactoryGirl.define do
-  factory :proposal_feature, class: Decidim::Feature do
-    name { Decidim::Features::Namer.new(participatory_process.organization.available_locales, :proposals).i18n_name }
-    manifest_name :proposals
-    participatory_process
-  end
-
-  factory :proposal, class: Decidim::Proposals::Proposal do
-    title { Faker::Lorem.sentence }
-    body { Faker::Lorem.sentences(3).join("\n") }
-    feature
-    author { create(:user, organization: feature.organization) }
-  end
-
-  factory :proposal_vote, class: Decidim::Proposals::ProposalVote do
-    proposal { build(:proposal) }
-    author { build(:user, organization: proposal.organization) }
-  end
-end
+require "decidim/proposals/test/factories"

data/decidim-proposals/spec/features/proposals_spec.rb

@@ -18,52 +18,189 @@ describe "Proposals", type: :feature do
     context "when the user is logged in" do
       before do
         login_as user, scope: :user
-        visit_feature      
+        visit_feature
       end
 
-      it "creates a new proposal" do
-        click_link "New proposal"
+      context "with creation enabled" do
+        let!(:feature) do
+          create(:proposal_feature,
+                 :with_creation_enabled,
+                 manifest: manifest,
+                 participatory_process: participatory_process)
+        end
+
+        it "creates a new proposal" do
+          click_link "New proposal"
 
-        within ".new_proposal" do
-          fill_in :proposal_title, with: "Oriol for president"
-          fill_in :proposal_body, with: "He will solve everything"
-          select category.name["en"], from: :proposal_category_id
-          select scope.name, from: :proposal_scope_id
+          within ".new_proposal" do
+            fill_in :proposal_title, with: "Oriol for president"
+            fill_in :proposal_body, with: "He will solve everything"
+            select category.name["en"], from: :proposal_category_id
+            select scope.name, from: :proposal_scope_id
 
-          find("*[type=submit]").click
+            find("*[type=submit]").click
+          end
+
+          expect(page).to have_content("successfully")
+          expect(page).to have_content("Oriol for president")
+          expect(page).to have_content("He will solve everything")
+          expect(page).to have_content(category.name["en"])
+          expect(page).to have_content(scope.name)
+          expect(page).to have_content(user.name)
         end
 
-        expect(page).to have_content("successfully")
-        expect(page).to have_content("Oriol for president")
-        expect(page).to have_content("He will solve everything")
-        expect(page).to have_content(category.name["en"])
-        expect(page).to have_content(scope.name)
+        context "when the user has verified organizations" do
+          let(:user_group) { create(:user_group, :verified) }
+
+          before do
+            create(:user_group_membership, user: user, user_group: user_group)
+          end
+
+          it "creates a new proposal as a user group" do
+            click_link "New proposal"
+
+            within ".new_proposal" do
+              fill_in :proposal_title, with: "Oriol for president"
+              fill_in :proposal_body, with: "He will solve everything"
+              select category.name["en"], from: :proposal_category_id
+              select scope.name, from: :proposal_scope_id
+              select user_group.name, from: :proposal_user_group_id
+
+              find("*[type=submit]").click
+            end
+
+            expect(page).to have_content("successfully")
+            expect(page).to have_content("Oriol for president")
+            expect(page).to have_content("He will solve everything")
+            expect(page).to have_content(category.name["en"])
+            expect(page).to have_content(scope.name)
+            expect(page).to have_content(user_group.name)
+          end
+        end
+      end
+
+      context "when creation is not enabled" do
+        it "does not show the creation button" do
+          expect(page).to have_no_link("New proposal")
+        end
       end
     end
   end
 
-  context "when it is an official proposal" do
-    let!(:official_proposal) { create(:proposal, feature: feature, author: nil) }
+  context "viewing a single proposal" do
+    it "allows viewing a single proposal" do
+      proposal = proposals.first
 
-    it "shows the author as official" do
-      visit_feature
-      click_link official_proposal.title
-      expect(page).to have_content("Official proposal")
+      click_link proposal.title
+
+      expect(page).to have_content(proposal.title)
+      expect(page).to have_content(proposal.body)
+      expect(page).to have_content(proposal.author.name)
+    end
+
+    context "when it is an official proposal" do
+      let!(:official_proposal) { create(:proposal, feature: feature, author: nil) }
+
+      it "shows the author as official" do
+        visit_feature
+        click_link official_proposal.title
+        expect(page).to have_content("Official proposal")
+      end
+    end
+
+    context "when a proposal has comments" do
+      let(:proposal) { create(:proposal, feature: feature) }
+      let(:author) { create(:user, :confirmed, organization: feature.organization) }
+      let!(:comments) { create_list(:comment, 3, commentable: proposal) }
+
+      it "shows the comments" do
+        visit_feature
+        click_link proposal.title
+
+        comments.each do |comment|
+          expect(page).to have_content(comment.body)
+        end
+      end
+    end
+
+    context "when a proposal has been linked in a meeting" do
+      let(:proposal) { create(:proposal, feature: feature) }
+      let(:meeting_feature) do
+        create(:feature, manifest_name: :meetings, participatory_process: proposal.feature.participatory_process)
+      end
+      let(:meeting) { create(:meeting, feature: meeting_feature) }
+
+      before do
+        meeting.link_resources([proposal], "proposals_from_meeting")
+      end
+
+      it "shows related meetings" do
+        visit_feature
+        click_link proposal.title
+
+        expect(page).to have_i18n_content(meeting.title)
+      end
+    end
+
+    context "when a proposal has been linked in a result" do
+      let(:proposal) { create(:proposal, feature: feature) }
+      let(:result_feature) do
+        create(:feature, manifest_name: :results, participatory_process: proposal.feature.participatory_process)
+      end
+      let(:result) { create(:result, feature: result_feature) }
+
+      before do
+        result.link_resources([proposal], "included_proposals")
+      end
+
+      it "shows related results" do
+        visit_feature
+        click_link proposal.title
+
+        expect(page).to have_i18n_content(result.title)
+      end
+    end
+
+    context "when a proposal has been accepted" do
+      let!(:proposal) { create(:proposal, :accepted, feature: feature) }
+
+      it "shows a badge" do
+        visit_feature
+        click_link proposal.title
+
+        expect(page).to have_content("Accepted")
+      end
+    end
+
+    context "when a proposal has been rejected" do
+      let!(:proposal) { create(:proposal, :rejected, feature: feature) }
+
+      it "shows the rejection reason" do
+        visit_feature
+        click_link proposal.title
+
+        expect(page).to have_content("Rejected")
+        expect(page).to have_i18n_content(proposal.answer)
+      end
     end
   end
 
-  context "when a proposal has comments" do
+  context "when a proposal has been linked in a project" do
     let(:proposal) { create(:proposal, feature: feature)}
-    let(:author) { create(:user, :confirmed, organization: feature.organization)}
-    let!(:comments) { create_list(:comment, 3, commentable: proposal) }
+    let(:budget_feature) do
+      create(:feature, manifest_name: :budgets, participatory_process: proposal.feature.participatory_process)
+    end
+    let(:project) { create(:project, feature: budget_feature) }
+
+    before do
+      project.link_resources([proposal], "included_proposals")
+    end
 
-    it "shows the comments" do
+    it "shows related projects" do
       visit_feature
       click_link proposal.title
 
-      comments.each do |comment| 
-        expect(page).to have_content(comment.body)
-      end
+      expect(page).to have_i18n_content(project.title)
     end
   end
 
@@ -72,16 +209,6 @@ describe "Proposals", type: :feature do
       expect(page).to have_css(".card--proposal", count: 3)
     end
 
-    it "allows viewing a single proposal" do
-      proposal = proposals.first
-
-      click_link proposal.title
-
-      expect(page).to have_content(proposal.title)
-      expect(page).to have_content(proposal.body)
-      expect(page).to have_content(proposal.author.name)
-    end
-
     context "when there are a lot of proposals" do
       before do
         create_list(:proposal, 17, feature: feature)
@@ -100,7 +227,7 @@ describe "Proposals", type: :feature do
     context "when filtering" do
       context "by origin 'official'" do
         it "lists the filtered proposals" do
-          create(:proposal, feature: feature, scope: scope, decidim_author_id: nil)
+          create(:proposal, :official, feature: feature, scope: scope)
           visit_feature
 
           within ".filters" do
@@ -122,6 +249,42 @@ describe "Proposals", type: :feature do
           expect(page).to have_content("#{proposals.size} PROPOSALS")
         end
       end
+
+      context "by accepted" do
+        it "lists the filtered proposals" do
+          create(:proposal, :accepted, feature: feature, scope: scope)
+          visit_feature
+
+          within ".filters" do
+            choose "Accepted"
+          end
+
+          expect(page).to have_css(".card--proposal", count: 1)
+          expect(page).to have_content("1 PROPOSAL")
+
+          within ".card--proposal" do
+            expect(page).to have_content("Accepted")
+          end
+        end
+      end
+
+      context "by rejected" do
+        it "lists the filtered proposals" do
+          create(:proposal, :rejected, feature: feature, scope: scope)
+          visit_feature
+
+          within ".filters" do
+            choose "Rejected"
+          end
+
+          expect(page).to have_css(".card--proposal", count: 1)
+          expect(page).to have_content("1 PROPOSAL")
+
+          within ".card--proposal" do
+            expect(page).to have_content("Rejected")
+          end
+        end
+      end
     end
   end
 end