forked from rDrama/rDrama
259 lines
7.1 KiB
JavaScript
259 lines
7.1 KiB
JavaScript
"use strict";
|
|
|
|
var _ava = _interopRequireDefault(require("ava"));
|
|
|
|
var _index = _interopRequireDefault(require("../index"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
// Node creation
|
|
var nodeTypes = [['attribute', '[href]', {
|
|
attribute: 'href'
|
|
}], ['className', '.classy', {
|
|
value: 'classy'
|
|
}], ['combinator', ' >> ', {
|
|
value: '>>',
|
|
spaces: {
|
|
before: ' ',
|
|
after: ' '
|
|
}
|
|
}], ['comment', '/* comment */', {
|
|
value: '/* comment */'
|
|
}], ['id', '#test', {
|
|
value: 'test'
|
|
}], ['nesting', '&'], ['pseudo', '::before', {
|
|
value: '::before'
|
|
}], ['string', '"wow"', {
|
|
value: '"wow"'
|
|
}], ['tag', 'button', {
|
|
value: 'button'
|
|
}], ['universal', '*']];
|
|
nodeTypes.forEach(function (type) {
|
|
(0, _ava["default"])("parser#" + type[0], function (t) {
|
|
var node = _index["default"][type[0]](type[2] || {});
|
|
|
|
t.deepEqual(String(node), type[1]);
|
|
});
|
|
});
|
|
(0, _ava["default"])('string constants', function (t) {
|
|
t.truthy(_index["default"].TAG);
|
|
t.truthy(_index["default"].STRING);
|
|
t.truthy(_index["default"].SELECTOR);
|
|
t.truthy(_index["default"].ROOT);
|
|
t.truthy(_index["default"].PSEUDO);
|
|
t.truthy(_index["default"].NESTING);
|
|
t.truthy(_index["default"].ID);
|
|
t.truthy(_index["default"].COMMENT);
|
|
t.truthy(_index["default"].COMBINATOR);
|
|
t.truthy(_index["default"].CLASS);
|
|
t.truthy(_index["default"].ATTRIBUTE);
|
|
t.truthy(_index["default"].UNIVERSAL);
|
|
});
|
|
(0, _ava["default"])('construct a whole tree', function (t) {
|
|
var root = _index["default"].root();
|
|
|
|
var selector = _index["default"].selector();
|
|
|
|
selector.append(_index["default"].id({
|
|
value: 'tree'
|
|
}));
|
|
root.append(selector);
|
|
t.deepEqual(String(root), '#tree');
|
|
});
|
|
(0, _ava["default"])('no operation', function (t) {
|
|
t.notThrows(function () {
|
|
return (0, _index["default"])().processSync('h1 h2 h3');
|
|
});
|
|
});
|
|
(0, _ava["default"])('empty selector string', function (t) {
|
|
t.notThrows(function () {
|
|
return (0, _index["default"])(function (selectors) {
|
|
selectors.walk(function (selector) {
|
|
selector.type = 'tag';
|
|
});
|
|
}).processSync('');
|
|
});
|
|
});
|
|
(0, _ava["default"])('async parser', function (t) {
|
|
return (0, _index["default"])(function (selectors) {
|
|
return new Promise(function (res) {
|
|
setTimeout(function () {
|
|
selectors.first.nodes[0].value = 'bar';
|
|
res();
|
|
}, 1);
|
|
});
|
|
}).process('foo').then(function (result) {
|
|
t.deepEqual(result, 'bar');
|
|
});
|
|
});
|
|
(0, _ava["default"])('parse errors with the async parser', function (t) {
|
|
return (0, _index["default"])(function (selectors) {
|
|
return new Promise(function (res) {
|
|
setTimeout(function () {
|
|
selectors.first.nodes[0].value = 'bar';
|
|
res();
|
|
}, 1);
|
|
});
|
|
}).process('a b: c')["catch"](function (err) {
|
|
return t.truthy(err);
|
|
});
|
|
});
|
|
(0, _ava["default"])('parse errors within the async processor', function (t) {
|
|
return (0, _index["default"])(function (selectors) {
|
|
return new Promise(function (res, rej) {
|
|
setTimeout(function () {
|
|
rej(selectors.error("async error"));
|
|
}, 1);
|
|
});
|
|
}).process('.foo')["catch"](function (err) {
|
|
return t.truthy(err);
|
|
});
|
|
});
|
|
(0, _ava["default"])('parse errors within the async processor before the promise returns', function (t) {
|
|
return (0, _index["default"])(function (selectors) {
|
|
throw selectors.error("async error");
|
|
}).process('.foo')["catch"](function (err) {
|
|
return t.truthy(err);
|
|
});
|
|
});
|
|
(0, _ava["default"])('returning a promise to the sync processor fails', function (t) {
|
|
t["throws"](function () {
|
|
return (0, _index["default"])(function () {
|
|
return new Promise(function (res) {
|
|
setTimeout(function () {
|
|
res();
|
|
}, 1);
|
|
});
|
|
}).processSync('.foo');
|
|
});
|
|
});
|
|
(0, _ava["default"])('Passing a rule works async', function (t) {
|
|
var rule = {
|
|
selector: '.foo'
|
|
};
|
|
return (0, _index["default"])(function (root) {
|
|
return new Promise(function (res) {
|
|
setTimeout(function () {
|
|
root.walkClasses(function (node) {
|
|
node.value = "bar";
|
|
});
|
|
res();
|
|
}, 1);
|
|
});
|
|
}).process(rule).then(function (newSel) {
|
|
t.deepEqual(newSel, ".bar");
|
|
t.deepEqual(rule.selector, ".bar");
|
|
});
|
|
});
|
|
(0, _ava["default"])('Passing a rule with mutation disabled works async', function (t) {
|
|
var rule = {
|
|
selector: '.foo'
|
|
};
|
|
return (0, _index["default"])(function (root) {
|
|
return new Promise(function (res) {
|
|
setTimeout(function () {
|
|
root.walkClasses(function (node) {
|
|
node.value = "bar";
|
|
});
|
|
res();
|
|
}, 1);
|
|
});
|
|
}).process(rule, {
|
|
updateSelector: false
|
|
}).then(function (newSel) {
|
|
t.deepEqual(newSel, ".bar");
|
|
t.deepEqual(rule.selector, ".foo");
|
|
});
|
|
});
|
|
(0, _ava["default"])('Passing a rule with mutation works sync', function (t) {
|
|
var rule = {
|
|
selector: '.foo'
|
|
};
|
|
var newSel = (0, _index["default"])(function (root) {
|
|
root.walkClasses(function (node) {
|
|
node.value = "bar";
|
|
});
|
|
}).processSync(rule, {
|
|
updateSelector: true
|
|
});
|
|
t.deepEqual(newSel, ".bar");
|
|
t.deepEqual(rule.selector, ".bar");
|
|
});
|
|
(0, _ava["default"])('Transform a selector synchronously', function (t) {
|
|
var rule = {
|
|
selector: '.foo'
|
|
};
|
|
var count = (0, _index["default"])(function (root) {
|
|
var classCount = 0;
|
|
root.walkClasses(function (node) {
|
|
classCount++;
|
|
node.value = "bar";
|
|
});
|
|
return classCount;
|
|
}).transformSync(rule, {
|
|
updateSelector: true
|
|
});
|
|
t.deepEqual(count, 1);
|
|
t.deepEqual(rule.selector, ".bar");
|
|
});
|
|
(0, _ava["default"])('Transform a selector asynchronously', function (t) {
|
|
var rule = {
|
|
selector: '.foo'
|
|
};
|
|
return (0, _index["default"])(function (root) {
|
|
return new Promise(function (res) {
|
|
setTimeout(function () {
|
|
var classCount = 0;
|
|
root.walkClasses(function (node) {
|
|
classCount++;
|
|
node.value = "bar";
|
|
});
|
|
res(classCount);
|
|
}, 1);
|
|
});
|
|
}).transform(rule, {
|
|
updateSelector: true
|
|
}).then(function (count) {
|
|
t.deepEqual(count, 1);
|
|
t.deepEqual(rule.selector, ".bar");
|
|
});
|
|
});
|
|
(0, _ava["default"])('get AST of a selector synchronously', function (t) {
|
|
var rule = {
|
|
selector: '.foo'
|
|
};
|
|
var ast = (0, _index["default"])(function (root) {
|
|
var classCount = 0;
|
|
root.walkClasses(function (node) {
|
|
classCount++;
|
|
node.value = "bar";
|
|
});
|
|
return classCount;
|
|
}).astSync(rule, {
|
|
updateSelector: true
|
|
});
|
|
t.deepEqual(ast.nodes[0].nodes[0].value, "bar");
|
|
t.deepEqual(rule.selector, ".bar");
|
|
});
|
|
(0, _ava["default"])('get AST a selector asynchronously', function (t) {
|
|
var rule = {
|
|
selector: '.foo'
|
|
};
|
|
return (0, _index["default"])(function (root) {
|
|
return new Promise(function (res) {
|
|
setTimeout(function () {
|
|
var classCount = 0;
|
|
root.walkClasses(function (node) {
|
|
classCount++;
|
|
node.value = "bar";
|
|
});
|
|
res(classCount);
|
|
}, 1);
|
|
});
|
|
}).ast(rule, {
|
|
updateSelector: true
|
|
}).then(function (ast) {
|
|
t.deepEqual(ast.nodes[0].nodes[0].value, "bar");
|
|
t.deepEqual(rule.selector, ".bar");
|
|
});
|
|
}); |