Fix callbacks in tests

lib/utils/__tests__/atRuleParamIndex.test.js

@@ -5,30 +5,26 @@ const postcss = require('postcss');
 
 describe('atRuleParamIndex', () => {
 	it('has a single space before the param', () => {
-		atRules('@media (color) {}', (atRule) => {
-			expect(atRuleParamIndex(atRule)).toBe(7);
-		});
+		expect(atRuleParamIndex(atRule('@media (color) {}'))).toBe(7);
 	});
 
 	it('has multiple spaces before the param', () => {
-		atRules('@media  (color) {}', (atRule) => {
-			expect(atRuleParamIndex(atRule)).toBe(8);
-		});
+		expect(atRuleParamIndex(atRule('@media  (color) {}'))).toBe(8);
 	});
 
 	it('has a newline before the param', () => {
-		atRules("@import\n'x.css');", (atRule) => {
-			expect(atRuleParamIndex(atRule)).toBe(8);
-		});
+		expect(atRuleParamIndex(atRule("@import\n'x.css');"))).toBe(8);
 	});
 
 	it('has a function param', () => {
-		atRules('@document url-prefix(http://www.w3.org/Style/)', (atRule) => {
-			expect(atRuleParamIndex(atRule)).toBe(10);
-		});
+		expect(atRuleParamIndex(atRule('@document url-prefix(http://www.w3.org/Style/)'))).toBe(10);
 	});
 });
 
-function atRules(css, cb) {
-	postcss.parse(css).walkAtRules(cb);
+function atRule(css) {
+	const list = [];
+
+	postcss.parse(css).walkAtRules((rule) => list.push(rule));
+
+	return list[0];
 }

lib/utils/__tests__/declarationValueIndex.test.js

@@ -5,36 +5,30 @@ const postcss = require('postcss');
 
 describe('declarationValueIndex', () => {
 	it('has a space before the value', () => {
-		rules('a { a: b}', (decl) => {
-			expect(declarationValueIndex(decl)).toBe(3);
-		});
+		expect(declarationValueIndex(decl('a { a: b}'))).toBe(3);
 	});
 
 	it('has a colon before the value', () => {
-		rules('a { a :b }', (decl) => {
-			expect(declarationValueIndex(decl)).toBe(3);
-		});
+		expect(declarationValueIndex(decl('a { a :b }'))).toBe(3);
 	});
 
 	it('has no spaces before the value', () => {
-		rules('a { a:b }', (decl) => {
-			expect(declarationValueIndex(decl)).toBe(2);
-		});
+		expect(declarationValueIndex(decl('a { a:b }'))).toBe(2);
 	});
 
 	it('has multiple characters before the value', () => {
-		rules('a { a  : b }', (decl) => {
-			expect(declarationValueIndex(decl)).toBe(5);
-		});
+		expect(declarationValueIndex(decl('a { a  : b }'))).toBe(5);
 	});
 
 	it('has a newline before the value', () => {
-		rules('a { a:\nb }', (decl) => {
-			expect(declarationValueIndex(decl)).toBe(3);
-		});
+		expect(declarationValueIndex(decl('a { a:\nb }'))).toBe(3);
 	});
 });
 
-function rules(css, cb) {
-	postcss.parse(css).walkDecls(cb);
+function decl(css) {
+	const list = [];
+
+	postcss.parse(css).walkDecls((decl) => list.push(decl));
+
+	return list[0];
 }

lib/utils/__tests__/isCustomPropertySet.test.js

@@ -5,18 +5,14 @@ const postcss = require('postcss');
 
 describe('isCustomPropertySet', () => {
 	it('accepts custom property set', () => {
-		customPropertySet('--foo: {};', (customPropertySet) => {
-			expect(isCustomPropertySet(customPropertySet)).toBeTruthy();
-		});
+		expect(isCustomPropertySet(node('--foo: {};'))).toBeTruthy();
 	});
 
 	it('rejects custom property', () => {
-		customPropertySet('--foo: red;', (customPropertySet) => {
-			expect(isCustomPropertySet(customPropertySet)).toBeFalsy();
-		});
+		expect(isCustomPropertySet(node('--foo: red;'))).toBeFalsy();
 	});
 });
 
-function customPropertySet(css, cb) {
-	postcss.parse(css).walk(cb);
+function node(css) {
+	return postcss.parse(css).first;
 }

lib/utils/__tests__/isFirstNested.test.js

@@ -22,9 +22,13 @@ describe('isFirstNested', () => {
       }
     `);
 
-		root.walkRules((rule) => {
-			expect(isFirstNested(rule)).toBe(true);
-		});
+		const rules = [];
+
+		root.walkRules((rule) => rules.push(rule));
+
+		expect(rules).toHaveLength(2);
+		expect(isFirstNested(rules[0])).toBe(true);
+		expect(isFirstNested(rules[1])).toBe(true);
 	});
 
 	it('returns true with the first-nested at-rule', () => {
@@ -37,9 +41,13 @@ describe('isFirstNested', () => {
       }
     `);
 
-		root.walkAtRules((atRule) => {
-			expect(isFirstNested(atRule)).toBe(true);
-		});
+		const atRules = [];
+
+		root.walkAtRules((rule) => atRules.push(rule));
+
+		expect(atRules).toHaveLength(2);
+		expect(isFirstNested(atRules[0])).toBe(true);
+		expect(isFirstNested(atRules[1])).toBe(true);
 	});
 
 	it('returns true with the first-nested declaration', () => {
@@ -52,9 +60,13 @@ describe('isFirstNested', () => {
       }
     `);
 
-		root.walkDecls((atRule) => {
-			expect(isFirstNested(atRule)).toBe(true);
-		});
+		const decls = [];
+
+		root.walkDecls((decl) => decls.push(decl));
+
+		expect(decls).toHaveLength(2);
+		expect(isFirstNested(decls[0])).toBe(true);
+		expect(isFirstNested(decls[1])).toBe(true);
 	});
 
 	it('returns true with first-nested non-statement', () => {
@@ -67,9 +79,14 @@ describe('isFirstNested', () => {
       }
     `);
 
-		root.walkComments((comment) => {
-			expect(isFirstNested(comment)).toBe(true);
-		});
+		const comments = [];
+
+		root.walkComments((comment) => comments.push(comment));
+
+		expect(comments).toHaveLength(3);
+		expect(isFirstNested(comments[0])).toBe(true);
+		expect(isFirstNested(comments[1])).toBe(true);
+		expect(isFirstNested(comments[2])).toBe(true);
 	});
 
 	it('returns false with not-first-nested rule', () => {
@@ -84,9 +101,13 @@ describe('isFirstNested', () => {
       }
     `);
 
-		root.walkRules('b', (rule) => {
-			expect(isFirstNested(rule)).toBe(false);
-		});
+		const rules = [];
+
+		root.walkRules('b', (rule) => rules.push(rule));
+
+		expect(rules).toHaveLength(2);
+		expect(isFirstNested(rules[0])).toBe(false);
+		expect(isFirstNested(rules[1])).toBe(false);
 	});
 
 	it('returns false with not-first-nested at-rule', () => {
@@ -101,9 +122,13 @@ describe('isFirstNested', () => {
       }
     `);
 
-		root.walkAtRules('expect', (atRule) => {
-			expect(isFirstNested(atRule)).toBe(false);
-		});
+		const atRules = [];
+
+		root.walkAtRules('expect', (atRule) => atRules.push(atRule));
+
+		expect(atRules).toHaveLength(2);
+		expect(isFirstNested(atRules[0])).toBe(false);
+		expect(isFirstNested(atRules[1])).toBe(false);
 	});
 
 	it('returns false with not-first-nested declaration', () => {
@@ -126,8 +151,14 @@ describe('isFirstNested', () => {
       }
     `);
 
-		root.walkDecls('color', (atRule) => {
-			expect(isFirstNested(atRule)).toBe(false);
-		});
+		const decls = [];
+
+		root.walkDecls('color', (decl) => decls.push(decl));
+
+		expect(decls).toHaveLength(4);
+		expect(isFirstNested(decls[0])).toBe(false);
+		expect(isFirstNested(decls[1])).toBe(false);
+		expect(isFirstNested(decls[2])).toBe(false);
+		expect(isFirstNested(decls[3])).toBe(false);
 	});
 });