decidim 0.0.2 → 0.0.3

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

@@ -9,12 +9,10 @@ describe "Vote Proposal", type: :feature do
   let!(:proposal) { Decidim::Proposals::Proposal.where(feature: feature).first }
   let!(:user) { create :user, :confirmed, organization: organization }
 
-  let(:votes_enabled) { false }
-
-  before do
-    feature.step_settings = { participatory_process.active_step.id => { votes_enabled: votes_enabled } }
-    feature.save
-    visit_feature      
+  let!(:feature) do
+    create(:proposal_feature,
+      manifest: manifest,
+      participatory_process: participatory_process)
   end
 
   context "when votes are not enabled" do
@@ -25,10 +23,17 @@ describe "Vote Proposal", type: :feature do
   end
 
   context "when votes are enabled" do
-    let(:votes_enabled) { true }   
-      
+    let!(:feature) do
+      create(:proposal_feature,
+        :with_votes_enabled,
+        manifest: manifest,
+        participatory_process: participatory_process)
+    end
+
     context "when the user is not logged in" do
       it "should be given the option to sign in" do
+        visit_feature
+        
         within ".card__support", match: :first do
           page.find('.card__button').click
         end
@@ -58,7 +63,7 @@ describe "Vote Proposal", type: :feature do
 
       context "when the proposal is already voted" do
         before do
-          create(:proposal_vote, proposal: proposal, author: user) 
+          create(:proposal_vote, proposal: proposal, author: user)
           visit_feature
         end
 
@@ -69,10 +74,77 @@ describe "Vote Proposal", type: :feature do
           end
 
           within "#proposal-#{proposal.id}-votes-count" do
-            expect(page).to have_content("1 VOTE")          
+            expect(page).to have_content("1 VOTE")
+          end
+        end
+      end
+
+      context "when the feature has a vote limit" do
+        let(:vote_limit) { 10 }
+
+        let!(:feature) do
+          create(:proposal_feature,
+            :with_votes_enabled,
+            :with_vote_limit,
+            vote_limit: vote_limit,
+            manifest: manifest,
+            participatory_process: participatory_process)
+        end
+
+        context "when the proposal is not voted yet" do
+          it "should update the remaining votes counter" do
+            within "#proposal-#{proposal.id}-vote-button" do
+              page.find('.card__button').click
+              expect(page).to have_css('.card__button.success')
+            end
+
+            expect(page).to have_content("REMAINING 9 VOTES")
+          end
+        end
+
+        context "when the proposal is already voted" do
+          before do
+            create(:proposal_vote, proposal: proposal, author: user)
+            visit_feature
+          end
+
+          it "should be able to undo the vote" do
+            within "#proposal-#{proposal.id}-vote-button" do
+              expect(page).to have_css('.card__button.success')
+              page.find('.card__button').click
+            end
+
+            expect(page).to have_content("REMAINING 10 VOTES")
+          end
+        end
+
+        context "when the user has reached the votes limit" do
+          let(:vote_limit) { 1 }
+
+          before do
+            create(:proposal_vote, proposal: proposal, author: user)
+            visit_feature
+          end
+
+          it "should not be able to vote other proposals" do
+            expect(page).to have_css('.card__button[disabled]', count: 2)
+          end
+
+          context "when votes are blocked" do
+            let!(:feature) do
+              create(:proposal_feature,
+                :with_votes_blocked,
+                manifest: manifest,
+                participatory_process: participatory_process)
+            end
+
+            it "shows the vote count but not the vote button" do
+              expect(page).to have_css('.card__support__data', text: "1 VOTE")
+              expect(page).to have_content("Voting disabled")
+            end
           end
         end
       end
     end
   end
-end
+end

data/decidim-proposals/spec/forms/decidim/proposals/admin_proposal_form_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require "spec_helper"
+require_relative "../../../shared/proposal_form_examples"
+
+module Decidim
+  module Proposals
+    module Admin
+      describe ProposalForm do
+        it_behaves_like "a proposal form"
+      end
+    end
+  end
+end

data/decidim-proposals/spec/forms/decidim/proposals/proposal_answer_form_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Proposals
+    module Admin
+      describe ProposalAnswerForm do
+        let(:organization) { create(:organization) }
+        let(:state) { "accepted" }
+        let(:answer) { Decidim::Faker::Localized.sentence(3) }
+        let(:params) do
+          {
+            state: state, answer: answer
+          }
+        end
+
+        let(:form) do
+          described_class.from_params(params).with_context(
+            current_organization: organization
+          )
+        end
+
+        subject { form }
+
+        context "when everything is OK" do
+          it { is_expected.to be_valid }
+        end
+
+        context "when the state is not valid" do
+          let(:state) { "foo" }
+          it { is_expected.to be_invalid }
+        end
+
+        context "when there's no state" do
+          let(:state) { nil }
+          it { is_expected.to be_invalid }
+        end
+
+        context "rejecting a proposal" do
+          let(:state) { "rejected" }
+
+          context "when there's no answer" do
+            let(:answer) { nil }
+            it { is_expected.to be_invalid }
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-proposals/spec/forms/decidim/proposals/proposal_form_spec.rb

@@ -1,105 +1,17 @@
 # frozen_string_literal: true
 require "spec_helper"
+require_relative "../../../shared/proposal_form_examples"
 
 module Decidim
   module Proposals
     describe ProposalForm do
-      let(:feature) { create(:feature)}
-      let(:title) { "Oriol for president!" }
-      let(:body) { "Everything would be better" }
-      let(:author) { create(:user, organization: feature.organization) }
-      let(:category) { create(:category, participatory_process: feature.participatory_process) }
-      let(:scope) { create(:scope, organization: feature.organization) }
-      let(:category_id) { category.try(:id)}
-      let(:scope_id) { scope.try(:id)}
-      let(:params) do
-        {
-          title: title,
-          body: body,
-          author: author,
-          category_id: category_id,
-          scope_id: scope_id
-        }
-      end
+      it_behaves_like "a proposal form"
 
-      let(:form) do
-        described_class.from_params(params).with_context(
-          current_feature: feature,
-          current_organization: feature.organization
+      let(:params) do
+        super.merge(
+          user_group_id: user_group_id
         )
       end
-
-      subject { form }
-
-      context "when everything is OK" do
-        it { is_expected.to be_valid }
-      end
-
-      context "when there's no title" do
-        let(:title) { nil }
-        it { is_expected.to be_invalid }
-      end
-
-      context "when there's no body" do
-        let(:body) { nil }
-        it { is_expected.to be_invalid }
-      end
-
-      context "when no category_id" do
-        let(:category_id) { nil }
-        it { is_expected.to be_valid }
-      end
-
-      context "when no scope_id" do
-        let(:scope_id) { nil }
-        it { is_expected.to be_valid }
-      end
-
-      context "with invalid category_id" do
-        let(:category_id) { 987 }
-        it { is_expected.to be_invalid}
-      end
-
-      context "with invalid scope_id" do
-        let(:scope_id) { 987 }
-        it { is_expected.to be_invalid}
-      end
-
-      describe "category" do
-        subject { form.category }
-
-        context "when the category exists" do
-          it { is_expected.to be_kind_of(Decidim::Category) }
-        end
-
-        context "when the category does not exist" do
-          let(:category_id) { 7654 }
-          it { is_expected.to eq(nil) }
-        end
-
-        context "when the category is from another process" do
-          let(:category_id) { create(:category).id }
-          it { is_expected.to eq(nil) }
-        end
-      end
-
-      describe "scope" do
-        subject { form.scope }
-
-        context "when the scope exists" do
-          it { is_expected.to be_kind_of(Decidim::Scope) }
-        end
-
-        context "when the scope does not exist" do
-          let(:scope_id) { 3456 }
-          it { is_expected.to eq(nil) }
-        end
-
-        context "when the scope is from another organization" do
-          let(:scope_id) { create(:scope).id }
-          it { is_expected.to eq(nil) }
-        end
-      end
     end
   end
 end

data/decidim-proposals/spec/helpers/application_helper_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Proposals
+    describe ApplicationHelper do
+      describe "humanize_proposal_state" do
+        let(:helper) do
+          Class.new.tap do |v|
+            v.extend(Decidim::Proposals::ApplicationHelper)
+          end
+        end
+
+        subject { helper.humanize_proposal_state(state) }
+
+        context "when it is accepted" do
+          let(:state) { "accepted" }
+          it { is_expected.to eq("Accepted") }
+        end
+
+        context "when it is rejected" do
+          let(:state) { "rejected" }
+          it { is_expected.to eq("Rejected") }
+        end
+
+        context "when it is nil" do
+          let(:state) { nil }
+          it { is_expected.to eq("Not answered") }
+        end
+      end
+    end
+  end
+end

data/decidim-proposals/spec/helpers/proposal_votes_helper_spec.rb

@@ -4,6 +4,17 @@ require "spec_helper"
 module Decidim
   module Proposals
     describe ProposalVotesHelper do
+      let(:organization) { create(:organization) }
+      let(:vote_limit) { 10 }
+      let(:proposal_feature) { create(:proposal_feature, organization: organization) }
+      let(:user) { create(:user, organization: organization) }
+
+      before do
+        allow(helper).to receive(:current_user).and_return(user)
+        allow(helper).to receive(:current_feature).and_return(proposal_feature)
+        allow(helper).to receive(:feature_settings).and_return(double(vote_limit: vote_limit))
+      end
+
       describe "#vote_button_classes" do
         it "returns small buttons classes from proposals list" do
           expect(helper.vote_button_classes(true)).to eq("small")
@@ -23,6 +34,48 @@ module Decidim
           expect(helper.votes_count_classes(false)).to eq(number: "extra__suport-number", label: "extra__suport-text")
         end
       end
+
+      describe "#vote_limit_enabled?" do
+        context "when the current_user is not present" do
+          let(:user) { nil }
+
+          it "returns false" do
+            expect(helper).to receive(:current_user).and_return(nil)
+            expect(helper.vote_limit_enabled?).to be_falsy
+          end
+        end
+
+        context "when the current_settings vote_limit is not present" do
+          let(:vote_limit) { nil }
+
+          it "returns false" do
+            expect(helper.vote_limit_enabled?).to be_falsy
+          end
+        end
+
+        context "when the current_settings vote_limit is less or equal 0" do
+          let(:vote_limit) { 0 }
+
+          it "returns false" do
+            expect(helper.vote_limit_enabled?).to be_falsy
+          end
+        end
+
+        context "when the current_settings vote_limit is greater than 0" do
+          it "returns true" do
+            expect(helper.vote_limit_enabled?).to be_truthy
+          end
+        end
+      end
+
+      describe "#remaining_votes_count_for" do
+        it "returns the remaining votes for a user based on the feature votes limit" do
+          proposal = create(:proposal, feature: proposal_feature)
+          create(:proposal_vote, author: user, proposal: proposal)
+
+          expect(helper.remaining_votes_count_for(user)).to eq(9)
+        end
+      end
     end
   end
 end

data/decidim-proposals/spec/lib/decidim/proposals/feature_spec.rb

@@ -24,7 +24,7 @@ describe "Proposals feature" do
           Decidim::Admin::DestroyFeature.call(feature)
         end.to broadcast(:invalid)
 
-        expect(feature).to_not be_destroyed
+        expect(feature).not_to be_destroyed
       end
     end
   end

data/decidim-proposals/spec/models/decidim/proposals/proposal_spec.rb

@@ -4,31 +4,19 @@ require "spec_helper"
 module Decidim
   module Proposals
     describe Proposal do
-      subject { create(:proposal) }
+      let(:proposal) { build(:proposal) }
+      subject { proposal }
+
+      include_examples "authorable"
+      include_examples "has feature"
+      include_examples "has scope"
+      include_examples "has category"
 
       it { is_expected.to be_valid }
 
       it "has a votes association returning proposal votes" do
         expect(subject.votes.count).to eq(0)
       end
-      
-      context "when the category is from another feature" do
-        subject { build(:proposal, category: create(:category))}
-
-        it { is_expected.to be_invalid}
-      end
-
-      context "when the author is from another organization" do
-        subject { build(:proposal, author: create(:user))}
-
-        it { is_expected.to be_invalid}
-      end
-
-      context "when the scope is from another organization" do
-        subject { build(:proposal, scope: create(:scope))}
-
-        it { is_expected.to be_invalid}
-      end
 
       describe "#voted_by?" do
         let(:user) { create(:user, organization: subject.organization) }
@@ -42,6 +30,20 @@ module Decidim
           expect(subject.voted_by?(user)).to be_truthy
         end
       end
+
+      context "when it has been accepted" do
+        let(:proposal) { build(:proposal, :accepted) }
+
+        it { is_expected.to be_answered }
+        it { is_expected.to be_accepted }
+      end
+
+      context "when it has been rejected" do
+        let(:proposal) { build(:proposal, :rejected) }
+
+        it { is_expected.to be_answered }
+        it { is_expected.to be_rejected }
+      end
     end
   end
 end