github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/apiserver/lifeflag/facade_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package lifeflag_test
     5  
     6  import (
     7  	"github.com/juju/testing"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  
    11  	"github.com/juju/juju/apiserver/common"
    12  	"github.com/juju/juju/apiserver/lifeflag"
    13  	"github.com/juju/juju/apiserver/params"
    14  )
    15  
    16  type FacadeSuite struct {
    17  	testing.IsolationSuite
    18  }
    19  
    20  var _ = gc.Suite(&FacadeSuite{})
    21  
    22  func (*FacadeSuite) TestFacadeAuthFailure(c *gc.C) {
    23  	facade, err := lifeflag.NewFacade(nil, nil, auth(false))
    24  	c.Check(facade, gc.IsNil)
    25  	c.Check(err, gc.Equals, common.ErrPerm)
    26  }
    27  
    28  func (*FacadeSuite) TestLifeBadEntity(c *gc.C) {
    29  	backend := &mockBackend{}
    30  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
    31  	c.Assert(err, jc.ErrorIsNil)
    32  
    33  	results, err := facade.Life(entities("archibald snookums"))
    34  	c.Check(err, jc.ErrorIsNil)
    35  	c.Assert(results.Results, gc.HasLen, 1)
    36  	result := results.Results[0]
    37  	c.Check(result.Life, gc.Equals, params.Life(""))
    38  
    39  	// TODO(fwereade): this is DUMB. should just be a parse error.
    40  	// but I'm not fixing the underlying implementation as well.
    41  	c.Check(result.Error, jc.Satisfies, params.IsCodeUnauthorized)
    42  }
    43  
    44  func (*FacadeSuite) TestLifeAuthFailure(c *gc.C) {
    45  	backend := &mockBackend{}
    46  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
    47  	c.Assert(err, jc.ErrorIsNil)
    48  
    49  	results, err := facade.Life(entities("unit-foo-1"))
    50  	c.Check(err, jc.ErrorIsNil)
    51  	c.Assert(results.Results, gc.HasLen, 1)
    52  	result := results.Results[0]
    53  	c.Check(result.Life, gc.Equals, params.Life(""))
    54  	c.Check(result.Error, jc.Satisfies, params.IsCodeUnauthorized)
    55  }
    56  
    57  func (*FacadeSuite) TestLifeNotFound(c *gc.C) {
    58  	backend := &mockBackend{}
    59  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
    60  	c.Assert(err, jc.ErrorIsNil)
    61  
    62  	results, err := facade.Life(modelEntity())
    63  	c.Check(err, jc.ErrorIsNil)
    64  	c.Assert(results.Results, gc.HasLen, 1)
    65  	result := results.Results[0]
    66  	c.Check(result.Life, gc.Equals, params.Life(""))
    67  	c.Check(result.Error, jc.Satisfies, params.IsCodeNotFound)
    68  }
    69  
    70  func (*FacadeSuite) TestLifeSuccess(c *gc.C) {
    71  	backend := &mockBackend{exist: true}
    72  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
    73  	c.Check(err, jc.ErrorIsNil)
    74  
    75  	results, err := facade.Life(modelEntity())
    76  	c.Check(err, jc.ErrorIsNil)
    77  	c.Check(results, jc.DeepEquals, params.LifeResults{
    78  		Results: []params.LifeResult{{Life: params.Dying}},
    79  	})
    80  }
    81  
    82  func (*FacadeSuite) TestWatchBadEntity(c *gc.C) {
    83  	backend := &mockBackend{}
    84  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
    85  	c.Assert(err, jc.ErrorIsNil)
    86  
    87  	results, err := facade.Watch(entities("archibald snookums"))
    88  	c.Check(err, jc.ErrorIsNil)
    89  	c.Assert(results.Results, gc.HasLen, 1)
    90  	result := results.Results[0]
    91  	c.Check(result.NotifyWatcherId, gc.Equals, "")
    92  
    93  	// TODO(fwereade): this is DUMB. should just be a parse error.
    94  	// but I'm not fixing the underlying implementation as well.
    95  	c.Check(result.Error, jc.Satisfies, params.IsCodeUnauthorized)
    96  }
    97  
    98  func (*FacadeSuite) TestWatchAuthFailure(c *gc.C) {
    99  	backend := &mockBackend{}
   100  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
   101  	c.Assert(err, jc.ErrorIsNil)
   102  
   103  	results, err := facade.Watch(entities("unit-foo-1"))
   104  	c.Check(err, jc.ErrorIsNil)
   105  	c.Assert(results.Results, gc.HasLen, 1)
   106  	result := results.Results[0]
   107  	c.Check(result.NotifyWatcherId, gc.Equals, "")
   108  	c.Check(result.Error, jc.Satisfies, params.IsCodeUnauthorized)
   109  }
   110  
   111  func (*FacadeSuite) TestWatchNotFound(c *gc.C) {
   112  	backend := &mockBackend{}
   113  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
   114  	c.Assert(err, jc.ErrorIsNil)
   115  
   116  	results, err := facade.Watch(modelEntity())
   117  	c.Check(err, jc.ErrorIsNil)
   118  	c.Assert(results.Results, gc.HasLen, 1)
   119  	result := results.Results[0]
   120  	c.Check(result.NotifyWatcherId, gc.Equals, "")
   121  	c.Check(result.Error, jc.Satisfies, params.IsCodeNotFound)
   122  }
   123  
   124  func (*FacadeSuite) TestWatchBadWatcher(c *gc.C) {
   125  	backend := &mockBackend{exist: true}
   126  	facade, err := lifeflag.NewFacade(backend, nil, auth(true))
   127  	c.Check(err, jc.ErrorIsNil)
   128  
   129  	results, err := facade.Watch(modelEntity())
   130  	c.Check(err, jc.ErrorIsNil)
   131  	c.Assert(results.Results, gc.HasLen, 1)
   132  	result := results.Results[0]
   133  	c.Check(result.NotifyWatcherId, gc.Equals, "")
   134  	c.Check(result.Error, gc.ErrorMatches, "blammo")
   135  }
   136  
   137  func (*FacadeSuite) TestWatchSuccess(c *gc.C) {
   138  	backend := &mockBackend{exist: true, watch: true}
   139  	resources := common.NewResources()
   140  	facade, err := lifeflag.NewFacade(backend, resources, auth(true))
   141  	c.Check(err, jc.ErrorIsNil)
   142  
   143  	results, err := facade.Watch(modelEntity())
   144  	c.Check(err, jc.ErrorIsNil)
   145  	c.Check(results, jc.DeepEquals, params.NotifyWatchResults{
   146  		Results: []params.NotifyWatchResult{{NotifyWatcherId: "1"}},
   147  	})
   148  }