github-mirror/caddy
2
0
Fork 0
mirror of https://github.com/caddyserver/caddy.git synced 2024-11-26 18:30:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
7c48b5fdbb
caddy/caddyconfig/caddyfile/lexer_test.go

530 lines
12 KiB
Go
Raw Normal View History

Make copyright notice more consistent Some files had the old copyright or were missing the license comment entirely. Also change Light Code Labs to Dyanim in security contact and releases.
2021-09-17 02:50:32 +08:00
// Copyright 2015 Matthew Holt and The Caddy Authors
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package caddyfile
import (
"testing"
)
func TestLexer(t *testing.T) {
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
testCases := []struct {
input []byte
expected []Token
expectErr bool
errorMessage string
}{
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`host:123`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "host:123"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`host:123
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
directive`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "host:123"},
{Line: 3, Text: "directive"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`host:123 {
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
directive
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
}`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "host:123"},
{Line: 1, Text: "{"},
{Line: 2, Text: "directive"},
{Line: 3, Text: "}"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`host:123 { directive }`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "host:123"},
{Line: 1, Text: "{"},
{Line: 1, Text: "directive"},
{Line: 1, Text: "}"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`host:123 {
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
#comment
directive
# comment
foobar # another comment
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
}`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "host:123"},
{Line: 1, Text: "{"},
{Line: 3, Text: "directive"},
{Line: 5, Text: "foobar"},
{Line: 6, Text: "}"},
},
},
caddyconfig: Don't start comments in middle of tokens (#3267) * caddyconfig: Only parse # as start of comment if preceded by space * caddyconfig: Simplify # logic using len(val), add a test
2020-05-06 02:32:12 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`host:123 {
caddyconfig: Don't start comments in middle of tokens (#3267) * caddyconfig: Only parse # as start of comment if preceded by space * caddyconfig: Simplify # logic using len(val), add a test
2020-05-06 02:32:12 +08:00
# hash inside string is not a comment
redir / /some/#/path
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
}`),
caddyconfig: Don't start comments in middle of tokens (#3267) * caddyconfig: Only parse # as start of comment if preceded by space * caddyconfig: Simplify # logic using len(val), add a test
2020-05-06 02:32:12 +08:00
expected: []Token{
{Line: 1, Text: "host:123"},
{Line: 1, Text: "{"},
{Line: 3, Text: "redir"},
{Line: 3, Text: "/"},
{Line: 3, Text: "/some/#/path"},
{Line: 4, Text: "}"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("# comment at beginning of file\n# comment at beginning of line\nhost:123"),
caddyconfig: Don't start comments in middle of tokens (#3267) * caddyconfig: Only parse # as start of comment if preceded by space * caddyconfig: Simplify # logic using len(val), add a test
2020-05-06 02:32:12 +08:00
expected: []Token{
{Line: 3, Text: "host:123"},
},
},
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`a "quoted value" b
foobar`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "a"},
{Line: 1, Text: "quoted value"},
{Line: 1, Text: "b"},
{Line: 2, Text: "foobar"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`A "quoted \"value\" inside" B`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "A"},
{Line: 1, Text: `quoted "value" inside`},
{Line: 1, Text: "B"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("An escaped \"newline\\\ninside\" quotes"),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
caddyfile: Fix lexer behavior with regards to escaped newlines Newlines (\n) can be escaped outside of quoted areas and the newline will be treated as whitespace but not as an actual line break. Escaping newlines inside a quoted area is not necessary, and because quotes trigger literal interpretation of the contents, the escaping backslash will be parsed as a literal backslash, and the newline will not be escaped. Caveat: When a newline is escaped, tokens after it until an unescaped newline will appear to the parser be on the same line as the initial token after the last unescaped newline. This may technically lead to some false line numbers if errors are given, but escaped newlines are counted so that the next token after an unescaped newline is correct. See #2766
2019-09-29 11:18:36 +08:00
{Line: 1, Text: "An"},
{Line: 1, Text: "escaped"},
{Line: 1, Text: "newline\\\ninside"},
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
{Line: 2, Text: "quotes"},
},
},
caddyfile: Fix lexer behavior with regards to escaped newlines Newlines (\n) can be escaped outside of quoted areas and the newline will be treated as whitespace but not as an actual line break. Escaping newlines inside a quoted area is not necessary, and because quotes trigger literal interpretation of the contents, the escaping backslash will be parsed as a literal backslash, and the newline will not be escaped. Caveat: When a newline is escaped, tokens after it until an unescaped newline will appear to the parser be on the same line as the initial token after the last unescaped newline. This may technically lead to some false line numbers if errors are given, but escaped newlines are counted so that the next token after an unescaped newline is correct. See #2766
2019-09-29 11:18:36 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("An escaped newline\\\noutside quotes"),
caddyfile: Fix lexer behavior with regards to escaped newlines Newlines (\n) can be escaped outside of quoted areas and the newline will be treated as whitespace but not as an actual line break. Escaping newlines inside a quoted area is not necessary, and because quotes trigger literal interpretation of the contents, the escaping backslash will be parsed as a literal backslash, and the newline will not be escaped. Caveat: When a newline is escaped, tokens after it until an unescaped newline will appear to the parser be on the same line as the initial token after the last unescaped newline. This may technically lead to some false line numbers if errors are given, but escaped newlines are counted so that the next token after an unescaped newline is correct. See #2766
2019-09-29 11:18:36 +08:00
expected: []Token{
{Line: 1, Text: "An"},
{Line: 1, Text: "escaped"},
{Line: 1, Text: "newline"},
{Line: 1, Text: "outside"},
{Line: 1, Text: "quotes"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("line1\\\nescaped\nline2\nline3"),
caddyfile: Fix lexer behavior with regards to escaped newlines Newlines (\n) can be escaped outside of quoted areas and the newline will be treated as whitespace but not as an actual line break. Escaping newlines inside a quoted area is not necessary, and because quotes trigger literal interpretation of the contents, the escaping backslash will be parsed as a literal backslash, and the newline will not be escaped. Caveat: When a newline is escaped, tokens after it until an unescaped newline will appear to the parser be on the same line as the initial token after the last unescaped newline. This may technically lead to some false line numbers if errors are given, but escaped newlines are counted so that the next token after an unescaped newline is correct. See #2766
2019-09-29 11:18:36 +08:00
expected: []Token{
{Line: 1, Text: "line1"},
{Line: 1, Text: "escaped"},
{Line: 3, Text: "line2"},
{Line: 4, Text: "line3"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("line1\\\nescaped1\\\nescaped2\nline4\nline5"),
caddyfile: Fix lexer behavior with regards to escaped newlines Newlines (\n) can be escaped outside of quoted areas and the newline will be treated as whitespace but not as an actual line break. Escaping newlines inside a quoted area is not necessary, and because quotes trigger literal interpretation of the contents, the escaping backslash will be parsed as a literal backslash, and the newline will not be escaped. Caveat: When a newline is escaped, tokens after it until an unescaped newline will appear to the parser be on the same line as the initial token after the last unescaped newline. This may technically lead to some false line numbers if errors are given, but escaped newlines are counted so that the next token after an unescaped newline is correct. See #2766
2019-09-29 11:18:36 +08:00
expected: []Token{
{Line: 1, Text: "line1"},
{Line: 1, Text: "escaped1"},
{Line: 1, Text: "escaped2"},
{Line: 4, Text: "line4"},
{Line: 5, Text: "line5"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`"unescapable\ in quotes"`),
caddyfile: Fix lexer behavior with regards to escaped newlines Newlines (\n) can be escaped outside of quoted areas and the newline will be treated as whitespace but not as an actual line break. Escaping newlines inside a quoted area is not necessary, and because quotes trigger literal interpretation of the contents, the escaping backslash will be parsed as a literal backslash, and the newline will not be escaped. Caveat: When a newline is escaped, tokens after it until an unescaped newline will appear to the parser be on the same line as the initial token after the last unescaped newline. This may technically lead to some false line numbers if errors are given, but escaped newlines are counted so that the next token after an unescaped newline is correct. See #2766
2019-09-29 11:18:36 +08:00
expected: []Token{
{Line: 1, Text: `unescapable\ in quotes`},
},
},
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`"don't\escape"`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: `don't\escape`},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`"don't\\escape"`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: `don't\\escape`},
},
},
v2: Make tests work on Windows (#2782) * file_server: Make tests work on Windows * caddyfile: Fix escaping when character is not escapable We only escape certain characters depending on inside or outside of quotes (mainly newlines and quotes). We don't want everyone to have to escape Windows file paths like C:\\Windows\\... but we can't drop the \ either if it's just C:\Windows\...
2019-10-16 06:05:53 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`un\escapable`),
v2: Make tests work on Windows (#2782) * file_server: Make tests work on Windows * caddyfile: Fix escaping when character is not escapable We only escape certain characters depending on inside or outside of quotes (mainly newlines and quotes). We don't want everyone to have to escape Windows file paths like C:\\Windows\\... but we can't drop the \ either if it's just C:\Windows\...
2019-10-16 06:05:53 +08:00
expected: []Token{
{Line: 1, Text: `un\escapable`},
},
},
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`A "quoted value with line
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
break inside" {
foobar
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
}`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "A"},
{Line: 1, Text: "quoted value with line\n\t\t\t\t\tbreak inside"},
{Line: 2, Text: "{"},
{Line: 3, Text: "foobar"},
{Line: 4, Text: "}"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`"C:\php\php-cgi.exe"`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: `C:\php\php-cgi.exe`},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte(`empty "" string`),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: `empty`},
{Line: 1, Text: ``},
{Line: 1, Text: `string`},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("skip those\r\nCR characters"),
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: "skip"},
{Line: 1, Text: "those"},
{Line: 2, Text: "CR"},
{Line: 2, Text: "characters"},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("\xEF\xBB\xBF:8080"), // test with leading byte order mark
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
expected: []Token{
{Line: 1, Text: ":8080"},
},
},
caddyfile: Support backticks as quotes (closes #2591) (#3242)
2020-05-06 02:27:49 +08:00
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("simple `backtick quoted` string"),
caddyfile: Support backticks as quotes (closes #2591) (#3242)
2020-05-06 02:27:49 +08:00
expected: []Token{
{Line: 1, Text: `simple`},
{Line: 1, Text: `backtick quoted`},
{Line: 1, Text: `string`},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("multiline `backtick\nquoted\n` string"),
caddyfile: Support backticks as quotes (closes #2591) (#3242)
2020-05-06 02:27:49 +08:00
expected: []Token{
{Line: 1, Text: `multiline`},
{Line: 1, Text: "backtick\nquoted\n"},
{Line: 3, Text: `string`},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("nested `\"quotes inside\" backticks` string"),
caddyfile: Support backticks as quotes (closes #2591) (#3242)
2020-05-06 02:27:49 +08:00
expected: []Token{
{Line: 1, Text: `nested`},
{Line: 1, Text: `"quotes inside" backticks`},
{Line: 1, Text: `string`},
},
},
{
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
input: []byte("reverse-nested \"`backticks` inside\" quotes"),
caddyfile: Support backticks as quotes (closes #2591) (#3242)
2020-05-06 02:27:49 +08:00
expected: []Token{
{Line: 1, Text: `reverse-nested`},
{Line: 1, Text: "`backticks` inside"},
{Line: 1, Text: `quotes`},
},
},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{
input: []byte(`heredoc <<EOF
content
EOF same-line-arg
`),
expected: []Token{
{Line: 1, Text: `heredoc`},
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
{Line: 1, Text: "content"},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{Line: 3, Text: `same-line-arg`},
},
},
{
input: []byte(`heredoc <<VERY-LONG-MARKER
content
VERY-LONG-MARKER same-line-arg
`),
expected: []Token{
{Line: 1, Text: `heredoc`},
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
{Line: 1, Text: "content"},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{Line: 3, Text: `same-line-arg`},
},
},
{
input: []byte(`heredoc <<EOF
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
extra-newline
EOF same-line-arg
`),
expected: []Token{
{Line: 1, Text: `heredoc`},
{Line: 1, Text: "extra-newline\n"},
{Line: 4, Text: `same-line-arg`},
},
},
{
input: []byte(`heredoc <<EOF
EOF same-line-arg
`),
expected: []Token{
{Line: 1, Text: `heredoc`},
{Line: 1, Text: ""},
{Line: 2, Text: `same-line-arg`},
},
},
{
input: []byte(`heredoc <<EOF
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
content
EOF same-line-arg
`),
expected: []Token{
{Line: 1, Text: `heredoc`},
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
{Line: 1, Text: "content"},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{Line: 3, Text: `same-line-arg`},
},
},
{
input: []byte(`prev-line
heredoc <<EOF
multi
line
content
EOF same-line-arg
next-line
`),
expected: []Token{
{Line: 1, Text: `prev-line`},
{Line: 2, Text: `heredoc`},
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
{Line: 2, Text: "\tmulti\n\tline\n\tcontent"},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{Line: 6, Text: `same-line-arg`},
{Line: 7, Text: `next-line`},
},
},
{
caddyfile: Loosen heredoc parsing (#5761)
2023-08-19 18:32:32 +08:00
input: []byte(`escaped-heredoc \<< >>`),
expected: []Token{
{Line: 1, Text: `escaped-heredoc`},
{Line: 1, Text: `<<`},
{Line: 1, Text: `>>`},
},
},
{
input: []byte(`not-a-heredoc <EOF
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
content
`),
expected: []Token{
caddyfile: Loosen heredoc parsing (#5761)
2023-08-19 18:32:32 +08:00
{Line: 1, Text: `not-a-heredoc`},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{Line: 1, Text: `<EOF`},
{Line: 2, Text: `content`},
caddyfile: Loosen heredoc parsing (#5761)
2023-08-19 18:32:32 +08:00
},
},
{
input: []byte(`not-a-heredoc <<<EOF content`),
expected: []Token{
{Line: 1, Text: `not-a-heredoc`},
{Line: 1, Text: `<<<EOF`},
{Line: 1, Text: `content`},
},
},
{
input: []byte(`not-a-heredoc "<<" ">>"`),
expected: []Token{
{Line: 1, Text: `not-a-heredoc`},
{Line: 1, Text: `<<`},
{Line: 1, Text: `>>`},
},
},
{
input: []byte(`not-a-heredoc << >>`),
expected: []Token{
{Line: 1, Text: `not-a-heredoc`},
{Line: 1, Text: `<<`},
{Line: 1, Text: `>>`},
},
},
{
input: []byte(`not-a-heredoc <<HERE SAME LINE
content
HERE same-line-arg
`),
expected: []Token{
{Line: 1, Text: `not-a-heredoc`},
{Line: 1, Text: `<<HERE`},
{Line: 1, Text: `SAME`},
{Line: 1, Text: `LINE`},
{Line: 2, Text: `content`},
{Line: 3, Text: `HERE`},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{Line: 3, Text: `same-line-arg`},
},
},
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
{
input: []byte(`heredoc <<s
<EFBFBD>
s
`),
expected: []Token{
{Line: 1, Text: `heredoc`},
{Line: 1, Text: "<22>"},
},
},
{
input: []byte("\u000Aheredoc \u003C\u003C\u0073\u0073\u000A\u00BF\u0057\u0001\u0000\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u003D\u001F\u000A\u0073\u0073\u000A\u00BF\u0057\u0001\u0000\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u003D\u001F\u000A\u00BF\u00BF\u0057\u0001\u0000\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u003D\u001F"),
expected: []Token{
{
Line: 2,
Text: "heredoc",
},
{
Line: 2,
Text: "\u00BF\u0057\u0001\u0000\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u003D\u001F",
},
{
Line: 5,
Text: "\u00BF\u0057\u0001\u0000\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u003D\u001F",
},
{
Line: 6,
Text: "\u00BF\u00BF\u0057\u0001\u0000\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u00FF\u003D\u001F",
},
},
},
caddyfile: Fix case where heredoc marker is empty after newline (#5769) Fixes `panic: runtime error: slice bounds out of range [:3] with capacity 2` Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2023-08-24 11:27:57 +08:00
{
input: []byte("not-a-heredoc <<\n"),
expectErr: true,
errorMessage: "missing opening heredoc marker on line #1; must contain only alpha-numeric characters, dashes and underscores; got empty string",
},
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
{
input: []byte(`heredoc <<<EOF
content
EOF same-line-arg
`),
expectErr: true,
errorMessage: "too many '<' for heredoc on line #1; only use two, for example <<END",
},
{
input: []byte(`heredoc <<EOF
content
`),
expectErr: true,
errorMessage: "incomplete heredoc <<EOF on line #3, expected ending marker EOF",
},
{
input: []byte(`heredoc <<EOF
content
EOF
`),
expectErr: true,
errorMessage: "mismatched leading whitespace in heredoc <<EOF on line #2 [\tcontent], expected whitespace [\t\t] to match the closing marker",
},
{
input: []byte(`heredoc <<EOF
content
EOF
`),
expectErr: true,
errorMessage: "mismatched leading whitespace in heredoc <<EOF on line #2 [ content], expected whitespace [\t\t] to match the closing marker",
},
caddyfile: Allow heredoc blank lines (#6051)
2024-01-19 11:57:18 +08:00
{
input: []byte(`heredoc <<EOF
The next line is a blank line
The previous line is a blank line
EOF`),
expected: []Token{
{Line: 1, Text: "heredoc"},
{Line: 1, Text: "The next line is a blank line\n\nThe previous line is a blank line"},
},
},
{
input: []byte(`heredoc <<EOF
One tab indented heredoc with blank next line
One tab indented heredoc with blank previous line
EOF`),
expected: []Token{
{Line: 1, Text: "heredoc"},
{Line: 1, Text: "One tab indented heredoc with blank next line\n\nOne tab indented heredoc with blank previous line"},
},
},
{
input: []byte(`heredoc <<EOF
The next line is a blank line with one tab
The previous line is a blank line with one tab
EOF`),
expected: []Token{
{Line: 1, Text: "heredoc"},
{Line: 1, Text: "The next line is a blank line with one tab\n\t\nThe previous line is a blank line with one tab"},
},
},
{
input: []byte(`heredoc <<EOF
The next line is a blank line with one tab less than the correct indentation
The previous line is a blank line with one tab less than the correct indentation
EOF`),
expectErr: true,
errorMessage: "mismatched leading whitespace in heredoc <<EOF on line #3 [\t], expected whitespace [\t\t] to match the closing marker",
},
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
}
for i, testCase := range testCases {
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
actual, err := Tokenize(testCase.input, "")
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
if testCase.expectErr {
if err == nil {
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
t.Fatalf("expected error, got actual: %v", actual)
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
continue
}
if err.Error() != testCase.errorMessage {
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
t.Fatalf("expected error '%v', got: %v", testCase.errorMessage, err)
caddyfile: Implement heredoc support (#5385)
2023-02-26 08:34:27 +08:00
}
continue
}
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
if err != nil {
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
t.Fatalf("%v", err)
caddyfile: Export Tokenize function for lexing (#3549)
2020-07-21 03:55:51 +08:00
}
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
lexerCompare(t, i, testCase.expected, actual)
}
}
func lexerCompare(t *testing.T, n int, expected, actual []Token) {
if len(expected) != len(actual) {
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
t.Fatalf("Test case %d: expected %d token(s) but got %d", n, len(expected), len(actual))
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
}
for i := 0; i < len(actual) && i < len(expected); i++ {
if actual[i].Line != expected[i].Line {
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
t.Fatalf("Test case %d token %d ('%s'): expected line %d but was line %d",
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
n, i, expected[i].Text, expected[i].Line, actual[i].Line)
break
}
if actual[i].Text != expected[i].Text {
caddyfile: Fix heredoc fuzz crasher, drop trailing newline (#5404) Co-authored-by: Mohammed Al Sahaf <msaa1990@gmail.com>
2023-02-27 05:56:48 +08:00
t.Fatalf("Test case %d token %d: expected text '%s' but was '%s'",
Implement config adapters and beginning of Caddyfile adapter Along with several other changes, such as renaming caddyhttp.ServerRoute to caddyhttp.Route, exporting some types that were not exported before, and tweaking the caddytls TLS values to be more consistent. Notably, we also now disable automatic cert management for names which already have a cert (manually) loaded into the cache. These names no longer need to be specified in the "skip_certificates" field of the automatic HTTPS config, because they will be skipped automatically.
2019-08-10 02:05:47 +08:00
n, i, expected[i].Text, actual[i].Text)
break
}
}
}
Reference in New Issue Copy Permalink