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: ¶ms.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: ¶ms.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 }