@theihtisham/devtools-with-cloud 1.0.0

package/tests/lib/test-runner/assertions.test.ts

@@ -0,0 +1,342 @@
+// @ts-nocheck
+import { describe, it, expect } from 'vitest';
+import {
+  assertions,
+  runAssertions,
+} from '@/lib/test-runner/assertions';
+
+describe('assertions', () => {
+  describe('equals', () => {
+    it('should return true for equal values', () => {
+      expect(assertions.equals(1, 1)).toBe(true);
+      expect(assertions.equals('hello', 'hello')).toBe(true);
+      expect(assertions.equals(null, null)).toBe(true);
+    });
+
+    it('should return false for unequal values', () => {
+      expect(assertions.equals(1, 2)).toBe(false);
+      expect(assertions.equals('a', 'b')).toBe(false);
+    });
+  });
+
+  describe('notEquals', () => {
+    it('should return true for unequal values', () => {
+      expect(assertions.notEquals(1, 2)).toBe(true);
+    });
+
+    it('should return false for equal values', () => {
+      expect(assertions.notEquals(1, 1)).toBe(false);
+    });
+  });
+
+  describe('greaterThan', () => {
+    it('should return true when actual > expected', () => {
+      expect(assertions.greaterThan(10, 5)).toBe(true);
+    });
+
+    it('should return false when actual <= expected', () => {
+      expect(assertions.greaterThan(5, 5)).toBe(false);
+      expect(assertions.greaterThan(3, 5)).toBe(false);
+    });
+  });
+
+  describe('lessThan', () => {
+    it('should return true when actual < expected', () => {
+      expect(assertions.lessThan(5, 10)).toBe(true);
+    });
+
+    it('should return false when actual >= expected', () => {
+      expect(assertions.lessThan(5, 5)).toBe(false);
+      expect(assertions.lessThan(10, 5)).toBe(false);
+    });
+  });
+
+  describe('contains', () => {
+    it('should return true when substring is found', () => {
+      expect(assertions.contains('hello world', 'world')).toBe(true);
+    });
+
+    it('should return false when substring is not found', () => {
+      expect(assertions.contains('hello world', 'foo')).toBe(false);
+    });
+  });
+
+  describe('matches', () => {
+    it('should return true when pattern matches', () => {
+      expect(assertions.matches('hello123', /\d+/)).toBe(true);
+    });
+
+    it('should return false when pattern does not match', () => {
+      expect(assertions.matches('hello', /^\d+$/)).toBe(false);
+    });
+  });
+
+  describe('hasProperty', () => {
+    it('should return true for existing property', () => {
+      expect(assertions.hasProperty({ name: 'test' }, 'name')).toBe(true);
+    });
+
+    it('should return false for missing property', () => {
+      expect(assertions.hasProperty({ name: 'test' }, 'age')).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(assertions.hasProperty(null, 'anything')).toBe(false);
+    });
+
+    it('should return false for undefined', () => {
+      expect(assertions.hasProperty(undefined, 'anything')).toBe(false);
+    });
+  });
+
+  describe('isArray', () => {
+    it('should return true for arrays', () => {
+      expect(assertions.isArray([1, 2, 3])).toBe(true);
+      expect(assertions.isArray([])).toBe(true);
+    });
+
+    it('should return false for non-arrays', () => {
+      expect(assertions.isArray({})).toBe(false);
+      expect(assertions.isArray('string')).toBe(false);
+      expect(assertions.isArray(42)).toBe(false);
+    });
+  });
+
+  describe('isObject', () => {
+    it('should return true for plain objects', () => {
+      expect(assertions.isObject({})).toBe(true);
+      expect(assertions.isObject({ key: 'value' })).toBe(true);
+    });
+
+    it('should return false for arrays', () => {
+      expect(assertions.isObject([1, 2])).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(assertions.isObject(null)).toBe(false);
+    });
+
+    it('should return false for primitives', () => {
+      expect(assertions.isObject('string')).toBe(false);
+      expect(assertions.isObject(42)).toBe(false);
+    });
+  });
+
+  describe('isString', () => {
+    it('should return true for strings', () => {
+      expect(assertions.isString('hello')).toBe(true);
+    });
+
+    it('should return false for non-strings', () => {
+      expect(assertions.isString(42)).toBe(false);
+    });
+  });
+
+  describe('isNumber', () => {
+    it('should return true for numbers', () => {
+      expect(assertions.isNumber(42)).toBe(true);
+    });
+
+    it('should return false for non-numbers', () => {
+      expect(assertions.isNumber('42')).toBe(false);
+    });
+  });
+
+  describe('isBoolean', () => {
+    it('should return true for booleans', () => {
+      expect(assertions.isBoolean(true)).toBe(true);
+      expect(assertions.isBoolean(false)).toBe(true);
+    });
+
+    it('should return false for non-booleans', () => {
+      expect(assertions.isBoolean('true')).toBe(false);
+    });
+  });
+
+  describe('hasStatus', () => {
+    it('should return true for matching status', () => {
+      expect(assertions.hasStatus(200, 200)).toBe(true);
+    });
+
+    it('should return false for non-matching status', () => {
+      expect(assertions.hasStatus(200, 404)).toBe(false);
+    });
+  });
+
+  describe('hasHeader', () => {
+    it('should return true for existing header (case-insensitive)', () => {
+      expect(assertions.hasHeader({ 'content-type': 'application/json' }, 'Content-Type')).toBe(true);
+    });
+
+    it('should return false for missing header', () => {
+      expect(assertions.hasHeader({ 'content-type': 'application/json' }, 'Authorization')).toBe(false);
+    });
+  });
+
+  describe('hasHeaderWithValue', () => {
+    it('should return true for matching header value', () => {
+      expect(
+        assertions.hasHeaderWithValue({ 'content-type': 'application/json' }, 'Content-Type', 'application/json'),
+      ).toBe(true);
+    });
+
+    it('should return false for non-matching value', () => {
+      expect(
+        assertions.hasHeaderWithValue({ 'content-type': 'text/html' }, 'Content-Type', 'application/json'),
+      ).toBe(false);
+    });
+  });
+
+  describe('jsonPathEquals', () => {
+    const data = { user: { name: 'John', scores: [10, 20, 30] } };
+
+    it('should find nested value', () => {
+      expect(assertions.jsonPathEquals(data, 'user.name', 'John')).toBe(true);
+    });
+
+    it('should return false for wrong value', () => {
+      expect(assertions.jsonPathEquals(data, 'user.name', 'Jane')).toBe(false);
+    });
+
+    it('should find array element', () => {
+      expect(assertions.jsonPathEquals(data, 'user.scores[0]', 10)).toBe(true);
+    });
+
+    it('should return false for missing path', () => {
+      expect(assertions.jsonPathEquals(data, 'user.missing', 'anything')).toBe(false);
+    });
+  });
+
+  describe('jsonPathExists', () => {
+    const data = { a: { b: 1 } };
+
+    it('should return true for existing path', () => {
+      expect(assertions.jsonPathExists(data, 'a.b')).toBe(true);
+    });
+
+    it('should return true for existing path with undefined value', () => {
+      expect(assertions.jsonPathExists(data, 'a')).toBe(true);
+    });
+
+    it('should return false for missing path', () => {
+      expect(assertions.jsonPathExists(data, 'a.b.c')).toBe(false);
+    });
+  });
+});
+
+describe('runAssertions', () => {
+  const mockResponse = {
+    status: 200,
+    statusText: 'OK',
+    headers: { 'content-type': 'application/json' },
+    body: '{"message":"hello","count":5}',
+    duration: 150,
+  };
+
+  it('should run pm.test assertions', () => {
+    const code = `
+      pm.test("Status is 200", function() {
+        if (pm.response.status !== 200) throw new Error("Wrong status");
+      });
+      pm.test("Has correct content type", function() {
+        if (pm.response.headers["content-type"] !== "application/json") throw new Error("Wrong type");
+      });
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results).toHaveLength(2);
+    expect(results.every((r) => r.passed)).toBe(true);
+  });
+
+  it('should capture failed assertions', () => {
+    const code = `
+      pm.test("Status check", function() {
+        if (pm.response.status !== 404) throw new Error("Expected 404");
+      });
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results).toHaveLength(1);
+    expect(results[0].passed).toBe(false);
+    expect(results[0].error).toContain('Expected 404');
+  });
+
+  it('should provide response.json() accessor', () => {
+    const code = `
+      pm.test("JSON body check", function() {
+        var data = pm.response.json();
+        if (data.message !== "hello") throw new Error("Wrong message");
+      });
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results[0].passed).toBe(true);
+  });
+
+  it('should handle pm.expect.to.equal', () => {
+    const code = `
+      pm.expect(200).to.equal(200);
+      pm.expect("hello").to.equal("hello");
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results.length).toBeGreaterThanOrEqual(2);
+    expect(results.every((r) => r.passed)).toBe(true);
+  });
+
+  it('should handle pm.expect.to.have.status', () => {
+    const code = `
+      pm.expect(pm.response).to.have.status(200);
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    const statusResult = results.find((r) => r.name.includes('Status'));
+    expect(statusResult?.passed).toBe(true);
+  });
+
+  it('should handle pm.expect.to.exist', () => {
+    const code = `
+      pm.expect("something").to.exist();
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results.some((r) => r.name.includes('exist') && r.passed)).toBe(true);
+  });
+
+  it('should handle pm.expect.to.be.an', () => {
+    const code = `
+      pm.expect([1,2,3]).to.be.an("array");
+      pm.expect({key:"val"}).to.be.an("object");
+      pm.expect("hello").to.be.an("string");
+      pm.expect(42).to.be.an("number");
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results.length).toBe(4);
+    expect(results.every((r) => r.passed)).toBe(true);
+  });
+
+  it('should handle pm.expect.to.be.below', () => {
+    const code = `
+      pm.expect(5).to.be.below(10);
+    `;
+    const results = runAssertions(code, mockResponse);
+    const belowResult = results.find((r) => r.name.includes('below'));
+    expect(belowResult?.passed).toBe(true);
+  });
+
+  it('should return execution error for invalid code', () => {
+    const code = 'throw new Error("syntax error {{{");';
+    const results = runAssertions(code, mockResponse);
+    expect(results).toHaveLength(1);
+    expect(results[0].passed).toBe(false);
+    expect(results[0].name).toBe('Test execution');
+  });
+
+  it('should handle empty test code', () => {
+    const results = runAssertions('', mockResponse);
+    expect(results).toHaveLength(0);
+  });
+
+  it('should include duration for each test', () => {
+    const code = `
+      pm.test("quick test", function() {});
+    `;
+    const results = runAssertions(code, mockResponse);
+    expect(results[0].duration).toBeTypeOf('number');
+  });
+});

package/tests/lib/utils/cn.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { cn } from '@/lib/utils/cn';
+
+describe('cn', () => {
+  it('should combine multiple class names', () => {
+    expect(cn('foo', 'bar')).toBe('foo bar');
+  });
+
+  it('should handle conditional classes with object syntax', () => {
+    expect(cn('foo', { bar: true, baz: false })).toBe('foo bar');
+  });
+
+  it('should handle arrays of classes', () => {
+    expect(cn(['foo', 'bar'], 'baz')).toBe('foo bar baz');
+  });
+
+  it('should filter out falsy values', () => {
+    expect(cn('foo', false, null, undefined, '', 'bar')).toBe('foo bar');
+  });
+
+  it('should merge conflicting Tailwind classes using twMerge', () => {
+    expect(cn('px-2 py-1', 'px-4')).toBe('py-1 px-4');
+  });
+
+  it('should merge responsive Tailwind classes', () => {
+    expect(cn('text-sm md:text-base', 'md:text-lg')).toBe('text-sm md:text-lg');
+  });
+
+  it('should handle empty input', () => {
+    expect(cn()).toBe('');
+  });
+
+  it('should handle single class', () => {
+    expect(cn('foo')).toBe('foo');
+  });
+
+  it('should handle nested arrays and objects', () => {
+    expect(cn(['foo', { bar: true }], { baz: true })).toBe('foo bar baz');
+  });
+
+  it('should deduplicate identical classes', () => {
+    // clsx does not deduplicate, but twMerge resolves conflicts
+    const result = cn('px-2', 'px-2');
+    expect(result).toBe('px-2');
+  });
+});

package/tests/lib/utils/content-type.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseContentType,
+  detectContentFromBody,
+  getExtensionForMimeType,
+  type ContentTypeCategory,
+} from '@/lib/utils/content-type';
+
+describe('parseContentType', () => {
+  it('should return unknown for null header', () => {
+    const result = parseContentType(null);
+    expect(result).toEqual({
+      category: 'unknown',
+      mimeType: 'application/octet-stream',
+      charset: null,
+      isText: false,
+    });
+  });
+
+  it('should parse application/json', () => {
+    const result = parseContentType('application/json');
+    expect(result.category).toBe('json');
+    expect(result.mimeType).toBe('application/json');
+    expect(result.isText).toBe(true);
+  });
+
+  it('should parse content type with charset', () => {
+    const result = parseContentType('application/json; charset=utf-8');
+    expect(result.category).toBe('json');
+    expect(result.charset).toBe('utf-8');
+  });
+
+  it('should parse content type with quoted charset', () => {
+    const result = parseContentType('text/html; charset="utf-8"');
+    expect(result.charset).toBe('utf-8');
+  });
+
+  it('should detect JSON variants', () => {
+    expect(parseContentType('application/ld+json').category).toBe('json');
+    expect(parseContentType('application/vnd.api+json').category).toBe('json');
+    expect(parseContentType('application/hal+json').category).toBe('json');
+    expect(parseContentType('application/problem+json').category).toBe('json');
+  });
+
+  it('should detect XML types', () => {
+    expect(parseContentType('application/xml').category).toBe('xml');
+    expect(parseContentType('text/xml').category).toBe('xml');
+    expect(parseContentType('application/soap+xml').category).toBe('xml');
+  });
+
+  it('should detect HTML', () => {
+    expect(parseContentType('text/html').category).toBe('html');
+  });
+
+  it('should detect text types', () => {
+    expect(parseContentType('text/plain').category).toBe('text');
+    expect(parseContentType('text/csv').category).toBe('text');
+    expect(parseContentType('text/markdown').category).toBe('text');
+  });
+
+  it('should detect form types', () => {
+    expect(parseContentType('application/x-www-form-urlencoded').category).toBe('form');
+    expect(parseContentType('multipart/form-data').category).toBe('form');
+  });
+
+  it('should detect image types', () => {
+    expect(parseContentType('image/png').category).toBe('image');
+    expect(parseContentType('image/jpeg').category).toBe('image');
+    expect(parseContentType('image/svg+xml').category).toBe('image');
+  });
+
+  it('should detect binary types', () => {
+    expect(parseContentType('application/pdf').category).toBe('binary');
+    expect(parseContentType('application/zip').category).toBe('binary');
+    expect(parseContentType('application/octet-stream').category).toBe('binary');
+  });
+
+  it('should mark unknown MIME types as binary', () => {
+    const result = parseContentType('application/some-unknown-type');
+    expect(result.category).toBe('binary');
+  });
+
+  it('should treat unknown text/ subtypes as text', () => {
+    const result = parseContentType('text/custom');
+    expect(result.isText).toBe(true);
+  });
+
+  it('should be case-insensitive for MIME type', () => {
+    const result = parseContentType('Application/JSON');
+    expect(result.category).toBe('json');
+    expect(result.mimeType).toBe('application/json');
+  });
+});
+
+describe('detectContentFromBody', () => {
+  it('should detect JSON object', () => {
+    expect(detectContentFromBody('{"key":"value"}')).toBe('json');
+  });
+
+  it('should detect JSON array', () => {
+    expect(detectContentFromBody('[1,2,3]')).toBe('json');
+  });
+
+  it('should not detect invalid JSON starting with { as json', () => {
+    expect(detectContentFromBody('{invalid json}')).toBe('text');
+  });
+
+  it('should detect XML with xml declaration', () => {
+    expect(detectContentFromBody('<?xml version="1.0"?><root/>')).toBe('xml');
+  });
+
+  it('should detect XML with <xml tag', () => {
+    expect(detectContentFromBody('<xml>content</xml>')).toBe('xml');
+  });
+
+  it('should detect RSS feed', () => {
+    expect(detectContentFromBody('<rss version="2.0"><channel></channel></rss>')).toBe('xml');
+  });
+
+  it('should detect HTML with DOCTYPE', () => {
+    expect(detectContentFromBody('<!DOCTYPE html><html></html>')).toBe('html');
+  });
+
+  it('should detect HTML with <html tag', () => {
+    expect(detectContentFromBody('<html><body></body></html>')).toBe('html');
+  });
+
+  it('should detect HTML case-insensitively', () => {
+    expect(detectContentFromBody('<HTML><body></body></HTML>')).toBe('html');
+  });
+
+  it('should default to text for unknown content', () => {
+    expect(detectContentFromBody('just some plain text')).toBe('text');
+  });
+
+  it('should handle whitespace-prefixed content', () => {
+    expect(detectContentFromBody('  {"key":"value"}')).toBe('json');
+  });
+});
+
+describe('getExtensionForMimeType', () => {
+  it('should return json for application/json', () => {
+    expect(getExtensionForMimeType('application/json')).toBe('json');
+  });
+
+  it('should return xml for application/xml', () => {
+    expect(getExtensionForMimeType('application/xml')).toBe('xml');
+  });
+
+  it('should return html for text/html', () => {
+    expect(getExtensionForMimeType('text/html')).toBe('html');
+  });
+
+  it('should return png for image/png', () => {
+    expect(getExtensionForMimeType('image/png')).toBe('png');
+  });
+
+  it('should return jpg for image/jpeg', () => {
+    expect(getExtensionForMimeType('image/jpeg')).toBe('jpg');
+  });
+
+  it('should return bin for unknown types', () => {
+    expect(getExtensionForMimeType('application/something')).toBe('bin');
+  });
+
+  it('should return correct extensions for all common types', () => {
+    expect(getExtensionForMimeType('text/plain')).toBe('txt');
+    expect(getExtensionForMimeType('text/css')).toBe('css');
+    expect(getExtensionForMimeType('application/javascript')).toBe('js');
+    expect(getExtensionForMimeType('application/pdf')).toBe('pdf');
+    expect(getExtensionForMimeType('application/zip')).toBe('zip');
+    expect(getExtensionForMimeType('image/gif')).toBe('gif');
+    expect(getExtensionForMimeType('image/svg+xml')).toBe('svg');
+  });
+});