github.com/ndau/noms@v1.0.5/go/spec/absolute_path_test.go (about)

     1  // Copyright 2016 Attic Labs, Inc. All rights reserved.
     2  // Licensed under the Apache License, version 2.0:
     3  // http://www.apache.org/licenses/LICENSE-2.0
     4  
     5  package spec
     6  
     7  import (
     8  	"fmt"
     9  	"strings"
    10  	"testing"
    11  
    12  	"github.com/ndau/noms/go/chunks"
    13  	"github.com/ndau/noms/go/datas"
    14  	"github.com/ndau/noms/go/hash"
    15  	"github.com/ndau/noms/go/types"
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  func TestAbsolutePathToAndFromString(t *testing.T) {
    20  	assert := assert.New(t)
    21  
    22  	test := func(str string) {
    23  		p, err := NewAbsolutePath(str)
    24  		assert.NoError(err)
    25  		assert.Equal(str, p.String())
    26  	}
    27  
    28  	h := types.Number(42).Hash() // arbitrary hash
    29  	test(fmt.Sprintf("foo.bar[#%s]", h.String()))
    30  	test(fmt.Sprintf("#%s.bar[42]", h.String()))
    31  }
    32  
    33  func TestAbsolutePaths(t *testing.T) {
    34  	assert := assert.New(t)
    35  	storage := &chunks.MemoryStorage{}
    36  	db := datas.NewDatabase(storage.NewView())
    37  
    38  	s0, s1 := types.String("foo"), types.String("bar")
    39  	list := types.NewList(db, s0, s1)
    40  	emptySet := types.NewSet(db)
    41  
    42  	db.WriteValue(s0)
    43  	db.WriteValue(s1)
    44  	db.WriteValue(list)
    45  	db.WriteValue(emptySet)
    46  
    47  	var err error
    48  	ds := db.GetDataset("ds")
    49  	ds, err = db.CommitValue(ds, list)
    50  	assert.NoError(err)
    51  	head := ds.Head()
    52  
    53  	resolvesTo := func(exp types.Value, str string) {
    54  		p, err := NewAbsolutePath(str)
    55  		assert.NoError(err)
    56  		act := p.Resolve(db)
    57  		if exp == nil {
    58  			assert.Nil(act)
    59  		} else {
    60  			assert.True(exp.Equals(act), "%s Expected %s Actual %s", str, types.EncodedValue(exp), types.EncodedValue(act))
    61  		}
    62  	}
    63  
    64  	resolvesTo(head, "ds")
    65  	resolvesTo(emptySet, "ds.parents")
    66  	resolvesTo(list, "ds.value")
    67  	resolvesTo(s0, "ds.value[0]")
    68  	resolvesTo(s1, "ds.value[1]")
    69  	resolvesTo(head, "#"+head.Hash().String())
    70  	resolvesTo(list, "#"+list.Hash().String())
    71  	resolvesTo(s0, "#"+s0.Hash().String())
    72  	resolvesTo(s1, "#"+s1.Hash().String())
    73  	resolvesTo(s0, "#"+list.Hash().String()+"[0]")
    74  	resolvesTo(s1, "#"+list.Hash().String()+"[1]")
    75  
    76  	resolvesTo(nil, "foo")
    77  	resolvesTo(nil, "foo.parents")
    78  	resolvesTo(nil, "foo.value")
    79  	resolvesTo(nil, "foo.value[0]")
    80  	resolvesTo(nil, "#"+types.String("baz").Hash().String())
    81  	resolvesTo(nil, "#"+types.String("baz").Hash().String()+"[0]")
    82  }
    83  
    84  func TestReadAbsolutePaths(t *testing.T) {
    85  	assert := assert.New(t)
    86  	storage := &chunks.MemoryStorage{}
    87  	db := datas.NewDatabase(storage.NewView())
    88  
    89  	s0, s1 := types.String("foo"), types.String("bar")
    90  	list := types.NewList(db, s0, s1)
    91  
    92  	ds := db.GetDataset("ds")
    93  	_, err := db.CommitValue(ds, list)
    94  	assert.NoError(err)
    95  
    96  	vals, err := ReadAbsolutePaths(db, "ds.value[0]", "ds.value[1]")
    97  	assert.NoError(err)
    98  
    99  	assert.Equal(2, len(vals))
   100  	assert.Equal("foo", string(vals[0].(types.String)))
   101  	assert.Equal("bar", string(vals[1].(types.String)))
   102  
   103  	vals, err = ReadAbsolutePaths(db, "!!#")
   104  	assert.Nil(vals)
   105  	assert.Equal("Invalid input path '!!#'", err.Error())
   106  
   107  	vals, err = ReadAbsolutePaths(db, "invalid.monkey")
   108  	assert.Nil(vals)
   109  	assert.Equal("Input path 'invalid.monkey' does not exist in database", err.Error())
   110  }
   111  
   112  func TestAbsolutePathParseErrors(t *testing.T) {
   113  	assert := assert.New(t)
   114  
   115  	test := func(path, errMsg string) {
   116  		p, err := NewAbsolutePath(path)
   117  		assert.Equal(AbsolutePath{}, p)
   118  		assert.Error(err)
   119  		assert.Equal(errMsg, err.Error())
   120  	}
   121  
   122  	test("", "Empty path")
   123  	test(".foo", "Invalid dataset name: .foo")
   124  	test(".foo.bar.baz", "Invalid dataset name: .foo.bar.baz")
   125  	test("#", "Invalid hash: ")
   126  	test("#abc", "Invalid hash: abc")
   127  	invHash := strings.Repeat("z", hash.StringLen)
   128  	test("#"+invHash, "Invalid hash: "+invHash)
   129  }