filejsonstore_test.go

Documentation: github.com/theupdateframework/go-tuf/client/filejsonstore

     1  package client
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"os"
     7  	"path/filepath"
     8  	"strings"
     9  	"testing"
    10  
    11  	"gopkg.in/check.v1"
    12  )
    13  
    14  type FileJSONStoreSuite struct{}
    15  
    16  var _ = check.Suite(&FileJSONStoreSuite{})
    17  
    18  // Hook up gocheck into the "go test" runner
    19  func Test(t *testing.T) { check.TestingT(t) }
    20  
    21  func (FileJSONStoreSuite) TestNewOk(c *check.C) {
    22  	tmp := c.MkDir()
    23  	p := filepath.Join(tmp, "tuf_raw.db")
    24  
    25  	// Assert path does not exist
    26  	fi, err := os.Stat(p)
    27  	c.Assert(fi, check.IsNil)
    28  	c.Assert(errors.Is(err, os.ErrNotExist), check.Equals, true)
    29  
    30  	// Create implementation
    31  	s, err := NewFileJSONStore(p)
    32  	c.Assert(err, check.IsNil)
    33  	c.Assert(s, check.NotNil)
    34  
    35  	// Assert path does exist and is a directory
    36  	fi, err = os.Stat(p)
    37  	c.Assert(fi, check.NotNil)
    38  	c.Assert(err, check.IsNil)
    39  	c.Assert(fi.IsDir(), check.Equals, true)
    40  }
    41  
    42  func (FileJSONStoreSuite) TestNewFileExists(c *check.C) {
    43  	tmp := c.MkDir()
    44  	p := filepath.Join(tmp, "tuf_raw.db")
    45  
    46  	// Create an empty file
    47  	f, err := os.Create(p)
    48  	c.Assert(err, check.IsNil)
    49  	f.Close()
    50  
    51  	// Create implementation
    52  	s, err := NewFileJSONStore(p)
    53  	c.Assert(s, check.IsNil)
    54  	c.Assert(err, check.NotNil)
    55  	found := strings.Contains(err.Error(), ", not a directory")
    56  	c.Assert(found, check.Equals, true)
    57  }
    58  
    59  func (FileJSONStoreSuite) TestNewDirectoryExists(c *check.C) {
    60  	tmp := c.MkDir()
    61  	p := filepath.Join(tmp, "tuf_raw.db")
    62  
    63  	err := os.Mkdir(p, 0750)
    64  	c.Assert(err, check.IsNil)
    65  
    66  	// Create implementation
    67  	s, err := NewFileJSONStore(p)
    68  	c.Assert(s, check.NotNil)
    69  	c.Assert(err, check.IsNil)
    70  }
    71  
    72  func (FileJSONStoreSuite) TestGetMetaEmpty(c *check.C) {
    73  	tmp := c.MkDir()
    74  	p := filepath.Join(tmp, "tuf_raw.db")
    75  	s, err := NewFileJSONStore(p)
    76  	c.Assert(err, check.IsNil)
    77  
    78  	md, err := s.GetMeta()
    79  	c.Assert(err, check.IsNil)
    80  	c.Assert(md, check.HasLen, 0)
    81  }
    82  
    83  func (FileJSONStoreSuite) TestGetNoDirectory(c *check.C) {
    84  	tmp := c.MkDir()
    85  	p := filepath.Join(tmp, "tuf_raw.db")
    86  	s, err := NewFileJSONStore(p)
    87  	c.Assert(err, check.IsNil)
    88  
    89  	err = os.Remove(p)
    90  	c.Assert(err, check.IsNil)
    91  
    92  	md, err := s.GetMeta()
    93  	c.Assert(md, check.IsNil)
    94  	c.Assert(err, check.NotNil)
    95  }
    96  
    97  func (FileJSONStoreSuite) TestMetadataOperations(c *check.C) {
    98  	tmp := c.MkDir()
    99  	p := filepath.Join(tmp, "tuf_raw.db")
   100  	s, err := NewFileJSONStore(p)
   101  	c.Assert(err, check.IsNil)
   102  
   103  	expected := map[string]json.RawMessage{
   104  		"file1.json": []byte{0xf1, 0xe1, 0xd1},
   105  		"file2.json": []byte{0xf2, 0xe2, 0xd2},
   106  		"file3.json": []byte{0xf3, 0xe3, 0xd3},
   107  	}
   108  
   109  	for k, v := range expected {
   110  		err := s.SetMeta(k, v)
   111  		c.Assert(err, check.IsNil)
   112  	}
   113  
   114  	md, err := s.GetMeta()
   115  	c.Assert(err, check.IsNil)
   116  	c.Assert(md, check.HasLen, 3)
   117  	c.Assert(md, check.DeepEquals, expected)
   118  
   119  	// Delete all items
   120  	count := 3
   121  	for k := range expected {
   122  		err = s.DeleteMeta(k)
   123  		c.Assert(err, check.IsNil)
   124  
   125  		md, err := s.GetMeta()
   126  		c.Assert(err, check.IsNil)
   127  
   128  		count--
   129  		c.Assert(md, check.HasLen, count)
   130  	}
   131  
   132  	md, err = s.GetMeta()
   133  	c.Assert(err, check.IsNil)
   134  	c.Assert(md, check.HasLen, 0)
   135  }
   136  
   137  func (FileJSONStoreSuite) TestGetNoJSON(c *check.C) {
   138  	tmp := c.MkDir()
   139  	p := filepath.Join(tmp, "tuf_raw.db")
   140  	s, err := NewFileJSONStore(p)
   141  	c.Assert(s, check.NotNil)
   142  	c.Assert(err, check.IsNil)
   143  
   144  	// Create a file which does not end with '.json'
   145  	fp := filepath.Join(p, "meta.xml")
   146  	err = os.WriteFile(fp, []byte{}, 0644)
   147  	c.Assert(err, check.IsNil)
   148  
   149  	md, err := s.GetMeta()
   150  	c.Assert(err, check.IsNil)
   151  	c.Assert(md, check.HasLen, 0)
   152  }
   153  
   154  func (FileJSONStoreSuite) TestNoJSON(c *check.C) {
   155  	tmp := c.MkDir()
   156  	p := filepath.Join(tmp, "tuf_raw.db")
   157  	s, err := NewFileJSONStore(p)
   158  	c.Assert(s, check.NotNil)
   159  	c.Assert(err, check.IsNil)
   160  
   161  	files := []string{
   162  		"file.xml",
   163  		"file",
   164  		"",
   165  	}
   166  	for _, f := range files {
   167  		err := s.SetMeta(f, []byte{})
   168  		c.Assert(err, check.ErrorMatches, "file.*is not a JSON file")
   169  	}
   170  }
   171  
   172  func (FileJSONStoreSuite) TestClose(c *check.C) {
   173  	tmp := c.MkDir()
   174  	p := filepath.Join(tmp, "tuf_raw.db")
   175  	s, err := NewFileJSONStore(p)
   176  	c.Assert(s, check.NotNil)
   177  	c.Assert(err, check.IsNil)
   178  
   179  	err = s.Close()
   180  	c.Assert(err, check.IsNil)
   181  }
   182  
   183  func (FileJSONStoreSuite) TestDelete(c *check.C) {
   184  	tmp := c.MkDir()
   185  	p := filepath.Join(tmp, "tuf_raw.db")
   186  	s, err := NewFileJSONStore(p)
   187  	c.Assert(s, check.NotNil)
   188  	c.Assert(err, check.IsNil)
   189  
   190  	err = s.DeleteMeta("not_json.yml")
   191  	c.Assert(err, check.ErrorMatches, "file not_json\\.yml is not a JSON file")
   192  	err = s.DeleteMeta("non_existing.json")
   193  	c.Assert(errors.Is(err, os.ErrNotExist), check.Equals, true)
   194  }
   195
View as plain text