github.com/jiasir/docker@v1.3.3-0.20170609024000-252e610103e7/builder/dockerfile/parser/parser_test.go (about)

     1  package parser
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"os"
     8  	"path/filepath"
     9  	"runtime"
    10  	"testing"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  const testDir = "testfiles"
    17  const negativeTestDir = "testfiles-negative"
    18  const testFileLineInfo = "testfile-line/Dockerfile"
    19  
    20  func getDirs(t *testing.T, dir string) []string {
    21  	f, err := os.Open(dir)
    22  	require.NoError(t, err)
    23  	defer f.Close()
    24  
    25  	dirs, err := f.Readdirnames(0)
    26  	require.NoError(t, err)
    27  	return dirs
    28  }
    29  
    30  func TestTestNegative(t *testing.T) {
    31  	for _, dir := range getDirs(t, negativeTestDir) {
    32  		dockerfile := filepath.Join(negativeTestDir, dir, "Dockerfile")
    33  
    34  		df, err := os.Open(dockerfile)
    35  		require.NoError(t, err)
    36  		defer df.Close()
    37  
    38  		_, err = Parse(df)
    39  		assert.Error(t, err)
    40  	}
    41  }
    42  
    43  func TestTestData(t *testing.T) {
    44  	for _, dir := range getDirs(t, testDir) {
    45  		dockerfile := filepath.Join(testDir, dir, "Dockerfile")
    46  		resultfile := filepath.Join(testDir, dir, "result")
    47  
    48  		df, err := os.Open(dockerfile)
    49  		require.NoError(t, err)
    50  		defer df.Close()
    51  
    52  		result, err := Parse(df)
    53  		require.NoError(t, err)
    54  
    55  		content, err := ioutil.ReadFile(resultfile)
    56  		require.NoError(t, err)
    57  
    58  		if runtime.GOOS == "windows" {
    59  			// CRLF --> CR to match Unix behavior
    60  			content = bytes.Replace(content, []byte{'\x0d', '\x0a'}, []byte{'\x0a'}, -1)
    61  		}
    62  
    63  		assert.Contains(t, result.AST.Dump()+"\n", string(content), "In "+dockerfile)
    64  	}
    65  }
    66  
    67  func TestParseWords(t *testing.T) {
    68  	tests := []map[string][]string{
    69  		{
    70  			"input":  {"foo"},
    71  			"expect": {"foo"},
    72  		},
    73  		{
    74  			"input":  {"foo bar"},
    75  			"expect": {"foo", "bar"},
    76  		},
    77  		{
    78  			"input":  {"foo\\ bar"},
    79  			"expect": {"foo\\ bar"},
    80  		},
    81  		{
    82  			"input":  {"foo=bar"},
    83  			"expect": {"foo=bar"},
    84  		},
    85  		{
    86  			"input":  {"foo bar 'abc xyz'"},
    87  			"expect": {"foo", "bar", "'abc xyz'"},
    88  		},
    89  		{
    90  			"input":  {`foo bar "abc xyz"`},
    91  			"expect": {"foo", "bar", `"abc xyz"`},
    92  		},
    93  		{
    94  			"input":  {"àöû"},
    95  			"expect": {"àöû"},
    96  		},
    97  		{
    98  			"input":  {`föo bàr "âbc xÿz"`},
    99  			"expect": {"föo", "bàr", `"âbc xÿz"`},
   100  		},
   101  	}
   102  
   103  	for _, test := range tests {
   104  		words := parseWords(test["input"][0], NewDefaultDirective())
   105  		assert.Equal(t, test["expect"], words)
   106  	}
   107  }
   108  
   109  func TestLineInformation(t *testing.T) {
   110  	df, err := os.Open(testFileLineInfo)
   111  	require.NoError(t, err)
   112  	defer df.Close()
   113  
   114  	result, err := Parse(df)
   115  	require.NoError(t, err)
   116  
   117  	ast := result.AST
   118  	if ast.StartLine != 5 || ast.endLine != 31 {
   119  		fmt.Fprintf(os.Stderr, "Wrong root line information: expected(%d-%d), actual(%d-%d)\n", 5, 31, ast.StartLine, ast.endLine)
   120  		t.Fatal("Root line information doesn't match result.")
   121  	}
   122  	assert.Len(t, ast.Children, 3)
   123  	expected := [][]int{
   124  		{5, 5},
   125  		{11, 12},
   126  		{17, 31},
   127  	}
   128  	for i, child := range ast.Children {
   129  		if child.StartLine != expected[i][0] || child.endLine != expected[i][1] {
   130  			t.Logf("Wrong line information for child %d: expected(%d-%d), actual(%d-%d)\n",
   131  				i, expected[i][0], expected[i][1], child.StartLine, child.endLine)
   132  			t.Fatal("Root line information doesn't match result.")
   133  		}
   134  	}
   135  }