github.com/kubiko/snapd@v0.0.0-20201013125620-d4f3094d9ddf/asserts/fetcher_test.go (about)

     1  // -*- Mode: Go; indent-tabs-mode: t -*-
     2  
     3  /*
     4   * Copyright (C) 2016 Canonical Ltd
     5   *
     6   * This program is free software: you can redistribute it and/or modify
     7   * it under the terms of the GNU General Public License version 3 as
     8   * published by the Free Software Foundation.
     9   *
    10   * This program is distributed in the hope that it will be useful,
    11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13   * GNU General Public License for more details.
    14   *
    15   * You should have received a copy of the GNU General Public License
    16   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    17   *
    18   */
    19  
    20  package asserts_test
    21  
    22  import (
    23  	"crypto"
    24  	"fmt"
    25  	"time"
    26  
    27  	"golang.org/x/crypto/sha3"
    28  
    29  	. "gopkg.in/check.v1"
    30  
    31  	"github.com/snapcore/snapd/asserts"
    32  	"github.com/snapcore/snapd/asserts/assertstest"
    33  )
    34  
    35  type fetcherSuite struct {
    36  	storeSigning *assertstest.StoreStack
    37  }
    38  
    39  var _ = Suite(&fetcherSuite{})
    40  
    41  func (s *fetcherSuite) SetUpTest(c *C) {
    42  	s.storeSigning = assertstest.NewStoreStack("can0nical", nil)
    43  }
    44  
    45  func fakeSnap(rev int) []byte {
    46  	fake := fmt.Sprintf("hsqs________________%d", rev)
    47  	return []byte(fake)
    48  }
    49  
    50  func fakeHash(rev int) []byte {
    51  	h := sha3.Sum384(fakeSnap(rev))
    52  	return h[:]
    53  }
    54  
    55  func makeDigest(rev int) string {
    56  	d, err := asserts.EncodeDigest(crypto.SHA3_384, fakeHash(rev))
    57  	if err != nil {
    58  		panic(err)
    59  	}
    60  	return string(d)
    61  }
    62  
    63  func (s *fetcherSuite) prereqSnapAssertions(c *C, revisions ...int) {
    64  	dev1Acct := assertstest.NewAccount(s.storeSigning, "developer1", nil, "")
    65  	err := s.storeSigning.Add(dev1Acct)
    66  	c.Assert(err, IsNil)
    67  
    68  	headers := map[string]interface{}{
    69  		"series":       "16",
    70  		"snap-id":      "snap-id-1",
    71  		"snap-name":    "foo",
    72  		"publisher-id": dev1Acct.AccountID(),
    73  		"timestamp":    time.Now().Format(time.RFC3339),
    74  	}
    75  	snapDecl, err := s.storeSigning.Sign(asserts.SnapDeclarationType, headers, nil, "")
    76  	c.Assert(err, IsNil)
    77  	err = s.storeSigning.Add(snapDecl)
    78  	c.Assert(err, IsNil)
    79  
    80  	for _, rev := range revisions {
    81  		headers = map[string]interface{}{
    82  			"series":        "16",
    83  			"snap-id":       "snap-id-1",
    84  			"snap-sha3-384": makeDigest(rev),
    85  			"snap-size":     "1000",
    86  			"snap-revision": fmt.Sprintf("%d", rev),
    87  			"developer-id":  dev1Acct.AccountID(),
    88  			"timestamp":     time.Now().Format(time.RFC3339),
    89  		}
    90  		snapRev, err := s.storeSigning.Sign(asserts.SnapRevisionType, headers, nil, "")
    91  		c.Assert(err, IsNil)
    92  		err = s.storeSigning.Add(snapRev)
    93  		c.Assert(err, IsNil)
    94  	}
    95  }
    96  
    97  func (s *fetcherSuite) TestFetch(c *C) {
    98  	s.prereqSnapAssertions(c, 10)
    99  
   100  	db, err := asserts.OpenDatabase(&asserts.DatabaseConfig{
   101  		Backstore: asserts.NewMemoryBackstore(),
   102  		Trusted:   s.storeSigning.Trusted,
   103  	})
   104  	c.Assert(err, IsNil)
   105  
   106  	ref := &asserts.Ref{
   107  		Type:       asserts.SnapRevisionType,
   108  		PrimaryKey: []string{makeDigest(10)},
   109  	}
   110  
   111  	retrieve := func(ref *asserts.Ref) (asserts.Assertion, error) {
   112  		return ref.Resolve(s.storeSigning.Find)
   113  	}
   114  
   115  	f := asserts.NewFetcher(db, retrieve, db.Add)
   116  
   117  	err = f.Fetch(ref)
   118  	c.Assert(err, IsNil)
   119  
   120  	snapRev, err := ref.Resolve(db.Find)
   121  	c.Assert(err, IsNil)
   122  	c.Check(snapRev.(*asserts.SnapRevision).SnapRevision(), Equals, 10)
   123  
   124  	snapDecl, err := db.Find(asserts.SnapDeclarationType, map[string]string{
   125  		"series":  "16",
   126  		"snap-id": "snap-id-1",
   127  	})
   128  	c.Assert(err, IsNil)
   129  	c.Check(snapDecl.(*asserts.SnapDeclaration).SnapName(), Equals, "foo")
   130  }
   131  
   132  func (s *fetcherSuite) TestSave(c *C) {
   133  	s.prereqSnapAssertions(c, 10)
   134  
   135  	db, err := asserts.OpenDatabase(&asserts.DatabaseConfig{
   136  		Backstore: asserts.NewMemoryBackstore(),
   137  		Trusted:   s.storeSigning.Trusted,
   138  	})
   139  	c.Assert(err, IsNil)
   140  
   141  	retrieve := func(ref *asserts.Ref) (asserts.Assertion, error) {
   142  		return ref.Resolve(s.storeSigning.Find)
   143  	}
   144  
   145  	f := asserts.NewFetcher(db, retrieve, db.Add)
   146  
   147  	ref := &asserts.Ref{
   148  		Type:       asserts.SnapRevisionType,
   149  		PrimaryKey: []string{makeDigest(10)},
   150  	}
   151  	rev, err := ref.Resolve(s.storeSigning.Find)
   152  	c.Assert(err, IsNil)
   153  
   154  	err = f.Save(rev)
   155  	c.Assert(err, IsNil)
   156  
   157  	snapRev, err := ref.Resolve(db.Find)
   158  	c.Assert(err, IsNil)
   159  	c.Check(snapRev.(*asserts.SnapRevision).SnapRevision(), Equals, 10)
   160  
   161  	snapDecl, err := db.Find(asserts.SnapDeclarationType, map[string]string{
   162  		"series":  "16",
   163  		"snap-id": "snap-id-1",
   164  	})
   165  	c.Assert(err, IsNil)
   166  	c.Check(snapDecl.(*asserts.SnapDeclaration).SnapName(), Equals, "foo")
   167  }