github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/api/caasfirewaller/client_test.go (about)

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package caasfirewaller_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/names.v2"
    12  
    13  	basetesting "github.com/juju/juju/api/base/testing"
    14  	"github.com/juju/juju/api/caasfirewaller"
    15  	"github.com/juju/juju/apiserver/params"
    16  	"github.com/juju/juju/core/application"
    17  	"github.com/juju/juju/core/life"
    18  )
    19  
    20  type FirewallerSuite struct {
    21  	testing.IsolationSuite
    22  }
    23  
    24  var _ = gc.Suite(&FirewallerSuite{})
    25  
    26  func (s *FirewallerSuite) TestIsExposed(c *gc.C) {
    27  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    28  		c.Check(objType, gc.Equals, "CAASFirewaller")
    29  		c.Check(version, gc.Equals, 0)
    30  		c.Check(id, gc.Equals, "")
    31  		c.Check(request, gc.Equals, "IsExposed")
    32  		c.Check(arg, jc.DeepEquals, params.Entities{
    33  			Entities: []params.Entity{{
    34  				Tag: "application-gitlab",
    35  			}},
    36  		})
    37  		c.Assert(result, gc.FitsTypeOf, &params.BoolResults{})
    38  		*(result.(*params.BoolResults)) = params.BoolResults{
    39  			Results: []params.BoolResult{{
    40  				Result: true,
    41  			}},
    42  		}
    43  		return nil
    44  	})
    45  
    46  	client := caasfirewaller.NewClient(apiCaller)
    47  	exposed, err := client.IsExposed("gitlab")
    48  	c.Assert(err, jc.ErrorIsNil)
    49  	c.Assert(exposed, jc.IsTrue)
    50  }
    51  
    52  func (s *FirewallerSuite) TestIsExposedError(c *gc.C) {
    53  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    54  		*(result.(*params.BoolResults)) = params.BoolResults{
    55  			Results: []params.BoolResult{{Error: &params.Error{
    56  				Code:    params.CodeNotFound,
    57  				Message: "bletch",
    58  			}}},
    59  		}
    60  		return nil
    61  	})
    62  
    63  	client := caasfirewaller.NewClient(apiCaller)
    64  	_, err := client.IsExposed("gitlab")
    65  	c.Assert(err, gc.ErrorMatches, "bletch")
    66  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
    67  }
    68  
    69  func (s *FirewallerSuite) TestIsExposedInvalidEntityame(c *gc.C) {
    70  	client := caasfirewaller.NewClient(basetesting.APICallerFunc(func(_ string, _ int, _, _ string, _, _ interface{}) error {
    71  		return errors.New("should not be called")
    72  	}))
    73  	_, err := client.IsExposed("")
    74  	c.Assert(err, gc.ErrorMatches, `application name "" not valid`)
    75  }
    76  
    77  func (s *FirewallerSuite) TestLife(c *gc.C) {
    78  	tag := names.NewApplicationTag("gitlab")
    79  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    80  		c.Check(objType, gc.Equals, "CAASFirewaller")
    81  		c.Check(version, gc.Equals, 0)
    82  		c.Check(id, gc.Equals, "")
    83  		c.Check(request, gc.Equals, "Life")
    84  		c.Check(arg, jc.DeepEquals, params.Entities{
    85  			Entities: []params.Entity{{
    86  				Tag: tag.String(),
    87  			}},
    88  		})
    89  		c.Assert(result, gc.FitsTypeOf, &params.LifeResults{})
    90  		*(result.(*params.LifeResults)) = params.LifeResults{
    91  			Results: []params.LifeResult{{
    92  				Life: params.Alive,
    93  			}},
    94  		}
    95  		return nil
    96  	})
    97  
    98  	client := caasfirewaller.NewClient(apiCaller)
    99  	lifeValue, err := client.Life(tag.Id())
   100  	c.Assert(err, jc.ErrorIsNil)
   101  	c.Assert(lifeValue, gc.Equals, life.Alive)
   102  }
   103  
   104  func (s *FirewallerSuite) TestLifeError(c *gc.C) {
   105  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   106  		*(result.(*params.LifeResults)) = params.LifeResults{
   107  			Results: []params.LifeResult{{Error: &params.Error{
   108  				Code:    params.CodeNotFound,
   109  				Message: "bletch",
   110  			}}},
   111  		}
   112  		return nil
   113  	})
   114  
   115  	client := caasfirewaller.NewClient(apiCaller)
   116  	_, err := client.Life("gitlab")
   117  	c.Assert(err, gc.ErrorMatches, "bletch")
   118  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
   119  }
   120  
   121  func (s *FirewallerSuite) TestLifeInvalidEntityame(c *gc.C) {
   122  	client := caasfirewaller.NewClient(basetesting.APICallerFunc(func(_ string, _ int, _, _ string, _, _ interface{}) error {
   123  		return errors.New("should not be called")
   124  	}))
   125  	_, err := client.Life("")
   126  	c.Assert(err, gc.ErrorMatches, `application name "" not valid`)
   127  }
   128  
   129  func (s *FirewallerSuite) TestWatchApplications(c *gc.C) {
   130  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   131  		c.Check(objType, gc.Equals, "CAASFirewaller")
   132  		c.Check(version, gc.Equals, 0)
   133  		c.Check(id, gc.Equals, "")
   134  		c.Check(request, gc.Equals, "WatchApplications")
   135  		c.Assert(result, gc.FitsTypeOf, &params.StringsWatchResult{})
   136  		*(result.(*params.StringsWatchResult)) = params.StringsWatchResult{
   137  			Error: &params.Error{Message: "FAIL"},
   138  		}
   139  		return nil
   140  	})
   141  
   142  	client := caasfirewaller.NewClient(apiCaller)
   143  	watcher, err := client.WatchApplications()
   144  	c.Assert(watcher, gc.IsNil)
   145  	c.Assert(err, gc.ErrorMatches, "FAIL")
   146  }
   147  
   148  func (s *FirewallerSuite) TestWatchApplication(c *gc.C) {
   149  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   150  		c.Check(objType, gc.Equals, "CAASFirewaller")
   151  		c.Check(version, gc.Equals, 0)
   152  		c.Check(id, gc.Equals, "")
   153  		c.Check(request, gc.Equals, "Watch")
   154  		c.Assert(arg, jc.DeepEquals, params.Entities{
   155  			Entities: []params.Entity{{
   156  				Tag: "application-gitlab",
   157  			}},
   158  		})
   159  		c.Assert(result, gc.FitsTypeOf, &params.NotifyWatchResults{})
   160  		*(result.(*params.NotifyWatchResults)) = params.NotifyWatchResults{
   161  			Results: []params.NotifyWatchResult{{
   162  				Error: &params.Error{Message: "FAIL"},
   163  			}},
   164  		}
   165  		return nil
   166  	})
   167  
   168  	client := caasfirewaller.NewClient(apiCaller)
   169  	watcher, err := client.WatchApplication("gitlab")
   170  	c.Assert(watcher, gc.IsNil)
   171  	c.Assert(err, gc.ErrorMatches, "FAIL")
   172  }
   173  
   174  func (s *FirewallerSuite) TestApplicationConfig(c *gc.C) {
   175  	apiCaller := basetesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   176  		c.Check(objType, gc.Equals, "CAASFirewaller")
   177  		c.Check(version, gc.Equals, 0)
   178  		c.Check(id, gc.Equals, "")
   179  		c.Check(request, gc.Equals, "ApplicationsConfig")
   180  		c.Assert(arg, jc.DeepEquals, params.Entities{
   181  			Entities: []params.Entity{{
   182  				Tag: "application-gitlab",
   183  			}},
   184  		})
   185  		c.Assert(result, gc.FitsTypeOf, &params.ApplicationGetConfigResults{})
   186  		*(result.(*params.ApplicationGetConfigResults)) = params.ApplicationGetConfigResults{
   187  			Results: []params.ConfigResult{{
   188  				Config: map[string]interface{}{"foo": "bar"},
   189  			}},
   190  		}
   191  		return nil
   192  	})
   193  
   194  	client := caasfirewaller.NewClient(apiCaller)
   195  	cfg, err := client.ApplicationConfig("gitlab")
   196  	c.Assert(err, jc.ErrorIsNil)
   197  	c.Assert(cfg, jc.DeepEquals, application.ConfigAttributes{"foo": "bar"})
   198  }