github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/common/getstatus_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package common_test
     5  
     6  import (
     7  	"time"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/names.v2"
    12  
    13  	"github.com/juju/juju/apiserver/common"
    14  	"github.com/juju/juju/apiserver/params"
    15  	"github.com/juju/juju/core/status"
    16  	"github.com/juju/juju/state/testing"
    17  	"github.com/juju/juju/testing/factory"
    18  )
    19  
    20  type statusGetterSuite struct {
    21  	statusBaseSuite
    22  	getter *common.StatusGetter
    23  }
    24  
    25  var _ = gc.Suite(&statusGetterSuite{})
    26  
    27  func (s *statusGetterSuite) SetUpTest(c *gc.C) {
    28  	s.statusBaseSuite.SetUpTest(c)
    29  
    30  	s.getter = common.NewStatusGetter(s.State, func() (common.AuthFunc, error) {
    31  		return s.authFunc, nil
    32  	})
    33  }
    34  
    35  func (s *statusGetterSuite) TestUnauthorized(c *gc.C) {
    36  	tag := names.NewMachineTag("42")
    37  	s.badTag = tag
    38  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
    39  		tag.String(),
    40  	}}})
    41  	c.Assert(err, jc.ErrorIsNil)
    42  	c.Assert(result.Results, gc.HasLen, 1)
    43  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeUnauthorized)
    44  }
    45  
    46  func (s *statusGetterSuite) TestNotATag(c *gc.C) {
    47  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
    48  		"not a tag",
    49  	}}})
    50  	c.Assert(err, jc.ErrorIsNil)
    51  	c.Assert(result.Results, gc.HasLen, 1)
    52  	c.Assert(result.Results[0].Error, gc.ErrorMatches, `"not a tag" is not a valid tag`)
    53  }
    54  
    55  func (s *statusGetterSuite) TestNotFound(c *gc.C) {
    56  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
    57  		names.NewMachineTag("42").String(),
    58  	}}})
    59  	c.Assert(err, jc.ErrorIsNil)
    60  	c.Assert(result.Results, gc.HasLen, 1)
    61  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeNotFound)
    62  }
    63  
    64  func (s *statusGetterSuite) TestGetMachineStatus(c *gc.C) {
    65  	machine := s.Factory.MakeMachine(c, nil)
    66  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
    67  		machine.Tag().String(),
    68  	}}})
    69  	c.Assert(err, jc.ErrorIsNil)
    70  	c.Assert(result.Results, gc.HasLen, 1)
    71  	machineStatus := result.Results[0]
    72  	c.Assert(machineStatus.Error, gc.IsNil)
    73  	c.Assert(machineStatus.Status, gc.Equals, status.Pending.String())
    74  }
    75  
    76  func (s *statusGetterSuite) TestGetUnitStatus(c *gc.C) {
    77  	// The status has to be a valid workload status, because get status
    78  	// on the unit returns the workload status not the agent status as it
    79  	// does on a machine.
    80  	unit := s.Factory.MakeUnit(c, &factory.UnitParams{Status: &status.StatusInfo{
    81  		Status: status.Maintenance,
    82  	}})
    83  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
    84  		unit.Tag().String(),
    85  	}}})
    86  	c.Assert(err, jc.ErrorIsNil)
    87  	c.Assert(result.Results, gc.HasLen, 1)
    88  	unitStatus := result.Results[0]
    89  	c.Assert(unitStatus.Error, gc.IsNil)
    90  	c.Assert(unitStatus.Status, gc.Equals, status.Maintenance.String())
    91  }
    92  
    93  func (s *statusGetterSuite) TestGetServiceStatus(c *gc.C) {
    94  	service := s.Factory.MakeApplication(c, &factory.ApplicationParams{Status: &status.StatusInfo{
    95  		Status: status.Maintenance,
    96  	}})
    97  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
    98  		service.Tag().String(),
    99  	}}})
   100  	c.Assert(err, jc.ErrorIsNil)
   101  	c.Assert(result.Results, gc.HasLen, 1)
   102  	serviceStatus := result.Results[0]
   103  	c.Assert(serviceStatus.Error, gc.IsNil)
   104  	c.Assert(serviceStatus.Status, gc.Equals, status.Maintenance.String())
   105  }
   106  
   107  func (s *statusGetterSuite) TestBulk(c *gc.C) {
   108  	s.badTag = names.NewMachineTag("42")
   109  	machine := s.Factory.MakeMachine(c, nil)
   110  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   111  		s.badTag.String(),
   112  	}, {
   113  		machine.Tag().String(),
   114  	}, {
   115  		"bad-tag",
   116  	}}})
   117  	c.Assert(err, jc.ErrorIsNil)
   118  	c.Assert(result.Results, gc.HasLen, 3)
   119  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeUnauthorized)
   120  	c.Assert(result.Results[1].Error, gc.IsNil)
   121  	c.Assert(result.Results[1].Status, gc.Equals, status.Pending.String())
   122  	c.Assert(result.Results[2].Error, gc.ErrorMatches, `"bad-tag" is not a valid tag`)
   123  }
   124  
   125  type serviceStatusGetterSuite struct {
   126  	statusBaseSuite
   127  	getter *common.ApplicationStatusGetter
   128  }
   129  
   130  var _ = gc.Suite(&serviceStatusGetterSuite{})
   131  
   132  func (s *serviceStatusGetterSuite) SetUpTest(c *gc.C) {
   133  	s.statusBaseSuite.SetUpTest(c)
   134  
   135  	s.getter = common.NewApplicationStatusGetter(s.State, func() (common.AuthFunc, error) {
   136  		return s.authFunc, nil
   137  	})
   138  }
   139  
   140  func (s *serviceStatusGetterSuite) TestUnauthorized(c *gc.C) {
   141  	// Machines are unauthorized since they are not units
   142  	tag := names.NewUnitTag("foo/0")
   143  	s.badTag = tag
   144  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   145  		tag.String(),
   146  	}}})
   147  	c.Assert(err, jc.ErrorIsNil)
   148  	c.Assert(result.Results, gc.HasLen, 1)
   149  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeUnauthorized)
   150  }
   151  
   152  func (s *serviceStatusGetterSuite) TestNotATag(c *gc.C) {
   153  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   154  		"not a tag",
   155  	}}})
   156  	c.Assert(err, jc.ErrorIsNil)
   157  	c.Assert(result.Results, gc.HasLen, 1)
   158  	c.Assert(result.Results[0].Error, gc.ErrorMatches, `"not a tag" is not a valid tag`)
   159  }
   160  
   161  func (s *serviceStatusGetterSuite) TestNotFound(c *gc.C) {
   162  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   163  		names.NewUnitTag("foo/0").String(),
   164  	}}})
   165  	c.Assert(err, jc.ErrorIsNil)
   166  	c.Assert(result.Results, gc.HasLen, 1)
   167  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeNotFound)
   168  }
   169  
   170  func (s *serviceStatusGetterSuite) TestGetMachineStatus(c *gc.C) {
   171  	machine := s.Factory.MakeMachine(c, nil)
   172  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   173  		machine.Tag().String(),
   174  	}}})
   175  	c.Assert(err, jc.ErrorIsNil)
   176  	c.Assert(result.Results, gc.HasLen, 1)
   177  	// Can't call service status on a machine.
   178  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeUnauthorized)
   179  }
   180  
   181  func (s *serviceStatusGetterSuite) TestGetServiceStatus(c *gc.C) {
   182  	service := s.Factory.MakeApplication(c, &factory.ApplicationParams{Status: &status.StatusInfo{
   183  		Status: status.Maintenance,
   184  	}})
   185  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   186  		service.Tag().String(),
   187  	}}})
   188  	c.Assert(err, jc.ErrorIsNil)
   189  	c.Assert(result.Results, gc.HasLen, 1)
   190  	// Can't call service status on a service.
   191  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeUnauthorized)
   192  }
   193  
   194  func (s *serviceStatusGetterSuite) TestGetUnitStatusNotLeader(c *gc.C) {
   195  	// If the unit isn't the leader, it can't get it.
   196  	unit := s.Factory.MakeUnit(c, &factory.UnitParams{Status: &status.StatusInfo{
   197  		Status: status.Maintenance,
   198  	}})
   199  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   200  		unit.Tag().String(),
   201  	}}})
   202  	c.Assert(err, jc.ErrorIsNil)
   203  	c.Assert(result.Results, gc.HasLen, 1)
   204  	status := result.Results[0]
   205  	c.Assert(status.Error, gc.ErrorMatches, ".* is not leader of .*")
   206  }
   207  
   208  func (s *serviceStatusGetterSuite) TestGetUnitStatusIsLeader(c *gc.C) {
   209  	// If the unit isn't the leader, it can't get it.
   210  	unit := s.Factory.MakeUnit(c, &factory.UnitParams{Status: &status.StatusInfo{
   211  		Status: status.Maintenance,
   212  	}})
   213  	service, err := unit.Application()
   214  	c.Assert(err, jc.ErrorIsNil)
   215  	s.State.LeadershipClaimer().ClaimLeadership(
   216  		service.Name(),
   217  		unit.Name(),
   218  		time.Minute)
   219  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   220  		unit.Tag().String(),
   221  	}}})
   222  	c.Assert(err, jc.ErrorIsNil)
   223  	c.Assert(result.Results, gc.HasLen, 1)
   224  	r := result.Results[0]
   225  	c.Assert(r.Error, gc.IsNil)
   226  	c.Assert(r.Application.Error, gc.IsNil)
   227  	c.Assert(r.Application.Status, gc.Equals, status.Maintenance.String())
   228  	units := r.Units
   229  	c.Assert(units, gc.HasLen, 1)
   230  	unitStatus, ok := units[unit.Name()]
   231  	c.Assert(ok, jc.IsTrue)
   232  	c.Assert(unitStatus.Error, gc.IsNil)
   233  	c.Assert(unitStatus.Status, gc.Equals, status.Maintenance.String())
   234  }
   235  
   236  func (s *serviceStatusGetterSuite) TestBulk(c *gc.C) {
   237  	s.badTag = names.NewMachineTag("42")
   238  	machine := s.Factory.MakeMachine(c, nil)
   239  	result, err := s.getter.Status(params.Entities{[]params.Entity{{
   240  		s.badTag.String(),
   241  	}, {
   242  		machine.Tag().String(),
   243  	}, {
   244  		"bad-tag",
   245  	}}})
   246  	c.Assert(err, jc.ErrorIsNil)
   247  	c.Assert(result.Results, gc.HasLen, 3)
   248  	c.Assert(result.Results[0].Error, jc.Satisfies, params.IsCodeUnauthorized)
   249  	c.Assert(result.Results[1].Error, jc.Satisfies, params.IsCodeUnauthorized)
   250  	c.Assert(result.Results[2].Error, gc.ErrorMatches, `"bad-tag" is not a valid tag`)
   251  }
   252  
   253  type statusBaseSuite struct {
   254  	testing.StateSuite
   255  	badTag names.Tag
   256  }
   257  
   258  func (s *statusBaseSuite) SetUpTest(c *gc.C) {
   259  	s.StateSuite.SetUpTest(c)
   260  	s.badTag = nil
   261  }
   262  
   263  func (s *statusBaseSuite) authFunc(tag names.Tag) bool {
   264  	return tag != s.badTag
   265  }