github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/apiserver/metricsender/metricsender_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package metricsender_test
     5  
     6  import (
     7  	"errors"
     8  	"time"
     9  
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/apiserver/metricsender"
    14  	"github.com/juju/juju/apiserver/metricsender/testing"
    15  	jujutesting "github.com/juju/juju/juju/testing"
    16  	"github.com/juju/juju/state"
    17  	"github.com/juju/juju/testing/factory"
    18  )
    19  
    20  type MetricSenderSuite struct {
    21  	jujutesting.JujuConnSuite
    22  	unit *state.Unit
    23  }
    24  
    25  var _ = gc.Suite(&MetricSenderSuite{})
    26  
    27  var _ metricsender.MetricSender = (*testing.MockSender)(nil)
    28  
    29  var _ metricsender.MetricSender = (*metricsender.NopSender)(nil)
    30  
    31  func (s *MetricSenderSuite) SetUpTest(c *gc.C) {
    32  	s.JujuConnSuite.SetUpTest(c)
    33  	meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "cs:quantal/metered"})
    34  	meteredService := s.Factory.MakeService(c, &factory.ServiceParams{Charm: meteredCharm})
    35  	s.unit = s.Factory.MakeUnit(c, &factory.UnitParams{Service: meteredService, SetCharmURL: true})
    36  }
    37  
    38  // TestSendMetrics creates 2 unsent metrics and a sent metric
    39  // and checks that the 2 unsent metrics get sent and have their
    40  // sent field set to true.
    41  func (s *MetricSenderSuite) TestSendMetrics(c *gc.C) {
    42  	var sender testing.MockSender
    43  	now := time.Now()
    44  	unsent1 := s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Time: &now})
    45  	unsent2 := s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Time: &now})
    46  	s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Sent: true, Time: &now})
    47  	err := metricsender.SendMetrics(s.State, &sender, 10)
    48  	c.Assert(err, jc.ErrorIsNil)
    49  	c.Assert(sender.Data, gc.HasLen, 1)
    50  	c.Assert(sender.Data[0], gc.HasLen, 2)
    51  
    52  	sent1, err := s.State.MetricBatch(unsent1.UUID())
    53  	c.Assert(err, jc.ErrorIsNil)
    54  	c.Assert(sent1.Sent(), jc.IsTrue)
    55  
    56  	sent2, err := s.State.MetricBatch(unsent2.UUID())
    57  	c.Assert(err, jc.ErrorIsNil)
    58  	c.Assert(sent2.Sent(), jc.IsTrue)
    59  }
    60  
    61  // TestSendBulkMetrics tests the logic of splitting sends
    62  // into batches is done correctly. The batch size is changed
    63  // to send batches of 10 metrics. If we create 100 metrics 10 calls
    64  // will be made to the sender
    65  func (s *MetricSenderSuite) TestSendBulkMetrics(c *gc.C) {
    66  	var sender testing.MockSender
    67  	now := time.Now()
    68  	for i := 0; i < 100; i++ {
    69  		s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Time: &now})
    70  	}
    71  	err := metricsender.SendMetrics(s.State, &sender, 10)
    72  	c.Assert(err, jc.ErrorIsNil)
    73  
    74  	c.Assert(sender.Data, gc.HasLen, 10)
    75  	for i := 0; i < 10; i++ {
    76  		c.Assert(sender.Data, gc.HasLen, 10)
    77  	}
    78  }
    79  
    80  // TestDontSendWithNopSender check that if the default sender
    81  // is nil we don't send anything, but still mark the items as sent
    82  func (s *MetricSenderSuite) TestDontSendWithNopSender(c *gc.C) {
    83  	now := time.Now()
    84  	for i := 0; i < 3; i++ {
    85  		s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Sent: false, Time: &now})
    86  	}
    87  	err := metricsender.SendMetrics(s.State, metricsender.NopSender{}, 10)
    88  	c.Assert(err, jc.ErrorIsNil)
    89  	sent, err := s.State.CountOfSentMetrics()
    90  	c.Assert(err, jc.ErrorIsNil)
    91  	c.Assert(sent, gc.Equals, 3)
    92  }
    93  
    94  func (s *MetricSenderSuite) TestFailureIncrementsConsecutiveFailures(c *gc.C) {
    95  	sender := &testing.ErrorSender{Err: errors.New("something went wrong")}
    96  	now := time.Now()
    97  	for i := 0; i < 3; i++ {
    98  		s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Sent: false, Time: &now})
    99  	}
   100  	err := metricsender.SendMetrics(s.State, sender, 1)
   101  	c.Assert(err, gc.ErrorMatches, "something went wrong")
   102  	mm, err := s.State.MetricsManager()
   103  	c.Assert(err, jc.ErrorIsNil)
   104  	c.Assert(mm.ConsecutiveErrors(), gc.Equals, 1)
   105  }
   106  
   107  func (s *MetricSenderSuite) TestFailuresResetOnSuccessfulSend(c *gc.C) {
   108  	mm, err := s.State.MetricsManager()
   109  	c.Assert(err, jc.ErrorIsNil)
   110  	err = mm.IncrementConsecutiveErrors()
   111  	c.Assert(err, jc.ErrorIsNil)
   112  	now := time.Now()
   113  	for i := 0; i < 3; i++ {
   114  		s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Sent: false, Time: &now})
   115  	}
   116  	err = metricsender.SendMetrics(s.State, metricsender.NopSender{}, 10)
   117  	c.Assert(err, jc.ErrorIsNil)
   118  	mm, err = s.State.MetricsManager()
   119  	c.Assert(err, jc.ErrorIsNil)
   120  	c.Assert(mm.ConsecutiveErrors(), gc.Equals, 0)
   121  }