github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/facades/agent/logger/logger_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package logger_test
     5  
     6  import (
     7  	"time"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/names.v2"
    12  	"gopkg.in/juju/worker.v1/workertest"
    13  
    14  	"github.com/juju/juju/apiserver/common"
    15  	"github.com/juju/juju/apiserver/facade"
    16  	"github.com/juju/juju/apiserver/facade/facadetest"
    17  	"github.com/juju/juju/apiserver/facades/agent/logger"
    18  	"github.com/juju/juju/apiserver/params"
    19  	apiservertesting "github.com/juju/juju/apiserver/testing"
    20  	"github.com/juju/juju/core/cache"
    21  	"github.com/juju/juju/core/cache/cachetest"
    22  	"github.com/juju/juju/state"
    23  	statetesting "github.com/juju/juju/state/testing"
    24  	"github.com/juju/juju/testing"
    25  )
    26  
    27  type loggerSuite struct {
    28  	statetesting.StateSuite
    29  
    30  	// These are raw State objects. Use them for setup and assertions, but
    31  	// should never be touched by the API calls themselves
    32  	rawMachine *state.Machine
    33  	logger     *logger.LoggerAPI
    34  	resources  *common.Resources
    35  	authorizer apiservertesting.FakeAuthorizer
    36  
    37  	change     cache.ModelChange
    38  	changes    chan interface{}
    39  	controller *cache.Controller
    40  	events     chan interface{}
    41  	capture    func(change interface{})
    42  }
    43  
    44  var _ = gc.Suite(&loggerSuite{})
    45  
    46  func (s *loggerSuite) SetUpTest(c *gc.C) {
    47  	s.StateSuite.SetUpTest(c)
    48  	s.resources = common.NewResources()
    49  	s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() })
    50  
    51  	// Create a machine to work with
    52  	var err error
    53  	s.rawMachine, err = s.State.AddMachine("quantal", state.JobHostUnits)
    54  	c.Assert(err, jc.ErrorIsNil)
    55  
    56  	// The default auth is as the machine agent
    57  	s.authorizer = apiservertesting.FakeAuthorizer{
    58  		Tag: s.rawMachine.Tag(),
    59  	}
    60  
    61  	s.events = make(chan interface{})
    62  	notify := func(change interface{}) {
    63  		send := false
    64  		switch change.(type) {
    65  		case cache.ModelChange:
    66  			send = true
    67  		case cache.RemoveModel:
    68  			send = true
    69  		default:
    70  			// no-op
    71  		}
    72  		if send {
    73  			c.Logf("sending %#v", change)
    74  			select {
    75  			case s.events <- change:
    76  			case <-time.After(testing.LongWait):
    77  				c.Fatalf("change not processed by test")
    78  			}
    79  		}
    80  	}
    81  
    82  	s.changes = make(chan interface{})
    83  	controller, err := cache.NewController(cache.ControllerConfig{
    84  		Changes: s.changes,
    85  		Notify:  notify,
    86  	})
    87  	c.Assert(err, jc.ErrorIsNil)
    88  	s.controller = controller
    89  	s.AddCleanup(func(c *gc.C) { workertest.CleanKill(c, s.controller) })
    90  	// Add the current model to the controller.
    91  	s.change = cachetest.ModelChangeFromState(c, s.State)
    92  	s.changes <- s.change
    93  	// Ensure it is processed before we create the logger api.
    94  	select {
    95  	case <-s.events:
    96  	case <-time.After(testing.LongWait):
    97  		c.Fatalf("change not processed by test")
    98  	}
    99  	s.logger, err = s.makeLoggerAPI(s.authorizer)
   100  	c.Assert(err, jc.ErrorIsNil)
   101  }
   102  
   103  func (s *loggerSuite) makeLoggerAPI(auth facade.Authorizer) (*logger.LoggerAPI, error) {
   104  	ctx := facadetest.Context{
   105  		Auth_:       auth,
   106  		Controller_: s.controller,
   107  		Resources_:  s.resources,
   108  		State_:      s.State,
   109  	}
   110  	return logger.NewLoggerAPI(ctx)
   111  }
   112  
   113  func (s *loggerSuite) TestNewLoggerAPIRefusesNonAgent(c *gc.C) {
   114  	// We aren't even a machine agent
   115  	anAuthorizer := s.authorizer
   116  	anAuthorizer.Tag = names.NewUserTag("some-user")
   117  	endPoint, err := s.makeLoggerAPI(anAuthorizer)
   118  	c.Assert(endPoint, gc.IsNil)
   119  	c.Assert(err, gc.ErrorMatches, "permission denied")
   120  }
   121  
   122  func (s *loggerSuite) TestNewLoggerAPIAcceptsUnitAgent(c *gc.C) {
   123  	// We aren't even a machine agent
   124  	anAuthorizer := s.authorizer
   125  	anAuthorizer.Tag = names.NewUnitTag("germany/7")
   126  	endPoint, err := s.makeLoggerAPI(anAuthorizer)
   127  	c.Assert(err, jc.ErrorIsNil)
   128  	c.Assert(endPoint, gc.NotNil)
   129  }
   130  
   131  func (s *loggerSuite) TestNewLoggerAPIAcceptsApplicationAgent(c *gc.C) {
   132  	anAuthorizer := s.authorizer
   133  	anAuthorizer.Tag = names.NewApplicationTag("germany")
   134  	endPoint, err := s.makeLoggerAPI(anAuthorizer)
   135  	c.Assert(err, jc.ErrorIsNil)
   136  	c.Assert(endPoint, gc.NotNil)
   137  }
   138  
   139  func (s *loggerSuite) TestWatchLoggingConfigNothing(c *gc.C) {
   140  	// Not an error to watch nothing
   141  	results := s.logger.WatchLoggingConfig(params.Entities{})
   142  	c.Assert(results.Results, gc.HasLen, 0)
   143  }
   144  
   145  func (s *loggerSuite) setLoggingConfig(c *gc.C, loggingConfig string) {
   146  	s.change.Config["logging-config"] = loggingConfig
   147  	s.changes <- s.change
   148  	select {
   149  	case <-s.events:
   150  	case <-time.After(testing.LongWait):
   151  		c.Fatalf("change not processed by test")
   152  	}
   153  }
   154  
   155  func (s *loggerSuite) TestWatchLoggingConfig(c *gc.C) {
   156  	args := params.Entities{
   157  		Entities: []params.Entity{{Tag: s.rawMachine.Tag().String()}},
   158  	}
   159  	results := s.logger.WatchLoggingConfig(args)
   160  	c.Assert(results.Results, gc.HasLen, 1)
   161  	c.Assert(results.Results[0].NotifyWatcherId, gc.Not(gc.Equals), "")
   162  	c.Assert(results.Results[0].Error, gc.IsNil)
   163  	resource := s.resources.Get(results.Results[0].NotifyWatcherId)
   164  	c.Assert(resource, gc.NotNil)
   165  
   166  	_, ok := resource.(cache.NotifyWatcher)
   167  	c.Assert(ok, jc.IsTrue)
   168  	// The watcher implementation is tested in the cache package.
   169  }
   170  
   171  func (s *loggerSuite) TestWatchLoggingConfigRefusesWrongAgent(c *gc.C) {
   172  	// We are a machine agent, but not the one we are trying to track
   173  	args := params.Entities{
   174  		Entities: []params.Entity{{Tag: "machine-12354"}},
   175  	}
   176  	results := s.logger.WatchLoggingConfig(args)
   177  	// It is not an error to make the request, but the specific item is rejected
   178  	c.Assert(results.Results, gc.HasLen, 1)
   179  	c.Assert(results.Results[0].NotifyWatcherId, gc.Equals, "")
   180  	c.Assert(results.Results[0].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
   181  }
   182  
   183  func (s *loggerSuite) TestLoggingConfigForNoone(c *gc.C) {
   184  	// Not an error to request nothing, dumb, but not an error.
   185  	results := s.logger.LoggingConfig(params.Entities{})
   186  	c.Assert(results.Results, gc.HasLen, 0)
   187  }
   188  
   189  func (s *loggerSuite) TestLoggingConfigRefusesWrongAgent(c *gc.C) {
   190  	args := params.Entities{
   191  		Entities: []params.Entity{{Tag: "machine-12354"}},
   192  	}
   193  	results := s.logger.LoggingConfig(args)
   194  	c.Assert(results.Results, gc.HasLen, 1)
   195  	result := results.Results[0]
   196  	c.Assert(result.Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
   197  }
   198  
   199  func (s *loggerSuite) TestLoggingConfigForAgent(c *gc.C) {
   200  	newLoggingConfig := "<root>=WARN;juju.log.test=DEBUG;unit=INFO"
   201  	s.setLoggingConfig(c, newLoggingConfig)
   202  
   203  	args := params.Entities{
   204  		Entities: []params.Entity{{Tag: s.rawMachine.Tag().String()}},
   205  	}
   206  	results := s.logger.LoggingConfig(args)
   207  	c.Assert(results.Results, gc.HasLen, 1)
   208  	result := results.Results[0]
   209  	c.Assert(result.Error, gc.IsNil)
   210  	c.Assert(result.Result, gc.Equals, newLoggingConfig)
   211  }