github.com/redhat-appstudio/release-service@v0.0.0-20240507045911-a8558ef3422a/metrics/release_test.go (about)

     1  /*
     2  Copyright 2022.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package metrics
    18  
    19  import (
    20  	"time"
    21  
    22  	"github.com/konflux-ci/operator-toolkit/test"
    23  	. "github.com/onsi/ginkgo/v2"
    24  	. "github.com/onsi/gomega"
    25  	"github.com/prometheus/client_golang/prometheus/testutil"
    26  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    27  )
    28  
    29  var _ = Describe("Release metrics", Ordered, func() {
    30  	var (
    31  		initializeMetrics func()
    32  	)
    33  
    34  	When("RegisterCompletedRelease is called", func() {
    35  		var completionTime, startTime *metav1.Time
    36  
    37  		BeforeEach(func() {
    38  			initializeMetrics()
    39  
    40  			completionTime = &metav1.Time{}
    41  			startTime = &metav1.Time{Time: completionTime.Add(-60 * time.Second)}
    42  		})
    43  
    44  		It("does nothing if the start time is nil", func() {
    45  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(0)))
    46  			RegisterCompletedRelease(nil, completionTime, "", "", "", "", "")
    47  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(0)))
    48  		})
    49  
    50  		It("does nothing if the completion time is nil", func() {
    51  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(0)))
    52  			RegisterCompletedRelease(startTime, nil, "", "", "", "", "")
    53  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(0)))
    54  		})
    55  
    56  		It("decrements ReleaseConcurrentTotal", func() {
    57  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(0)))
    58  			RegisterCompletedRelease(startTime, completionTime, "", "", "", "", "")
    59  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(-1)))
    60  		})
    61  
    62  		It("adds an observation to ReleaseDurationSeconds", func() {
    63  			RegisterCompletedRelease(startTime, completionTime,
    64  				releaseDurationSecondsLabels[0],
    65  				releaseDurationSecondsLabels[1],
    66  				releaseDurationSecondsLabels[2],
    67  				releaseDurationSecondsLabels[3],
    68  				releaseDurationSecondsLabels[4],
    69  			)
    70  			Expect(testutil.CollectAndCompare(ReleaseDurationSeconds,
    71  				test.NewHistogramReader(
    72  					releaseDurationSecondsOpts,
    73  					releaseDurationSecondsLabels,
    74  					startTime, completionTime,
    75  				))).To(Succeed())
    76  		})
    77  
    78  		It("increments ReleaseTotal", func() {
    79  			RegisterCompletedRelease(startTime, completionTime,
    80  				releaseTotalLabels[0],
    81  				releaseTotalLabels[1],
    82  				releaseTotalLabels[2],
    83  				releaseTotalLabels[3],
    84  				releaseTotalLabels[4],
    85  			)
    86  			Expect(testutil.CollectAndCompare(ReleaseTotal,
    87  				test.NewCounterReader(
    88  					releaseTotalOpts,
    89  					releaseTotalLabels,
    90  				))).To(Succeed())
    91  		})
    92  	})
    93  
    94  	When("RegisterCompletedReleasePostActionsExecuted is called", func() {
    95  		var completionTime, startTime *metav1.Time
    96  
    97  		BeforeEach(func() {
    98  			initializeMetrics()
    99  
   100  			completionTime = &metav1.Time{}
   101  			startTime = &metav1.Time{Time: completionTime.Add(-60 * time.Second)}
   102  		})
   103  
   104  		It("does nothing if the start time is nil", func() {
   105  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(0)))
   106  			RegisterCompletedReleasePostActionsExecuted(nil, completionTime, "")
   107  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(0)))
   108  		})
   109  
   110  		It("does nothing if the completion time is nil", func() {
   111  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(0)))
   112  			RegisterCompletedReleasePostActionsExecuted(startTime, nil, "")
   113  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(0)))
   114  		})
   115  
   116  		It("decrements ReleaseConcurrentPostActionsExecutionsTotal", func() {
   117  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(0)))
   118  			RegisterCompletedReleasePostActionsExecuted(startTime, completionTime, "")
   119  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(-1)))
   120  		})
   121  
   122  		It("adds an observation to ReleasePostActionsExecutionDurationSeconds", func() {
   123  			RegisterCompletedReleasePostActionsExecuted(startTime, completionTime,
   124  				releasePostActionsExecutionDurationSecondsLabels[0],
   125  			)
   126  			Expect(testutil.CollectAndCompare(ReleasePostActionsExecutionDurationSeconds,
   127  				test.NewHistogramReader(
   128  					releasePostActionsExecutionDurationSecondsOpts,
   129  					releasePostActionsExecutionDurationSecondsLabels,
   130  					startTime, completionTime,
   131  				))).To(Succeed())
   132  		})
   133  	})
   134  
   135  	When("RegisterCompletedReleaseProcessing is called", func() {
   136  		var completionTime, startTime *metav1.Time
   137  
   138  		BeforeEach(func() {
   139  			initializeMetrics()
   140  
   141  			completionTime = &metav1.Time{}
   142  			startTime = &metav1.Time{Time: completionTime.Add(-60 * time.Second)}
   143  		})
   144  
   145  		It("does nothing if the start time is nil", func() {
   146  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   147  			RegisterCompletedReleaseProcessing(nil, completionTime, "", "")
   148  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   149  		})
   150  
   151  		It("does nothing if the completion time is nil", func() {
   152  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   153  			RegisterCompletedReleaseProcessing(startTime, nil, "", "")
   154  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   155  		})
   156  
   157  		It("decrements ReleaseConcurrentProcessingsTotal", func() {
   158  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   159  			RegisterCompletedReleaseProcessing(startTime, completionTime, "", "")
   160  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(-1)))
   161  		})
   162  
   163  		It("adds an observation to ReleaseProcessingDurationSeconds", func() {
   164  			RegisterCompletedReleaseProcessing(startTime, completionTime,
   165  				releaseProcessingDurationSecondsLabels[0],
   166  				releaseProcessingDurationSecondsLabels[1],
   167  			)
   168  			Expect(testutil.CollectAndCompare(ReleaseProcessingDurationSeconds,
   169  				test.NewHistogramReader(
   170  					releaseProcessingDurationSecondsOpts,
   171  					releaseProcessingDurationSecondsLabels,
   172  					startTime, completionTime,
   173  				))).To(Succeed())
   174  		})
   175  	})
   176  
   177  	When("RegisterValidatedRelease is called", func() {
   178  		var validationTime, startTime *metav1.Time
   179  
   180  		BeforeEach(func() {
   181  			initializeMetrics()
   182  
   183  			validationTime = &metav1.Time{}
   184  			startTime = &metav1.Time{Time: validationTime.Add(-60 * time.Second)}
   185  		})
   186  
   187  		It("does nothing if the validation start time is nil", func() {
   188  			RegisterValidatedRelease(nil, validationTime, "", "")
   189  		})
   190  
   191  		It("does nothing if the start time is nil", func() {
   192  			RegisterValidatedRelease(startTime, nil, "", "")
   193  		})
   194  
   195  		It("adds an observation to ReleaseValidationDurationSeconds", func() {
   196  			RegisterValidatedRelease(startTime, validationTime,
   197  				releaseValidationDurationSecondsLabels[0],
   198  				releaseValidationDurationSecondsLabels[1],
   199  			)
   200  			Expect(testutil.CollectAndCompare(ReleaseValidationDurationSeconds,
   201  				test.NewHistogramReader(
   202  					releaseValidationDurationSecondsOpts,
   203  					releaseValidationDurationSecondsLabels,
   204  					startTime, validationTime,
   205  				))).To(Succeed())
   206  		})
   207  	})
   208  
   209  	When("RegisterNewRelease is called", func() {
   210  		BeforeEach(func() {
   211  			initializeMetrics()
   212  		})
   213  
   214  		It("increments ReleaseConcurrentTotal", func() {
   215  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(0)))
   216  			RegisterNewRelease()
   217  			Expect(testutil.ToFloat64(ReleaseConcurrentTotal.WithLabelValues())).To(Equal(float64(1)))
   218  		})
   219  	})
   220  
   221  	When("RegisterNewReleaseProcessing is called", func() {
   222  		var processingStartTime, startTime *metav1.Time
   223  
   224  		BeforeEach(func() {
   225  			initializeMetrics()
   226  
   227  			processingStartTime = &metav1.Time{}
   228  			startTime = &metav1.Time{Time: processingStartTime.Add(-60 * time.Second)}
   229  		})
   230  
   231  		It("does nothing if the processing start time is nil", func() {
   232  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   233  			RegisterNewReleaseProcessing(nil, processingStartTime, "", "")
   234  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   235  		})
   236  
   237  		It("does nothing if the start time is nil", func() {
   238  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   239  			RegisterNewReleaseProcessing(startTime, nil, "", "")
   240  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   241  		})
   242  
   243  		It("adds an observation to ReleasePreProcessingDurationSeconds", func() {
   244  			RegisterNewReleaseProcessing(startTime, processingStartTime,
   245  				releasePreProcessingDurationSecondsLabels[0],
   246  				releasePreProcessingDurationSecondsLabels[1],
   247  			)
   248  			Expect(testutil.CollectAndCompare(ReleasePreProcessingDurationSeconds,
   249  				test.NewHistogramReader(
   250  					releasePreProcessingDurationSecondsOpts,
   251  					releasePreProcessingDurationSecondsLabels,
   252  					startTime, processingStartTime,
   253  				))).To(Succeed())
   254  		})
   255  
   256  		It("increments ReleaseConcurrentProcessingsTotal", func() {
   257  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(0)))
   258  			RegisterNewReleaseProcessing(startTime, processingStartTime,
   259  				releasePreProcessingDurationSecondsLabels[0],
   260  				releasePreProcessingDurationSecondsLabels[1],
   261  			)
   262  			Expect(testutil.ToFloat64(ReleaseConcurrentProcessingsTotal.WithLabelValues())).To(Equal(float64(1)))
   263  		})
   264  	})
   265  
   266  	When("RegisterNewReleasePostActionsExecution is called", func() {
   267  		BeforeEach(func() {
   268  			initializeMetrics()
   269  		})
   270  
   271  		It("increments ReleaseConcurrentPostActionsExecutionsTotal", func() {
   272  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(0)))
   273  			RegisterNewReleasePostActionsExecution()
   274  			Expect(testutil.ToFloat64(ReleaseConcurrentPostActionsExecutionsTotal.WithLabelValues())).To(Equal(float64(1)))
   275  		})
   276  	})
   277  
   278  	initializeMetrics = func() {
   279  		ReleaseConcurrentTotal.Reset()
   280  		ReleaseConcurrentProcessingsTotal.Reset()
   281  		ReleaseConcurrentPostActionsExecutionsTotal.Reset()
   282  		ReleaseValidationDurationSeconds.Reset()
   283  		ReleasePreProcessingDurationSeconds.Reset()
   284  		ReleaseDurationSeconds.Reset()
   285  		ReleaseProcessingDurationSeconds.Reset()
   286  		ReleasePostActionsExecutionDurationSeconds.Reset()
   287  		ReleaseTotal.Reset()
   288  	}
   289  
   290  })