decidim 0.0.1 → 0.0.2

data/decidim-comments/lib/decidim/comments/test/factories.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+FactoryGirl.define do
+  factory :comment, class: Decidim::Comments::Comment do
+    author { build(:user, organization: commentable.organization) }
+    commentable { build(:participatory_process) }
+    body { Faker::Lorem.paragraph }
+  end
+
+  factory :comment_vote, class: Decidim::Comments::CommentVote do
+    comment { build(:comment) }
+    author { build(:user, organization: comment.organization) }
+    weight { [-1, 1].sample }
+
+    trait :up_vote do
+      weight 1
+    end
+
+    trait :down_vote do
+      weight(-1)
+    end
+  end
+end

data/decidim-comments/spec/commands/vote_comment_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe VoteComment, :db do
+      describe "call" do
+        let(:organization) { create :organization }
+        let(:participatory_process) { create(:participatory_process, organization: organization) }
+        let(:author) { create(:user, organization: organization) }
+        let(:comment) { create(:comment, commentable: participatory_process) }
+        let(:command) { described_class.new(comment, author) }
+
+        describe "when the vote is not created" do
+          before do
+            expect(comment.up_votes).to receive(:create!).and_raise(ActiveRecord::RecordInvalid)
+          end
+
+          it "broadcasts invalid" do
+            expect { command.call }.to broadcast(:invalid)
+          end
+
+          it "doesn't create a comment vote" do
+            expect do
+              command.call
+            end.to_not change { CommentVote.count }
+          end
+        end
+
+        describe "when the vote is already created for this user" do
+          before do
+            expect(comment.up_votes).to receive(:create!).and_raise(ActiveRecord::RecordNotUnique)
+          end
+
+          it "broadcasts invalid" do
+            expect { command.call }.to broadcast(:invalid)
+          end
+
+          it "doesn't create a comment vote" do
+            expect do
+              command.call
+            end.to_not change { CommentVote.count }
+          end
+        end
+
+        describe "when the vote is created" do
+          it "broadcasts ok" do
+            expect { command.call }.to broadcast(:ok)
+          end
+
+          it "creates a new comment vote" do
+            expect(comment.up_votes).to receive(:create!).with({
+              author: author
+            }).and_call_original
+            expect do
+              command.call
+            end.to change { CommentVote.count }.by(1)
+          end
+        end
+
+        describe "when weight value is not the default" do
+          describe "and it is equal to -1" do
+            let(:command) { described_class.new(comment, author, weight: -1) }
+
+            describe "when the vote is not created" do
+              before do
+                expect(comment.down_votes).to receive(:create!).and_raise(ActiveRecord::RecordInvalid)
+              end
+
+              it "broadcasts invalid" do
+                expect { command.call }.to broadcast(:invalid)
+              end
+
+              it "doesn't create a comment vote" do
+                expect do
+                  command.call
+                end.to_not change { CommentVote.count }
+              end
+            end
+
+            describe "when the vote is already created for this user" do
+              before do
+                expect(comment.down_votes).to receive(:create!).and_raise(ActiveRecord::RecordNotUnique)
+              end
+
+              it "broadcasts invalid" do
+                expect { command.call }.to broadcast(:invalid)
+              end
+
+              it "doesn't create a comment vote" do
+                expect do
+                  command.call
+                end.to_not change { CommentVote.count }
+              end
+            end
+
+            describe "when the vote is created" do
+              it "broadcasts ok" do
+                expect { command.call }.to broadcast(:ok)
+              end
+
+              it "creates a new comment vote" do
+                expect(comment.down_votes).to receive(:create!).with({
+                  author: author
+                }).and_call_original
+                expect do
+                  command.call
+                end.to change { CommentVote.count }.by(1)
+              end
+            end
+          end
+
+          describe "and it has a invalid value" do
+            let(:command) { described_class.new(comment, author, weight: 2) }
+
+            it "broadcasts invalid" do
+              expect { command.call }.to broadcast(:invalid)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-comments/spec/factories.rb

@@ -1,9 +1,2 @@
-require_relative "../../decidim-core/spec/factories"
-
-FactoryGirl.define do
-  factory :comment, class: Decidim::Comments::Comment do
-    author { build(:user, organization: commentable.organization) }
-    commentable { build(:participatory_process) }
-    body { Faker::Lorem.paragraph }
-  end
-end
+require "decidim/core/test/factories"
+require "decidim/comments/test/factories"

data/decidim-comments/spec/features/comments_spec.rb

@@ -28,6 +28,21 @@ describe "Comments", type: :feature do
       end
     end
   end
+  
+  it "user should be able to sort the comments" do
+    comment = create(:comment, commentable: participatory_process, body: "Most Rated Comment")
+    create(:comment_vote, comment: comment, author: user, weight: 1)
+
+    visit decidim.dummy_path(participatory_process)
+    page.find("div.order-by__dropdown.order-by__dropdown--right").hover
+    within "div.order-by__dropdown.order-by__dropdown--right" do
+      click_link "Best Rated"
+    end
+
+    within "#comments" do
+      expect(page.find('.comment', match: :first)).to have_content "Most Rated Comment"
+    end
+  end
 
   context "when not authenticated" do
     it "user should not see the form to add comments" do
@@ -93,5 +108,27 @@ describe "Comments", type: :feature do
         end
       end
     end
+
+    context "when votable option is enabled" do
+      before do
+        visit decidim.dummy_path(participatory_process, votable: true)
+      end
+
+      it "user can upvote a comment" do
+        within "#comment_#{comments[0].id}" do
+          expect(page).to have_selector('.comment__votes--up', text: /0/)
+          page.find('.comment__votes--up').click
+          expect(page).to have_selector('.comment__votes--up', text: /1/)
+        end
+      end
+
+      it "user can downvote a comment" do
+        within "#comment_#{comments[0].id}" do
+          expect(page).to have_selector('.comment__votes--down', text: /0/)
+          page.find('.comment__votes--down').click
+          expect(page).to have_selector('.comment__votes--down', text: /1/)
+        end
+      end
+    end
   end
 end

data/decidim-comments/spec/models/comment_spec.rb

@@ -7,6 +7,8 @@ module Decidim
       let!(:commentable) { create(:participatory_process) }
       let!(:comment) { create(:comment, commentable: commentable) }
       let!(:replies) { 3.times.map { create(:comment, commentable: comment) } }
+      let!(:up_vote) { create(:comment_vote, :up_vote, comment: comment) }
+      let!(:down_vote) { create(:comment_vote, :down_vote, comment: comment) }
 
       it "is valid" do
         expect(comment).to be_valid
@@ -24,6 +26,14 @@ module Decidim
         expect(comment.replies).to match_array(replies)
       end
 
+      it "has a up_votes association returning comment votes with weight 1" do
+        expect(comment.up_votes.count).to eq(1)
+      end
+
+      it "has a down_votes association returning comment votes with weight -1" do
+        expect(comment.down_votes.count).to eq(1)
+      end
+
       it "is not valid if its parent is a comment and cannot have replies" do
         expect(comment).to receive(:can_have_replies?).and_return false
         expect(replies[0]).not_to be_valid
@@ -59,6 +69,30 @@ module Decidim
         comment.alignment = 2
         expect(comment).not_to be_valid
       end
+
+      describe "#up_voted_by?" do
+        let(:user) { create(:user, organization: comment.organization) }
+        it "should return true if the given user has upvoted the comment" do
+          create(:comment_vote, comment: comment, author: user, weight: 1)
+          expect(comment.up_voted_by?(user)).to be_truthy
+        end
+
+        it "should return false if the given user has not upvoted the comment" do
+          expect(comment.up_voted_by?(user)).to be_falsy
+        end
+      end
+
+      describe "#down_voted_by?" do
+        let(:user) { create(:user, organization: comment.organization) }
+        it "should return true if the given user has downvoted the comment" do
+          create(:comment_vote, comment: comment, author: user, weight: -1)
+          expect(comment.down_voted_by?(user)).to be_truthy
+        end
+
+        it "should return false if the given user has not downvoted the comment" do
+          expect(comment.down_voted_by?(user)).to be_falsy
+        end
+      end
     end
   end
 end

data/decidim-comments/spec/models/comment_vote_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe CommentVote do
+      let!(:organization) { create(:organization) }
+      let!(:participatory_process) { create(:participatory_process, organization: organization) }
+      let!(:author) { create(:user, organization: organization) }
+      let!(:comment) { create(:comment, commentable: participatory_process, author: author)}
+      let!(:comment_vote) { create(:comment_vote, comment: comment, author: author) }
+
+      it "is valid" do
+        expect(comment_vote).to be_valid
+      end
+
+      it "has an associated author" do
+        expect(comment_vote.author).to be_a(Decidim::User)
+      end
+
+      it "has an associated comment" do
+        expect(comment_vote.comment).to be_a(Decidim::Comments::Comment)
+      end
+
+      it "validates uniqueness for author and comment combination" do
+        expect {
+          create(:comment_vote, comment: comment, author: author)
+        }.to raise_error(ActiveRecord::RecordInvalid)
+      end
+
+      it "is invalid with a weight different from 1 and -1" do
+        comment_vote.weight = 2
+        expect(comment_vote).to be_invalid
+      end
+
+      it "is invalid if comment and author have different organizations" do
+        author = create(:user)
+        comment = create(:comment)
+        comment_vote = build(:comment_vote, comment: comment, author: author)
+        expect(comment_vote).to be_invalid
+      end
+    end
+  end
+end

data/decidim-comments/spec/models/seed_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe Seed do
+      let!(:organization) { create(:organization) }
+      let(:subject) { Decidim::Comments::Seed }
+
+      describe "#comments_for(resource)" do
+        it 'creates comments for a page if one is given' do
+          user = create(:user, organization: organization)
+          subject.comments_for(user)
+          expect(Decidim::Comments::CommentsWithReplies.for(user).length).to be_between(1, 5).inclusive
+        end
+      end
+    end
+  end
+end

data/decidim-comments/spec/queries/comments_with_replies_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe Decidim::Comments::CommentsWithReplies do
+  let!(:organization) { create(:organization) }
+  let!(:author) { create(:user, organization: organization) }
+  let!(:commentable) { create(:participatory_process, organization: organization) }
+  let!(:comment) { create(:comment, commentable: commentable, author: author) }
+  let!(:order_by) {}
+
+  subject { described_class.new(commentable, order_by: order_by) }
+  
+  it "returns the commentable's comments" do
+    expect(subject.query).to eq [comment]
+  end
+
+  it "eager loads comment's author, up_votes and down_votes" do
+    comment = subject.query[0]
+    expect {
+      expect(comment.author.name).to be_present
+      expect(comment.up_votes.size).to eq(0)
+      expect(comment.down_votes.size).to eq(0)        
+    }.to_not make_database_queries
+  end
+
+  it "eager loads a comment tree based on the MAX_DEPTH" do
+    reply = comment
+    
+    Decidim::Comments::Comment::MAX_DEPTH.times do
+      reply = create(:comment, commentable: reply)
+    end
+
+    comment = subject.query[0]
+
+    expect {
+      Decidim::Comments::Comment::MAX_DEPTH.times do
+        comment = comment.replies[0]
+      end
+      expect(comment.author.name).to be_present
+      expect(comment.up_votes.size).to eq(0)
+      expect(comment.down_votes.size).to eq(0)
+    }.to_not make_database_queries
+  end
+
+  it "return the comments ordered by created_at asc by default" do
+    previous_comment = create(:comment, commentable: commentable, author: author, created_at: 1.week.ago, updated_at: 1.week.ago)
+    future_comment = create(:comment, commentable: commentable, author: author, created_at: 1.week.from_now, updated_at: 1.week.from_now)
+    expect(subject.query).to eq [previous_comment, comment, future_comment]    
+  end
+    
+  context "When order_by is not default" do
+    context "When order by recent" do
+      let!(:order_by) {"recent"}
+
+      it "return the comments ordered by recent" do
+        previous_comment = create(:comment, commentable: commentable, author: author, created_at: 1.week.ago, updated_at: 1.week.ago)
+        future_comment = create(:comment, commentable: commentable, author: author, created_at: 1.week.from_now, updated_at: 1.week.from_now)
+        expect(subject.query).to eq [previous_comment, comment, future_comment].reverse 
+      end
+    end
+    
+    context "When order by best_rated" do
+      let!(:order_by) {"best_rated"}
+
+      it "return the comments ordered by best_rated" do
+        most_voted_comment = create(:comment, commentable: commentable, author: author, created_at: 1.week.ago, updated_at: 1.week.ago)
+        less_voted_comment = create(:comment, commentable: commentable, author: author, created_at: 1.week.from_now, updated_at: 1.week.from_now)  
+        create(:comment_vote, comment: most_voted_comment, author: author, weight: 1)
+        create(:comment_vote, comment: less_voted_comment, author: author, weight: -1)
+        expect(subject.query).to eq [most_voted_comment, comment, less_voted_comment] 
+      end
+    end
+
+    context "When order by most_discussed" do
+      let!(:order_by) {"most_discussed"}
+
+      it "return the comments ordered by most_discussed" do
+        most_commented = create(:comment, commentable: commentable, author: author, created_at: 1.week.ago, updated_at: 1.week.ago)
+        less_commented = create(:comment, commentable: commentable, author: author, created_at: 1.week.from_now, updated_at: 1.week.from_now)    
+        create(:comment, commentable: comment)
+        create_list(:comment, 3, commentable: most_commented)
+        expect(subject.query).to eq [most_commented, comment, less_commented]
+      end
+    end
+  end
+end

data/decidim-comments/spec/spec_helper.rb

@@ -1,2 +1,4 @@
 ENV["ENGINE_NAME"] = File.dirname(File.dirname(__FILE__)).split("/").last
-require "decidim/test/base_spec_helper"
+
+require "decidim/dev/test/base_spec_helper"
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/decidim-comments/spec/support/dummy.rb

@@ -10,7 +10,7 @@ class Decidim::DummyController < Decidim::ApplicationController
 
   def show
     @participatory_process = Decidim::ParticipatoryProcess.find(params[:id])
-    @options = params.slice(:arguable)
+    @options = params.slice(:arguable, :votable)
     @options.each { |key, val| @options[key] = val === 'true' }
     render inline: %{
       <%= javascript_include_tag 'application' %>

data/decidim-comments/spec/types/comment_mutation_type_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "decidim/api/test/type_context"
+
+module Decidim
+  module Comments
+    describe CommentMutationType do
+      include_context "graphql type"
+      let(:model) { create(:comment) }
+
+      describe "upVote" do
+        let(:query) {
+          "{ upVote { upVoted } }"
+        }
+
+        before do
+          allow(Decidim::Comments::VoteComment).to receive(:call).with(model, current_user, weight: 1).and_return (
+            model
+          )
+        end
+
+        it "should call UpVoteComment command" do
+          expect(model).to receive(:up_voted_by?).with(current_user).and_return(true)
+          expect(response["upVote"]).to include("upVoted" => true)
+        end
+      end
+
+      describe "downVote" do
+        let(:query) {
+          "{ downVote { downVoted } }"
+        }
+
+        before do
+          allow(Decidim::Comments::VoteComment).to receive(:call).with(model, current_user, weight: -1).and_return (
+            model
+          )
+        end
+
+        it "should call UpVoteComment command" do
+          expect(model).to receive(:down_voted_by?).with(current_user).and_return(true)
+          expect(response["downVote"]).to include("downVoted" => true)
+        end
+      end
+    end
+  end
+end