jira-pat 1.0.0

package/frontend/src/__tests__/utils/issueHelpers.test.jsx

@@ -0,0 +1,336 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getIssueTypeIcon,
+  getStatusClass,
+  getPriorityIcon,
+  getSeverityIcon,
+  formatSeverity,
+  getInitials,
+  SEVERITY_FIELD
+} from '../../utils/issueHelpers';
+
+describe('issueHelpers', () => {
+  describe('SEVERITY_FIELD', () => {
+    it('should export the correct severity field name', () => {
+      expect(SEVERITY_FIELD).toBe('customfield_10260');
+    });
+  });
+
+  describe('getIssueTypeIcon', () => {
+    it('should return a React element for null/undefined input', () => {
+      const resultNull = getIssueTypeIcon(null);
+      const resultUndefined = getIssueTypeIcon(undefined);
+      
+      expect(resultNull).toBeTruthy();
+      expect(resultNull.type).toBeDefined();
+      expect(resultUndefined).toBeTruthy();
+      expect(resultUndefined.type).toBeDefined();
+    });
+
+    it('should return a Bug icon element for types containing "bug"', () => {
+      const result = getIssueTypeIcon('Bug');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return a Layers icon element for story types', () => {
+      const result = getIssueTypeIcon('Story');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return a Layers icon element for epic types', () => {
+      const result = getIssueTypeIcon('Epic');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return a ClipboardList icon element for task types', () => {
+      const result = getIssueTypeIcon('Task');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return a FileText icon element as default for unknown types', () => {
+      const result = getIssueTypeIcon('Improvement');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should handle case-insensitive matching', () => {
+      const bugResult = getIssueTypeIcon('BUG');
+      const storyResult = getIssueTypeIcon('STORY');
+      const taskResult = getIssueTypeIcon('TASK');
+      
+      expect(bugResult).toBeTruthy();
+      expect(storyResult).toBeTruthy();
+      expect(taskResult).toBeTruthy();
+    });
+
+    it('should handle mixed case types', () => {
+      expect(getIssueTypeIcon('Bug Report')).toBeTruthy();
+      expect(getIssueTypeIcon('user story')).toBeTruthy();
+    });
+  });
+
+  describe('getStatusClass', () => {
+    it('should return empty string for null/undefined input', () => {
+      expect(getStatusClass(null)).toBe('');
+      expect(getStatusClass(undefined)).toBe('');
+    });
+
+    it('should return "in-progress" for in-progress status', () => {
+      expect(getStatusClass('in-progress')).toBe('in-progress');
+    });
+
+    it('should return "done" for done status', () => {
+      expect(getStatusClass('done')).toBe('done');
+    });
+
+    it('should return "closed" for closed status', () => {
+      expect(getStatusClass('closed')).toBe('closed');
+    });
+
+    it('should return "todo" as default for unknown statuses', () => {
+      expect(getStatusClass('To Do')).toBe('todo');
+      expect(getStatusClass('Open')).toBe('todo');
+      expect(getStatusClass('Backlog')).toBe('todo');
+    });
+
+    it('should normalize status by replacing spaces with hyphens', () => {
+      expect(getStatusClass('in progress')).toBe('in-progress');
+      expect(getStatusClass('IN PROGRESS')).toBe('in-progress');
+    });
+
+    it('should handle mixed case input', () => {
+      expect(getStatusClass('In-Progress')).toBe('in-progress');
+      expect(getStatusClass('DONE')).toBe('done');
+    });
+  });
+
+  describe('getPriorityIcon', () => {
+    it('should return null for null/undefined input', () => {
+      expect(getPriorityIcon(null)).toBeNull();
+      expect(getPriorityIcon(undefined)).toBeNull();
+    });
+
+    it('should return ChevronUp for highest priority', () => {
+      const result = getPriorityIcon('Highest');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return ChevronUp for high priority', () => {
+      const result = getPriorityIcon('High');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return ChevronDown for lowest priority', () => {
+      const result = getPriorityIcon('Lowest');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return ChevronDown for low priority', () => {
+      const result = getPriorityIcon('Low');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should return Minus for medium priority (default)', () => {
+      const result = getPriorityIcon('Medium');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(16);
+    });
+
+    it('should handle case-insensitive matching', () => {
+      expect(getPriorityIcon('HIGHEST')).toBeTruthy();
+      expect(getPriorityIcon('LOW')).toBeTruthy();
+      expect(getPriorityIcon('MEDIUM')).toBeTruthy();
+    });
+  });
+
+  describe('getSeverityIcon', () => {
+    it('should return null for null/undefined input', () => {
+      expect(getSeverityIcon(null)).toBeNull();
+      expect(getSeverityIcon(undefined)).toBeNull();
+    });
+
+    it('should return AlertCircle for blocker severity', () => {
+      const result = getSeverityIcon('Blocker');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return AlertCircle for critical severity', () => {
+      const result = getSeverityIcon('Critical');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return AlertCircle for sev-1 severity', () => {
+      const result = getSeverityIcon('Sev-1');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return ChevronUp for major severity', () => {
+      const result = getSeverityIcon('Major');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return ChevronUp for sev-2 severity', () => {
+      const result = getSeverityIcon('Sev-2');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return Minus for minor severity', () => {
+      const result = getSeverityIcon('Minor');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return Minus for sev-3 severity', () => {
+      const result = getSeverityIcon('Sev-3');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return ChevronDown for trivial severity', () => {
+      const result = getSeverityIcon('Trivial');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return ChevronDown for sev-4 severity', () => {
+      const result = getSeverityIcon('Sev-4');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return ChevronDown for sev-5 severity', () => {
+      const result = getSeverityIcon('Sev-5');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should return Info for unknown severity (default)', () => {
+      const result = getSeverityIcon('Low');
+      expect(result).toBeTruthy();
+      expect(result.type).toBeDefined();
+      expect(result.props.size).toBe(14);
+    });
+
+    it('should handle case-insensitive matching', () => {
+      expect(getSeverityIcon('BLOCKER')).toBeTruthy();
+      expect(getSeverityIcon('MAJOR')).toBeTruthy();
+      expect(getSeverityIcon('SEV-1')).toBeTruthy();
+    });
+  });
+
+  describe('formatSeverity', () => {
+    it('should return empty string for null/undefined input', () => {
+      expect(formatSeverity(null)).toBe('');
+      expect(formatSeverity(undefined)).toBe('');
+    });
+
+    it('should return the severity string as-is', () => {
+      expect(formatSeverity('Critical')).toBe('Critical');
+      expect(formatSeverity('Minor')).toBe('Minor');
+      expect(formatSeverity('Low')).toBe('Low');
+    });
+
+    it('should handle numeric severity values', () => {
+      expect(formatSeverity(1)).toBe(1);
+      expect(formatSeverity(5)).toBe(5);
+    });
+  });
+
+  describe('getInitials', () => {
+    it('should return "?" for null input', () => {
+      expect(getInitials(null)).toBe('?');
+    });
+
+    it('should return "?" for undefined input', () => {
+      expect(getInitials(undefined)).toBe('?');
+    });
+
+    it('should return "?" for non-string input', () => {
+      expect(getInitials(123)).toBe('?');
+      expect(getInitials({})).toBe('?');
+      expect(getInitials([])).toBe('?');
+    });
+
+    it('should return "?" for empty string', () => {
+      expect(getInitials('')).toBe('?');
+    });
+
+    it('should return "?" for whitespace-only string', () => {
+      expect(getInitials('   ')).toBe('?');
+    });
+
+    it('should return "@" for string that is just @ (atIndex is 0, not > 0)', () => {
+      expect(getInitials('@')).toBe('@');
+    });
+
+    it('should return first two characters for single word name', () => {
+      expect(getInitials('John')).toBe('JO');
+      expect(getInitials('alice')).toBe('AL');
+    });
+
+    it('should return first and last initials for full name', () => {
+      expect(getInitials('John Doe')).toBe('JD');
+      expect(getInitials('Alice Smith')).toBe('AS');
+    });
+
+    it('should handle names with multiple spaces', () => {
+      expect(getInitials('John   Doe')).toBe('JD');
+    });
+
+    it('should handle email addresses by extracting name part before @', () => {
+      expect(getInitials('john.doe@example.com')).toBe('JO');
+      expect(getInitials('user@domain.org')).toBe('US');
+    });
+
+    it('should handle email with single name', () => {
+      expect(getInitials('admin@example.com')).toBe('AD');
+    });
+
+    it('should handle names with special characters', () => {
+      expect(getInitials("John O'Brien")).toBe('JO');
+      expect(getInitials('Mary-Jane Watson')).toBe('MW');
+    });
+
+    it('should return uppercase initials', () => {
+      expect(getInitials('john doe')).toBe('JD');
+      expect(getInitials('ALICE SMITH')).toBe('AS');
+    });
+
+    it('should handle string that splits to only whitespace parts', () => {
+      expect(getInitials(' \t \t ')).toBe('?');
+    });
+  });
+});

package/frontend/src/__tests__/utils/sanitize.test.js

@@ -0,0 +1,238 @@
+import { describe, it, expect } from 'vitest';
+import { sanitizeHtml } from '../../utils/sanitize';
+
+describe('sanitize', () => {
+  describe('sanitizeHtml', () => {
+    it('should return empty string for null input', () => {
+      expect(sanitizeHtml(null)).toBe('');
+    });
+
+    it('should return empty string for undefined input', () => {
+      expect(sanitizeHtml(undefined)).toBe('');
+    });
+
+    it('should return empty string for empty string input', () => {
+      expect(sanitizeHtml('')).toBe('');
+    });
+
+    it('should preserve plain text', () => {
+      expect(sanitizeHtml('Hello World')).toBe('Hello World');
+    });
+
+    it('should preserve allowed tags: p', () => {
+      const result = sanitizeHtml('<p>Paragraph</p>');
+      expect(result).toContain('<p>Paragraph</p>');
+    });
+
+    it('should preserve allowed tags: strong', () => {
+      const result = sanitizeHtml('<strong>Bold text</strong>');
+      expect(result).toContain('<strong>Bold text</strong>');
+    });
+
+    it('should preserve allowed tags: em', () => {
+      const result = sanitizeHtml('<em>Italic text</em>');
+      expect(result).toContain('<em>Italic text</em>');
+    });
+
+    it('should preserve allowed tags: u', () => {
+      const result = sanitizeHtml('<u>Underlined text</u>');
+      expect(result).toContain('<u>Underlined text</u>');
+    });
+
+    it('should preserve allowed tags: s (strikethrough)', () => {
+      const result = sanitizeHtml('<s>Strikethrough</s>');
+      expect(result).toContain('<s>Strikethrough</s>');
+    });
+
+    it('should preserve allowed tags: del', () => {
+      const result = sanitizeHtml('<del>Deleted text</del>');
+      expect(result).toContain('<del>Deleted text</del>');
+    });
+
+    it('should preserve allowed tags: ins', () => {
+      const result = sanitizeHtml('<ins>Inserted text</ins>');
+      expect(result).toContain('<ins>Inserted text</ins>');
+    });
+
+    it('should preserve allowed tags: a with href', () => {
+      const result = sanitizeHtml('<a href="https://example.com">Link</a>');
+      expect(result).toContain('<a href="https://example.com">Link</a>');
+    });
+
+    it('should preserve allowed tags: img with src and alt', () => {
+      const result = sanitizeHtml('<img src="image.png" alt="Description" />');
+      expect(result).toContain('<img src="image.png" alt="Description"');
+    });
+
+    it('should preserve allowed tags: span', () => {
+      const result = sanitizeHtml('<span>Span text</span>');
+      expect(result).toContain('<span>Span text</span>');
+    });
+
+    it('should preserve allowed tags: div', () => {
+      const result = sanitizeHtml('<div>Div content</div>');
+      expect(result).toContain('<div>Div content</div>');
+    });
+
+    it('should preserve allowed tags: ul, ol, li', () => {
+      const result = sanitizeHtml('<ul><li>Item 1</li><li>Item 2</li></ul>');
+      expect(result).toContain('<ul>');
+      expect(result).toContain('<li>Item 1</li>');
+      expect(result).toContain('<li>Item 2</li>');
+    });
+
+    it('should preserve allowed tags: h1-h6', () => {
+      expect(sanitizeHtml('<h1>Heading 1</h1>')).toContain('<h1>Heading 1</h1>');
+      expect(sanitizeHtml('<h2>Heading 2</h2>')).toContain('<h2>Heading 2</h2>');
+      expect(sanitizeHtml('<h3>Heading 3</h3>')).toContain('<h3>Heading 3</h3>');
+      expect(sanitizeHtml('<h4>Heading 4</h4>')).toContain('<h4>Heading 4</h4>');
+      expect(sanitizeHtml('<h5>Heading 5</h5>')).toContain('<h5>Heading 5</h5>');
+      expect(sanitizeHtml('<h6>Heading 6</h6>')).toContain('<h6>Heading 6</h6>');
+    });
+
+    it('should preserve allowed tags: code', () => {
+      const result = sanitizeHtml('<code>inline code</code>');
+      expect(result).toContain('<code>inline code</code>');
+    });
+
+    it('should preserve allowed tags: pre', () => {
+      const result = sanitizeHtml('<pre>Preformatted text</pre>');
+      expect(result).toContain('<pre>Preformatted text</pre>');
+    });
+
+    it('should preserve allowed tags: blockquote', () => {
+      const result = sanitizeHtml('<blockquote>Quote text</blockquote>');
+      expect(result).toContain('<blockquote>Quote text</blockquote>');
+    });
+
+    it('should preserve allowed tags: table elements', () => {
+      const html = '<table><thead><tbody><tr><th>Header</th></tr><tr><td>Data</td></tr></tbody></thead></table>';
+      const result = sanitizeHtml(html);
+      expect(result).toContain('<table>');
+      expect(result).toContain('<thead>');
+      expect(result).toContain('<tbody>');
+      expect(result).toContain('<tr>');
+      expect(result).toContain('<th>Header</th>');
+      expect(result).toContain('<td>Data</td>');
+    });
+
+    it('should preserve allowed tags: br', () => {
+      const result = sanitizeHtml('Line 1<br>Line 2');
+      expect(result).toContain('<br>');
+    });
+
+    it('should preserve allowed tags: hr', () => {
+      const result = sanitizeHtml('Before<hr>After');
+      expect(result).toContain('<hr>');
+    });
+
+    it('should preserve allowed tags: sup and sub', () => {
+      expect(sanitizeHtml('x<sup>2</sup>')).toContain('<sup>2</sup>');
+      expect(sanitizeHtml('H<sub>2</sub>O')).toContain('<sub>2</sub>');
+    });
+
+    it('should preserve allowed attributes: class', () => {
+      const result = sanitizeHtml('<div class="my-class">Content</div>');
+      expect(result).toContain('class="my-class"');
+    });
+
+    it('should preserve allowed attributes: id', () => {
+      const result = sanitizeHtml('<div id="my-id">Content</div>');
+      expect(result).toContain('id="my-id"');
+    });
+
+    it('should preserve allowed attributes: style', () => {
+      const result = sanitizeHtml('<div style="color: red">Content</div>');
+      expect(result).toContain('style="color: red"');
+    });
+
+    it('should preserve allowed attributes: target', () => {
+      const result = sanitizeHtml('<a href="url" target="_blank">Link</a>');
+      expect(result).toContain('target="_blank"');
+    });
+
+    it('should preserve allowed attributes: colspan and rowspan', () => {
+      const result = sanitizeHtml('<td colspan="2" rowspan="3">Cell</td>');
+      expect(result).toContain('Cell');
+    });
+
+    it('should remove script tags', () => {
+      const result = sanitizeHtml('<p>Safe</p><script>alert("xss")</script>');
+      expect(result).not.toContain('<script>');
+      expect(result).toContain('<p>Safe</p>');
+    });
+
+    it('should remove onclick handlers', () => {
+      const result = sanitizeHtml('<div onclick="alert(1)">Click me</div>');
+      expect(result).not.toContain('onclick');
+      expect(result).toContain('<div>Click me</div>');
+    });
+
+    it('should remove onerror handlers', () => {
+      const result = sanitizeHtml('<img src="x" onerror="alert(1)" />');
+      expect(result).not.toContain('onerror');
+    });
+
+    it('should remove javascript: URLs', () => {
+      const result = sanitizeHtml('<a href="javascript:alert(1)">Evil</a>');
+      expect(result).not.toContain('javascript:');
+    });
+
+    it('should remove iframe tags', () => {
+      const result = sanitizeHtml('<p>Text</p><iframe src="evil.com"></iframe>');
+      expect(result).not.toContain('<iframe>');
+      expect(result).toContain('<p>Text</p>');
+    });
+
+    it('should remove object tags', () => {
+      const result = sanitizeHtml('<p>Text</p><object data="evil.swf"></object>');
+      expect(result).not.toContain('<object>');
+      expect(result).toContain('<p>Text</p>');
+    });
+
+    it('should remove embed tags', () => {
+      const result = sanitizeHtml('<p>Text</p><embed src="evil.swf">');
+      expect(result).not.toContain('<embed>');
+      expect(result).toContain('<p>Text</p>');
+    });
+
+    it('should remove form tags', () => {
+      const result = sanitizeHtml('<p>Text</p><form action="evil.com"><input name="q"></form>');
+      expect(result).not.toContain('<form>');
+      expect(result).not.toContain('<input>');
+    });
+
+    it('should handle mixed content with safe and unsafe HTML', () => {
+      const result = sanitizeHtml('<p>Hello <strong>world</strong></p><script>evil()</script>');
+      expect(result).toContain('<p>Hello <strong>world</strong></p>');
+      expect(result).not.toContain('<script>');
+    });
+
+    it('should preserve nested allowed tags', () => {
+      const result = sanitizeHtml('<div><p><strong><em>Nested</em></strong></p></div>');
+      expect(result).toContain('<div>');
+      expect(result).toContain('<p>');
+      expect(result).toContain('<strong>');
+      expect(result).toContain('<em>Nested</em>');
+    });
+
+    it('should handle complex HTML structure', () => {
+      const html = `
+        <h1>Title</h1>
+        <p>Paragraph with <a href="https://example.com">link</a></p>
+        <ul>
+          <li>Item 1</li>
+          <li>Item 2</li>
+        </ul>
+        <pre><code>code block</code></pre>
+      `;
+      const result = sanitizeHtml(html);
+      expect(result).toContain('<h1>Title</h1>');
+      expect(result).toContain('<p>Paragraph with <a href="https://example.com">link</a></p>');
+      expect(result).toContain('<ul>');
+      expect(result).toContain('<li>Item 1</li>');
+      expect(result).toContain('<li>Item 2</li>');
+      expect(result).toContain('<pre><code>code block</code></pre>');
+    });
+  });
+});