github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/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  	f := factory.NewFactory(s.State)
   109  	machine0 := f.MakeMachine(c, &factory.MachineParams{
   110  		Series: "quantal",
   111  		Jobs:   []state.MachineJob{state.JobHostUnits},
   112  	})
   113  
   114  	meteredCharm := f.MakeCharm(c, &factory.CharmParams{
   115  		Name: "metered",
   116  		URL:  "cs:quantal/metered",
   117  	})
   118  	meteredService := f.MakeApplication(c, &factory.ApplicationParams{
   119  		Charm: meteredCharm,
   120  	})
   121  	meteredUnit := f.MakeUnit(c, &factory.UnitParams{
   122  		Application: meteredService,
   123  		SetCharmURL: true,
   124  		Machine:     machine0,
   125  	})
   126  
   127  	state, _ := s.OpenAPIAsNewMachine(c)
   128  	s.adder = metricsadder.NewClient(state)
   129  	s.unitTag = meteredUnit.Tag()
   130  }
   131  
   132  func (s *metricsAdderIntegrationSuite) TestAddMetricBatches(c *gc.C) {
   133  	batches := []params.MetricBatchParam{{
   134  		Tag: s.unitTag.String(),
   135  		Batch: params.MetricBatch{
   136  			UUID:     utils.MustNewUUID().String(),
   137  			CharmURL: "cs:quantal/metered",
   138  			Created:  time.Now(),
   139  			Metrics:  []params.Metric{{Key: "pings", Value: "5", Time: time.Now().UTC()}},
   140  		},
   141  	}}
   142  
   143  	results, err := s.adder.AddMetricBatches(batches)
   144  	c.Assert(err, jc.ErrorIsNil)
   145  	c.Assert(results, gc.HasLen, 1)
   146  	result, ok := results[batches[0].Batch.UUID]
   147  	c.Assert(ok, jc.IsTrue)
   148  	c.Assert(result, gc.IsNil)
   149  
   150  	stateBatches, err := s.State.AllMetricBatches()
   151  	c.Assert(err, jc.ErrorIsNil)
   152  	c.Assert(stateBatches, gc.HasLen, 1)
   153  	c.Assert(stateBatches[0].CharmURL(), gc.Equals, batches[0].Batch.CharmURL)
   154  	c.Assert(stateBatches[0].UUID(), gc.Equals, batches[0].Batch.UUID)
   155  	c.Assert(stateBatches[0].ModelUUID(), gc.Equals, s.State.ModelUUID())
   156  	c.Assert(stateBatches[0].Unit(), gc.Equals, s.unitTag.Id())
   157  }