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

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package metricsadder_test
     5  
     6  import (
     7  	"time"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	"github.com/juju/utils"
    11  	gc "gopkg.in/check.v1"
    12  	"gopkg.in/juju/names.v2"
    13  
    14  	"github.com/juju/juju/api/metricsadder"
    15  	"github.com/juju/juju/apiserver/common"
    16  	"github.com/juju/juju/apiserver/params"
    17  	jujutesting "github.com/juju/juju/juju/testing"
    18  	"github.com/juju/juju/state"
    19  	"github.com/juju/juju/testing/factory"
    20  )
    21  
    22  type metricsAdderSuite struct {
    23  	jujutesting.JujuConnSuite
    24  
    25  	adder *metricsadder.Client
    26  }
    27  
    28  var _ = gc.Suite(&metricsAdderSuite{})
    29  
    30  func (s *metricsAdderSuite) SetUpTest(c *gc.C) {
    31  	s.JujuConnSuite.SetUpTest(c)
    32  	s.adder = metricsadder.NewClient(s.APIState)
    33  	c.Assert(s.adder, gc.NotNil)
    34  }
    35  
    36  func (s *metricsAdderSuite) TestAddMetricBatches(c *gc.C) {
    37  	var called bool
    38  	var callParams params.MetricBatchParams
    39  	metricsadder.PatchFacadeCall(s, s.adder, func(request string, args, response interface{}) error {
    40  		p, ok := args.(params.MetricBatchParams)
    41  		c.Assert(ok, jc.IsTrue)
    42  		callParams = p
    43  		called = true
    44  		c.Assert(request, gc.Equals, "AddMetricBatches")
    45  		result := response.(*params.ErrorResults)
    46  		result.Results = make([]params.ErrorResult, 1)
    47  		return nil
    48  	})
    49  
    50  	batches := []params.MetricBatchParam{{
    51  		Tag: names.NewUnitTag("test-unit/0").String(),
    52  		Batch: params.MetricBatch{
    53  			UUID:     utils.MustNewUUID().String(),
    54  			CharmURL: "test-charm-url",
    55  			Created:  time.Now(),
    56  			Metrics:  []params.Metric{{Key: "pings", Value: "5", Time: time.Now().UTC()}},
    57  		},
    58  	}}
    59  
    60  	_, err := s.adder.AddMetricBatches(batches)
    61  	c.Assert(err, jc.ErrorIsNil)
    62  	c.Assert(called, jc.IsTrue)
    63  	c.Assert(callParams.Batches, gc.DeepEquals, batches)
    64  }
    65  
    66  func (s *metricsAdderSuite) TestAddMetricBatchesFails(c *gc.C) {
    67  	var called bool
    68  	metricsadder.PatchFacadeCall(s, s.adder, func(request string, args, response interface{}) error {
    69  		_, ok := args.(params.MetricBatchParams)
    70  		c.Assert(ok, jc.IsTrue)
    71  		called = true
    72  		c.Assert(request, gc.Equals, "AddMetricBatches")
    73  		result := response.(*params.ErrorResults)
    74  		result.Results = make([]params.ErrorResult, 1)
    75  		result.Results[0].Error = common.ServerError(common.ErrPerm)
    76  		return nil
    77  	})
    78  
    79  	batches := []params.MetricBatchParam{{
    80  		Tag: names.NewUnitTag("test-unit/0").String(),
    81  		Batch: params.MetricBatch{
    82  			UUID:     utils.MustNewUUID().String(),
    83  			CharmURL: "test-charm-url",
    84  			Created:  time.Now(),
    85  			Metrics:  []params.Metric{{Key: "pings", Value: "5", Time: time.Now().UTC()}},
    86  		},
    87  	}}
    88  
    89  	results, err := s.adder.AddMetricBatches(batches)
    90  	c.Assert(err, jc.ErrorIsNil)
    91  	result, ok := results[batches[0].Batch.UUID]
    92  	c.Assert(ok, jc.IsTrue)
    93  	c.Assert(result.Error(), gc.Equals, "permission denied")
    94  	c.Assert(called, jc.IsTrue)
    95  }
    96  
    97  type metricsAdderIntegrationSuite struct {
    98  	jujutesting.JujuConnSuite
    99  
   100  	adder   *metricsadder.Client
   101  	unitTag names.Tag
   102  }
   103  
   104  var _ = gc.Suite(&metricsAdderIntegrationSuite{})
   105  
   106  func (s *metricsAdderIntegrationSuite) SetUpTest(c *gc.C) {
   107  	s.JujuConnSuite.SetUpTest(c)
   108  	machine0 := s.Factory.MakeMachine(c, &factory.MachineParams{
   109  		Series: "quantal",
   110  		Jobs:   []state.MachineJob{state.JobHostUnits},
   111  	})
   112  
   113  	meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{
   114  		Name: "metered",
   115  		URL:  "cs:quantal/metered",
   116  	})
   117  	meteredApp := s.Factory.MakeApplication(c, &factory.ApplicationParams{
   118  		Charm: meteredCharm,
   119  	})
   120  	meteredUnit := s.Factory.MakeUnit(c, &factory.UnitParams{
   121  		Application: meteredApp,
   122  		SetCharmURL: true,
   123  		Machine:     machine0,
   124  	})
   125  
   126  	state, _ := s.OpenAPIAsNewMachine(c)
   127  	s.adder = metricsadder.NewClient(state)
   128  	s.unitTag = meteredUnit.Tag()
   129  }
   130  
   131  func (s *metricsAdderIntegrationSuite) TestAddMetricBatches(c *gc.C) {
   132  	batches := []params.MetricBatchParam{{
   133  		Tag: s.unitTag.String(),
   134  		Batch: params.MetricBatch{
   135  			UUID:     utils.MustNewUUID().String(),
   136  			CharmURL: "cs:quantal/metered",
   137  			Created:  time.Now(),
   138  			Metrics:  []params.Metric{{Key: "pings", Value: "5", Time: time.Now().UTC()}},
   139  		},
   140  	}}
   141  
   142  	results, err := s.adder.AddMetricBatches(batches)
   143  	c.Assert(err, jc.ErrorIsNil)
   144  	c.Assert(results, gc.HasLen, 1)
   145  	result, ok := results[batches[0].Batch.UUID]
   146  	c.Assert(ok, jc.IsTrue)
   147  	c.Assert(result, gc.IsNil)
   148  
   149  	stateBatches, err := s.State.AllMetricBatches()
   150  	c.Assert(err, jc.ErrorIsNil)
   151  	c.Assert(stateBatches, gc.HasLen, 1)
   152  	c.Assert(stateBatches[0].CharmURL(), gc.Equals, batches[0].Batch.CharmURL)
   153  	c.Assert(stateBatches[0].UUID(), gc.Equals, batches[0].Batch.UUID)
   154  	c.Assert(stateBatches[0].ModelUUID(), gc.Equals, s.State.ModelUUID())
   155  	c.Assert(stateBatches[0].Unit(), gc.Equals, s.unitTag.Id())
   156  }