github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/core/charm/repository/sanitiser_test.go (about)

     1  // Copyright 2020 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package repository
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/core/arch"
    11  	corecharm "github.com/juju/juju/core/charm"
    12  )
    13  
    14  type sanitiseCharmOriginSuite struct{}
    15  
    16  var _ = gc.Suite(&sanitiseCharmOriginSuite{})
    17  
    18  func (s *sanitiseCharmOriginSuite) TestSanitise(c *gc.C) {
    19  	received := corecharm.Origin{
    20  		Platform: corecharm.Platform{
    21  			Architecture: "all",
    22  			OS:           "all",
    23  			Channel:      "all",
    24  		},
    25  	}
    26  	requested := corecharm.Origin{
    27  		Platform: corecharm.Platform{
    28  			Architecture: arch.DefaultArchitecture,
    29  			OS:           "Ubuntu",
    30  			Channel:      "20.04",
    31  		},
    32  	}
    33  	got, err := sanitiseCharmOrigin(received, requested)
    34  	c.Assert(err, jc.ErrorIsNil)
    35  	c.Assert(got, gc.DeepEquals, corecharm.Origin{
    36  		Platform: corecharm.Platform{
    37  			Architecture: arch.DefaultArchitecture,
    38  			OS:           "ubuntu",
    39  			Channel:      "20.04",
    40  		},
    41  	})
    42  }
    43  
    44  func (s *sanitiseCharmOriginSuite) TestSanitiseWithValues(c *gc.C) {
    45  	received := corecharm.Origin{
    46  		Platform: corecharm.Platform{
    47  			Architecture: "arm64",
    48  			OS:           "windows",
    49  			Channel:      "win8",
    50  		},
    51  	}
    52  	requested := corecharm.Origin{
    53  		Platform: corecharm.Platform{
    54  			Architecture: arch.DefaultArchitecture,
    55  			OS:           "Ubuntu",
    56  			Channel:      "20.04",
    57  		},
    58  	}
    59  	got, err := sanitiseCharmOrigin(received, requested)
    60  	c.Assert(err, jc.ErrorIsNil)
    61  	c.Assert(got, gc.DeepEquals, corecharm.Origin{
    62  		Platform: corecharm.Platform{
    63  			Architecture: "arm64",
    64  			OS:           "windows",
    65  			Channel:      "win8",
    66  		},
    67  	})
    68  }
    69  
    70  func (s *sanitiseCharmOriginSuite) TestSanitiseWithEmptyValues(c *gc.C) {
    71  	received := corecharm.Origin{
    72  		Platform: corecharm.Platform{
    73  			Architecture: "",
    74  			OS:           "",
    75  			Channel:      "",
    76  		},
    77  	}
    78  	requested := corecharm.Origin{
    79  		Platform: corecharm.Platform{
    80  			Architecture: arch.DefaultArchitecture,
    81  			OS:           "Ubuntu",
    82  			Channel:      "20.04",
    83  		},
    84  	}
    85  	got, err := sanitiseCharmOrigin(received, requested)
    86  	c.Assert(err, jc.ErrorIsNil)
    87  	c.Assert(got, gc.DeepEquals, corecharm.Origin{
    88  		Platform: corecharm.Platform{
    89  			Architecture: "",
    90  			OS:           "",
    91  			Channel:      "",
    92  		},
    93  	})
    94  }
    95  
    96  func (s *sanitiseCharmOriginSuite) TestSanitiseWithRequestedEmptyValues(c *gc.C) {
    97  	received := corecharm.Origin{
    98  		Platform: corecharm.Platform{
    99  			Architecture: "all",
   100  			OS:           "all",
   101  			Channel:      "all",
   102  		},
   103  	}
   104  	requested := corecharm.Origin{
   105  		Platform: corecharm.Platform{
   106  			Architecture: "",
   107  			OS:           "",
   108  			Channel:      "",
   109  		},
   110  	}
   111  	got, err := sanitiseCharmOrigin(received, requested)
   112  	c.Assert(err, jc.ErrorIsNil)
   113  	c.Assert(got, gc.DeepEquals, corecharm.Origin{
   114  		Platform: corecharm.Platform{
   115  			Architecture: "",
   116  			OS:           "",
   117  			Channel:      "",
   118  		},
   119  	})
   120  }
   121  
   122  func (s *sanitiseCharmOriginSuite) TestSanitiseWithRequestedEmptyValuesAlt(c *gc.C) {
   123  	received := corecharm.Origin{
   124  		Platform: corecharm.Platform{
   125  			Architecture: "all",
   126  			OS:           "ubuntu",
   127  			Channel:      "20.04",
   128  		},
   129  	}
   130  	requested := corecharm.Origin{
   131  		Platform: corecharm.Platform{
   132  			Architecture: "",
   133  			OS:           "",
   134  			Channel:      "",
   135  		},
   136  	}
   137  	got, err := sanitiseCharmOrigin(received, requested)
   138  	c.Assert(err, jc.ErrorIsNil)
   139  	c.Assert(got, gc.DeepEquals, corecharm.Origin{
   140  		Platform: corecharm.Platform{
   141  			Architecture: "",
   142  			OS:           "ubuntu",
   143  			Channel:      "20.04",
   144  		},
   145  	})
   146  }
   147  
   148  func (s *sanitiseCharmOriginSuite) TestSanitiseWithRequestedEmptyValuesOSVersusChannel(c *gc.C) {
   149  	received := corecharm.Origin{
   150  		Platform: corecharm.Platform{
   151  			Architecture: "all",
   152  			OS:           "ubuntu",
   153  			Channel:      "all",
   154  		},
   155  	}
   156  	requested := corecharm.Origin{
   157  		Platform: corecharm.Platform{
   158  			Architecture: "",
   159  			OS:           "",
   160  			Channel:      "",
   161  		},
   162  	}
   163  	got, err := sanitiseCharmOrigin(received, requested)
   164  	c.Assert(err, jc.ErrorIsNil)
   165  	c.Assert(got, gc.DeepEquals, corecharm.Origin{
   166  		Platform: corecharm.Platform{
   167  			Architecture: "",
   168  			OS:           "ubuntu",
   169  			Channel:      "",
   170  		},
   171  	})
   172  }
   173  
   174  func (s *sanitiseCharmOriginSuite) TestSanitiseChannel(c *gc.C) {
   175  	ch := corecharm.MustParseChannel("stable")
   176  	received := corecharm.Origin{
   177  		Channel: &ch,
   178  	}
   179  	got, err := sanitiseCharmOrigin(received, corecharm.Origin{})
   180  	c.Assert(err, jc.ErrorIsNil)
   181  	c.Assert(*got.Channel, gc.Equals, corecharm.MustParseChannel("latest/stable"))
   182  }
   183  
   184  func (s *sanitiseCharmOriginSuite) TestSanitiseChannelNop(c *gc.C) {
   185  	ch := corecharm.MustParseChannel("latest/stable")
   186  	received := corecharm.Origin{
   187  		Channel: &ch,
   188  	}
   189  	got, err := sanitiseCharmOrigin(received, corecharm.Origin{})
   190  	c.Assert(err, jc.ErrorIsNil)
   191  	c.Assert(*got.Channel, gc.Equals, corecharm.MustParseChannel("latest/stable"))
   192  }
   193  
   194  func (s *sanitiseCharmOriginSuite) TestSanitiseChannelNopOtherTrack(c *gc.C) {
   195  	ch := corecharm.MustParseChannel("5/stable")
   196  	received := corecharm.Origin{
   197  		Channel: &ch,
   198  	}
   199  	got, err := sanitiseCharmOrigin(received, corecharm.Origin{})
   200  	c.Assert(err, jc.ErrorIsNil)
   201  	c.Assert(*got.Channel, gc.Equals, corecharm.MustParseChannel("5/stable"))
   202  }