github.com/x-oss-byte/git-lfs@v2.5.2+incompatible/git/gitattr/tree_test.go (about)

     1  package gitattr
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"testing"
     7  
     8  	"github.com/git-lfs/gitobj"
     9  	"github.com/git-lfs/wildmatch"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  var (
    15  	dat = wildmatch.NewWildmatch("*.dat",
    16  		wildmatch.Basename,
    17  		wildmatch.SystemCase)
    18  
    19  	example = &Tree{
    20  		Lines: []*Line{{
    21  			Pattern: dat,
    22  			Attrs: []*Attr{
    23  				{
    24  					K: "filter", V: "lfs",
    25  				},
    26  				{
    27  					K: "diff", V: "lfs",
    28  				},
    29  				{
    30  					K: "merge", V: "lfs",
    31  				},
    32  				{
    33  					K: "text", V: "false",
    34  				},
    35  			},
    36  		}},
    37  		Children: map[string]*Tree{
    38  			"subdir": &Tree{
    39  				Lines: []*Line{{
    40  					Pattern: dat,
    41  					Attrs: []*Attr{
    42  						{
    43  							K: "subdir", V: "yes",
    44  						},
    45  					},
    46  				}},
    47  			},
    48  		},
    49  	}
    50  )
    51  
    52  func TestTreeAppliedInRoot(t *testing.T) {
    53  	attrs := example.Applied("a.dat")
    54  
    55  	assert.Len(t, attrs, 4)
    56  	assert.Equal(t, attrs[0], &Attr{K: "filter", V: "lfs"})
    57  	assert.Equal(t, attrs[1], &Attr{K: "diff", V: "lfs"})
    58  	assert.Equal(t, attrs[2], &Attr{K: "merge", V: "lfs"})
    59  	assert.Equal(t, attrs[3], &Attr{K: "text", V: "false"})
    60  }
    61  
    62  func TestTreeAppliedInSubtreeRelevant(t *testing.T) {
    63  	attrs := example.Applied("subdir/a.dat")
    64  
    65  	assert.Len(t, attrs, 5)
    66  	assert.Equal(t, attrs[0], &Attr{K: "filter", V: "lfs"})
    67  	assert.Equal(t, attrs[1], &Attr{K: "diff", V: "lfs"})
    68  	assert.Equal(t, attrs[2], &Attr{K: "merge", V: "lfs"})
    69  	assert.Equal(t, attrs[3], &Attr{K: "text", V: "false"})
    70  	assert.Equal(t, attrs[4], &Attr{K: "subdir", V: "yes"})
    71  }
    72  
    73  func TestTreeAppliedInSubtreeIrrelevant(t *testing.T) {
    74  	attrs := example.Applied("subdir/a.txt")
    75  
    76  	assert.Empty(t, attrs)
    77  }
    78  
    79  func TestTreeAppliedInIrrelevantSubtree(t *testing.T) {
    80  	attrs := example.Applied("other/subdir/a.dat")
    81  
    82  	assert.Len(t, attrs, 4)
    83  	assert.Equal(t, attrs[0], &Attr{K: "filter", V: "lfs"})
    84  	assert.Equal(t, attrs[1], &Attr{K: "diff", V: "lfs"})
    85  	assert.Equal(t, attrs[2], &Attr{K: "merge", V: "lfs"})
    86  	assert.Equal(t, attrs[3], &Attr{K: "text", V: "false"})
    87  }
    88  
    89  func TestNewDiscoversSimpleTrees(t *testing.T) {
    90  	tmp, err := ioutil.TempDir("", "")
    91  	require.NoError(t, err)
    92  	defer os.Remove(tmp)
    93  
    94  	db, err := gitobj.FromFilesystem(tmp, "")
    95  	require.NoError(t, err)
    96  	defer db.Close()
    97  
    98  	blob, err := db.WriteBlob(gitobj.NewBlobFromBytes([]byte(`
    99  		*.dat filter=lfs diff=lfs merge=lfs -text
   100  	`)))
   101  	require.NoError(t, err)
   102  
   103  	tree, err := New(db, &gitobj.Tree{Entries: []*gitobj.TreeEntry{
   104  		{
   105  			Name:     ".gitattributes",
   106  			Oid:      blob,
   107  			Filemode: 0100644,
   108  		},
   109  	}})
   110  	require.NoError(t, err)
   111  
   112  	attrs := tree.Applied("foo.dat")
   113  
   114  	assert.Len(t, attrs, 4)
   115  	assert.Equal(t, attrs[0], &Attr{K: "filter", V: "lfs"})
   116  	assert.Equal(t, attrs[1], &Attr{K: "diff", V: "lfs"})
   117  	assert.Equal(t, attrs[2], &Attr{K: "merge", V: "lfs"})
   118  	assert.Equal(t, attrs[3], &Attr{K: "text", V: "false"})
   119  }
   120  
   121  func TestNewDiscoversSimpleChildrenTrees(t *testing.T) {
   122  	tmp, err := ioutil.TempDir("", "")
   123  	require.NoError(t, err)
   124  	defer os.Remove(tmp)
   125  
   126  	db, err := gitobj.FromFilesystem(tmp, "")
   127  	require.NoError(t, err)
   128  	defer db.Close()
   129  
   130  	blob, err := db.WriteBlob(gitobj.NewBlobFromBytes([]byte(`
   131  		*.dat filter=lfs diff=lfs merge=lfs -text
   132  	`)))
   133  	require.NoError(t, err)
   134  
   135  	child, err := db.WriteTree(&gitobj.Tree{Entries: []*gitobj.TreeEntry{
   136  		{
   137  			Name:     ".gitattributes",
   138  			Oid:      blob,
   139  			Filemode: 0100644,
   140  		},
   141  	}})
   142  
   143  	tree, err := New(db, &gitobj.Tree{Entries: []*gitobj.TreeEntry{
   144  		{
   145  			Name:     "child",
   146  			Oid:      child,
   147  			Filemode: 040000,
   148  		},
   149  	}})
   150  	require.NoError(t, err)
   151  	assert.Empty(t, tree.Lines)
   152  	assert.Len(t, tree.Children, 1)
   153  
   154  	attrs := tree.Applied("child/foo.dat")
   155  
   156  	assert.Len(t, attrs, 4)
   157  	assert.Equal(t, attrs[0], &Attr{K: "filter", V: "lfs"})
   158  	assert.Equal(t, attrs[1], &Attr{K: "diff", V: "lfs"})
   159  	assert.Equal(t, attrs[2], &Attr{K: "merge", V: "lfs"})
   160  	assert.Equal(t, attrs[3], &Attr{K: "text", V: "false"})
   161  }
   162  
   163  func TestNewDiscoversIndirectChildrenTrees(t *testing.T) {
   164  	tmp, err := ioutil.TempDir("", "")
   165  	require.NoError(t, err)
   166  	defer os.Remove(tmp)
   167  
   168  	db, err := gitobj.FromFilesystem(tmp, "")
   169  	require.NoError(t, err)
   170  	defer db.Close()
   171  
   172  	blob, err := db.WriteBlob(gitobj.NewBlobFromBytes([]byte(`
   173  		*.dat filter=lfs diff=lfs merge=lfs -text
   174  	`)))
   175  	require.NoError(t, err)
   176  
   177  	indirect, err := db.WriteTree(&gitobj.Tree{Entries: []*gitobj.TreeEntry{
   178  		{
   179  			Name:     ".gitattributes",
   180  			Oid:      blob,
   181  			Filemode: 0100644,
   182  		},
   183  	}})
   184  
   185  	child, err := db.WriteTree(&gitobj.Tree{Entries: []*gitobj.TreeEntry{
   186  		{
   187  			Name:     "indirect",
   188  			Oid:      indirect,
   189  			Filemode: 040000,
   190  		},
   191  	}})
   192  
   193  	tree, err := New(db, &gitobj.Tree{Entries: []*gitobj.TreeEntry{
   194  		{
   195  			Name:     "child",
   196  			Oid:      child,
   197  			Filemode: 040000,
   198  		},
   199  	}})
   200  	require.NoError(t, err)
   201  	assert.Empty(t, tree.Lines)
   202  	assert.Len(t, tree.Children, 1)
   203  
   204  	attrs := tree.Applied("child/indirect/foo.dat")
   205  
   206  	assert.Len(t, attrs, 4)
   207  	assert.Equal(t, attrs[0], &Attr{K: "filter", V: "lfs"})
   208  	assert.Equal(t, attrs[1], &Attr{K: "diff", V: "lfs"})
   209  	assert.Equal(t, attrs[2], &Attr{K: "merge", V: "lfs"})
   210  	assert.Equal(t, attrs[3], &Attr{K: "text", V: "false"})
   211  }
   212  
   213  func TestNewIgnoresChildrenAppropriately(t *testing.T) {
   214  	tmp, err := ioutil.TempDir("", "")
   215  	require.NoError(t, err)
   216  	defer os.Remove(tmp)
   217  
   218  	db, err := gitobj.FromFilesystem(tmp, "")
   219  	require.NoError(t, err)
   220  	defer db.Close()
   221  
   222  	blob, err := db.WriteBlob(gitobj.NewBlobFromBytes([]byte(`
   223  		*.dat filter=lfs diff=lfs merge=lfs -text
   224  	`)))
   225  	require.NoError(t, err)
   226  
   227  	child, err := db.WriteTree(&gitobj.Tree{Entries: []*gitobj.TreeEntry{
   228  		{
   229  			Name:     "README.md",
   230  			Oid:      []byte("00000000000000000000"),
   231  			Filemode: 0100644,
   232  		},
   233  	}})
   234  
   235  	tree, err := New(db, &gitobj.Tree{Entries: []*gitobj.TreeEntry{
   236  		{
   237  			Name:     ".gitattributes",
   238  			Oid:      blob,
   239  			Filemode: 0100644,
   240  		},
   241  		{
   242  			Name:     "child",
   243  			Oid:      child,
   244  			Filemode: 040000,
   245  		},
   246  	}})
   247  	require.NoError(t, err)
   248  
   249  	assert.NotContains(t, tree.Children, "child")
   250  }