decidim 0.0.1.alpha9 → 0.0.1

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe CreateComment, :db do
+      describe "call" do
+        let(:organization) { create(:organization) }
+        let(:author) { create(:user, organization: organization) }
+        let(:commentable) { create :participatory_process, organization: organization }
+        let(:body) { ::Faker::Lorem.paragraph }
+        let(:alignment) { 1 }
+        let(:form_params) do
+          {
+            "comment" => {
+              "body" => body,
+              "alignment" => alignment
+            }
+          }
+        end
+        let(:form) do
+          CommentForm.from_params(
+            form_params
+          )
+        end
+        let(:command) { described_class.new(form, author, commentable) }
+
+        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 comment" do
+            expect do
+              command.call
+            end.to_not change { Comment.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 comment" do
+            expect(Comment).to receive(:create!).with({
+              author: author,
+              commentable: commentable,
+              body: body,
+              alignment: alignment
+            }).and_call_original
+            expect do
+              command.call
+            end.to change { Comment.count }.by(1)
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-comments/spec/factories.rb

@@ -0,0 +1,9 @@
+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

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe "Comments", type: :feature do
+  let!(:organization) { create(:organization) }
+  let!(:user) { create(:user, :confirmed, organization: organization) }
+  let!(:participatory_process) { create(:participatory_process, organization: organization) }
+  let!(:comments) {
+    3.times.map do
+      create(:comment, commentable: participatory_process)
+    end
+  }
+
+  before do
+    switch_to_host(organization.host)
+  end
+
+  it "user should see a list of comments" do
+    visit decidim.dummy_path(participatory_process)
+
+    expect(page).to have_selector("#comments")
+    expect(page).to have_selector("article.comment", count: comments.length)
+
+    within "#comments" do
+      comments.each do |comment|
+        expect(page).to have_content comment.author.name
+        expect(page).to have_content comment.body
+      end
+    end
+  end
+
+  context "when not authenticated" do
+    it "user should not see the form to add comments" do
+      visit decidim.dummy_path(participatory_process)
+      expect(page).to_not have_selector(".add-comment form")
+    end
+  end
+
+  context "when authenticated" do
+    before do
+      login_as user, scope: :user
+    end
+
+    it "user should not see the form to add comments" do
+      visit decidim.dummy_path(participatory_process)
+      expect(page).to have_selector(".add-comment form")
+    end
+
+    it "user can add a new comment" do
+      visit decidim.dummy_path(participatory_process)
+      expect(page).to have_selector(".add-comment form")
+
+      within ".add-comment form" do
+        fill_in "add-comment-#{participatory_process.class.name}-#{participatory_process.id}", with: "This is a new comment"
+        click_button "Send"
+      end
+
+      within "#comments" do
+        expect(page).to have_content user.name
+        expect(page).to have_content "This is a new comment"
+      end
+    end
+
+    it "user can reply a comment" do
+      comment = create(:comment, commentable: participatory_process)
+      visit decidim.dummy_path(participatory_process)
+
+      expect(page).to have_selector(".comment__reply")
+ 
+      within "#comments #comment_#{comment.id}" do
+        click_button "Reply"
+        fill_in "add-comment-#{comment.class.name}-#{comment.id}", with: "This is a reply"
+        click_button "Send"
+
+        expect(page).to have_content "This is a reply"
+      end
+    end
+
+    context "when arguable option is enabled" do
+      it "user can comment in favor" do
+        visit decidim.dummy_path(participatory_process, arguable: true)
+        expect(page).to have_selector(".add-comment form")
+
+        click_button "I am in favor"
+
+        within ".add-comment form" do
+          fill_in "add-comment-#{participatory_process.class.name}-#{participatory_process.id}", with: "I am in favor about this!"
+          click_button "Send"
+        end
+
+        within "#comments" do
+          expect(page).to have_selector 'span.success.label', text: "In favor"
+        end
+      end
+    end
+  end
+end

data/decidim-comments/spec/forms/comment_form_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe CommentForm do
+      let(:body) { "This is a new comment" }
+      let(:alignment) { 1 }
+
+      let(:attributes) do
+        {
+          "comment" => {
+            "body" => body,
+            "alignment" => alignment
+          }
+        }
+      end
+
+      subject do
+        described_class.from_params(
+          attributes
+        )
+      end
+
+      context "when everything is OK" do
+        it { is_expected.to be_valid }
+      end
+
+      context "when body is blank" do
+        let(:body) { "" }
+
+        it { is_expected.not_to be_valid }
+      end
+
+      context "when alignment is not present" do
+        let(:alignment) { nil }
+        
+        it { is_expected.to be_valid }
+      end
+
+      context "when alignment is present and it is different from 0, 1 and -1" do
+        let(:alignment) { 2 }
+
+        it { is_expected.not_to be_valid }      
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe CommentsHelper do
+      class DummyCommentable
+        def id
+          1
+        end
+      end
+
+      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",
+              commentableId: "1",
+              options: {
+                arguable: true
+              },
+              locale: I18n.locale
+            })
+            .and_call_original
+
+          helper.comments_for(commentable, arguable: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe Comment do
+      let!(:commentable) { create(:participatory_process) }
+      let!(:comment) { create(:comment, commentable: commentable) }
+      let!(:replies) { 3.times.map { create(:comment, commentable: comment) } }
+
+      it "is valid" do
+        expect(comment).to be_valid
+      end
+
+      it "has an associated author" do
+        expect(comment.author).to be_a(Decidim::User)
+      end
+
+      it "has an associated commentable" do
+        expect(comment.commentable).to be_a(Decidim::ParticipatoryProcess)
+      end
+
+      it "has a replies association" do
+        expect(comment.replies).to match_array(replies)
+      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
+      end
+
+      it "should compute its depth before saving the model" do
+        expect(comment.depth).to eq(0)
+        comment.replies.each do |reply|
+          expect(reply.depth).to eq(1)
+        end
+      end
+
+      it "is not valid if the author organization is different" do
+        foreign_user = build(:user)
+        comment = build(:comment, author: foreign_user)
+
+        expect(comment).to_not be_valid
+      end
+
+      describe "#can_have_replies?" do
+        it "should return true if the comment's depth is below MAX_DEPTH" do
+          comment.depth = Comment::MAX_DEPTH - 1
+          expect(comment.can_have_replies?).to be_truthy
+        end
+
+        it "should return false if the comment's depth is equal or greater than MAX_DEPTH" do
+          comment.depth = Comment::MAX_DEPTH
+          expect(comment.can_have_replies?).to be_falsy          
+        end
+      end
+
+      it "is not valid if alignment is not 0, 1 or -1" do
+        comment.alignment = 2
+        expect(comment).not_to be_valid
+      end
+    end
+  end
+end

data/decidim-comments/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+ENV["ENGINE_NAME"] = File.dirname(File.dirname(__FILE__)).split("/").last
+require "decidim/test/base_spec_helper"

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

@@ -0,0 +1,20 @@
+Decidim::Core::Engine.routes.draw do
+  mount Decidim::Api::Engine => "/api"
+
+  get '/dummy/:id' => 'dummy#show', as: :dummy
+end
+
+class Decidim::DummyController < Decidim::ApplicationController
+  helper Decidim::Comments::CommentsHelper
+  skip_authorization_check
+
+  def show
+    @participatory_process = Decidim::ParticipatoryProcess.find(params[:id])
+    @options = params.slice(:arguable)
+    @options.each { |key, val| @options[key] = val === 'true' }
+    render inline: %{
+      <%= javascript_include_tag 'application' %>
+      <%= comments_for(@participatory_process, @options) %>
+    }.html_safe
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require "decidim/api/test/type_context"
+
+module Decidim
+  module Comments
+    describe AuthorType do
+      include_context "graphql type"
+      
+      let(:model) { FactoryGirl.create(:user) }
+
+      describe "avatarUrl" do
+        let (:query) { "{ avatarUrl }" }
+
+        it "returns the user avatar url" do
+          expect(response).to include("avatarUrl" => model.avatar.url)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "decidim/api/test/type_context"
+
+module Decidim
+  module Comments
+    describe CommentType do
+      include_context "graphql type"
+
+      let(:model) { FactoryGirl.create(:comment) }
+
+      describe "createdAt" do
+        let(:query) { "{ createdAt }" }
+
+        it "returns its created_at field" do
+          expect(response).to include("createdAt" => model.created_at.to_s)
+        end
+      end
+
+      describe "canHaveReplies" do
+        let (:query) { "{ canHaveReplies }" }
+        
+        it "returns the return value of can_have_replies? method" do
+          expect(response).to include("canHaveReplies" => model.can_have_replies?)
+        end
+      end
+
+      describe "replies" do
+        let!(:random_comment) { FactoryGirl.create(:comment) }
+        let!(:replies) { 3.times.map { FactoryGirl.create(:comment, commentable: model) } }
+
+        let(:query) { "{ replies { id } }" }
+
+        it "return comment's replies comments data" do
+          replies.each do |reply|
+            expect(response["replies"]).to include("id" => reply.id.to_s)
+          end
+          expect(response["replies"]).to_not include("id" => random_comment.id.to_s)
+        end
+      end
+
+      describe "alignment" do
+        let(:query) { "{ alignment }" }
+
+        it "returns the alignment field" do
+          expect(response).to include("alignment" => model.alignment)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "decidim/api/test/type_context"
+
+describe Decidim::Api::QueryType do
+  include_context "graphql type"
+
+  describe "currentUser" do
+    let(:query) { "{ currentUser { name } } " }
+
+    context "When the user is logged in" do
+      it "return current user data" do
+        expect(response["currentUser"]).to include("name" => current_user.name)
+      end
+    end
+
+    context "When the user is not logged in" do
+      let!(:current_user) { nil }
+
+      it "return a nil object" do
+        expect(response["currentUser"]).to be_nil
+      end
+    end
+  end
+
+  describe "comments" do
+    let!(:participatory_process_1) { create(:participatory_process, organization: current_organization) }
+    let!(:comment_1) { create(:comment, commentable: participatory_process_1) }
+    let!(:comment_2) { create(:comment, commentable: participatory_process_1) }
+    let!(:participatory_process_2) { create(:participatory_process, organization: current_organization) }
+    let!(:comment_3) { create(:comment, commentable: participatory_process_2) }
+
+    let(:query) { "{ comments(commentableId: \"#{participatory_process_1.id}\", commentableType: \"Decidim::ParticipatoryProcess\") { id } }" }
+
+    it "returns comments from a commentable resource" do
+      expect(response["comments"]).to     include("id" => comment_1.id.to_s)
+      expect(response["comments"]).to     include("id" => comment_2.id.to_s)
+      expect(response["comments"]).to_not include("id" => comment_3.id.to_s)
+    end
+
+    it "returns comments ordered by creation date" do
+      comment_2.update_attribute(:created_at, 2.days.ago)
+      comment_1.update_attribute(:created_at, 1.days.ago)
+
+      expect(response["comments"][0]["id"]).to eq comment_2.id.to_s
+      expect(response["comments"][1]["id"]).to eq comment_1.id.to_s
+    end
+  end
+end