Add tests for comment paragraph plugin

Victor Costa · Michel Felipe
1 parent 7b6978a6
Showing 10 changed files with 366 additions and 12 deletions Show diff stats
src/app/hotspot/hotspot.decorator.ts
src/plugins/comment_paragraph/allow-comment/allow-comment.component.spec.ts
src/plugins/comment_paragraph/allow-comment/allow-comment.component.ts
src/plugins/comment_paragraph/events/comment-paragraph-event.service.spec.ts
src/plugins/comment_paragraph/hotspot/comment-paragraph-article-button.component.spec.ts
src/plugins/comment_paragraph/hotspot/comment-paragraph-article-button.component.ts
src/plugins/comment_paragraph/http/comment-paragraph.service.spec.ts
src/plugins/comment_paragraph/side-comments/side-comments.component.spec.ts
src/plugins/comment_paragraph/side-comments/side-comments.component.ts
src/spec/component-test-helper.ts
 export function Hotspot(hotspotName: string) {
     return (target: any) => {
         target['hotspot'] = hotspotName;
-    }
+    };
 }
@@ -0,0 +1,78 @@
+import {AllowCommentComponent} from "./allow-comment.component";
+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
+import * as helpers from "../../../spec/helpers";
+import {Provider} from 'ng-forward';
+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
+
+let htmlTemplate = '<comment-paragraph-plugin-allow-comment [content]="ctrl.content" [paragraph-uuid]="ctrl.paragraphUuid" [article]="ctrl.article"></comment-paragraph-plugin-allow-comment>';
+
+describe("Components", () => {
+    describe("Allow Comment Component", () => {
+
+        let serviceMock = {
+            commentParagraphCount: () => {
+                return Promise.resolve(5);
+            }
+        };
+        let functionToggleCommentParagraph: Function;
+        let eventServiceMock = {
+            // toggleCommentParagraph
+            subscribeToggleCommentParagraph: (fn: Function) => {
+                functionToggleCommentParagraph = fn;
+            }
+        };
+
+        let providers = [
+            new Provider('CommentParagraphService', { useValue: serviceMock }),
+            new Provider('CommentParagraphEventService', { useValue: eventServiceMock })
+        ];
+        let helper: ComponentTestHelper;
+
+        beforeEach(angular.mock.module("templates"));
+
+        beforeEach((done) => {
+            let cls = createClass({
+                template: htmlTemplate,
+                directives: [AllowCommentComponent],
+                providers: providers,
+                properties: {
+                    content: "",
+                    paragraphUuid: "uuid",
+                    article: {
+                        setting: {
+                            comment_paragraph_plugin_activate: true
+                        }
+                    }
+                }
+            });
+            helper = new ComponentTestHelper(cls, done);
+        });
+
+        it('update comments count', () => {
+            expect(helper.component.commentsCount).toEqual(5);
+        });
+
+        it('display paragraph content', () => {
+            expect(helper.all(".paragraph .paragraph-content").length).toEqual(1);
+        });
+
+        it('display button to side comments', () => {
+            expect(helper.all(".paragraph .actions a").length).toEqual(1);
+        });
+
+        it('set display to true when click in show paragraph', () => {
+            helper.component.showParagraphComments();
+            expect(helper.component.display).toBeTruthy();
+        });
+
+        it('set display to false when click in hide paragraph', () => {
+            helper.component.hideParagraphComments();
+            expect(helper.component.display).toBeFalsy();
+        });
+
+        it('update article when receive a toogle paragraph event', () => {
+            functionToggleCommentParagraph({ id: 2 });
+            expect(helper.component.article.id).toEqual(2);
+        });
+    });
+});
@@ -26,13 +26,13 @@ export class AllowCommentComponent {
             this.article = article;
             this.$scope.$apply();
         });
-        this.commentParagraphService.commentParagraphCount(this.article, this.paragraphUuid).then((count: any) => {
+        this.commentParagraphService.commentParagraphCount(this.article, this.paragraphUuid).then((count: number) => {
             this.commentsCount = count;
         });
     }
     isActivated() {
-        return this.article.setting.comment_paragraph_plugin_activate;
+        return this.article && this.article.setting && this.article.setting.comment_paragraph_plugin_activate;
     }
     showParagraphComments() {
@@ -0,0 +1,28 @@
+import {CommentParagraphEventService} from "./comment-paragraph-event.service";
+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
+import * as helpers from "../../../spec/helpers";
+import {Provider} from 'ng-forward';
+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
+
+describe("Services", () => {
+    describe("Comment Paragraph Event Service", () => {
+        let eventService: CommentParagraphEventService;
+
+        beforeEach(() => {
+            eventService = new CommentParagraphEventService();
+            eventService['toggleCommentParagraphEmitter'] = jasmine.createSpyObj("toggleCommentParagraphEmitter", ["next", "subscribe"]);
+        });
+
+        it('subscribe to toggle comment paragraph event', () => {
+            eventService['toggleCommentParagraphEmitter'].subscribe = jasmine.createSpy("subscribe");
+            eventService.subscribeToggleCommentParagraph(() => { });
+            expect(eventService['toggleCommentParagraphEmitter'].subscribe).toHaveBeenCalled();
+        });
+
+        it('emit event when toggle comment paragraph', () => {
+            eventService['toggleCommentParagraphEmitter'].subscribe = jasmine.createSpy("next");
+            eventService.toggleCommentParagraph(<noosfero.Article>{});
+            expect(eventService['toggleCommentParagraphEmitter'].next).toHaveBeenCalled();
+        });
+    });
+});
@@ -0,0 +1,85 @@
+import {CommentParagraphArticleButtonHotspotComponent} from "./comment-paragraph-article-button.component";
+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
+import * as helpers from "../../../spec/helpers";
+import {Provider} from 'ng-forward';
+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
+
+let htmlTemplate = '<comment-paragraph-article-button-hotspot [article]="ctrl.article"></comment-paragraph-article-button-hotspot>';
+
+describe("Components", () => {
+    describe("Comment Paragraph Article Button Hotspot Component", () => {
+
+        let serviceMock = jasmine.createSpyObj("CommentParagraphService", ["deactivateCommentParagraph", "activateCommentParagraph"]);
+        let eventServiceMock = jasmine.createSpyObj("CommentParagraphEventService", ["toggleCommentParagraph"]);
+
+        let providers = [
+            new Provider('CommentParagraphService', { useValue: serviceMock }),
+            new Provider('CommentParagraphEventService', { useValue: eventServiceMock })
+        ].concat(helpers.provideFilters('translateFilter'));
+        let helper: ComponentTestHelper;
+
+        beforeEach(angular.mock.module("templates"));
+
+        beforeEach((done) => {
+            let cls = createClass({
+                template: htmlTemplate,
+                directives: [CommentParagraphArticleButtonHotspotComponent],
+                providers: providers,
+                properties: {
+                    article: {}
+                }
+            });
+            helper = new ComponentTestHelper(cls, done);
+        });
+
+        it('emit event when deactivate comment paragraph in an article', () => {
+            serviceMock.deactivateCommentParagraph = jasmine.createSpy("deactivateCommentParagraph").and.returnValue(
+                { then: (fn: Function) => { fn({ data: {} }); } }
+            );
+            eventServiceMock.toggleCommentParagraph = jasmine.createSpy("toggleCommentParagraph");
+            helper.component.deactivateCommentParagraph();
+
+            expect(serviceMock.deactivateCommentParagraph).toHaveBeenCalled();
+            expect(eventServiceMock.toggleCommentParagraph).toHaveBeenCalled();
+        });
+
+        it('emit event when activate comment paragraph in an article', () => {
+            serviceMock.activateCommentParagraph = jasmine.createSpy("activateCommentParagraph").and.returnValue(
+                { then: (fn: Function) => { fn({ data: {} }); } }
+            );
+            eventServiceMock.toggleCommentParagraph = jasmine.createSpy("toggleCommentParagraph");
+            helper.component.activateCommentParagraph();
+
+            expect(serviceMock.activateCommentParagraph).toHaveBeenCalled();
+            expect(eventServiceMock.toggleCommentParagraph).toHaveBeenCalled();
+        });
+
+        it('return true when comment paragraph is active', () => {
+            helper.component.article = { setting: { comment_paragraph_plugin_activate: true } };
+            helper.detectChanges();
+            expect(helper.component.isActivated()).toBeTruthy();
+        });
+
+        it('return false when comment paragraph is not active', () => {
+            expect(helper.component.isActivated()).toBeFalsy();
+        });
+
+        it('return false when article has no setting attribute', () => {
+            helper.component.article = {};
+            helper.detectChanges();
+            expect(helper.component.isActivated()).toBeFalsy();
+        });
+
+        it('display activate button when comment paragraph is not active', () => {
+            expect(helper.all('.comment-paragraph-activate').length).toEqual(1);
+            expect(helper.all('.comment-paragraph-deactivate').length).toEqual(0);
+        });
+
+        it('display deactivate button when comment paragraph is active', () => {
+            helper.component.article = { setting: { comment_paragraph_plugin_activate: true } };
+            helper.detectChanges();
+            expect(helper.all('.comment-paragraph-deactivate').length).toEqual(1);
+            expect(helper.all('.comment-paragraph-activate').length).toEqual(0);
+        });
+    });
+});
@@ -18,14 +18,19 @@ export class CommentParagraphArticleButtonHotspotComponent {
         private commentParagraphEventService: CommentParagraphEventService) { }
     deactivateCommentParagraph() {
-        this.commentParagraphService.deactivateCommentParagraph(this.article).then((result: noosfero.RestResult<noosfero.Article>) => {
-            this.article = result.data;
-            this.commentParagraphEventService.toggleCommentParagraph(this.article);
-        });
+        this.toggleCommentParagraph(this.commentParagraphService.deactivateCommentParagraph(this.article));
     }
     activateCommentParagraph() {
-        this.commentParagraphService.activateCommentParagraph(this.article).then((result: noosfero.RestResult<noosfero.Article>) => {
+        this.toggleCommentParagraph(this.commentParagraphService.activateCommentParagraph(this.article));
+    }
+
+    isActivated() {
+        return this.article && this.article.setting && this.article.setting.comment_paragraph_plugin_activate;
+    }
+
+    private toggleCommentParagraph(promise: ng.IPromise<noosfero.RestResult<noosfero.Article>>) {
+        promise.then((result: noosfero.RestResult<noosfero.Article>) => {
             this.article = result.data;
             this.commentParagraphEventService.toggleCommentParagraph(this.article);
         });
@@ -0,0 +1,90 @@
+import {CommentParagraphService} from "./comment-paragraph.service";
+
+
+describe("Services", () => {
+
+    describe("Comment Paragraph Service", () => {
+
+        let $httpBackend: ng.IHttpBackendService;
+        let commentParagraphService: CommentParagraphService;
+
+        beforeEach(angular.mock.module("noosferoApp", ($translateProvider: angular.translate.ITranslateProvider) => {
+            $translateProvider.translations('en', {});
+        }));
+
+        beforeEach(inject((_$httpBackend_: ng.IHttpBackendService, _CommentParagraphService_: CommentParagraphService) => {
+            $httpBackend = _$httpBackend_;
+            commentParagraphService = _CommentParagraphService_;
+        }));
+
+
+        describe("Succesfull requests", () => {
+
+            it("should return paragraph comments by article", (done) => {
+                let articleId = 1;
+                $httpBackend.expectGET(`/api/v1/articles/${articleId}/comment_paragraph_plugin/comments?without_reply=true`).respond(200, { comments: [{ body: "comment1" }] });
+                commentParagraphService.getByArticle(<noosfero.Article>{ id: articleId }).then((result: noosfero.RestResult<noosfero.Comment[]>) => {
+                    expect(result.data).toEqual([{ body: "comment1" }]);
+                    done();
+                });
+                $httpBackend.flush();
+            });
+
+            it("should create a paragraph comment", (done) => {
+                let articleId = 1;
+                $httpBackend.expectPOST(`/api/v1/articles/${articleId}/comment_paragraph_plugin/comments`).respond(200, { comment: { body: "comment1" } });
+                commentParagraphService.createInArticle(<noosfero.Article>{ id: articleId }, <noosfero.Comment>{ body: "comment1" }).then((result: noosfero.RestResult<noosfero.Comment>) => {
+                    expect(result.data).toEqual({ body: "comment1" });
+                    done();
+                });
+                $httpBackend.flush();
+            });
+
+            it("activate paragraph comments for an article", (done) => {
+                let articleId = 1;
+                $httpBackend.expectPOST(`/api/v1/articles/${articleId}/comment_paragraph_plugin/activate`).respond(200, { article: { title: "article1" } });
+                commentParagraphService.activateCommentParagraph(<noosfero.Article>{ id: articleId }).then((result: noosfero.RestResult<noosfero.Article>) => {
+                    expect(result.data).toEqual({ title: "article1" });
+                    done();
+                });
+                $httpBackend.flush();
+            });
+
+            it("deactivate paragraph comments for an article", (done) => {
+                let articleId = 1;
+                $httpBackend.expectPOST(`/api/v1/articles/${articleId}/comment_paragraph_plugin/deactivate`).respond(200, { article: { title: "article1" } });
+                commentParagraphService.deactivateCommentParagraph(<noosfero.Article>{ id: articleId }).then((result: noosfero.RestResult<noosfero.Article>) => {
+                    expect(result.data).toEqual({ title: "article1" });
+                    done();
+                });
+                $httpBackend.flush();
+            });
+
+            it("return counts for paragraph comments", (done) => {
+                let articleId = 1;
+                $httpBackend.expectGET(`/api/v1/articles/${articleId}/comment_paragraph_plugin/comments/count`).respond(200, { '1': 5, '2': 6 });
+                commentParagraphService.commentParagraphCount(<noosfero.Article>{ id: articleId }, '1').then((count: number) => {
+                    expect(count).toEqual(5);
+                    done();
+                });
+                $httpBackend.flush();
+            });
+
+            it("reset promise when comment paragraph counts fails", (done) => {
+                let articleId = 1;
+                commentParagraphService['articleService'] = jasmine.createSpyObj("articleService", ["getElement"]);
+                commentParagraphService['articleService'].getElement = jasmine.createSpy("getElement").and.returnValue(
+                    {
+                        customGET: (path: string) => {
+                            return Promise.reject({});
+                        }
+                    }
+                );
+                commentParagraphService.commentParagraphCount(<noosfero.Article>{ id: articleId }, '1').catch(() => {
+                    expect(commentParagraphService['commentParagraphCountsPromise']).toBeNull();
+                    done();
+                });
+            });
+        });
+    });
+});
@@ -0,0 +1,50 @@
+import {SideCommentsComponent} from "./side-comments.component";
+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
+import * as helpers from "../../../spec/helpers";
+import {Provider} from 'ng-forward';
+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
+
+let htmlTemplate = '<comment-paragraph-side-comments [article]="ctrl.article" [paragraph-uuid]="ctrl.paragraphUuid"></comment-paragraph-side-comments>';
+
+describe("Components", () => {
+    describe("Side Comments Component", () => {
+
+        let serviceMock = jasmine.createSpyObj("CommentParagraphService", ["getByArticle"]);
+        serviceMock.getByArticle = jasmine.createSpy("getByArticle").and.returnValue(Promise.resolve({ data: {} }));
+
+        let commentServiceMock = {};
+        let postCommentEventService = jasmine.createSpyObj("postCommentEventService", ["emit", "subscribe"]);
+        postCommentEventService.subscribe = jasmine.createSpy("subscribe");
+
+        let providers = [
+            new Provider('CommentParagraphService', { useValue: serviceMock }),
+            new Provider('CommentService', { useValue: commentServiceMock }),
+            new Provider('PostCommentEventService', { useValue: postCommentEventService })
+        ];
+        let helper: ComponentTestHelper;
+
+        beforeEach(angular.mock.module("templates"));
+
+        beforeEach((done) => {
+            let cls = createClass({
+                template: htmlTemplate,
+                directives: [SideCommentsComponent],
+                providers: providers,
+                properties: {
+                    paragraphUuid: "uuid",
+                    article: {}
+                }
+            });
+            helper = new ComponentTestHelper(cls, done);
+        });
+
+        it('call service to load paragraph comments', () => {
+            helper.component.loadComments();
+            expect(serviceMock.getByArticle).toHaveBeenCalled();
+        });
+
+        it('set paragraph uuid in new comment object', () => {
+            expect(helper.component.newComment['paragraph_uuid']).toEqual('uuid');
+        });
+    });
+});
@@ -2,19 +2,23 @@ import {Component, Inject, Input, Output} from &quot;ng-forward&quot;;
 import {CommentsComponent} from "../../../app/article/comment/comments.component";
 import {CommentService} from "../../../lib/ng-noosfero-api/http/comment.service";
 import {CommentParagraphService} from "../http/comment-paragraph.service";
+import { PostCommentEventService } from "../../../app/article/comment/post-comment/post-comment-event.service";
 @Component({
     selector: "comment-paragraph-side-comments",
     templateUrl: 'app/article/comment/comments.html',
 })
-@Inject(CommentService, "$rootScope", CommentParagraphService)
+@Inject(CommentService, PostCommentEventService, "$scope", CommentParagraphService)
 export class SideCommentsComponent extends CommentsComponent {
     @Input() article: noosfero.Article;
     @Input() paragraphUuid: string;
-    constructor(commentService: CommentService, $rootScope: ng.IScope, private commentParagraphService: CommentParagraphService) {
-        super(commentService, $rootScope);
+    constructor(commentService: CommentService,
+        postCommentEventService: PostCommentEventService,
+        $scope: ng.IScope,
+        private commentParagraphService: CommentParagraphService) {
+        super(commentService, postCommentEventService, $scope);
     }
     ngOnInit() {
@@ -68,6 +68,8 @@ export class ComponentTestHelper&lt;T extends any&gt; {
         this.init(done);
     }
+    fixture: any;
+
     /**
      * @ngdoc method
      * @name init
@@ -79,7 +81,8 @@ export class ComponentTestHelper&lt;T extends any&gt; {
         let promisse = this.tcb.createAsync(this.mockComponent) as Promise<ComponentFixture>;
         return promisse.then((fixture: any) => {
             // Fire all angular events and parsing
-            fixture.detectChanges();
+            this.fixture = fixture;
+            this.detectChanges();
             // The main debug element
             this.debugElement = fixture.debugElement;
             this.component = <T>this.debugElement.componentViewChildren[0].componentInstance;
@@ -96,6 +99,17 @@ export class ComponentTestHelper&lt;T extends any&gt; {
     /**
      * @ngdoc method
+     * @name detectChanges
+     * @methodOf spec.ComponentTestHelper
+     * @description
+     *  Detect changes in component
+     */
+    detectChanges() {
+        this.fixture.detectChanges();
+    }
+
+    /**
+     * @ngdoc method
      * @name all
      * @methodOf spec.ComponentTestHelper
      * @description
1	export function Hotspot(hotspotName: string) {	1	export function Hotspot(hotspotName: string) {
2	return (target: any) => {	2	return (target: any) => {
3	target['hotspot'] = hotspotName;	3	target['hotspot'] = hotspotName;
4	- }	4	+ };
5	}	5	}
@@ -0,0 +1,78 @@		@@ -0,0 +1,78 @@
	1	+import {AllowCommentComponent} from "./allow-comment.component";
	2	+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
	3	+import * as helpers from "../../../spec/helpers";
	4	+import {Provider} from 'ng-forward';
	5	+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
	6	+
	7	+let htmlTemplate = '<comment-paragraph-plugin-allow-comment [content]="ctrl.content" [paragraph-uuid]="ctrl.paragraphUuid" [article]="ctrl.article"></comment-paragraph-plugin-allow-comment>';
	8	+
	9	+describe("Components", () => {
	10	+ describe("Allow Comment Component", () => {
	11	+
	12	+ let serviceMock = {
	13	+ commentParagraphCount: () => {
	14	+ return Promise.resolve(5);
	15	+ }
	16	+ };
	17	+ let functionToggleCommentParagraph: Function;
	18	+ let eventServiceMock = {
	19	+ // toggleCommentParagraph
	20	+ subscribeToggleCommentParagraph: (fn: Function) => {
	21	+ functionToggleCommentParagraph = fn;
	22	+ }
	23	+ };
	24	+
	25	+ let providers = [
	26	+ new Provider('CommentParagraphService', { useValue: serviceMock }),
	27	+ new Provider('CommentParagraphEventService', { useValue: eventServiceMock })
	28	+ ];
	29	+ let helper: ComponentTestHelper;
	30	+
	31	+ beforeEach(angular.mock.module("templates"));
	32	+
	33	+ beforeEach((done) => {
	34	+ let cls = createClass({
	35	+ template: htmlTemplate,
	36	+ directives: [AllowCommentComponent],
	37	+ providers: providers,
	38	+ properties: {
	39	+ content: "",
	40	+ paragraphUuid: "uuid",
	41	+ article: {
	42	+ setting: {
	43	+ comment_paragraph_plugin_activate: true
	44	+ }
	45	+ }
	46	+ }
	47	+ });
	48	+ helper = new ComponentTestHelper(cls, done);
	49	+ });
	50	+
	51	+ it('update comments count', () => {
	52	+ expect(helper.component.commentsCount).toEqual(5);
	53	+ });
	54	+
	55	+ it('display paragraph content', () => {
	56	+ expect(helper.all(".paragraph .paragraph-content").length).toEqual(1);
	57	+ });
	58	+
	59	+ it('display button to side comments', () => {
	60	+ expect(helper.all(".paragraph .actions a").length).toEqual(1);
	61	+ });
	62	+
	63	+ it('set display to true when click in show paragraph', () => {
	64	+ helper.component.showParagraphComments();
	65	+ expect(helper.component.display).toBeTruthy();
	66	+ });
	67	+
	68	+ it('set display to false when click in hide paragraph', () => {
	69	+ helper.component.hideParagraphComments();
	70	+ expect(helper.component.display).toBeFalsy();
	71	+ });
	72	+
	73	+ it('update article when receive a toogle paragraph event', () => {
	74	+ functionToggleCommentParagraph({ id: 2 });
	75	+ expect(helper.component.article.id).toEqual(2);
	76	+ });
	77	+ });
	78	+});
	@@ -26,13 +26,13 @@ export class AllowCommentComponent {		@@ -26,13 +26,13 @@ export class AllowCommentComponent {
26	this.article = article;	26	this.article = article;
27	this.$scope.$apply();	27	this.$scope.$apply();
28	});	28	});
29	- this.commentParagraphService.commentParagraphCount(this.article, this.paragraphUuid).then((count: any) => {	29	+ this.commentParagraphService.commentParagraphCount(this.article, this.paragraphUuid).then((count: number) => {
30	this.commentsCount = count;	30	this.commentsCount = count;
31	});	31	});
32	}	32	}
33		33
34	isActivated() {	34	isActivated() {
35	- return this.article.setting.comment_paragraph_plugin_activate;	35	+ return this.article && this.article.setting && this.article.setting.comment_paragraph_plugin_activate;
36	}	36	}
37		37
38	showParagraphComments() {	38	showParagraphComments() {
@@ -0,0 +1,28 @@		@@ -0,0 +1,28 @@
	1	+import {CommentParagraphEventService} from "./comment-paragraph-event.service";
	2	+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
	3	+import * as helpers from "../../../spec/helpers";
	4	+import {Provider} from 'ng-forward';
	5	+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
	6	+
	7	+describe("Services", () => {
	8	+ describe("Comment Paragraph Event Service", () => {
	9	+ let eventService: CommentParagraphEventService;
	10	+
	11	+ beforeEach(() => {
	12	+ eventService = new CommentParagraphEventService();
	13	+ eventService['toggleCommentParagraphEmitter'] = jasmine.createSpyObj("toggleCommentParagraphEmitter", ["next", "subscribe"]);
	14	+ });
	15	+
	16	+ it('subscribe to toggle comment paragraph event', () => {
	17	+ eventService['toggleCommentParagraphEmitter'].subscribe = jasmine.createSpy("subscribe");
	18	+ eventService.subscribeToggleCommentParagraph(() => { });
	19	+ expect(eventService['toggleCommentParagraphEmitter'].subscribe).toHaveBeenCalled();
	20	+ });
	21	+
	22	+ it('emit event when toggle comment paragraph', () => {
	23	+ eventService['toggleCommentParagraphEmitter'].subscribe = jasmine.createSpy("next");
	24	+ eventService.toggleCommentParagraph(<noosfero.Article>{});
	25	+ expect(eventService['toggleCommentParagraphEmitter'].next).toHaveBeenCalled();
	26	+ });
	27	+ });
	28	+});
@@ -0,0 +1,85 @@		@@ -0,0 +1,85 @@
	1	+import {CommentParagraphArticleButtonHotspotComponent} from "./comment-paragraph-article-button.component";
	2	+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
	3	+import * as helpers from "../../../spec/helpers";
	4	+import {Provider} from 'ng-forward';
	5	+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
	6	+
	7	+let htmlTemplate = '<comment-paragraph-article-button-hotspot [article]="ctrl.article"></comment-paragraph-article-button-hotspot>';
	8	+
	9	+describe("Components", () => {
	10	+ describe("Comment Paragraph Article Button Hotspot Component", () => {
	11	+
	12	+ let serviceMock = jasmine.createSpyObj("CommentParagraphService", ["deactivateCommentParagraph", "activateCommentParagraph"]);
	13	+ let eventServiceMock = jasmine.createSpyObj("CommentParagraphEventService", ["toggleCommentParagraph"]);
	14	+
	15	+ let providers = [
	16	+ new Provider('CommentParagraphService', { useValue: serviceMock }),
	17	+ new Provider('CommentParagraphEventService', { useValue: eventServiceMock })
	18	+ ].concat(helpers.provideFilters('translateFilter'));
	19	+ let helper: ComponentTestHelper;
	20	+
	21	+ beforeEach(angular.mock.module("templates"));
	22	+
	23	+ beforeEach((done) => {
	24	+ let cls = createClass({
	25	+ template: htmlTemplate,
	26	+ directives: [CommentParagraphArticleButtonHotspotComponent],
	27	+ providers: providers,
	28	+ properties: {
	29	+ article: {}
	30	+ }
	31	+ });
	32	+ helper = new ComponentTestHelper(cls, done);
	33	+ });
	34	+
	35	+ it('emit event when deactivate comment paragraph in an article', () => {
	36	+ serviceMock.deactivateCommentParagraph = jasmine.createSpy("deactivateCommentParagraph").and.returnValue(
	37	+ { then: (fn: Function) => { fn({ data: {} }); } }
	38	+ );
	39	+ eventServiceMock.toggleCommentParagraph = jasmine.createSpy("toggleCommentParagraph");
	40	+ helper.component.deactivateCommentParagraph();
	41	+
	42	+ expect(serviceMock.deactivateCommentParagraph).toHaveBeenCalled();
	43	+ expect(eventServiceMock.toggleCommentParagraph).toHaveBeenCalled();
	44	+ });
	45	+
	46	+ it('emit event when activate comment paragraph in an article', () => {
	47	+ serviceMock.activateCommentParagraph = jasmine.createSpy("activateCommentParagraph").and.returnValue(
	48	+ { then: (fn: Function) => { fn({ data: {} }); } }
	49	+ );
	50	+ eventServiceMock.toggleCommentParagraph = jasmine.createSpy("toggleCommentParagraph");
	51	+ helper.component.activateCommentParagraph();
	52	+
	53	+ expect(serviceMock.activateCommentParagraph).toHaveBeenCalled();
	54	+ expect(eventServiceMock.toggleCommentParagraph).toHaveBeenCalled();
	55	+ });
	56	+
	57	+ it('return true when comment paragraph is active', () => {
	58	+ helper.component.article = { setting: { comment_paragraph_plugin_activate: true } };
	59	+ helper.detectChanges();
	60	+ expect(helper.component.isActivated()).toBeTruthy();
	61	+ });
	62	+
	63	+ it('return false when comment paragraph is not active', () => {
	64	+ expect(helper.component.isActivated()).toBeFalsy();
	65	+ });
	66	+
	67	+ it('return false when article has no setting attribute', () => {
	68	+ helper.component.article = {};
	69	+ helper.detectChanges();
	70	+ expect(helper.component.isActivated()).toBeFalsy();
	71	+ });
	72	+
	73	+ it('display activate button when comment paragraph is not active', () => {
	74	+ expect(helper.all('.comment-paragraph-activate').length).toEqual(1);
	75	+ expect(helper.all('.comment-paragraph-deactivate').length).toEqual(0);
	76	+ });
	77	+
	78	+ it('display deactivate button when comment paragraph is active', () => {
	79	+ helper.component.article = { setting: { comment_paragraph_plugin_activate: true } };
	80	+ helper.detectChanges();
	81	+ expect(helper.all('.comment-paragraph-deactivate').length).toEqual(1);
	82	+ expect(helper.all('.comment-paragraph-activate').length).toEqual(0);
	83	+ });
	84	+ });
	85	+});
@@ -0,0 +1,90 @@		@@ -0,0 +1,90 @@
	1	+import {CommentParagraphService} from "./comment-paragraph.service";
	2	+
	3	+
	4	+describe("Services", () => {
	5	+
	6	+ describe("Comment Paragraph Service", () => {
	7	+
	8	+ let $httpBackend: ng.IHttpBackendService;
	9	+ let commentParagraphService: CommentParagraphService;
	10	+
	11	+ beforeEach(angular.mock.module("noosferoApp", ($translateProvider: angular.translate.ITranslateProvider) => {
	12	+ $translateProvider.translations('en', {});
	13	+ }));
	14	+
	15	+ beforeEach(inject((_$httpBackend_: ng.IHttpBackendService, _CommentParagraphService_: CommentParagraphService) => {
	16	+ $httpBackend = _$httpBackend_;
	17	+ commentParagraphService = _CommentParagraphService_;
	18	+ }));
	19	+
	20	+
	21	+ describe("Succesfull requests", () => {
	22	+
	23	+ it("should return paragraph comments by article", (done) => {
	24	+ let articleId = 1;
	25	+ $httpBackend.expectGET(`/api/v1/articles/${articleId}/comment_paragraph_plugin/comments?without_reply=true`).respond(200, { comments: [{ body: "comment1" }] });
	26	+ commentParagraphService.getByArticle(<noosfero.Article>{ id: articleId }).then((result: noosfero.RestResult<noosfero.Comment[]>) => {
	27	+ expect(result.data).toEqual([{ body: "comment1" }]);
	28	+ done();
	29	+ });
	30	+ $httpBackend.flush();
	31	+ });
	32	+
	33	+ it("should create a paragraph comment", (done) => {
	34	+ let articleId = 1;
	35	+ $httpBackend.expectPOST(`/api/v1/articles/${articleId}/comment_paragraph_plugin/comments`).respond(200, { comment: { body: "comment1" } });
	36	+ commentParagraphService.createInArticle(<noosfero.Article>{ id: articleId }, <noosfero.Comment>{ body: "comment1" }).then((result: noosfero.RestResult<noosfero.Comment>) => {
	37	+ expect(result.data).toEqual({ body: "comment1" });
	38	+ done();
	39	+ });
	40	+ $httpBackend.flush();
	41	+ });
	42	+
	43	+ it("activate paragraph comments for an article", (done) => {
	44	+ let articleId = 1;
	45	+ $httpBackend.expectPOST(`/api/v1/articles/${articleId}/comment_paragraph_plugin/activate`).respond(200, { article: { title: "article1" } });
	46	+ commentParagraphService.activateCommentParagraph(<noosfero.Article>{ id: articleId }).then((result: noosfero.RestResult<noosfero.Article>) => {
	47	+ expect(result.data).toEqual({ title: "article1" });
	48	+ done();
	49	+ });
	50	+ $httpBackend.flush();
	51	+ });
	52	+
	53	+ it("deactivate paragraph comments for an article", (done) => {
	54	+ let articleId = 1;
	55	+ $httpBackend.expectPOST(`/api/v1/articles/${articleId}/comment_paragraph_plugin/deactivate`).respond(200, { article: { title: "article1" } });
	56	+ commentParagraphService.deactivateCommentParagraph(<noosfero.Article>{ id: articleId }).then((result: noosfero.RestResult<noosfero.Article>) => {
	57	+ expect(result.data).toEqual({ title: "article1" });
	58	+ done();
	59	+ });
	60	+ $httpBackend.flush();
	61	+ });
	62	+
	63	+ it("return counts for paragraph comments", (done) => {
	64	+ let articleId = 1;
	65	+ $httpBackend.expectGET(`/api/v1/articles/${articleId}/comment_paragraph_plugin/comments/count`).respond(200, { '1': 5, '2': 6 });
	66	+ commentParagraphService.commentParagraphCount(<noosfero.Article>{ id: articleId }, '1').then((count: number) => {
	67	+ expect(count).toEqual(5);
	68	+ done();
	69	+ });
	70	+ $httpBackend.flush();
	71	+ });
	72	+
	73	+ it("reset promise when comment paragraph counts fails", (done) => {
	74	+ let articleId = 1;
	75	+ commentParagraphService['articleService'] = jasmine.createSpyObj("articleService", ["getElement"]);
	76	+ commentParagraphService['articleService'].getElement = jasmine.createSpy("getElement").and.returnValue(
	77	+ {
	78	+ customGET: (path: string) => {
	79	+ return Promise.reject({});
	80	+ }
	81	+ }
	82	+ );
	83	+ commentParagraphService.commentParagraphCount(<noosfero.Article>{ id: articleId }, '1').catch(() => {
	84	+ expect(commentParagraphService['commentParagraphCountsPromise']).toBeNull();
	85	+ done();
	86	+ });
	87	+ });
	88	+ });
	89	+ });
	90	+});
@@ -0,0 +1,50 @@		@@ -0,0 +1,50 @@
	1	+import {SideCommentsComponent} from "./side-comments.component";
	2	+import {ComponentTestHelper, createClass} from '../../../spec/component-test-helper';
	3	+import * as helpers from "../../../spec/helpers";
	4	+import {Provider} from 'ng-forward';
	5	+import {ComponentFixture} from 'ng-forward/cjs/testing/test-component-builder';
	6	+
	7	+let htmlTemplate = '<comment-paragraph-side-comments [article]="ctrl.article" [paragraph-uuid]="ctrl.paragraphUuid"></comment-paragraph-side-comments>';
	8	+
	9	+describe("Components", () => {
	10	+ describe("Side Comments Component", () => {
	11	+
	12	+ let serviceMock = jasmine.createSpyObj("CommentParagraphService", ["getByArticle"]);
	13	+ serviceMock.getByArticle = jasmine.createSpy("getByArticle").and.returnValue(Promise.resolve({ data: {} }));
	14	+
	15	+ let commentServiceMock = {};
	16	+ let postCommentEventService = jasmine.createSpyObj("postCommentEventService", ["emit", "subscribe"]);
	17	+ postCommentEventService.subscribe = jasmine.createSpy("subscribe");
	18	+
	19	+ let providers = [
	20	+ new Provider('CommentParagraphService', { useValue: serviceMock }),
	21	+ new Provider('CommentService', { useValue: commentServiceMock }),
	22	+ new Provider('PostCommentEventService', { useValue: postCommentEventService })
	23	+ ];
	24	+ let helper: ComponentTestHelper;
	25	+
	26	+ beforeEach(angular.mock.module("templates"));
	27	+
	28	+ beforeEach((done) => {
	29	+ let cls = createClass({
	30	+ template: htmlTemplate,
	31	+ directives: [SideCommentsComponent],
	32	+ providers: providers,
	33	+ properties: {
	34	+ paragraphUuid: "uuid",
	35	+ article: {}
	36	+ }
	37	+ });
	38	+ helper = new ComponentTestHelper(cls, done);
	39	+ });
	40	+
	41	+ it('call service to load paragraph comments', () => {
	42	+ helper.component.loadComments();
	43	+ expect(serviceMock.getByArticle).toHaveBeenCalled();
	44	+ });
	45	+
	46	+ it('set paragraph uuid in new comment object', () => {
	47	+ expect(helper.component.newComment['paragraph_uuid']).toEqual('uuid');
	48	+ });
	49	+ });
	50	+});