| /** | |
| * @license | |
| * Copyright 2020 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import '../test/common-test-setup'; | |
| import { | |
| computeDisplayLine, | |
| createCommentThreads, | |
| createNew, | |
| createNewReply, | |
| createUserFixSuggestion, | |
| getContentInCommentRange, | |
| getMentionedThreads, | |
| getPatchRangeForCommentUrl, | |
| getUserSuggestion, | |
| getUserSuggestionFromString, | |
| hasUserSuggestion, | |
| isNewThread, | |
| isUnresolved, | |
| PROVIDED_FIX_ID, | |
| replacementsToString, | |
| sanitiseRanges, | |
| sortComments, | |
| stringToReplacements, | |
| USER_SUGGESTION_START_PATTERN, | |
| } from './comment-util'; | |
| import { | |
| createAccountWithEmail, | |
| createComment, | |
| createCommentThread, | |
| } from '../test/test-data-generators'; | |
| import {CommentSide, SpecialFilePath} from '../constants/constants'; | |
| import { | |
| Comment, | |
| FixReplacementInfo, | |
| PARENT, | |
| RevisionPatchSetNum, | |
| SavingState, | |
| Timestamp, | |
| UrlEncodedCommentId, | |
| } from '../types/common'; | |
| import {assert} from '@open-wc/testing'; | |
| suite('comment-util', () => { | |
| test('isUnresolved', () => { | |
| const thread = createCommentThread([createComment()]); | |
| assert.isFalse(isUnresolved(thread)); | |
| assert.isTrue( | |
| isUnresolved({ | |
| ...thread, | |
| comments: [{...createComment(), unresolved: true}], | |
| }) | |
| ); | |
| assert.isFalse( | |
| isUnresolved({ | |
| ...thread, | |
| comments: [{...createComment(), unresolved: false}], | |
| }) | |
| ); | |
| assert.isTrue( | |
| isUnresolved({ | |
| ...thread, | |
| comments: [ | |
| {...createComment(), unresolved: false}, | |
| {...createComment(), unresolved: true}, | |
| ], | |
| }) | |
| ); | |
| assert.isFalse( | |
| isUnresolved({ | |
| ...thread, | |
| comments: [ | |
| {...createComment(), unresolved: true}, | |
| {...createComment(), unresolved: false}, | |
| ], | |
| }) | |
| ); | |
| }); | |
| test('isNewThread', () => { | |
| let thread = createCommentThread([createComment()]); | |
| assert.isFalse(isNewThread(thread)); | |
| thread = createCommentThread([createComment(), createNew()]); | |
| assert.isFalse(isNewThread(thread)); | |
| thread = createCommentThread([createNew()]); | |
| assert.isTrue(isNewThread(thread)); | |
| }); | |
| suite('getPatchRangeForCommentUrl', () => { | |
| test('comment created with side=PARENT does not navigate to latest ps', () => { | |
| const comment = { | |
| ...createComment(), | |
| id: 'c4' as UrlEncodedCommentId, | |
| line: 10, | |
| patch_set: 4 as RevisionPatchSetNum, | |
| side: CommentSide.PARENT, | |
| path: '/COMMIT_MSG', | |
| }; | |
| assert.deepEqual( | |
| getPatchRangeForCommentUrl(comment, 11 as RevisionPatchSetNum), | |
| { | |
| basePatchNum: PARENT, | |
| patchNum: 4 as RevisionPatchSetNum, | |
| } | |
| ); | |
| }); | |
| }); | |
| test('getMentionedThreads', () => { | |
| const account = createAccountWithEmail('abcd@def.com'); | |
| const threads = [ | |
| createCommentThread([ | |
| { | |
| ...createComment(), | |
| message: 'random text with no emails', | |
| }, | |
| ]), | |
| createCommentThread([ | |
| { | |
| ...createComment(), | |
| message: '@abcd@def.com please take a look', | |
| }, | |
| { | |
| ...createComment(), | |
| message: '@abcd@def.com please take a look again at this', | |
| }, | |
| ]), | |
| createCommentThread([ | |
| { | |
| ...createComment(), | |
| message: '@abcd@def.com this is important', | |
| }, | |
| ]), | |
| ]; | |
| assert.deepEqual(getMentionedThreads(threads, account), [ | |
| threads[1], | |
| threads[2], | |
| ]); | |
| assert.deepEqual( | |
| getMentionedThreads(threads, createAccountWithEmail('xyz@def.com')), | |
| [] | |
| ); | |
| }); | |
| test('comments sorting', () => { | |
| const updated = '2023-12-24 12:00:00.123000000' as Timestamp; | |
| const comments: Comment[] = [ | |
| { | |
| id: 'pslevel' as UrlEncodedCommentId, | |
| path: SpecialFilePath.PATCHSET_LEVEL_COMMENTS, | |
| updated, | |
| }, | |
| { | |
| id: 'commit-message' as UrlEncodedCommentId, | |
| path: SpecialFilePath.COMMIT_MESSAGE, | |
| updated, | |
| }, | |
| { | |
| id: 'path2-id1-updated-earlier' as UrlEncodedCommentId, | |
| path: 'path2', | |
| updated: '2023-12-23 12:00:00.123000000' as Timestamp, | |
| }, | |
| { | |
| id: 'path2-id1' as UrlEncodedCommentId, | |
| path: 'path2', | |
| updated, | |
| }, | |
| { | |
| id: 'path2-id2' as UrlEncodedCommentId, | |
| path: 'path2', | |
| updated, | |
| }, | |
| { | |
| id: 'path2-id1-updated-later' as UrlEncodedCommentId, | |
| path: 'path2', | |
| updated: '2023-12-24 15:55:00.123000000' as Timestamp, | |
| }, | |
| { | |
| id: 'path2-line1' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 1, | |
| updated, | |
| }, | |
| { | |
| id: 'path2-line2' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| updated, | |
| }, | |
| { | |
| id: 'range-1-0-2-0' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| range: { | |
| start_line: 1, | |
| start_character: 0, | |
| end_line: 2, | |
| end_character: 0, | |
| }, | |
| updated, | |
| }, | |
| { | |
| id: 'range-1-0-3-0' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| range: { | |
| start_line: 1, | |
| start_character: 0, | |
| end_line: 3, | |
| end_character: 0, | |
| }, | |
| updated, | |
| }, | |
| { | |
| id: 'range-2-0-3-0' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| range: { | |
| start_line: 2, | |
| start_character: 0, | |
| end_line: 3, | |
| end_character: 0, | |
| }, | |
| updated, | |
| }, | |
| { | |
| id: 'range-2-0-3-5' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| range: { | |
| start_line: 2, | |
| start_character: 0, | |
| end_line: 3, | |
| end_character: 5, | |
| }, | |
| updated, | |
| }, | |
| { | |
| id: 'range-2-5-3-5' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| range: { | |
| start_line: 2, | |
| start_character: 5, | |
| end_line: 3, | |
| end_character: 5, | |
| }, | |
| updated, | |
| }, | |
| { | |
| id: 'path2-line2-ps1' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| patch_set: 1 as RevisionPatchSetNum, | |
| updated, | |
| }, | |
| { | |
| id: 'path2-line2-ps2' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| patch_set: 2 as RevisionPatchSetNum, | |
| updated, | |
| }, | |
| { | |
| id: 'path2-line2-ps2-updated-later' as UrlEncodedCommentId, | |
| path: 'path2', | |
| line: 2, | |
| patch_set: 2 as RevisionPatchSetNum, | |
| updated, | |
| }, | |
| { | |
| client_id: 'new1' as UrlEncodedCommentId, | |
| client_created_ms: 1, | |
| savingState: SavingState.OK, | |
| path: 'path2', | |
| line: 2, | |
| patch_set: 2 as RevisionPatchSetNum, | |
| }, | |
| { | |
| client_id: 'new2' as UrlEncodedCommentId, | |
| client_created_ms: 2, | |
| savingState: SavingState.OK, | |
| path: 'path2', | |
| line: 2, | |
| patch_set: 2 as RevisionPatchSetNum, | |
| }, | |
| { | |
| client_id: 'new2-sort-by-id' as UrlEncodedCommentId, | |
| client_created_ms: 2, | |
| savingState: SavingState.OK, | |
| path: 'path2', | |
| line: 2, | |
| patch_set: 2 as RevisionPatchSetNum, | |
| }, | |
| ]; | |
| const shuffled = [...comments].sort(() => Math.random() - 0.5); | |
| const sorted = sortComments(shuffled); | |
| assert.sameOrderedMembers(comments, sorted); | |
| }); | |
| suite('createCommentThreads', () => { | |
| test('creates threads from individual comments', () => { | |
| const comments: Comment[] = [ | |
| { | |
| id: 'sallys_confession' as UrlEncodedCommentId, | |
| message: 'i like you, jack', | |
| updated: '2015-12-23 15:00:20.396000000' as Timestamp, | |
| line: 1, | |
| patch_set: 1 as RevisionPatchSetNum, | |
| path: 'some/path', | |
| }, | |
| { | |
| id: 'jacks_reply' as UrlEncodedCommentId, | |
| message: 'i like you, too', | |
| updated: '2015-12-24 15:01:20.396000000' as Timestamp, | |
| line: 1, | |
| in_reply_to: 'sallys_confession' as UrlEncodedCommentId, | |
| patch_set: 1 as RevisionPatchSetNum, | |
| path: 'some/path', | |
| }, | |
| { | |
| id: 'new_draft' as UrlEncodedCommentId, | |
| message: 'i do not like either of you' as UrlEncodedCommentId, | |
| savingState: SavingState.OK, | |
| updated: '2015-12-20 15:01:20.396000000' as Timestamp, | |
| line: 1, | |
| patch_set: 1 as RevisionPatchSetNum, | |
| path: 'some/path', | |
| }, | |
| ]; | |
| const actualThreads = createCommentThreads(comments); | |
| assert.equal(actualThreads.length, 2); | |
| assert.equal(actualThreads[0].comments.length, 2); | |
| assert.deepEqual(actualThreads[0].comments[0], comments[0]); | |
| assert.deepEqual(actualThreads[0].comments[1], comments[1]); | |
| assert.equal(actualThreads[0].patchNum, 1 as RevisionPatchSetNum); | |
| assert.equal(actualThreads[0].line, 1); | |
| assert.equal(actualThreads[1].comments.length, 1); | |
| assert.deepEqual(actualThreads[1].comments[0], comments[2]); | |
| assert.equal(actualThreads[1].patchNum, 1 as RevisionPatchSetNum); | |
| assert.equal(actualThreads[1].line, 1); | |
| }); | |
| test('derives patchNum and range', () => { | |
| const comments = [ | |
| { | |
| id: 'betsys_confession' as UrlEncodedCommentId, | |
| message: 'i like you, jack', | |
| updated: '2015-12-24 15:00:10.396000000' as Timestamp, | |
| range: { | |
| start_line: 1, | |
| start_character: 1, | |
| end_line: 1, | |
| end_character: 2, | |
| }, | |
| patch_set: 5 as RevisionPatchSetNum, | |
| path: '/p', | |
| line: 1, | |
| }, | |
| ]; | |
| const expectedThreads = [ | |
| { | |
| commentSide: CommentSide.REVISION, | |
| path: '/p', | |
| rootId: 'betsys_confession' as UrlEncodedCommentId, | |
| mergeParentNum: undefined, | |
| comments: [ | |
| { | |
| id: 'betsys_confession' as UrlEncodedCommentId, | |
| path: '/p', | |
| message: 'i like you, jack', | |
| updated: '2015-12-24 15:00:10.396000000' as Timestamp, | |
| range: { | |
| start_line: 1, | |
| start_character: 1, | |
| end_line: 1, | |
| end_character: 2, | |
| }, | |
| patch_set: 5 as RevisionPatchSetNum, | |
| line: 1, | |
| }, | |
| ], | |
| patchNum: 5 as RevisionPatchSetNum, | |
| range: { | |
| start_line: 1, | |
| start_character: 1, | |
| end_line: 1, | |
| end_character: 2, | |
| }, | |
| line: 1, | |
| }, | |
| ]; | |
| assert.deepEqual(createCommentThreads(comments), expectedThreads); | |
| }); | |
| test('does not thread unrelated comments at same location', () => { | |
| const comments = [ | |
| { | |
| id: 'sallys_confession' as UrlEncodedCommentId, | |
| message: 'i like you, jack', | |
| updated: '2015-12-23 15:00:20.396000000' as Timestamp, | |
| path: '/p', | |
| }, | |
| { | |
| id: 'jacks_reply' as UrlEncodedCommentId, | |
| message: 'i like you, too', | |
| updated: '2015-12-24 15:01:20.396000000' as Timestamp, | |
| path: '/p', | |
| }, | |
| ]; | |
| assert.equal(createCommentThreads(comments).length, 2); | |
| }); | |
| }); | |
| test('hasUserSuggestion', () => { | |
| const comment = { | |
| ...createComment(), | |
| message: `${USER_SUGGESTION_START_PATTERN}${'test'}${'\n```'}`, | |
| }; | |
| assert.isTrue(hasUserSuggestion(comment)); | |
| }); | |
| test('getUserSuggestion', () => { | |
| const suggestion = 'test'; | |
| const comment = { | |
| ...createComment(), | |
| message: `${USER_SUGGESTION_START_PATTERN}${suggestion}${'\n```'}`, | |
| }; | |
| assert.equal(getUserSuggestion(comment), suggestion); | |
| }); | |
| suite('getContentInCommentRange', () => { | |
| test('one line', () => { | |
| const comment = { | |
| ...createComment(), | |
| line: 1, | |
| }; | |
| const content = 'line1\nline2\nline3'; | |
| assert.equal(getContentInCommentRange(content, comment), 'line1'); | |
| }); | |
| test('multi line', () => { | |
| const comment = { | |
| ...createComment(), | |
| line: 3, | |
| range: { | |
| start_line: 1, | |
| start_character: 5, | |
| end_line: 3, | |
| end_character: 39, | |
| }, | |
| }; | |
| const selectedText = | |
| ' * Examples:\n' + | |
| ' * Acknowledge/Dismiss, Delete, Report a bug, Report as not useful,\n' + | |
| ' * Make blocking, Downgrade severity.'; | |
| const content = `${selectedText}\n`; | |
| assert.equal(getContentInCommentRange(content, comment), selectedText); | |
| }); | |
| }); | |
| suite('createUserFixSuggestion', () => { | |
| test('one line', () => { | |
| const comment = { | |
| ...createComment(), | |
| line: 1, | |
| path: 'abc.txt', | |
| }; | |
| const line = 'lane1'; | |
| const replacement = 'line1'; | |
| assert.deepEqual(createUserFixSuggestion(comment, line, replacement), [ | |
| { | |
| fix_id: PROVIDED_FIX_ID, | |
| description: 'User suggestion', | |
| replacements: [ | |
| { | |
| path: 'abc.txt', | |
| range: { | |
| start_line: 1, | |
| start_character: 0, | |
| end_line: 1, | |
| end_character: line.length, | |
| }, | |
| replacement, | |
| }, | |
| ], | |
| }, | |
| ]); | |
| }); | |
| test('multiline', () => { | |
| const comment = { | |
| ...createComment(), | |
| line: 3, | |
| range: { | |
| start_line: 1, | |
| start_character: 5, | |
| end_line: 3, | |
| end_character: 39, | |
| }, | |
| path: 'abc.txt', | |
| }; | |
| const line = | |
| ' * Examples:\n' + | |
| ' * Acknowledge/Dismiss, Delete, Report a bug, Report as not useful,\n' + | |
| ' * Make blocking, Downgrade severity.'; | |
| const replacement = | |
| ' - Examples:\n' + | |
| ' - Acknowledge/Dismiss, Delete, Report a bug, Report as not useful,\n' + | |
| ' - Make blocking, Downgrade severity.'; | |
| assert.deepEqual(createUserFixSuggestion(comment, line, replacement), [ | |
| { | |
| fix_id: PROVIDED_FIX_ID, | |
| description: 'User suggestion', | |
| replacements: [ | |
| { | |
| path: 'abc.txt', | |
| range: { | |
| start_line: 1, | |
| start_character: 0, | |
| end_line: 3, | |
| end_character: 42, | |
| }, | |
| replacement, | |
| }, | |
| ], | |
| }, | |
| ]); | |
| }); | |
| }); | |
| suite('getUserSuggestionFromString', () => { | |
| const createSuggestionContent = (suggestions: string[]) => | |
| suggestions | |
| .map(s => `${USER_SUGGESTION_START_PATTERN}${s}\n\`\`\``) | |
| .join('\n'); | |
| test('returns empty string for content without suggestions', () => { | |
| const content = 'This is a comment without any suggestions.'; | |
| assert.equal(getUserSuggestionFromString(content), ''); | |
| }); | |
| test('returns first suggestion when no index is provided', () => { | |
| const content = createSuggestionContent(['First suggestion']); | |
| assert.equal(getUserSuggestionFromString(content), 'First suggestion'); | |
| }); | |
| test('returns correct suggestion for given index', () => { | |
| const content = createSuggestionContent([ | |
| 'First suggestion', | |
| 'Second suggestion', | |
| 'Third suggestion', | |
| ]); | |
| assert.equal( | |
| getUserSuggestionFromString(content, 1), | |
| 'Second suggestion' | |
| ); | |
| }); | |
| test('returns last suggestion when index is out of bounds', () => { | |
| const content = createSuggestionContent([ | |
| 'First suggestion', | |
| 'Second suggestion', | |
| ]); | |
| assert.equal( | |
| getUserSuggestionFromString(content, 5), | |
| 'Second suggestion' | |
| ); | |
| }); | |
| test('handles suggestion without closing backticks', () => { | |
| const content = `${USER_SUGGESTION_START_PATTERN}Unclosed suggestion`; | |
| assert.equal(getUserSuggestionFromString(content), 'Unclosed suggestion'); | |
| }); | |
| test('handles multiple suggestions with varying content', () => { | |
| const content = createSuggestionContent([ | |
| 'First\nMultiline\nSuggestion', | |
| 'Second suggestion', | |
| 'Third suggestion with `backticks`', | |
| ]); | |
| assert.equal( | |
| getUserSuggestionFromString(content, 0), | |
| 'First\nMultiline\nSuggestion' | |
| ); | |
| assert.equal( | |
| getUserSuggestionFromString(content, 1), | |
| 'Second suggestion' | |
| ); | |
| assert.equal( | |
| getUserSuggestionFromString(content, 2), | |
| 'Third suggestion with `backticks`' | |
| ); | |
| }); | |
| }); | |
| suite('stringToReplacements and replacementsToString', () => { | |
| const REPLACEMENT_1: FixReplacementInfo = { | |
| path: 'a/b/c.js', | |
| range: {start_line: 1, end_line: 2, start_character: 0, end_character: 0}, | |
| replacement: 'line 1\nline 2', | |
| }; | |
| const REPLACEMENT_2: FixReplacementInfo = { | |
| path: 'd/e/f.js', | |
| range: {start_line: 3, end_line: 4, start_character: 0, end_character: 0}, | |
| replacement: 'line 3', | |
| }; | |
| const TEXT_1 = | |
| '--- START REPLACEMENT path=a/b/c.js range=1-2\nline 1\nline 2\n--- END REPLACEMENT ---'; | |
| const TEXT_2 = | |
| '--- START REPLACEMENT path=d/e/f.js range=3-4\nline 3\n--- END REPLACEMENT ---'; | |
| suite('stringToReplacements', () => { | |
| test('single replacement', () => { | |
| assert.deepEqual(stringToReplacements(TEXT_1), [REPLACEMENT_1]); | |
| }); | |
| test('multiple replacements', () => { | |
| const text = `${TEXT_1}\n\n${TEXT_2}`; | |
| assert.deepEqual(stringToReplacements(text), [ | |
| REPLACEMENT_1, | |
| REPLACEMENT_2, | |
| ]); | |
| }); | |
| test('throws error for no replacements', () => { | |
| assert.throws(() => stringToReplacements('no replacements here')); | |
| }); | |
| }); | |
| suite('replacementsToString', () => { | |
| test('single replacement', () => { | |
| assert.equal(replacementsToString([REPLACEMENT_1]), TEXT_1); | |
| }); | |
| test('multiple replacements', () => { | |
| const expectedText = `${TEXT_1}\n\n${TEXT_2}`; | |
| assert.equal( | |
| replacementsToString([REPLACEMENT_1, REPLACEMENT_2]), | |
| expectedText | |
| ); | |
| }); | |
| test('empty array', () => { | |
| assert.equal(replacementsToString([]), ''); | |
| }); | |
| }); | |
| }); | |
| suite('sanitiseRanges', () => { | |
| test('copies range from parent to child', () => { | |
| const comments: Comment[] = [ | |
| { | |
| id: 'parent_comment' as UrlEncodedCommentId, | |
| message: 'i am a parent', | |
| updated: '2015-12-23 15:00:20.396000000' as Timestamp, | |
| line: 1, | |
| patch_set: 1 as RevisionPatchSetNum, | |
| path: 'some/path', | |
| range: { | |
| start_line: 1, | |
| start_character: 0, | |
| end_line: 2, | |
| end_character: 0, | |
| }, | |
| }, | |
| { | |
| id: 'child_comment' as UrlEncodedCommentId, | |
| message: 'i am a child', | |
| updated: '2015-12-24 15:01:20.396000000' as Timestamp, | |
| line: 1, | |
| in_reply_to: 'parent_comment' as UrlEncodedCommentId, | |
| patch_set: 1 as RevisionPatchSetNum, | |
| path: 'some/path', | |
| }, | |
| ]; | |
| sanitiseRanges(comments); | |
| assert.deepEqual(comments[1].range, comments[0].range); | |
| }); | |
| }); | |
| suite('computeDisplayLine', () => { | |
| test('PatchSetLevel', () => { | |
| assert.equal( | |
| computeDisplayLine({ | |
| path: SpecialFilePath.PATCHSET_LEVEL_COMMENTS, | |
| }), | |
| '' | |
| ); | |
| }); | |
| test('FILE', () => { | |
| assert.equal( | |
| computeDisplayLine({ | |
| line: 'FILE', | |
| }), | |
| 'FILE' | |
| ); | |
| }); | |
| test('line number', () => { | |
| assert.equal( | |
| computeDisplayLine({ | |
| line: 123, | |
| }), | |
| '#123' | |
| ); | |
| }); | |
| test('range', () => { | |
| assert.equal( | |
| computeDisplayLine({ | |
| range: { | |
| start_line: 1, | |
| start_character: 1, | |
| end_line: 10, | |
| end_character: 10, | |
| }, | |
| }), | |
| '#10' | |
| ); | |
| }); | |
| test('invalid range', () => { | |
| assert.equal( | |
| computeDisplayLine({ | |
| range: { | |
| start_line: 12, | |
| start_character: 1, | |
| end_line: 1, | |
| end_character: 10, | |
| }, | |
| }), | |
| '#12' | |
| ); | |
| }); | |
| test('empty', () => { | |
| assert.equal(computeDisplayLine({}), ''); | |
| }); | |
| }); | |
| suite('createNewReply', () => { | |
| test('standard comment reply (no range)', () => { | |
| const replyingTo = { | |
| ...createComment(), | |
| id: 'parent_id' as UrlEncodedCommentId, | |
| line: 5, | |
| }; | |
| const reply = createNewReply(replyingTo, 'reply message', false); | |
| assert.equal(reply.line, 5); | |
| assert.isUndefined(reply.range); | |
| assert.equal(reply.in_reply_to, 'parent_id'); | |
| }); | |
| test('reply to comment with range (mismatched line)', () => { | |
| const replyingTo = { | |
| ...createComment(), | |
| id: 'parent_id' as UrlEncodedCommentId, | |
| line: 1, | |
| range: { | |
| start_line: 1, | |
| start_character: 0, | |
| end_line: 2, | |
| end_character: 5, | |
| }, | |
| }; | |
| const reply = createNewReply(replyingTo, 'reply message', false); | |
| assert.equal(reply.line, 2); // Should match range.end_line, not replyingTo.line | |
| assert.deepEqual(reply.range, replyingTo.range); | |
| assert.equal(reply.in_reply_to, 'parent_id'); | |
| }); | |
| }); | |
| }); |