github.com/kata-containers/tests@v0.0.0-20240307153542-772105b56064/cmd/check-markdown/add_test.go (about)

     1  //
     2  // Copyright (c) 2019 Intel Corporation
     3  //
     4  // SPDX-License-Identifier: Apache-2.0
     5  //
     6  
     7  package main
     8  
     9  import (
    10  	"fmt"
    11  	"os"
    12  	"path/filepath"
    13  	"testing"
    14  
    15  	"github.com/sirupsen/logrus"
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  const (
    20  	testFileMode = os.FileMode(0640)
    21  	testDirMode  = os.FileMode(0750)
    22  	readmeName   = "README.md"
    23  )
    24  
    25  func createFile(file, contents string) error {
    26  	return os.WriteFile(file, []byte(contents), testFileMode)
    27  }
    28  
    29  // makeDirs creates two directories below the specified base directory: one is
    30  // an empty director named emptyDirName and the other is named readmeDirName
    31  // and contains a markdown file called "README.md".
    32  func makeDirs(assert *assert.Assertions, baseDir string, readmeDirName, emptyDirName string) {
    33  	readmeDir := filepath.Join(baseDir, readmeDirName)
    34  	err := os.MkdirAll(readmeDir, testDirMode)
    35  	assert.NoError(err)
    36  
    37  	readme := filepath.Join(readmeDir, "README.md")
    38  
    39  	err = createFile(readme, "# hello")
    40  	assert.NoError(err)
    41  
    42  	emptyDir := filepath.Join(baseDir, emptyDirName)
    43  	err = os.MkdirAll(emptyDir, testDirMode)
    44  	assert.NoError(err)
    45  }
    46  
    47  func TestDocAddHeading(t *testing.T) {
    48  	assert := assert.New(t)
    49  
    50  	type testData struct {
    51  		heading     Heading
    52  		expectError bool
    53  	}
    54  
    55  	data := []testData{
    56  		{Heading{"", "", "", -1}, true},
    57  		{Heading{"Foo", "", "", -1}, true},
    58  		{Heading{"Foo", "", "", 0}, true},
    59  		{Heading{"Foo", "", "", 1}, true},
    60  		{Heading{"Foo", "", "foo", -1}, true},
    61  		{Heading{"Foo", "", "foo", 0}, true},
    62  
    63  		{Heading{"Foo", "", "foo", 1}, false},
    64  		{Heading{"`Foo`", "`Foo`", "foo", 1}, false},
    65  	}
    66  
    67  	logger := logrus.WithField("test", "true")
    68  
    69  	for i, d := range data {
    70  		doc := newDoc("foo", logger)
    71  
    72  		assert.Empty(doc.Headings)
    73  
    74  		msg := fmt.Sprintf("test[%d]: %+v\n", i, d)
    75  
    76  		err := doc.addHeading(d.heading)
    77  		if d.expectError {
    78  			assert.Error(err, msg)
    79  			continue
    80  		}
    81  
    82  		assert.NoError(err, msg)
    83  		assert.NotEmpty(doc.Headings, msg)
    84  
    85  		name := d.heading.Name
    86  
    87  		result, ok := doc.Headings[name]
    88  		assert.True(ok, msg)
    89  
    90  		assert.Equal(d.heading, result, msg)
    91  	}
    92  }
    93  
    94  func TestDocAddLink(t *testing.T) {
    95  	assert := assert.New(t)
    96  
    97  	type testData struct {
    98  		link        Link
    99  		expectError bool
   100  	}
   101  
   102  	data := []testData{
   103  		{Link{nil, "", "", "", -1}, true},
   104  		{Link{nil, "foo", "", "", unknownLink}, true},
   105  
   106  		{Link{nil, "foo", "", "", internalLink}, false},
   107  		{Link{nil, "http://google.com", "", "", urlLink}, false},
   108  		{Link{nil, "https://google.com", "", "", urlLink}, false},
   109  		{Link{nil, "mailto:me@somewhere.com", "", "", mailLink}, false},
   110  	}
   111  
   112  	logger := logrus.WithField("test", "true")
   113  
   114  	for i, d := range data {
   115  		doc := newDoc("foo", logger)
   116  
   117  		assert.Empty(doc.Links)
   118  
   119  		msg := fmt.Sprintf("test[%d]: %+v\n", i, d)
   120  
   121  		err := doc.addLink(d.link)
   122  		if d.expectError {
   123  			assert.Error(err, msg)
   124  			continue
   125  		}
   126  
   127  		assert.NoError(err, msg)
   128  		assert.NotEmpty(doc.Links, msg)
   129  		addr := d.link.Address
   130  
   131  		result := doc.Links[addr][0]
   132  		assert.Equal(result, d.link)
   133  	}
   134  }
   135  
   136  func TestDocLinkAddrToPath(t *testing.T) {
   137  	assert := assert.New(t)
   138  
   139  	dir, err := os.MkdirTemp("", "")
   140  	assert.NoError(err)
   141  
   142  	cwd, err := os.Getwd()
   143  	assert.NoError(err)
   144  	defer os.Chdir(cwd)
   145  
   146  	err = os.Chdir(dir)
   147  	assert.NoError(err)
   148  	defer os.RemoveAll(dir)
   149  
   150  	savedDocRoot := docRoot
   151  	docRoot = dir
   152  
   153  	defer func() {
   154  		docRoot = savedDocRoot
   155  
   156  	}()
   157  
   158  	mdFile := "bar.md"
   159  	mdPath := filepath.Join("/", mdFile)
   160  	actualMDPath := filepath.Join(dir, mdFile)
   161  
   162  	type testData struct {
   163  		linkAddr     string
   164  		expectedPath string
   165  		expectError  bool
   166  	}
   167  
   168  	data := []testData{
   169  		{"", "", true},
   170  		{"bar", "bar", false},
   171  		{"bar.md", "bar.md", false},
   172  		{mdPath, actualMDPath, false},
   173  	}
   174  
   175  	logger := logrus.WithField("test", "true")
   176  	doc := newDoc("foo", logger)
   177  
   178  	for i, d := range data {
   179  		msg := fmt.Sprintf("test[%d]: %+v\n", i, d)
   180  
   181  		result, err := doc.linkAddrToPath(d.linkAddr)
   182  
   183  		if d.expectError {
   184  			assert.Error(err, msg)
   185  			continue
   186  		}
   187  
   188  		assert.NoError(err, msg)
   189  		assert.Equal(d.expectedPath, result)
   190  	}
   191  }