FilesExpand file tree

 master

/

css-syntax-error.test.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

192 lines (167 loc) · 5.58 KB

 master

/

css-syntax-error.test.js

Copy path

Top

File metadata and controls

• Code
• Blame

192 lines (167 loc) · 5.58 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

import CssSyntaxError from '../lib/css-syntax-error';

import postcss from '../lib/postcss';

import stripAnsi from 'strip-ansi';

import Concat from 'concat-with-sourcemaps';

import chalk from 'chalk';

import path from 'path';

function parseError(css, opts) {

let error;

try {

postcss.parse(css, opts);

} catch (e) {

if ( e.name === 'CssSyntaxError' ) {

error = e;

} else {

throw e;

}

}

return error;

}

it('saves source', () => {

let error = parseError('a {\n content: "\n}');

expect(error instanceof CssSyntaxError).toBeTruthy();

expect(error.name).toEqual('CssSyntaxError');

expect(error.message).toEqual('<css input>:2:12: Unclosed string');

expect(error.reason).toEqual('Unclosed string');

expect(error.line).toEqual(2);

expect(error.column).toEqual(12);

expect(error.source).toEqual('a {\n content: "\n}');

expect(error.input).toEqual({

line: error.line,

column: error.column,

source: error.source

});

});

it('has stack trace', () => {

expect(parseError('a {\n content: "\n}').stack)

.toMatch(/css-syntax-error\.test\.js/);

});

it('highlights broken line with colors', () => {

let c = chalk;

expect(parseError('a {').showSourceCode(true)).toEqual(

c.red.bold('>') + c.grey(' 1 | ') + 'a ' + c.yellow('{') + '\n ' +

c.grey(' | ') + c.red.bold('^'));

});

it('highlights broken line', () => {

expect(parseError('a {\n content: "\n}').showSourceCode(false))

.toEqual(' 1 | a {\n' +

'> 2 | content: "\n' +

' | ^\n' +

' 3 | }');

});

it('highlights broken line, when indented with tabs', () => {

expect(parseError('a {\n\t \t content:\t"\n}').showSourceCode(false))

.toEqual(' 1 | a {\n' +

'> 2 | \t \t content:\t"\n' +

' | \t \t \t^\n' +

' 3 | }');

});

it('highlights small code example', () => {

expect(parseError('a {').showSourceCode(false))

.toEqual('> 1 | a {\n' +

' | ^');

});

it('add leading space for line numbers', () => {

let css = '\n\n\n\n\n\n\na {\n content: "\n}\n\n\n';

expect(parseError(css).showSourceCode(false))

.toEqual(' 7 | \n' +

' 8 | a {\n' +

'> 9 | content: "\n' +

' | ^\n' +

' 10 | }\n' +

' 11 | ');

});

it('prints with highlight', () => {

expect(stripAnsi(parseError('a {').toString()))

.toEqual('CssSyntaxError: <css input>:1:1: Unclosed block\n' +

'\n' +

'> 1 | a {\n' +

' | ^\n');

});

it('misses highlights without source content', () => {

let error = parseError('a {');

error.source = null;

expect(error.toString())

.toEqual('CssSyntaxError: <css input>:1:1: Unclosed block');

});

it('misses position without source', () => {

let decl = postcss.decl({ prop: 'color', value: 'black' });

let error = decl.error('Test');

expect(error.toString()).toEqual('CssSyntaxError: <css input>: Test');

});

it('uses source map', () => {

let concat = new Concat(true, 'all.css');

concat.add('a.css', 'a { }\n');

concat.add('b.css', '\nb {\n');

let error = parseError(concat.content, {

from: 'build/all.css',

map: { prev: concat.sourceMap }

});

expect(error.file).toEqual(path.resolve('b.css'));

expect(error.line).toEqual(2);

expect(error.source).not.toBeDefined();

expect(error.input).toEqual({

file: path.resolve('build/all.css'),

line: 3,

column: 1,

source: 'a { }\n\nb {\n'

});

});

it('shows origin source', () => {

let input = postcss().process('a{}', {

from: '/a.css',

to: '/b.css',

map: { inline: false }

});

let error = parseError('a{', {

from: '/b.css',

to: '/c.css',

map: { prev: input.map }

});

expect(error.source).toEqual('a{}');

});

it('does not uses wrong source map', () => {

let error = parseError('a { }\nb {', {

from: 'build/all.css',

map: {

prev: {

version: 3,

file: 'build/all.css',

sources: ['a.css', 'b.css'],

mappings: 'A'

}

}

});

expect(error.file).toEqual(path.resolve('build/all.css'));

});

it('set source plugin', () => {

let error = postcss.parse('a{}').first.error('Error', { plugin: 'PL' });

expect(error.plugin).toEqual('PL');

expect(error.toString())

.toMatch(/^CssSyntaxError: PL: <css input>:1:1: Error/);

});

it('set source plugin automatically', () => {

let plugin = postcss.plugin('test-plugin', () => {

return css => {

throw css.first.error('Error');

};

});

return postcss([plugin]).process('a{}').catch( error => {

if ( error.name !== 'CssSyntaxError' ) throw error;

expect(error.plugin).toEqual('test-plugin');

expect(error.toString()).toMatch(/test-plugin/);

});

});

it('set plugin automatically in async', () => {

let plugin = postcss.plugin('async-plugin', () => {

return css => {

return new Promise( (resolve, reject) => {

reject(css.first.error('Error'));

});

};

});

return postcss([plugin]).process('a{}').catch( error => {

if ( error.name !== 'CssSyntaxError' ) throw error;

expect(error.plugin).toEqual('async-plugin');

});

});