github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/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:     &upgrader.UpgradeReadyError{},
    58  		isFatal: true,
    59  	}, {
    60  		err: &params.Error{
    61  			Message: "blah",
    62  			Code:    params.CodeNotProvisioned,
    63  		},
    64  		isFatal: false,
    65  	}, {
    66  		err:     &FatalError{"some fatal error"},
    67  		isFatal: true,
    68  	}, {
    69  		err:     stderrors.New("foo"),
    70  		isFatal: false,
    71  	}, {
    72  		err: &params.Error{
    73  			Message: "blah",
    74  			Code:    params.CodeNotFound,
    75  		},
    76  		isFatal: false,
    77  	},
    78  }
    79  
    80  func (s *toolSuite) TestConnectionIsFatal(c *gc.C) {
    81  	okConn := &testConn{broken: false}
    82  	errConn := &testConn{broken: true}
    83  
    84  	for i, conn := range []*testConn{errConn, okConn} {
    85  		for j, test := range isFatalTests {
    86  			c.Logf("test %d.%d: %s", i, j, test.err)
    87  			fatal := ConnectionIsFatal(logger, conn)(test.err)
    88  			if test.isFatal {
    89  				c.Check(fatal, jc.IsTrue)
    90  			} else {
    91  				c.Check(fatal, gc.Equals, i == 0)
    92  			}
    93  		}
    94  	}
    95  }
    96  
    97  func (s *toolSuite) TestConnectionIsFatalWithMultipleConns(c *gc.C) {
    98  	okConn := &testConn{broken: false}
    99  	errConn := &testConn{broken: true}
   100  
   101  	someErr := stderrors.New("foo")
   102  
   103  	c.Assert(ConnectionIsFatal(logger, okConn, okConn)(someErr),
   104  		jc.IsFalse)
   105  	c.Assert(ConnectionIsFatal(logger, okConn, okConn, okConn)(someErr),
   106  		jc.IsFalse)
   107  	c.Assert(ConnectionIsFatal(logger, okConn, errConn)(someErr),
   108  		jc.IsTrue)
   109  	c.Assert(ConnectionIsFatal(logger, okConn, okConn, errConn)(someErr),
   110  		jc.IsTrue)
   111  	c.Assert(ConnectionIsFatal(logger, errConn, okConn, okConn)(someErr),
   112  		jc.IsTrue)
   113  }
   114  
   115  func (s *toolSuite) TestPingerIsFatal(c *gc.C) {
   116  	var errPinger testPinger = func() error {
   117  		return stderrors.New("ping error")
   118  	}
   119  	var okPinger testPinger = func() error {
   120  		return nil
   121  	}
   122  	for i, pinger := range []testPinger{errPinger, okPinger} {
   123  		for j, test := range isFatalTests {
   124  			c.Logf("test %d.%d: %s", i, j, test.err)
   125  			fatal := PingerIsFatal(logger, pinger)(test.err)
   126  			if test.isFatal {
   127  				c.Check(fatal, jc.IsTrue)
   128  			} else {
   129  				c.Check(fatal, gc.Equals, i == 0)
   130  			}
   131  		}
   132  	}
   133  }
   134  
   135  func (s *toolSuite) TestPingerIsFatalWithMultipleConns(c *gc.C) {
   136  	var errPinger testPinger = func() error {
   137  		return stderrors.New("ping error")
   138  	}
   139  	var okPinger testPinger = func() error {
   140  		return nil
   141  	}
   142  
   143  	someErr := stderrors.New("foo")
   144  
   145  	c.Assert(PingerIsFatal(logger, okPinger, okPinger)(someErr),
   146  		jc.IsFalse)
   147  	c.Assert(PingerIsFatal(logger, okPinger, okPinger, okPinger)(someErr),
   148  		jc.IsFalse)
   149  	c.Assert(PingerIsFatal(logger, okPinger, errPinger)(someErr),
   150  		jc.IsTrue)
   151  	c.Assert(PingerIsFatal(logger, okPinger, okPinger, errPinger)(someErr),
   152  		jc.IsTrue)
   153  	c.Assert(PingerIsFatal(logger, errPinger, okPinger, okPinger)(someErr),
   154  		jc.IsTrue)
   155  }
   156  
   157  func (*toolSuite) TestIsFatal(c *gc.C) {
   158  
   159  	for i, test := range isFatalTests {
   160  		c.Logf("test %d: %s", i, test.err)
   161  		c.Assert(IsFatal(test.err), gc.Equals, test.isFatal)
   162  	}
   163  }
   164  
   165  type testConn struct {
   166  	broken bool
   167  }
   168  
   169  func (c *testConn) IsBroken() bool {
   170  	return c.broken
   171  }
   172  
   173  type testPinger func() error
   174  
   175  func (f testPinger) Ping() error {
   176  	return f()
   177  }