github.com/juju/juju@v0.0.0-20240327075706-a90865de2538/worker/lease/manager_validation_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package lease_test
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/juju/clock"
    10  	"github.com/juju/clock/testclock"
    11  	"github.com/juju/errors"
    12  	"github.com/juju/loggo"
    13  	"github.com/juju/testing"
    14  	jc "github.com/juju/testing/checkers"
    15  	"github.com/prometheus/client_golang/prometheus"
    16  	gc "gopkg.in/check.v1"
    17  
    18  	corelease "github.com/juju/juju/core/lease"
    19  	"github.com/juju/juju/worker/lease"
    20  )
    21  
    22  type ValidationSuite struct {
    23  	testing.IsolationSuite
    24  
    25  	config lease.ManagerConfig
    26  }
    27  
    28  var _ = gc.Suite(&ValidationSuite{})
    29  
    30  func (s *ValidationSuite) SetUpTest(c *gc.C) {
    31  	s.IsolationSuite.SetUpTest(c)
    32  	s.config = lease.ManagerConfig{
    33  		Store: struct{ corelease.Store }{},
    34  		Clock: struct{ clock.Clock }{},
    35  		Secretary: func(string) (lease.Secretary, error) {
    36  			return nil, nil
    37  		},
    38  		MaxSleep:             time.Minute,
    39  		Logger:               loggo.GetLogger("lease_test"),
    40  		PrometheusRegisterer: struct{ prometheus.Registerer }{},
    41  	}
    42  }
    43  
    44  func (s *ValidationSuite) TestConfigValid(c *gc.C) {
    45  	err := s.config.Validate()
    46  	c.Assert(err, jc.ErrorIsNil)
    47  }
    48  
    49  func (s *ValidationSuite) TestMissingStore(c *gc.C) {
    50  	s.config.Store = nil
    51  	manager, err := lease.NewManager(s.config)
    52  	c.Check(err, gc.ErrorMatches, "nil Store not valid")
    53  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    54  	c.Check(manager, gc.IsNil)
    55  }
    56  
    57  func (s *ValidationSuite) TestMissingClock(c *gc.C) {
    58  	s.config.Clock = nil
    59  	manager, err := lease.NewManager(s.config)
    60  	c.Check(err, gc.ErrorMatches, "nil Clock not valid")
    61  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    62  	c.Check(manager, gc.IsNil)
    63  }
    64  
    65  func (s *ValidationSuite) TestMissingLogger(c *gc.C) {
    66  	s.config.Logger = nil
    67  	manager, err := lease.NewManager(s.config)
    68  	c.Check(err, gc.ErrorMatches, "nil Logger not valid")
    69  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    70  	c.Check(manager, gc.IsNil)
    71  }
    72  
    73  func (s *ValidationSuite) TestMissingSecretary(c *gc.C) {
    74  	s.config.Secretary = nil
    75  	manager, err := lease.NewManager(s.config)
    76  	c.Check(err, gc.ErrorMatches, "nil Secretary not valid")
    77  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    78  	c.Check(manager, gc.IsNil)
    79  }
    80  
    81  func (s *ValidationSuite) TestMissingPrometheusRegisterer(c *gc.C) {
    82  	s.config.PrometheusRegisterer = nil
    83  	err := s.config.Validate()
    84  	// Fine to miss this out for now.
    85  	c.Assert(err, jc.ErrorIsNil)
    86  }
    87  
    88  func (s *ValidationSuite) TestMissingMaxSleep(c *gc.C) {
    89  	s.config.MaxSleep = 0
    90  	manager, err := lease.NewManager(s.config)
    91  	c.Check(err, gc.ErrorMatches, "non-positive MaxSleep not valid")
    92  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    93  	c.Check(manager, gc.IsNil)
    94  }
    95  
    96  func (s *ValidationSuite) TestNegativeMaxSleep(c *gc.C) {
    97  	s.config.MaxSleep = -time.Nanosecond
    98  	manager, err := lease.NewManager(s.config)
    99  	c.Check(err, gc.ErrorMatches, "non-positive MaxSleep not valid")
   100  	c.Check(err, jc.Satisfies, errors.IsNotValid)
   101  	c.Check(manager, gc.IsNil)
   102  }
   103  
   104  func (s *ValidationSuite) TestClaim_LeaseName(c *gc.C) {
   105  	fix := &Fixture{}
   106  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   107  		err := getClaimer(c, manager).Claim("INVALID", "bar/0", time.Minute)
   108  		c.Check(err, gc.ErrorMatches, `cannot claim lease "INVALID": name not valid`)
   109  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   110  	})
   111  }
   112  
   113  func (s *ValidationSuite) TestClaim_HolderName(c *gc.C) {
   114  	fix := &Fixture{}
   115  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   116  		err := getClaimer(c, manager).Claim("foo", "INVALID", time.Minute)
   117  		c.Check(err, gc.ErrorMatches, `cannot claim lease for holder "INVALID": name not valid`)
   118  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   119  	})
   120  }
   121  
   122  func (s *ValidationSuite) TestClaim_Duration(c *gc.C) {
   123  	fix := &Fixture{}
   124  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   125  		err := getClaimer(c, manager).Claim("foo", "bar/0", time.Second)
   126  		c.Check(err, gc.ErrorMatches, `cannot claim lease for 1s: time not valid`)
   127  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   128  	})
   129  }
   130  
   131  func (s *ValidationSuite) TestToken_LeaseName(c *gc.C) {
   132  	fix := &Fixture{}
   133  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   134  		token := getChecker(c, manager).Token("INVALID", "bar/0")
   135  		err := token.Check()
   136  		c.Check(err, gc.ErrorMatches, `cannot check lease "INVALID": name not valid`)
   137  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   138  	})
   139  }
   140  
   141  func (s *ValidationSuite) TestToken_HolderName(c *gc.C) {
   142  	fix := &Fixture{}
   143  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   144  		token := getChecker(c, manager).Token("foo", "INVALID")
   145  		err := token.Check()
   146  		c.Check(err, gc.ErrorMatches, `cannot check holder "INVALID": name not valid`)
   147  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   148  	})
   149  }
   150  
   151  func (s *ValidationSuite) TestWaitUntilExpired_LeaseName(c *gc.C) {
   152  	fix := &Fixture{}
   153  	fix.RunTest(c, func(manager *lease.Manager, _ *testclock.Clock) {
   154  		err := getClaimer(c, manager).WaitUntilExpired("INVALID", nil)
   155  		c.Check(err, gc.ErrorMatches, `cannot wait for lease "INVALID" expiry: name not valid`)
   156  		c.Check(err, jc.Satisfies, errors.IsNotValid)
   157  	})
   158  }