func (s *ContextRelationSuite) TestMemberCaching(c *gc.C) {
unit, err := s.svc.AddUnit()
c.Assert(err, jc.ErrorIsNil)
ru, err := s.rel.Unit(unit)
c.Assert(err, jc.ErrorIsNil)
err = ru.EnterScope(map[string]interface{}{"blib": "blob"})
c.Assert(err, jc.ErrorIsNil)
settings, err := ru.Settings()
c.Assert(err, jc.ErrorIsNil)
settings.Set("ping", "pong")
_, err = settings.Write()
c.Assert(err, jc.ErrorIsNil)
cache := context.NewRelationCache(s.apiRelUnit.ReadSettings, []string{"u/1"})
ctx := context.NewContextRelation(s.apiRelUnit, cache)
// Check that uncached settings are read from state.
m, err := ctx.ReadSettings("u/1")
c.Assert(err, jc.ErrorIsNil)
expectMap := settings.Map()
expectSettings := convertMap(expectMap)
c.Assert(m, gc.DeepEquals, expectSettings)
// Check that changes to state do not affect the cached settings.
settings.Set("ping", "pow")
_, err = settings.Write()
c.Assert(err, jc.ErrorIsNil)
m, err = ctx.ReadSettings("u/1")
c.Assert(err, jc.ErrorIsNil)
c.Assert(m, gc.DeepEquals, expectSettings)
}
func (s *HookContextSuite) getHookContext(c *gc.C, uuid string, relid int,
remote string, proxies proxy.Settings) *context.HookContext {
if relid != -1 {
_, found := s.apiRelunits[relid]
c.Assert(found, jc.IsTrue)
}
facade, err := s.st.Uniter()
c.Assert(err, jc.ErrorIsNil)
relctxs := map[int]*context.ContextRelation{}
for relId, relUnit := range s.apiRelunits {
cache := context.NewRelationCache(relUnit.ReadSettings, nil)
relctxs[relId] = context.NewContextRelation(relUnit, cache)
}
env, err := s.State.Environment()
c.Assert(err, jc.ErrorIsNil)
context, err := context.NewHookContext(s.apiUnit, facade, "TestCtx", uuid,
env.Name(), relid, remote, relctxs, apiAddrs,
proxies, false, nil, nil, s.machine.Tag().(names.MachineTag),
runnertesting.NewRealPaths(c))
c.Assert(err, jc.ErrorIsNil)
return context
}
func (s *HookContextSuite) getMeteredHookContext(c *gc.C, uuid string, relid int,
remote string, proxies proxy.Settings, canAddMetrics bool, metrics *charm.Metrics, paths runnertesting.RealPaths) *context.HookContext {
if relid != -1 {
_, found := s.apiRelunits[relid]
c.Assert(found, jc.IsTrue)
}
facade, err := s.st.Uniter()
c.Assert(err, jc.ErrorIsNil)
relctxs := map[int]*context.ContextRelation{}
for relId, relUnit := range s.apiRelunits {
cache := context.NewRelationCache(relUnit.ReadSettings, nil)
relctxs[relId] = context.NewContextRelation(relUnit, cache)
}
context, err := context.NewHookContext(s.meteredApiUnit, facade, "TestCtx", uuid,
"test-env-name", relid, remote, relctxs, apiAddrs,
proxies, canAddMetrics, metrics, nil, s.machine.Tag().(names.MachineTag),
paths)
c.Assert(err, jc.ErrorIsNil)
return context
}
func (s *ContextRelationSuite) TestLocalSettings(c *gc.C) {
ctx := context.NewContextRelation(s.apiRelUnit, nil)
// Change Settings...
node, err := ctx.Settings()
c.Assert(err, jc.ErrorIsNil)
expectSettings := node.Map()
expectOldMap := convertSettings(expectSettings)
node.Set("change", "exciting")
// ...and check it's not written to state.
settings, err := s.ru.ReadSettings("u/0")
c.Assert(err, jc.ErrorIsNil)
c.Assert(settings, gc.DeepEquals, expectOldMap)
// Write settings...
err = ctx.WriteSettings()
c.Assert(err, jc.ErrorIsNil)
// ...and check it was written to state.
settings, err = s.ru.ReadSettings("u/0")
c.Assert(err, jc.ErrorIsNil)
c.Assert(settings, gc.DeepEquals, map[string]interface{}{"change": "exciting"})
}