decidim 0.0.4 → 0.0.5

data/decidim-comments/lib/decidim/comments/query_extensions.rb

@@ -11,17 +11,14 @@ module Decidim
       # Returns nothing.
       def self.extend!(type)
         type.define do
-          field :comments do
-            description "Lists all commentable's comments."
-            type !types[CommentType]
+          field :commentable do
+            type !CommentableType
 
-            argument :commentableId, !types.String, "The commentable's ID"
-            argument :commentableType, !types.String, "The commentable's class name. i.e. `Decidim::ParticipatoryProcess`"
-            argument :orderBy, types.String, "Order the comments"
+            argument :id, !types.String, "The commentable's ID"
+            argument :type, !types.String, "The commentable's class name. i.e. `Decidim::ParticipatoryProcess`"
 
             resolve lambda { |_obj, args, _ctx|
-              commentable = args[:commentableType].constantize.find(args[:commentableId])
-              CommentsWithReplies.for(commentable, order_by: args[:orderBy])
+              args[:type].constantize.find(args[:id])
             }
           end
         end

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

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

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

@@ -7,8 +7,10 @@ module Decidim
       describe "call" do
         let(:organization) { create :organization }
         let(:participatory_process) { create(:participatory_process, organization: organization) }
+        let(:feature) { create(:feature, participatory_process: participatory_process) }
+        let(:commentable) { create(:dummy_resource, feature: feature) }
         let(:author) { create(:user, organization: organization) }
-        let(:comment) { create(:comment, commentable: participatory_process) }
+        let(:comment) { create(:comment, commentable: commentable) }
         let(:command) { described_class.new(comment, author) }
 
         describe "when the vote is not created" do

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

@@ -3,7 +3,7 @@ require "spec_helper"
 
 describe "Comments", type: :feature do
   let!(:organization) { create(:organization) }
-  let!(:feature) { create(:feature, organization: organization) }
+  let!(:feature) { create(:feature, manifest_name: :dummy, organization: organization) }
   let!(:user) { create(:user, :confirmed, organization: organization) }
   let!(:commentable) { create(:dummy_resource, feature: feature) }
   let!(:comments) {
@@ -11,17 +11,22 @@ describe "Comments", type: :feature do
       create(:comment, commentable: commentable)
     end
   }
+  let(:authenticated) { false }
 
-  def visit_commentable_path(options = {})
-    visit decidim_dummy.dummy_resource_path(commentable, feature_id: commentable.feature, participatory_process_id: commentable.feature.participatory_process, arguable: options[:arguable], votable: options[:votable])
+  def visit_commentable_path
+    if authenticated
+      login_as user, scope: :user
+    end
+    visit decidim_dummy.dummy_resource_path(commentable, feature_id: commentable.feature, participatory_process_id: commentable.feature.participatory_process)
   end
 
   before do
     switch_to_host(organization.host)
-    visit_commentable_path
   end
 
   it "user should see a list of comments" do
+    visit_commentable_path
+
     expect(page).to have_selector("#comments")
     expect(page).to have_selector("article.comment", count: comments.length)
 
@@ -51,25 +56,27 @@ describe "Comments", type: :feature do
 
   context "when not authenticated" do
     it "user should not see the form to add comments" do
+      visit_commentable_path
       expect(page).not_to have_selector(".add-comment form")
     end
   end
 
   context "when authenticated" do
-    before do
-      login_as user, scope: :user
+    let(:authenticated) { true }
+
+    it "user sees the form to add comments" do
       visit_commentable_path
-    end
 
-    it "user should not see the form to add comments" do
       expect(page).to have_selector(".add-comment form")
     end
 
     it "user can add a new comment" do
+      visit_commentable_path
+
       expect(page).to have_selector(".add-comment form")
 
       within ".add-comment form" do
-        fill_in "add-comment-#{commentable.class.name}-#{commentable.id}", with: "This is a new comment"
+        fill_in "add-comment-#{commentable.commentable_type}-#{commentable.id}", with: "This is a new comment"
         click_button "Send"
       end
 
@@ -84,14 +91,15 @@ describe "Comments", type: :feature do
 
       before do
         create(:user_group_membership, user: user, user_group: user_group)
-        visit_commentable_path
       end
 
       it "user can add a new comment as a user group" do
+        visit_commentable_path
+
         expect(page).to have_selector(".add-comment form")
 
         within ".add-comment form" do
-          fill_in "add-comment-#{commentable.class.name}-#{commentable.id}", with: "This is a new comment"
+          fill_in "add-comment-#{commentable.commentable_type}-#{commentable.id}", with: "This is a new comment"
           select user_group.name, from: "Comment as"
           click_button "Send"
         end
@@ -121,16 +129,18 @@ describe "Comments", type: :feature do
 
     context "when arguable option is enabled" do
       before do
-        visit_commentable_path arguable: true
+        expect_any_instance_of(Decidim::DummyResource).to receive(:comments_have_alignment?).and_return(true)
       end
 
       it "user can comment in favor" do
+        visit_commentable_path
+
         expect(page).to have_selector(".add-comment form")
 
         page.find('.opinion-toggle--ok').click
 
         within ".add-comment form" do
-          fill_in "add-comment-#{commentable.class.name}-#{commentable.id}", with: "I am in favor about this!"
+          fill_in "add-comment-#{commentable.commentable_type}-#{commentable.id}", with: "I am in favor about this!"
           click_button "Send"
         end
 
@@ -142,10 +152,12 @@ describe "Comments", type: :feature do
 
     context "when votable option is enabled" do
       before do
-        visit_commentable_path votable: true
+        expect_any_instance_of(Decidim::DummyResource).to receive(:comments_have_votes?).and_return(true)
       end
 
       it "user can upvote a comment" do
+        visit_commentable_path
+
         within "#comment_#{comments[0].id}" do
           expect(page).to have_selector('.comment__votes--up', text: /0/)
           page.find('.comment__votes--up').click
@@ -154,6 +166,8 @@ describe "Comments", type: :feature do
       end
 
       it "user can downvote a comment" do
+        visit_commentable_path
+
         within "#comment_#{comments[0].id}" do
           expect(page).to have_selector('.comment__votes--down', text: /0/)
           page.find('.comment__votes--down').click

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

@@ -3,7 +3,7 @@ require "spec_helper"
 
 describe "Comment notifications", type: :feature do
   let!(:organization) { create(:organization) }
-  let!(:feature) { create(:feature, organization: organization) }
+  let!(:feature) { create(:feature, manifest_name: :dummy, organization: organization) }
   let!(:user) { create(:user, :confirmed, organization: organization) }
   let!(:commentable) { create(:dummy_resource, feature: feature) }
   let!(:comments) {

data/decidim-comments/spec/helpers/comments_helper_spec.rb

@@ -4,43 +4,20 @@ require "spec_helper"
 module Decidim
   module Comments
     describe CommentsHelper do
-      class DummyCommentable
-        def id
-          1
-        end
-      end
+      let(:dummy_resource) { create(:dummy_resource) }
 
-      let(:commentable) { DummyCommentable.new }
-        
       describe "comments_for" do
         it "should render the react component `Comments` with the correct data" do
           expect(helper)
             .to receive(:react_comments_component)
-            .with("comments-for-DummyCommentable-1", {
-              commentableType: "Decidim::Comments::DummyCommentable",
-              commentableId: "1",
-              options: {},
-              locale: I18n.locale
-            })
-            .and_call_original
-
-          helper.comments_for(commentable)
-        end
-
-        it "should accept an optional hash of options" do
-          expect(helper)
-            .to receive(:react_comments_component)
-            .with("comments-for-DummyCommentable-1", {
-              commentableType: "Decidim::Comments::DummyCommentable",
+            .with("comments-for-DummyResource-1", {
+              commentableType: "Decidim::DummyResource",
               commentableId: "1",
-              options: {
-                arguable: true
-              },
               locale: I18n.locale
             })
             .and_call_original
 
-          helper.comments_for(commentable, arguable: true)
+          helper.comments_for(dummy_resource)
         end
       end
     end

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

@@ -4,7 +4,7 @@ require "spec_helper"
 module Decidim
   module Comments
     describe Comment do
-      let!(:commentable) { create(:participatory_process) }
+      let!(:commentable) { create(:dummy_resource) }
       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) }
@@ -22,10 +22,6 @@ module Decidim
         expect(subject.commentable).to eq(commentable)
       end
 
-      it "has a replies association" do
-        expect(subject.replies).to match_array(replies)
-      end
-
       it "has a up_votes association returning comment votes with weight 1" do
         expect(subject.up_votes.count).to eq(1)
       end
@@ -34,27 +30,27 @@ module Decidim
         expect(subject.down_votes.count).to eq(1)
       end
 
-      it "is not valid if its parent is a comment and cannot have replies" do
-        expect(subject).to receive(:can_have_replies?).and_return false
+      it "is not valid if its parent is a comment and cannot accept new comments" do
+        expect(subject).to receive(:accepts_new_comments?).and_return false
         expect(replies[0]).not_to be_valid
       end
 
       it "should compute its depth before saving the model" do
         expect(subject.depth).to eq(0)
-        comment.replies.each do |reply|
+        comment.comments.each do |reply|
           expect(reply.depth).to eq(1)
         end
       end
 
-      describe "#can_have_replies?" do
+      describe "#accepts_new_comments?" do
         it "should return true if the comment's depth is below MAX_DEPTH" do
           subject.depth = Comment::MAX_DEPTH - 1
-          expect(subject.can_have_replies?).to be_truthy
+          expect(subject.accepts_new_comments?).to be_truthy
         end
 
         it "should return false if the comment's depth is equal or greater than MAX_DEPTH" do
           subject.depth = Comment::MAX_DEPTH
-          expect(subject.can_have_replies?).to be_falsy
+          expect(subject.accepts_new_comments?).to be_falsy
         end
       end
 

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

@@ -6,8 +6,10 @@ module Decidim
     describe CommentVote do
       let!(:organization) { create(:organization) }
       let!(:participatory_process) { create(:participatory_process, organization: organization) }
+      let!(:feature) { create(:feature, participatory_process: participatory_process) }
+      let!(:commentable) { create(:dummy_resource, feature: feature) }
       let!(:author) { create(:user, organization: organization) }
-      let!(:comment) { create(:comment, commentable: participatory_process, author: author)}
+      let!(:comment) { create(:comment, commentable: commentable, author: author)}
       let!(:comment_vote) { create(:comment_vote, comment: comment, author: author) }
 
       it "is valid" do

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

@@ -4,14 +4,13 @@ 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
+          dummy_resource = create(:dummy_resource)
+          subject.comments_for(dummy_resource)
+          expect(Decidim::Comments::SortedComments.for(dummy_resource).length).to be_between(1, 5).inclusive
         end
       end
     end

data/decidim-comments/spec/queries/{comments_with_replies_spec.rb → sorted_comments_spec.rb}

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 require "spec_helper"
 
-describe Decidim::Comments::CommentsWithReplies do
+describe Decidim::Comments::SortedComments do
   let!(:organization) { create(:organization) }
+  let!(:participatory_process) { create(:participatory_process, organization: organization) }
+  let!(:feature) { create(:feature, participatory_process: participatory_process) }
   let!(:author) { create(:user, organization: organization) }
-  let!(:commentable) { create(:participatory_process, organization: organization) }
+  let!(:commentable) { create(:dummy_resource, feature: feature) }
   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
@@ -17,25 +19,6 @@ describe Decidim::Comments::CommentsWithReplies do
   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)        
-    }.not_to 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)
@@ -45,9 +28,9 @@ describe Decidim::Comments::CommentsWithReplies do
   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]    
+    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"}
@@ -55,19 +38,19 @@ describe Decidim::Comments::CommentsWithReplies do
       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 
+        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)  
+        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] 
+        expect(subject.query).to eq [most_voted_comment, comment, less_voted_comment]
       end
     end
 
@@ -76,7 +59,7 @@ describe Decidim::Comments::CommentsWithReplies do
 
       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)    
+        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]

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

@@ -17,43 +17,49 @@ module Decidim
         end
       end
 
-      describe "hasReplies" do
-        let (:query) { "{ hasReplies }" }
+      describe "hasComments" do
+        let (:query) { "{ hasComments }" }
 
-        it "returns false if the comment has not replies" do
-          expect(response).to include("hasReplies" => false)
+        it "returns false if the comment has not comments" do
+          expect(response).to include("hasComments" => false)
         end
 
-        it "returns true if the comment has replies" do
+        it "returns true if the comment has comments" do
           FactoryGirl.create(:comment, commentable: model)
-          expect(response).to include("hasReplies" => true)
+          expect(response).to include("hasComments" => true)
+        end
+
+        it "returns false if the comment depth is equal to MAX_DEPTH" do
+          FactoryGirl.create(:comment, commentable: model)
+          model.update_attribute(:depth, Comment::MAX_DEPTH)
+          expect(response).to include("hasComments" => false)
         end
       end
 
-      describe "canHaveReplies" do
-        let (:query) { "{ canHaveReplies }" }
+      describe "acceptsNewComments" do
+        let (:query) { "{ acceptsNewComments }" }
 
-        it "returns the return value of can_have_replies? method" do
-          expect(response).to include("canHaveReplies" => model.can_have_replies?)
+        it "returns the return value of accepts_new_comments? method" do
+          expect(response).to include("acceptsNewComments" => model.accepts_new_comments?)
         end
       end
 
-      describe "replies" do
+      describe "comments" do
         let!(:random_comment) { FactoryGirl.create(:comment) }
         let!(:replies) { 3.times.map { |n| FactoryGirl.create(:comment, commentable: model, created_at: Time.now - n.days) } }
 
 
-        let(:query) { "{ replies { id } }" }
+        let(:query) { "{ comments { id } }" }
 
-        it "return comment's replies comments data" do
+        it "return comment's comments comments data" do
           replies.each do |reply|
-            expect(response["replies"]).to include("id" => reply.id.to_s)
+            expect(response["comments"]).to include("id" => reply.id.to_s)
           end
-          expect(response["replies"]).not_to include("id" => random_comment.id.to_s)
+          expect(response["comments"]).not_to include("id" => random_comment.id.to_s)
         end
 
-        it "return comment's replies ordered by date" do
-          response_ids = response["replies"].map{|reply| reply["id"].to_i }
+        it "return comment's comments ordered by date" do
+          response_ids = response["comments"].map{|reply| reply["id"].to_i }
           replies_ids = replies.sort_by(&:created_at).map(&:id)
           expect(response_ids).to eq(replies_ids)
         end