github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/api/client/modelupgrader/upgrader_test.go (about)

     1  // Copyright 2022 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package modelupgrader_test
     5  
     6  import (
     7  	"fmt"
     8  	"io"
     9  	"net/http"
    10  	"strings"
    11  
    12  	jc "github.com/juju/testing/checkers"
    13  	"github.com/juju/version/v2"
    14  	"go.uber.org/mock/gomock"
    15  	gc "gopkg.in/check.v1"
    16  	"gopkg.in/httprequest.v1"
    17  
    18  	"github.com/juju/juju/api/client/modelupgrader"
    19  	"github.com/juju/juju/api/client/modelupgrader/mocks"
    20  	"github.com/juju/juju/rpc/params"
    21  	coretesting "github.com/juju/juju/testing"
    22  	coretools "github.com/juju/juju/tools"
    23  )
    24  
    25  type UpgradeModelSuite struct {
    26  	coretesting.BaseSuite
    27  }
    28  
    29  var _ = gc.Suite(&UpgradeModelSuite{})
    30  
    31  func (s *UpgradeModelSuite) TestAbortModelUpgrade(c *gc.C) {
    32  	ctrl := gomock.NewController(c)
    33  	defer ctrl.Finish()
    34  	apiCaller := mocks.NewMockAPICallCloser(ctrl)
    35  
    36  	gomock.InOrder(
    37  		apiCaller.EXPECT().BestFacadeVersion("ModelUpgrader").Return(1),
    38  		apiCaller.EXPECT().APICall(
    39  			"ModelUpgrader", 1, "", "AbortModelUpgrade",
    40  			params.ModelParam{
    41  				ModelTag: coretesting.ModelTag.String(),
    42  			}, nil,
    43  		).Return(nil),
    44  	)
    45  
    46  	client := modelupgrader.NewClient(apiCaller)
    47  	err := client.AbortModelUpgrade(coretesting.ModelTag.Id())
    48  	c.Assert(err, jc.ErrorIsNil)
    49  }
    50  
    51  func (s *UpgradeModelSuite) TestUpgradeModel(c *gc.C) {
    52  	ctrl := gomock.NewController(c)
    53  	defer ctrl.Finish()
    54  	apiCaller := mocks.NewMockAPICallCloser(ctrl)
    55  
    56  	gomock.InOrder(
    57  		apiCaller.EXPECT().BestFacadeVersion("ModelUpgrader").Return(1),
    58  		apiCaller.EXPECT().APICall(
    59  			"ModelUpgrader", 1, "", "UpgradeModel",
    60  			params.UpgradeModelParams{
    61  				ModelTag:            coretesting.ModelTag.String(),
    62  				TargetVersion:       version.MustParse("2.9.1"),
    63  				IgnoreAgentVersions: true,
    64  				DryRun:              true,
    65  			}, &params.UpgradeModelResult{},
    66  		).DoAndReturn(func(objType string, facadeVersion int, id, request string, args, result interface{}) error {
    67  			out := result.(*params.UpgradeModelResult)
    68  			out.ChosenVersion = version.MustParse("2.9.99")
    69  			return nil
    70  		}),
    71  	)
    72  
    73  	client := modelupgrader.NewClient(apiCaller)
    74  	chosenVersion, err := client.UpgradeModel(
    75  		coretesting.ModelTag.Id(),
    76  		version.MustParse("2.9.1"),
    77  		"", true, true,
    78  	)
    79  	c.Assert(err, jc.ErrorIsNil)
    80  	c.Assert(chosenVersion, gc.DeepEquals, version.MustParse("2.9.99"))
    81  }
    82  
    83  func (s *UpgradeModelSuite) TestUploadTools(c *gc.C) {
    84  	ctrl := gomock.NewController(c)
    85  	defer ctrl.Finish()
    86  	apiCaller := mocks.NewMockAPICallCloser(ctrl)
    87  	doer := mocks.NewMockDoer(ctrl)
    88  	ctx := mocks.NewMockContext(ctrl)
    89  
    90  	req, err := http.NewRequest(
    91  		"POST",
    92  		fmt.Sprintf(
    93  			"/tools?binaryVersion=%s",
    94  			version.MustParseBinary("2.9.100-ubuntu-amd64"),
    95  		), nil,
    96  	)
    97  	c.Assert(err, jc.ErrorIsNil)
    98  	req.Header.Set("Content-Type", "application/x-tar-gz")
    99  	req = req.WithContext(ctx)
   100  
   101  	resp := &http.Response{
   102  		Request:    req,
   103  		StatusCode: http.StatusCreated,
   104  		Header:     http.Header{},
   105  		Body:       io.NopCloser(strings.NewReader(`{"tools": [{"version": "2.9.100-ubuntu-amd64"}]}`)),
   106  	}
   107  	resp.Header.Set("Content-Type", "application/json")
   108  
   109  	gomock.InOrder(
   110  		apiCaller.EXPECT().BestFacadeVersion("ModelUpgrader").Return(1),
   111  		apiCaller.EXPECT().HTTPClient().Return(&httprequest.Client{Doer: doer}, nil),
   112  		apiCaller.EXPECT().Context().Return(ctx),
   113  		doer.EXPECT().Do(req).Return(resp, nil),
   114  	)
   115  
   116  	client := modelupgrader.NewClient(apiCaller)
   117  
   118  	result, err := client.UploadTools(
   119  		nil, version.MustParseBinary("2.9.100-ubuntu-amd64"),
   120  	)
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	c.Assert(result, gc.DeepEquals, coretools.List{
   123  		{Version: version.MustParseBinary("2.9.100-ubuntu-amd64")},
   124  	})
   125  }