github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/cmd/jujud/util/util_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package util
     5  
     6  import (
     7  	stderrors "errors"
     8  
     9  	"github.com/juju/errors"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/apiserver/params"
    14  	coretesting "github.com/juju/juju/testing"
    15  	"github.com/juju/juju/worker"
    16  	"github.com/juju/juju/worker/upgrader"
    17  )
    18  
    19  var (
    20  	_ = gc.Suite(&toolSuite{})
    21  )
    22  
    23  type toolSuite struct {
    24  	coretesting.BaseSuite
    25  }
    26  
    27  func (*toolSuite) TestErrorImportance(c *gc.C) {
    28  
    29  	errorImportanceTests := []error{
    30  		nil,
    31  		stderrors.New("foo"),
    32  		&upgrader.UpgradeReadyError{},
    33  		worker.ErrTerminateAgent,
    34  	}
    35  
    36  	for i, err0 := range errorImportanceTests {
    37  		for j, err1 := range errorImportanceTests {
    38  			c.Assert(MoreImportant(err0, err1), gc.Equals, i > j)
    39  
    40  			// Should also work if errors are wrapped.
    41  			c.Assert(MoreImportant(errors.Trace(err0), errors.Trace(err1)), gc.Equals, i > j)
    42  		}
    43  	}
    44  }
    45  
    46  var isFatalTests = []struct {
    47  	err     error
    48  	isFatal bool
    49  }{
    50  	{
    51  		err:     worker.ErrTerminateAgent,
    52  		isFatal: true,
    53  	}, {
    54  		err:     errors.Trace(worker.ErrTerminateAgent),
    55  		isFatal: true,
    56  	}, {
    57  		err:     worker.ErrRestartAgent,
    58  		isFatal: true,
    59  	}, {
    60  		err:     errors.Trace(worker.ErrRestartAgent),
    61  		isFatal: true,
    62  	}, {
    63  		err:     &upgrader.UpgradeReadyError{},
    64  		isFatal: true,
    65  	}, {
    66  		err: &params.Error{
    67  			Message: "blah",
    68  			Code:    params.CodeNotProvisioned,
    69  		},
    70  		isFatal: false,
    71  	}, {
    72  		err:     &FatalError{"some fatal error"},
    73  		isFatal: true,
    74  	}, {
    75  		err:     stderrors.New("foo"),
    76  		isFatal: false,
    77  	}, {
    78  		err: &params.Error{
    79  			Message: "blah",
    80  			Code:    params.CodeNotFound,
    81  		},
    82  		isFatal: false,
    83  	},
    84  }
    85  
    86  func (s *toolSuite) TestConnectionIsFatal(c *gc.C) {
    87  	okConn := &testConn{broken: false}
    88  	errConn := &testConn{broken: true}
    89  
    90  	for i, conn := range []*testConn{errConn, okConn} {
    91  		for j, test := range isFatalTests {
    92  			c.Logf("test %d.%d: %s", i, j, test.err)
    93  			fatal := ConnectionIsFatal(logger, conn)(test.err)
    94  			if test.isFatal {
    95  				c.Check(fatal, jc.IsTrue)
    96  			} else {
    97  				c.Check(fatal, gc.Equals, i == 0)
    98  			}
    99  		}
   100  	}
   101  }
   102  
   103  func (s *toolSuite) TestConnectionIsFatalWithMultipleConns(c *gc.C) {
   104  	okConn := &testConn{broken: false}
   105  	errConn := &testConn{broken: true}
   106  
   107  	someErr := stderrors.New("foo")
   108  
   109  	c.Assert(ConnectionIsFatal(logger, okConn, okConn)(someErr),
   110  		jc.IsFalse)
   111  	c.Assert(ConnectionIsFatal(logger, okConn, okConn, okConn)(someErr),
   112  		jc.IsFalse)
   113  	c.Assert(ConnectionIsFatal(logger, okConn, errConn)(someErr),
   114  		jc.IsTrue)
   115  	c.Assert(ConnectionIsFatal(logger, okConn, okConn, errConn)(someErr),
   116  		jc.IsTrue)
   117  	c.Assert(ConnectionIsFatal(logger, errConn, okConn, okConn)(someErr),
   118  		jc.IsTrue)
   119  }
   120  
   121  func (s *toolSuite) TestPingerIsFatal(c *gc.C) {
   122  	var errPinger testPinger = func() error {
   123  		return stderrors.New("ping error")
   124  	}
   125  	var okPinger testPinger = func() error {
   126  		return nil
   127  	}
   128  	for i, pinger := range []testPinger{errPinger, okPinger} {
   129  		for j, test := range isFatalTests {
   130  			c.Logf("test %d.%d: %s", i, j, test.err)
   131  			fatal := PingerIsFatal(logger, pinger)(test.err)
   132  			if test.isFatal {
   133  				c.Check(fatal, jc.IsTrue)
   134  			} else {
   135  				c.Check(fatal, gc.Equals, i == 0)
   136  			}
   137  		}
   138  	}
   139  }
   140  
   141  func (s *toolSuite) TestPingerIsFatalWithMultipleConns(c *gc.C) {
   142  	var errPinger testPinger = func() error {
   143  		return stderrors.New("ping error")
   144  	}
   145  	var okPinger testPinger = func() error {
   146  		return nil
   147  	}
   148  
   149  	someErr := stderrors.New("foo")
   150  
   151  	c.Assert(PingerIsFatal(logger, okPinger, okPinger)(someErr),
   152  		jc.IsFalse)
   153  	c.Assert(PingerIsFatal(logger, okPinger, okPinger, okPinger)(someErr),
   154  		jc.IsFalse)
   155  	c.Assert(PingerIsFatal(logger, okPinger, errPinger)(someErr),
   156  		jc.IsTrue)
   157  	c.Assert(PingerIsFatal(logger, okPinger, okPinger, errPinger)(someErr),
   158  		jc.IsTrue)
   159  	c.Assert(PingerIsFatal(logger, errPinger, okPinger, okPinger)(someErr),
   160  		jc.IsTrue)
   161  }
   162  
   163  func (*toolSuite) TestIsFatal(c *gc.C) {
   164  
   165  	for i, test := range isFatalTests {
   166  		c.Logf("test %d: %s", i, test.err)
   167  		c.Assert(IsFatal(test.err), gc.Equals, test.isFatal)
   168  	}
   169  }
   170  
   171  type testConn struct {
   172  	broken bool
   173  }
   174  
   175  func (c *testConn) IsBroken() bool {
   176  	return c.broken
   177  }
   178  
   179  type testPinger func() error
   180  
   181  func (f testPinger) Ping() error {
   182  	return f()
   183  }