Exemple #1
0
func (*FacadeSuite) TestWatchSuccess(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, results interface{}) error {
		typed, ok := results.(*params.NotifyWatchResults)
		c.Assert(ok, jc.IsTrue)
		*typed = params.NotifyWatchResults{
			Results: []params.NotifyWatchResult{{
				NotifyWatcherId: "123",
			}},
		}
		return nil
	})
	expectWatcher := &struct{ watcher.NotifyWatcher }{}
	newWatcher := func(apiCaller base.APICaller, result params.NotifyWatchResult) watcher.NotifyWatcher {
		c.Check(apiCaller, gc.NotNil) // uncomparable
		c.Check(result, jc.DeepEquals, params.NotifyWatchResult{
			NotifyWatcherId: "123",
		})
		return expectWatcher
	}
	facade := lifeflag.NewFacade(caller, newWatcher)

	watcher, err := facade.Watch(names.NewServiceTag("blah"))
	c.Check(err, jc.ErrorIsNil)
	c.Check(watcher, gc.Equals, expectWatcher)
}
Exemple #2
0
func (*FacadeSuite) TestLifeNoResultsError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, _ interface{}) error {
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	result, err := facade.Life(names.NewServiceTag("blah"))
	c.Check(err, gc.ErrorMatches, "expected 1 Life result, got 0")
	c.Check(result, gc.Equals, life.Value(""))
}
Exemple #3
0
func (*FacadeSuite) TestLifeCallError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, _ interface{}) error {
		return errors.New("crunch belch")
	})
	facade := lifeflag.NewFacade(caller, nil)

	result, err := facade.Life(names.NewServiceTag("blah"))
	c.Check(err, gc.ErrorMatches, "crunch belch")
	c.Check(result, gc.Equals, life.Value(""))
}
Exemple #4
0
func (*FacadeSuite) TestWatchNoResultsError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, _ interface{}) error {
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	watcher, err := facade.Watch(names.NewServiceTag("blah"))
	c.Check(err, gc.ErrorMatches, "expected 1 Watch result, got 0")
	c.Check(watcher, gc.IsNil)
}
Exemple #5
0
func (*FacadeSuite) TestWatchCallError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, _ interface{}) error {
		return errors.New("crunch belch")
	})
	facade := lifeflag.NewFacade(caller, nil)

	watcher, err := facade.Watch(names.NewServiceTag("blah"))
	c.Check(err, gc.ErrorMatches, "crunch belch")
	c.Check(watcher, gc.IsNil)
}
Exemple #6
0
func (*FacadeSuite) TestLifeInvalidResultError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, results interface{}) error {
		typed, ok := results.(*params.LifeResults)
		c.Assert(ok, jc.IsTrue)
		*typed = params.LifeResults{
			Results: []params.LifeResult{{Life: "decomposed"}},
		}
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	result, err := facade.Life(names.NewServiceTag("blah"))
	c.Check(err, gc.ErrorMatches, `life value "decomposed" not valid`)
	c.Check(result, gc.Equals, life.Value(""))
}
Exemple #7
0
func (*FacadeSuite) TestLifeExtraResultsError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, results interface{}) error {
		typed, ok := results.(*params.LifeResults)
		c.Assert(ok, jc.IsTrue)
		*typed = params.LifeResults{
			Results: make([]params.LifeResult, 2),
		}
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	result, err := facade.Life(names.NewServiceTag("blah"))
	c.Check(err, gc.ErrorMatches, "expected 1 Life result, got 2")
	c.Check(result, gc.Equals, life.Value(""))
}
Exemple #8
0
func (*FacadeSuite) TestLifeCall(c *gc.C) {
	var called bool
	caller := apiCaller(c, func(request string, args, _ interface{}) error {
		called = true
		c.Check(request, gc.Equals, "Life")
		c.Check(args, jc.DeepEquals, params.Entities{
			Entities: []params.Entity{{Tag: "service-blah"}},
		})
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	facade.Life(names.NewServiceTag("blah"))
	c.Check(called, jc.IsTrue)
}
Exemple #9
0
func (*FacadeSuite) TestWatchExtraResultsError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, results interface{}) error {
		typed, ok := results.(*params.NotifyWatchResults)
		c.Assert(ok, jc.IsTrue)
		*typed = params.NotifyWatchResults{
			Results: make([]params.NotifyWatchResult, 2),
		}
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	watcher, err := facade.Watch(names.NewServiceTag("blah"))
	c.Check(err, gc.ErrorMatches, "expected 1 Watch result, got 2")
	c.Check(watcher, gc.IsNil)
}
Exemple #10
0
func (*FacadeSuite) TestLifeSuccess(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, results interface{}) error {
		typed, ok := results.(*params.LifeResults)
		c.Assert(ok, jc.IsTrue)
		*typed = params.LifeResults{
			Results: []params.LifeResult{{Life: "dying"}},
		}
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	result, err := facade.Life(names.NewServiceTag("blah"))
	c.Check(err, jc.ErrorIsNil)
	c.Check(result, gc.Equals, life.Dying)
}
Exemple #11
0
func (*FacadeSuite) TestWatchCall(c *gc.C) {
	var called bool
	caller := apiCaller(c, func(request string, args, _ interface{}) error {
		called = true
		c.Check(request, gc.Equals, "Watch")
		c.Check(args, jc.DeepEquals, params.Entities{
			Entities: []params.Entity{{Tag: "application-blah"}},
		})
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	facade.Watch(names.NewApplicationTag("blah"))
	c.Check(called, jc.IsTrue)
}
Exemple #12
0
func (*FacadeSuite) TestLifeNotFoundError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, results interface{}) error {
		typed, ok := results.(*params.LifeResults)
		c.Assert(ok, jc.IsTrue)
		*typed = params.LifeResults{
			Results: []params.LifeResult{{
				Error: &params.Error{Code: params.CodeNotFound},
			}},
		}
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	result, err := facade.Life(names.NewServiceTag("blah"))
	c.Check(err, gc.Equals, lifeflag.ErrNotFound)
	c.Check(result, gc.Equals, life.Value(""))
}
Exemple #13
0
func (*FacadeSuite) TestWatchNotFoundError(c *gc.C) {
	caller := apiCaller(c, func(_ string, _, results interface{}) error {
		typed, ok := results.(*params.NotifyWatchResults)
		c.Assert(ok, jc.IsTrue)
		*typed = params.NotifyWatchResults{
			Results: []params.NotifyWatchResult{{
				Error: &params.Error{Code: params.CodeNotFound},
			}},
		}
		return nil
	})
	facade := lifeflag.NewFacade(caller, nil)

	watcher, err := facade.Watch(names.NewApplicationTag("blah"))
	c.Check(err, gc.Equals, lifeflag.ErrNotFound)
	c.Check(watcher, gc.IsNil)
}
Exemple #14
0
func NewFacade(apiCaller base.APICaller) (Facade, error) {
	facade := lifeflag.NewFacade(apiCaller, watcher.NewNotifyWatcher)
	return facade, nil
}