github.com/Pankov404/juju@v0.0.0-20150703034450-be266991dceb/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  	"testing"
     9  
    10  	"github.com/juju/errors"
    11  	"github.com/juju/loggo"
    12  	jc "github.com/juju/testing/checkers"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/apiserver/params"
    16  	coretesting "github.com/juju/juju/testing"
    17  	"github.com/juju/juju/worker"
    18  	"github.com/juju/juju/worker/upgrader"
    19  )
    20  
    21  var (
    22  	_      = gc.Suite(&toolSuite{})
    23  	logger = loggo.GetLogger("juju.cmd.jujud")
    24  )
    25  
    26  type toolSuite struct {
    27  	coretesting.BaseSuite
    28  }
    29  
    30  func Test(t *testing.T) {
    31  	gc.TestingT(t)
    32  }
    33  
    34  func (*toolSuite) TestErrorImportance(c *gc.C) {
    35  
    36  	errorImportanceTests := []error{
    37  		nil,
    38  		stderrors.New("foo"),
    39  		&upgrader.UpgradeReadyError{},
    40  		worker.ErrTerminateAgent,
    41  	}
    42  
    43  	for i, err0 := range errorImportanceTests {
    44  		for j, err1 := range errorImportanceTests {
    45  			c.Assert(MoreImportant(err0, err1), gc.Equals, i > j)
    46  
    47  			// Should also work if errors are wrapped.
    48  			c.Assert(MoreImportant(errors.Trace(err0), errors.Trace(err1)), gc.Equals, i > j)
    49  		}
    50  	}
    51  }
    52  
    53  var isFatalTests = []struct {
    54  	err     error
    55  	isFatal bool
    56  }{
    57  	{
    58  		err:     worker.ErrTerminateAgent,
    59  		isFatal: true,
    60  	}, {
    61  		err:     errors.Trace(worker.ErrTerminateAgent),
    62  		isFatal: true,
    63  	}, {
    64  		err:     &upgrader.UpgradeReadyError{},
    65  		isFatal: true,
    66  	}, {
    67  		err: &params.Error{
    68  			Message: "blah",
    69  			Code:    params.CodeNotProvisioned,
    70  		},
    71  		isFatal: false,
    72  	}, {
    73  		err:     &FatalError{"some fatal error"},
    74  		isFatal: true,
    75  	}, {
    76  		err:     stderrors.New("foo"),
    77  		isFatal: false,
    78  	}, {
    79  		err: &params.Error{
    80  			Message: "blah",
    81  			Code:    params.CodeNotFound,
    82  		},
    83  		isFatal: false,
    84  	},
    85  }
    86  
    87  func (s *toolSuite) TestConnectionIsFatal(c *gc.C) {
    88  	var (
    89  		errPinger testPinger = func() error {
    90  			return stderrors.New("ping error")
    91  		}
    92  		okPinger testPinger = func() error {
    93  			return nil
    94  		}
    95  	)
    96  	for i, pinger := range []testPinger{errPinger, okPinger} {
    97  		for j, test := range isFatalTests {
    98  			c.Logf("test %d.%d: %s", i, j, test.err)
    99  			fatal := ConnectionIsFatal(logger, pinger)(test.err)
   100  			if test.isFatal {
   101  				c.Check(fatal, jc.IsTrue)
   102  			} else {
   103  				c.Check(fatal, gc.Equals, i == 0)
   104  			}
   105  		}
   106  	}
   107  }
   108  
   109  func (s *toolSuite) TestConnectionIsFatalWithMultipleConns(c *gc.C) {
   110  	var (
   111  		errPinger testPinger = func() error {
   112  			return stderrors.New("ping error")
   113  		}
   114  		okPinger testPinger = func() error {
   115  			return nil
   116  		}
   117  	)
   118  
   119  	someErr := stderrors.New("foo")
   120  
   121  	c.Assert(ConnectionIsFatal(logger, okPinger, okPinger)(someErr),
   122  		jc.IsFalse)
   123  	c.Assert(ConnectionIsFatal(logger, okPinger, okPinger, okPinger)(someErr),
   124  		jc.IsFalse)
   125  	c.Assert(ConnectionIsFatal(logger, okPinger, errPinger)(someErr),
   126  		jc.IsTrue)
   127  	c.Assert(ConnectionIsFatal(logger, okPinger, okPinger, errPinger)(someErr),
   128  		jc.IsTrue)
   129  	c.Assert(ConnectionIsFatal(logger, errPinger, okPinger, okPinger)(someErr),
   130  		jc.IsTrue)
   131  }
   132  
   133  func (*toolSuite) TestIsFatal(c *gc.C) {
   134  
   135  	for i, test := range isFatalTests {
   136  		c.Logf("test %d: %s", i, test.err)
   137  		c.Assert(IsFatal(test.err), gc.Equals, test.isFatal)
   138  	}
   139  }
   140  
   141  type testPinger func() error
   142  
   143  func (f testPinger) Ping() error {
   144  	return f()
   145  }