github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/environs/tools/validation_test.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package tools
     5  
     6  import (
     7  	"path"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	"github.com/juju/utils/v3"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/environs/filestorage"
    14  	"github.com/juju/juju/environs/simplestreams"
    15  	sstesting "github.com/juju/juju/environs/simplestreams/testing"
    16  	"github.com/juju/juju/testing"
    17  )
    18  
    19  type ValidateSuite struct {
    20  	testing.BaseSuite
    21  	metadataDir string
    22  	dataSource  simplestreams.DataSource
    23  }
    24  
    25  var _ = gc.Suite(&ValidateSuite{})
    26  
    27  func (s *ValidateSuite) makeLocalMetadata(c *gc.C, stream, version, osType string) {
    28  	tm := []*ToolsMetadata{{
    29  		Version:  version,
    30  		Release:  osType,
    31  		Arch:     "amd64",
    32  		Path:     "/tools/tools.tar.gz",
    33  		Size:     1234,
    34  		FileType: "tar.gz",
    35  		SHA256:   "f65a92b3b41311bdf398663ee1c5cd0c",
    36  	}}
    37  
    38  	stor, err := filestorage.NewFileStorageWriter(s.metadataDir)
    39  	c.Assert(err, jc.ErrorIsNil)
    40  	streamMetadata := map[string][]*ToolsMetadata{
    41  		stream: tm,
    42  	}
    43  	err = WriteMetadata(stor, streamMetadata, []string{stream}, false)
    44  	c.Assert(err, jc.ErrorIsNil)
    45  }
    46  
    47  func (s *ValidateSuite) SetUpTest(c *gc.C) {
    48  	s.BaseSuite.SetUpTest(c)
    49  	s.metadataDir = c.MkDir()
    50  	s.dataSource = sstesting.VerifyDefaultCloudDataSource("test", s.toolsURL())
    51  }
    52  
    53  func (s *ValidateSuite) toolsURL() string {
    54  	return utils.MakeFileURL(path.Join(s.metadataDir, "tools"))
    55  }
    56  
    57  func (s *ValidateSuite) TestExactVersionMatch(c *gc.C) {
    58  	s.makeLocalMetadata(c, "released", "1.11.2", "ubuntu")
    59  	params := &ToolsMetadataLookupParams{
    60  		Version: "1.11.2",
    61  		MetadataLookupParams: simplestreams.MetadataLookupParams{
    62  			Region:        "region-2",
    63  			Release:       "ubuntu",
    64  			Architectures: []string{"amd64"},
    65  			Endpoint:      "some-auth-url",
    66  			Stream:        "released",
    67  			Sources:       []simplestreams.DataSource{s.dataSource},
    68  		},
    69  	}
    70  	ss := simplestreams.NewSimpleStreams(sstesting.TestDataSourceFactory())
    71  	versions, resolveInfo, err := ValidateToolsMetadata(ss, params)
    72  	c.Assert(err, jc.ErrorIsNil)
    73  	c.Assert(versions, gc.DeepEquals, []string{"1.11.2-ubuntu-amd64"})
    74  	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
    75  		Source:    "test",
    76  		Signed:    false,
    77  		IndexURL:  utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
    78  		MirrorURL: "",
    79  	})
    80  }
    81  
    82  func (s *ValidateSuite) TestMajorVersionMatch(c *gc.C) {
    83  	s.makeLocalMetadata(c, "released", "1.11.2", "ubuntu")
    84  	params := &ToolsMetadataLookupParams{
    85  		Major: 1,
    86  		Minor: -1,
    87  		MetadataLookupParams: simplestreams.MetadataLookupParams{
    88  			Region:        "region-2",
    89  			Release:       "ubuntu",
    90  			Architectures: []string{"amd64"},
    91  			Endpoint:      "some-auth-url",
    92  			Stream:        "released",
    93  			Sources:       []simplestreams.DataSource{s.dataSource},
    94  		},
    95  	}
    96  	ss := simplestreams.NewSimpleStreams(sstesting.TestDataSourceFactory())
    97  	versions, resolveInfo, err := ValidateToolsMetadata(ss, params)
    98  	c.Assert(err, jc.ErrorIsNil)
    99  	c.Assert(versions, gc.DeepEquals, []string{"1.11.2-ubuntu-amd64"})
   100  	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
   101  		Source:    "test",
   102  		Signed:    false,
   103  		IndexURL:  utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
   104  		MirrorURL: "",
   105  	})
   106  }
   107  
   108  func (s *ValidateSuite) TestMajorMinorVersionMatch(c *gc.C) {
   109  	s.makeLocalMetadata(c, "released", "1.11.2", "ubuntu")
   110  	params := &ToolsMetadataLookupParams{
   111  		Major: 1,
   112  		Minor: 11,
   113  		MetadataLookupParams: simplestreams.MetadataLookupParams{
   114  			Region:        "region-2",
   115  			Release:       "ubuntu",
   116  			Architectures: []string{"amd64"},
   117  			Endpoint:      "some-auth-url",
   118  			Stream:        "released",
   119  			Sources:       []simplestreams.DataSource{s.dataSource}},
   120  	}
   121  	ss := simplestreams.NewSimpleStreams(sstesting.TestDataSourceFactory())
   122  	versions, resolveInfo, err := ValidateToolsMetadata(ss, params)
   123  	c.Assert(err, jc.ErrorIsNil)
   124  	c.Assert(versions, gc.DeepEquals, []string{"1.11.2-ubuntu-amd64"})
   125  	c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
   126  		Source:    "test",
   127  		Signed:    false,
   128  		IndexURL:  utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
   129  		MirrorURL: "",
   130  	})
   131  }
   132  
   133  func (s *ValidateSuite) TestNoMatch(c *gc.C) {
   134  	s.makeLocalMetadata(c, "released", "1.11.2", "ubuntu")
   135  	params := &ToolsMetadataLookupParams{
   136  		Version: "1.11.2",
   137  		MetadataLookupParams: simplestreams.MetadataLookupParams{
   138  			Region:        "region-2",
   139  			Release:       "precise",
   140  			Architectures: []string{"amd64"},
   141  			Endpoint:      "some-auth-url",
   142  			Stream:        "released",
   143  			Sources:       []simplestreams.DataSource{s.dataSource}},
   144  	}
   145  	ss := simplestreams.NewSimpleStreams(sstesting.TestDataSourceFactory())
   146  	_, _, err := ValidateToolsMetadata(ss, params)
   147  	c.Assert(err, gc.Not(gc.IsNil))
   148  }
   149  
   150  func (s *ValidateSuite) TestStreamsNoMatch(c *gc.C) {
   151  	s.makeLocalMetadata(c, "proposed", "1.11.2", "ubuntu")
   152  	params := &ToolsMetadataLookupParams{
   153  		Version: "1.11.2",
   154  		MetadataLookupParams: simplestreams.MetadataLookupParams{
   155  			Region:        "region-2",
   156  			Release:       "ubuntu",
   157  			Architectures: []string{"amd64"},
   158  			Endpoint:      "some-auth-url",
   159  			Stream:        "testing",
   160  			Sources:       []simplestreams.DataSource{s.dataSource}},
   161  	}
   162  	ss := simplestreams.NewSimpleStreams(sstesting.TestDataSourceFactory())
   163  	_, _, err := ValidateToolsMetadata(ss, params)
   164  	c.Assert(err, gc.Not(gc.IsNil))
   165  }