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 }