326 lines
11 KiB
TypeScript
326 lines
11 KiB
TypeScript
import { describe, it, expect, beforeEach } from 'vitest';
|
|
import { cheerio, food, eleven } from './__fixtures__/fixtures.js';
|
|
import { type CheerioAPI } from './index.js';
|
|
|
|
describe('cheerio', () => {
|
|
describe('.html', () => {
|
|
it('() : should return innerHTML; $.html(obj) should return outerHTML', () => {
|
|
const $div = cheerio(
|
|
'div',
|
|
'<div><span>foo</span><span>bar</span></div>',
|
|
);
|
|
const span = $div.children()[1];
|
|
expect(cheerio(span).html()).toBe('bar');
|
|
expect(cheerio.html(span)).toBe('<span>bar</span>');
|
|
});
|
|
|
|
it('(<obj>) : should accept an object, an array, or a cheerio object', () => {
|
|
const $span = cheerio('<span>foo</span>');
|
|
expect(cheerio.html($span[0])).toBe('<span>foo</span>');
|
|
expect(cheerio.html($span)).toBe('<span>foo</span>');
|
|
});
|
|
|
|
it('(<value>) : should be able to set to an empty string', () => {
|
|
const $elem = cheerio('<span>foo</span>').html('');
|
|
expect(cheerio.html($elem)).toBe('<span></span>');
|
|
});
|
|
|
|
it('(<root>) : does not render the root element', () => {
|
|
const $ = cheerio.load('');
|
|
expect(cheerio.html($.root())).toBe(
|
|
'<html><head></head><body></body></html>',
|
|
);
|
|
});
|
|
|
|
it('(<elem>, <root>, <elem>) : does not render the root element', () => {
|
|
const $ = cheerio.load('<div>a div</div><span>a span</span>');
|
|
const $collection = $('div').add($.root()).add('span');
|
|
const expected =
|
|
'<html><head></head><body><div>a div</div><span>a span</span></body></html><div>a div</div><span>a span</span>';
|
|
expect(cheerio.html($collection)).toBe(expected);
|
|
});
|
|
|
|
it('() : does not crash with `null` as `this` value', () => {
|
|
const { html } = cheerio;
|
|
expect(html.call(null as never)).toBe('');
|
|
expect(html.call(null as never, '#nothing')).toBe('');
|
|
});
|
|
});
|
|
|
|
describe('.text', () => {
|
|
it('(cheerio object) : should return the text contents of the specified elements', () => {
|
|
const $ = cheerio.load('<a>This is <em>content</em>.</a>');
|
|
expect(cheerio.text($('a'))).toBe('This is content.');
|
|
});
|
|
|
|
it('(cheerio object) : should omit comment nodes', () => {
|
|
const $ = cheerio.load(
|
|
'<a>This is <!-- a comment --> not a comment.</a>',
|
|
);
|
|
expect(cheerio.text($('a'))).toBe('This is not a comment.');
|
|
});
|
|
|
|
it('(cheerio object) : should include text contents of children recursively', () => {
|
|
const $ = cheerio.load(
|
|
'<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>',
|
|
);
|
|
expect(cheerio.text($('a'))).toBe(
|
|
'This is a child with another child and not a comment followed by one last child and some final text.',
|
|
);
|
|
});
|
|
|
|
it('() : should return the rendered text content of the root', () => {
|
|
const $ = cheerio.load(
|
|
'<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>',
|
|
);
|
|
expect(cheerio.text($.root())).toBe(
|
|
'This is a child with another child and not a comment followed by one last child and some final text.',
|
|
);
|
|
});
|
|
|
|
it('(cheerio object) : should not omit script tags', () => {
|
|
const $ = cheerio.load('<script>console.log("test")</script>');
|
|
expect(cheerio.text($.root())).toBe('console.log("test")');
|
|
});
|
|
|
|
it('(cheerio object) : should omit style tags', () => {
|
|
const $ = cheerio.load(
|
|
'<style type="text/css">.cf-hidden { display: none; }</style>',
|
|
);
|
|
expect($.text()).toBe('.cf-hidden { display: none; }');
|
|
});
|
|
|
|
it('() : does not crash with `null` as `this` value', () => {
|
|
const { text } = cheerio;
|
|
expect(text.call(null as never)).toBe('');
|
|
});
|
|
});
|
|
|
|
describe('.parseHTML', () => {
|
|
const $ = cheerio.load('');
|
|
|
|
it('() : returns null', () => {
|
|
expect($.parseHTML()).toBe(null);
|
|
});
|
|
|
|
it('(null) : returns null', () => {
|
|
expect($.parseHTML(null)).toBe(null);
|
|
});
|
|
|
|
it('("") : returns null', () => {
|
|
expect($.parseHTML('')).toBe(null);
|
|
});
|
|
|
|
it('(largeHtmlString) : parses large HTML strings', () => {
|
|
const html = '<div></div>'.repeat(10);
|
|
const nodes = $.parseHTML(html);
|
|
|
|
expect(nodes.length).toBe(10);
|
|
expect(nodes).toBeInstanceOf(Array);
|
|
});
|
|
|
|
it('("<script>") : ignores scripts by default', () => {
|
|
const html = '<script>undefined()</script>';
|
|
expect($.parseHTML(html)).toHaveLength(0);
|
|
});
|
|
|
|
it('("<script>", true) : preserves scripts when requested', () => {
|
|
const html = '<script>undefined()</script>';
|
|
expect($.parseHTML(html, true)[0]).toHaveProperty('tagName', 'script');
|
|
});
|
|
|
|
it('("scriptAndNonScript) : preserves non-script nodes', () => {
|
|
const html = '<script>undefined()</script><div></div>';
|
|
expect($.parseHTML(html)[0]).toHaveProperty('tagName', 'div');
|
|
});
|
|
|
|
it('(scriptAndNonScript, true) : Preserves script position', () => {
|
|
const html = '<script>undefined()</script><div></div>';
|
|
expect($.parseHTML(html, true)[0]).toHaveProperty('tagName', 'script');
|
|
});
|
|
|
|
it('(text) : returns a text node', () => {
|
|
expect($.parseHTML('text')[0].type).toBe('text');
|
|
});
|
|
|
|
it('(<tab>>text) : preserves leading whitespace', () => {
|
|
expect($.parseHTML('\t<div></div>')[0]).toHaveProperty('data', '\t');
|
|
});
|
|
|
|
it('( text) : Leading spaces are treated as text nodes', () => {
|
|
expect($.parseHTML(' <div/> ')[0].type).toBe('text');
|
|
});
|
|
|
|
it('(html) : should preserve content', () => {
|
|
const html = '<div>test div</div>';
|
|
expect(cheerio($.parseHTML(html)[0]).html()).toBe('test div');
|
|
});
|
|
|
|
it('(malformedHtml) : should not break', () => {
|
|
expect($.parseHTML('<span><span>')).toHaveLength(1);
|
|
});
|
|
|
|
it('(garbageInput) : should not cause an error', () => {
|
|
expect(
|
|
$.parseHTML('<#if><tr><p>This is a test.</p></tr><#/if>'),
|
|
).toBeTruthy();
|
|
});
|
|
|
|
it('(text) : should return an array that is not effected by DOM manipulation methods', () => {
|
|
const $div = cheerio.load('<div>');
|
|
const elems = $div.parseHTML('<b></b><i></i>');
|
|
|
|
$div('div').append(elems);
|
|
|
|
expect(elems).toHaveLength(2);
|
|
});
|
|
|
|
it('(html, context) : should ignore context argument', () => {
|
|
const $div = cheerio.load('<div>');
|
|
const elems = $div.parseHTML('<script>foo</script><a>', { foo: 123 });
|
|
|
|
$div('div').append(elems);
|
|
|
|
expect(elems).toHaveLength(1);
|
|
});
|
|
|
|
it('(html, context, keepScripts) : should ignore context argument', () => {
|
|
const $div = cheerio.load('<div>');
|
|
const elems = $div.parseHTML(
|
|
'<script>foo</script><a>',
|
|
{ foo: 123 },
|
|
true,
|
|
);
|
|
|
|
$div('div').append(elems);
|
|
|
|
expect(elems).toHaveLength(2);
|
|
});
|
|
});
|
|
|
|
describe('.merge', () => {
|
|
const $ = cheerio.load('');
|
|
|
|
it('should be a function', () => {
|
|
expect(typeof $.merge).toBe('function');
|
|
});
|
|
|
|
it('(arraylike, arraylike) : should modify the first array, but not the second', () => {
|
|
const arr1 = [1, 2, 3];
|
|
const arr2 = [4, 5, 6];
|
|
|
|
const ret = $.merge(arr1, arr2);
|
|
expect(typeof ret).toBe('object');
|
|
expect(Array.isArray(ret)).toBe(true);
|
|
expect(ret).toBe(arr1);
|
|
expect(arr1).toHaveLength(6);
|
|
expect(arr2).toHaveLength(3);
|
|
});
|
|
|
|
it('(arraylike, arraylike) : should handle objects that arent arrays, but are arraylike', () => {
|
|
const arr1: ArrayLike<string> = {
|
|
length: 3,
|
|
0: 'a',
|
|
1: 'b',
|
|
2: 'c',
|
|
};
|
|
const arr2 = {
|
|
length: 3,
|
|
0: 'd',
|
|
1: 'e',
|
|
2: 'f',
|
|
};
|
|
|
|
$.merge(arr1, arr2);
|
|
expect(arr1).toHaveLength(6);
|
|
expect(arr1[3]).toBe('d');
|
|
expect(arr1[4]).toBe('e');
|
|
expect(arr1[5]).toBe('f');
|
|
expect(arr2).toHaveLength(3);
|
|
});
|
|
|
|
it('(?, ?) : should gracefully reject invalid inputs', () => {
|
|
expect($.merge([4], 3 as never)).toBeFalsy();
|
|
expect($.merge({} as never, {} as never)).toBeFalsy();
|
|
expect($.merge([], {} as never)).toBeFalsy();
|
|
expect($.merge({} as never, [])).toBeFalsy();
|
|
const fakeArray1 = { length: 3, 0: 'a', 1: 'b', 3: 'd' };
|
|
expect($.merge(fakeArray1, [])).toBeFalsy();
|
|
expect($.merge([], fakeArray1)).toBeFalsy();
|
|
expect($.merge({ length: '7' } as never, [])).toBeFalsy();
|
|
expect($.merge({ length: -1 }, [])).toBeFalsy();
|
|
});
|
|
|
|
it('(?, ?) : should no-op on invalid inputs', () => {
|
|
const fakeArray1 = { length: 3, 0: 'a', 1: 'b', 3: 'd' };
|
|
$.merge(fakeArray1, []);
|
|
expect(fakeArray1).toHaveLength(3);
|
|
expect(fakeArray1[0]).toBe('a');
|
|
expect(fakeArray1[1]).toBe('b');
|
|
expect(fakeArray1[3]).toBe('d');
|
|
$.merge([], fakeArray1);
|
|
expect(fakeArray1).toHaveLength(3);
|
|
expect(fakeArray1[0]).toBe('a');
|
|
expect(fakeArray1[1]).toBe('b');
|
|
expect(fakeArray1[3]).toBe('d');
|
|
});
|
|
});
|
|
|
|
describe('.contains', () => {
|
|
let $: CheerioAPI;
|
|
|
|
beforeEach(() => {
|
|
$ = cheerio.load(food);
|
|
});
|
|
|
|
it('(container, contained) : should correctly detect the provided element', () => {
|
|
const $food = $('#food');
|
|
const $fruits = $('#fruits');
|
|
const $apple = $('.apple');
|
|
|
|
expect($.contains($food[0], $fruits[0])).toBe(true);
|
|
expect($.contains($food[0], $apple[0])).toBe(true);
|
|
});
|
|
|
|
it('(container, other) : should not detect elements that are not contained', () => {
|
|
const $fruits = $('#fruits');
|
|
const $vegetables = $('#vegetables');
|
|
const $apple = $('.apple');
|
|
|
|
expect($.contains($vegetables[0], $apple[0])).toBe(false);
|
|
expect($.contains($fruits[0], $vegetables[0])).toBe(false);
|
|
expect($.contains($vegetables[0], $fruits[0])).toBe(false);
|
|
expect($.contains($fruits[0], $fruits[0])).toBe(false);
|
|
expect($.contains($vegetables[0], $vegetables[0])).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('.root', () => {
|
|
it('() : should return a cheerio-wrapped root object', () => {
|
|
const $ = cheerio.load('<html><head></head><body>foo</body></html>');
|
|
$.root().append('<div id="test"></div>');
|
|
expect($.html()).toBe(
|
|
'<html><head></head><body>foo</body></html><div id="test"></div>',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('.extract', () => {
|
|
it('() : should extract values for selectors', () => {
|
|
const $ = cheerio.load(eleven);
|
|
|
|
expect(
|
|
$.extract({
|
|
red: [{ selector: '.red', value: 'outerHTML' }],
|
|
}),
|
|
).toStrictEqual({
|
|
red: [
|
|
'<li class="red">Four</li>',
|
|
'<li class="red">Five</li>',
|
|
'<li class="red sel">Nine</li>',
|
|
],
|
|
});
|
|
});
|
|
});
|
|
});
|