github.com/Pankov404/juju@v0.0.0-20150703034450-be266991dceb/apiserver/cleaner/cleaner_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package cleaner_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/apiserver/cleaner"
    13  	"github.com/juju/juju/apiserver/common"
    14  	"github.com/juju/juju/apiserver/params"
    15  	apiservertesting "github.com/juju/juju/apiserver/testing"
    16  	"github.com/juju/juju/state"
    17  	coretesting "github.com/juju/juju/testing"
    18  )
    19  
    20  type CleanerSuite struct {
    21  	coretesting.BaseSuite
    22  
    23  	st         *mockState
    24  	api        *cleaner.CleanerAPI
    25  	authoriser apiservertesting.FakeAuthorizer
    26  }
    27  
    28  var _ = gc.Suite(&CleanerSuite{})
    29  
    30  func (s *CleanerSuite) SetUpTest(c *gc.C) {
    31  	s.BaseSuite.SetUpTest(c)
    32  
    33  	s.authoriser = apiservertesting.FakeAuthorizer{
    34  		EnvironManager: true,
    35  	}
    36  	s.st = &mockState{&testing.Stub{}, false}
    37  	cleaner.PatchState(s, s.st)
    38  	var err error
    39  	res := common.NewResources()
    40  	s.api, err = cleaner.NewCleanerAPI(nil, res, s.authoriser)
    41  	c.Assert(err, jc.ErrorIsNil)
    42  	c.Assert(s.api, gc.NotNil)
    43  }
    44  
    45  func (s *CleanerSuite) TestNewCleanerAPIRequiresEnvironManager(c *gc.C) {
    46  	anAuthoriser := s.authoriser
    47  	anAuthoriser.EnvironManager = false
    48  	api, err := cleaner.NewCleanerAPI(nil, nil, anAuthoriser)
    49  	c.Assert(api, gc.IsNil)
    50  	c.Assert(err, gc.ErrorMatches, "permission denied")
    51  	c.Assert(common.ServerError(err), jc.Satisfies, params.IsCodeUnauthorized)
    52  	//c.Assert(common.ServerError(err), jc.Satisfies, errors.IsUnauthorized)
    53  }
    54  
    55  func (s *CleanerSuite) TestWatchCleanupsSuccess(c *gc.C) {
    56  	_, err := s.api.WatchCleanups()
    57  	c.Assert(err, jc.ErrorIsNil)
    58  	s.st.CheckCallNames(c, "WatchCleanups")
    59  }
    60  
    61  func (s *CleanerSuite) TestWatchCleanupsFailure(c *gc.C) {
    62  	s.st.SetErrors(errors.New("boom!"))
    63  	s.st.watchCleanupsFails = true
    64  
    65  	result, err := s.api.WatchCleanups()
    66  	c.Assert(err, jc.ErrorIsNil)
    67  	c.Assert(result.Error.Error(), gc.Equals, "boom!")
    68  	s.st.CheckCallNames(c, "WatchCleanups")
    69  }
    70  
    71  func (s *CleanerSuite) TestCleanupSuccess(c *gc.C) {
    72  	err := s.api.Cleanup()
    73  	c.Assert(err, jc.ErrorIsNil)
    74  	s.st.CheckCallNames(c, "Cleanup")
    75  }
    76  
    77  func (s *CleanerSuite) TestCleanupFailure(c *gc.C) {
    78  	s.st.SetErrors(errors.New("Boom!"))
    79  	err := s.api.Cleanup()
    80  	c.Assert(err, gc.ErrorMatches, "Boom!")
    81  	s.st.CheckCallNames(c, "Cleanup")
    82  }
    83  
    84  type mockState struct {
    85  	*testing.Stub
    86  	watchCleanupsFails bool
    87  }
    88  
    89  type cleanupWatcher struct {
    90  	out chan struct{}
    91  	st  *mockState
    92  }
    93  
    94  func (w *cleanupWatcher) Changes() <-chan struct{} {
    95  	return w.out
    96  }
    97  
    98  func (w *cleanupWatcher) Stop() error {
    99  	return nil
   100  }
   101  
   102  func (w *cleanupWatcher) Kill() {
   103  }
   104  
   105  func (w *cleanupWatcher) Wait() error {
   106  	return nil
   107  }
   108  
   109  func (w *cleanupWatcher) Err() error {
   110  	return w.st.NextErr()
   111  }
   112  
   113  func (st *mockState) WatchCleanups() state.NotifyWatcher {
   114  	w := &cleanupWatcher{
   115  		out: make(chan struct{}, 1),
   116  		st:  st,
   117  	}
   118  	if st.watchCleanupsFails {
   119  		close(w.out)
   120  	} else {
   121  		w.out <- struct{}{}
   122  	}
   123  	st.MethodCall(st, "WatchCleanups")
   124  	return w
   125  }
   126  
   127  func (st *mockState) Cleanup() error {
   128  	st.MethodCall(st, "Cleanup")
   129  	return st.NextErr()
   130  }