github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/api/agent/uniter/podspec_test.go (about)

     1  // Copyright 2018 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package uniter_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/names/v5"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/api/agent/uniter"
    13  	basetesting "github.com/juju/juju/api/base/testing"
    14  	"github.com/juju/juju/rpc/params"
    15  	coretesting "github.com/juju/juju/testing"
    16  )
    17  
    18  type podSpecSuite struct {
    19  	coretesting.BaseSuite
    20  }
    21  
    22  var _ = gc.Suite(&podSpecSuite{})
    23  
    24  func (s *podSpecSuite) TestGetPodSpec(c *gc.C) {
    25  	expected := params.Entities{
    26  		Entities: []params.Entity{{
    27  			Tag: "application-mysql",
    28  		}},
    29  	}
    30  
    31  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    32  		c.Assert(objType, gc.Equals, "Uniter")
    33  		c.Assert(version, gc.Equals, 0)
    34  		c.Assert(id, gc.Equals, "")
    35  		c.Assert(request, gc.Equals, "GetPodSpec")
    36  		c.Assert(arg, gc.DeepEquals, expected)
    37  		c.Assert(result, gc.FitsTypeOf, &params.StringResults{})
    38  		*(result.(*params.StringResults)) = params.StringResults{
    39  			Results: []params.StringResult{{
    40  				Error: &params.Error{Message: "yoink"},
    41  			}},
    42  		}
    43  		return nil
    44  	})
    45  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
    46  	_, err := st.GetPodSpec("mysql")
    47  	c.Assert(err, gc.ErrorMatches, "yoink")
    48  }
    49  
    50  func (s *podSpecSuite) TestGetPodSpecInvalidApplicationName(c *gc.C) {
    51  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    52  		c.Fail()
    53  		return nil
    54  	})
    55  
    56  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
    57  	_, err := st.GetPodSpec("")
    58  	c.Assert(err, gc.ErrorMatches, `application name "" not valid`)
    59  }
    60  
    61  func (s *podSpecSuite) TestGetPodSpecError(c *gc.C) {
    62  	expected := params.Entities{
    63  		Entities: []params.Entity{{
    64  			Tag: "application-mysql",
    65  		}},
    66  	}
    67  
    68  	var called bool
    69  	msg := "yoink"
    70  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    71  		c.Assert(objType, gc.Equals, "Uniter")
    72  		c.Assert(version, gc.Equals, 0)
    73  		c.Assert(id, gc.Equals, "")
    74  		c.Assert(request, gc.Equals, "GetPodSpec")
    75  		c.Assert(arg, gc.DeepEquals, expected)
    76  		called = true
    77  
    78  		c.Assert(result, gc.FitsTypeOf, &params.StringResults{})
    79  		return errors.New(msg)
    80  	})
    81  
    82  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
    83  	_, err := st.GetPodSpec("mysql")
    84  	c.Assert(err, gc.ErrorMatches, msg)
    85  	c.Assert(called, jc.IsTrue)
    86  }
    87  
    88  func (s *podSpecSuite) TestGetPodSpecArity(c *gc.C) {
    89  	expected := params.Entities{
    90  		Entities: []params.Entity{{
    91  			Tag: "application-mysql",
    92  		}},
    93  	}
    94  
    95  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    96  		c.Assert(objType, gc.Equals, "Uniter")
    97  		c.Assert(version, gc.Equals, 0)
    98  		c.Assert(id, gc.Equals, "")
    99  		c.Assert(request, gc.Equals, "GetPodSpec")
   100  		c.Assert(arg, gc.DeepEquals, expected)
   101  		c.Assert(result, gc.FitsTypeOf, &params.StringResults{})
   102  		*(result.(*params.StringResults)) = params.StringResults{
   103  			Results: []params.StringResult{{}, {}},
   104  		}
   105  		return nil
   106  	})
   107  
   108  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
   109  	_, err := st.GetPodSpec("mysql")
   110  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   111  }
   112  
   113  func (s *podSpecSuite) TestGetRawK8sSpec(c *gc.C) {
   114  	expected := params.Entities{
   115  		Entities: []params.Entity{{
   116  			Tag: "application-mysql",
   117  		}},
   118  	}
   119  
   120  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   121  		c.Assert(objType, gc.Equals, "Uniter")
   122  		c.Assert(version, gc.Equals, 0)
   123  		c.Assert(id, gc.Equals, "")
   124  		c.Assert(request, gc.Equals, "GetRawK8sSpec")
   125  		c.Assert(arg, gc.DeepEquals, expected)
   126  		c.Assert(result, gc.FitsTypeOf, &params.StringResults{})
   127  		*(result.(*params.StringResults)) = params.StringResults{
   128  			Results: []params.StringResult{{
   129  				Error: &params.Error{Message: "yoink"},
   130  			}},
   131  		}
   132  		return nil
   133  	})
   134  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
   135  	_, err := st.GetRawK8sSpec("mysql")
   136  	c.Assert(err, gc.ErrorMatches, "yoink")
   137  }
   138  
   139  func (s *podSpecSuite) TestGetRawK8sSpecInvalidApplicationName(c *gc.C) {
   140  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   141  		c.Fail()
   142  		return nil
   143  	})
   144  
   145  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
   146  	_, err := st.GetRawK8sSpec("")
   147  	c.Assert(err, gc.ErrorMatches, `application name "" not valid`)
   148  }
   149  
   150  func (s *podSpecSuite) TestGetRawK8sSpecError(c *gc.C) {
   151  	expected := params.Entities{
   152  		Entities: []params.Entity{{
   153  			Tag: "application-mysql",
   154  		}},
   155  	}
   156  
   157  	var called bool
   158  	msg := "yoink"
   159  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   160  		c.Assert(objType, gc.Equals, "Uniter")
   161  		c.Assert(version, gc.Equals, 0)
   162  		c.Assert(id, gc.Equals, "")
   163  		c.Assert(request, gc.Equals, "GetRawK8sSpec")
   164  		c.Assert(arg, gc.DeepEquals, expected)
   165  		called = true
   166  
   167  		c.Assert(result, gc.FitsTypeOf, &params.StringResults{})
   168  		return errors.New(msg)
   169  	})
   170  
   171  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
   172  	_, err := st.GetRawK8sSpec("mysql")
   173  	c.Assert(err, gc.ErrorMatches, msg)
   174  	c.Assert(called, jc.IsTrue)
   175  }
   176  
   177  func (s *podSpecSuite) TestGetRawK8sSpecArity(c *gc.C) {
   178  	expected := params.Entities{
   179  		Entities: []params.Entity{{
   180  			Tag: "application-mysql",
   181  		}},
   182  	}
   183  
   184  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   185  		c.Assert(objType, gc.Equals, "Uniter")
   186  		c.Assert(version, gc.Equals, 0)
   187  		c.Assert(id, gc.Equals, "")
   188  		c.Assert(request, gc.Equals, "GetRawK8sSpec")
   189  		c.Assert(arg, gc.DeepEquals, expected)
   190  		c.Assert(result, gc.FitsTypeOf, &params.StringResults{})
   191  		*(result.(*params.StringResults)) = params.StringResults{
   192  			Results: []params.StringResult{{}, {}},
   193  		}
   194  		return nil
   195  	})
   196  
   197  	st := uniter.NewState(apiCaller, names.NewUnitTag("mysql/0"))
   198  	_, err := st.GetRawK8sSpec("mysql")
   199  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   200  }