1
Fork 0
mirror of https://github.com/caddyserver/caddy.git synced 2024-12-16 21:56:40 -05:00
caddy/caddyconfig/caddyfile/formatter_test.go
Vaibhav f192ae5ea5
cmd: fmt: Fix brace opening block indentation (#3153)
This fixes indentation for blocks starting with
a brace as:
```Caddyfile
{
    ...
}
```

Fixes #3144

Signed-off-by: Vaibhav <vrongmeal@gmail.com>
2020-03-17 09:55:36 -06:00

228 lines
2 KiB
Go

// Copyright 2015 Matthew Holt and The Caddy Authors
//
// 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 TestFormatBasicIndentation(t *testing.T) {
input := []byte(`
a
b
c {
d
}
e { f
}
g {
h {
i
}
}
j { k {
l
}
}
m {
n { o
}
}
{
p
}
{ q
}
{
{ r
}
}
`)
expected := []byte(`
a
b
c {
d
}
e {
f
}
g {
h {
i
}
}
j {
k {
l
}
}
m {
n {
o
}
}
{
p
}
{
q
}
{
{
r
}
}
`)
testFormat(t, input, expected)
}
func TestFormatBasicSpacing(t *testing.T) {
input := []byte(`
a{
b
}
c{ d
}
`)
expected := []byte(`
a {
b
}
c {
d
}
`)
testFormat(t, input, expected)
}
func TestFormatEnvironmentVariable(t *testing.T) {
input := []byte(`
{$A}
b {
{$C}
}
d { {$E}
}
{ {$F}
}
`)
expected := []byte(`
{$A}
b {
{$C}
}
d {
{$E}
}
{
{$F}
}
`)
testFormat(t, input, expected)
}
func TestFormatComments(t *testing.T) {
input := []byte(`
# a "\n"
# b {
c
}
d {
e # f
# g
}
h { # i
}
`)
expected := []byte(`
# a "\n"
# b {
c
}
d {
e # f
# g
}
h {
# i
}
`)
testFormat(t, input, expected)
}
func TestFormatQuotesAndEscapes(t *testing.T) {
input := []byte(`
"a \"b\" #c
d
e {
"f"
}
g { "h"
}
`)
expected := []byte(`
"a \"b\" #c
d
e {
"f"
}
g {
"h"
}
`)
testFormat(t, input, expected)
}
func testFormat(t *testing.T, input, expected []byte) {
output := Format(input)
if string(output) != string(expected) {
t.Errorf("Expected:\n%s\ngot:\n%s", string(expected), string(output))
}
}