github.com/newrelic/newrelic-client-go@v1.1.0/pkg/alerts/conditions_test.go (about)

     1  //go:build unit
     2  // +build unit
     3  
     4  package alerts
     5  
     6  import (
     7  	"net/http"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  var (
    14  	testListConditionsResponseJSON = `{
    15  		"conditions": [
    16  			{
    17  				"id": 123,
    18  				"type": "apm_app_metric",
    19  				"name": "Apdex (High)",
    20  				"enabled": true,
    21  				"entities": [
    22  					"321"
    23  				],
    24  				"metric": "apdex",
    25  				"condition_scope": "application",
    26  				"terms": [
    27  					{
    28  						"duration": "5",
    29  						"operator": "above",
    30  						"priority": "critical",
    31  						"threshold": "0.9",
    32  						"time_function": "all"
    33  					}
    34  				]
    35  			}
    36  		]
    37  	}`
    38  
    39  	testConditionJSON = `{
    40  		"condition": {
    41  			"id": 123,
    42  			"type": "apm_app_metric",
    43  			"name": "Apdex (High)",
    44  			"enabled": true,
    45  			"entities": [
    46  				"321"
    47  			],
    48  			"metric": "apdex",
    49  			"condition_scope": "application",
    50  			"violation_close_timer": 0,
    51  			"terms": [
    52  				{
    53  					"duration": "5",
    54  					"operator": "above",
    55  					"priority": "critical",
    56  					"threshold": "0.9",
    57  					"time_function": "all"
    58  				}
    59  			]
    60  		}
    61  	}`
    62  
    63  	testConditionUpdateJSON = `{
    64  		"condition": {
    65  			"id": 123,
    66  			"type": "apm_app_metric",
    67  			"name": "Apdex (High)",
    68  			"enabled": true,
    69  			"entities": [
    70  				"321"
    71  			],
    72  			"metric": "apdex",
    73  			"condition_scope": "application",
    74  			"violation_close_timer": 0,
    75  			"terms": [
    76  				{
    77  					"duration": "10",
    78  					"operator": "below",
    79  					"priority": "warning",
    80  					"threshold": ".5",
    81  					"time_function": "all"
    82  				}
    83  			]
    84  		}
    85  	}`
    86  )
    87  
    88  func TestListConditions(t *testing.T) {
    89  	t.Parallel()
    90  	alerts := newMockResponse(t, testListConditionsResponseJSON, http.StatusOK)
    91  
    92  	expected := []*Condition{
    93  		{
    94  			ID:         123,
    95  			Type:       ConditionTypes.APMApplicationMetric,
    96  			Name:       "Apdex (High)",
    97  			Enabled:    true,
    98  			Entities:   []string{"321"},
    99  			Metric:     MetricTypes.Apdex,
   100  			RunbookURL: "",
   101  			Terms: []ConditionTerm{
   102  				{
   103  					Duration:     5,
   104  					Operator:     "above",
   105  					Priority:     "critical",
   106  					Threshold:    0.9,
   107  					TimeFunction: TimeFunctionTypes.All,
   108  				},
   109  			},
   110  			UserDefined: ConditionUserDefined{
   111  				Metric:        "",
   112  				ValueFunction: "",
   113  			},
   114  			Scope:               "application",
   115  			GCMetric:            "",
   116  			ViolationCloseTimer: 0,
   117  		},
   118  	}
   119  
   120  	actual, err := alerts.ListConditions(333)
   121  
   122  	assert.NoError(t, err)
   123  	assert.NotNil(t, actual)
   124  	assert.Equal(t, expected, actual)
   125  }
   126  
   127  func TestGetCondition(t *testing.T) {
   128  	t.Parallel()
   129  	alerts := newMockResponse(t, testListConditionsResponseJSON, http.StatusOK)
   130  
   131  	expected := &Condition{
   132  		ID:         123,
   133  		Type:       ConditionTypes.APMApplicationMetric,
   134  		Name:       "Apdex (High)",
   135  		Enabled:    true,
   136  		Entities:   []string{"321"},
   137  		Metric:     MetricTypes.Apdex,
   138  		RunbookURL: "",
   139  		Terms: []ConditionTerm{
   140  			{
   141  				Duration:     5,
   142  				Operator:     "above",
   143  				Priority:     "critical",
   144  				Threshold:    0.9,
   145  				TimeFunction: TimeFunctionTypes.All,
   146  			},
   147  		},
   148  		UserDefined: ConditionUserDefined{
   149  			Metric:        "",
   150  			ValueFunction: "",
   151  		},
   152  		Scope:               "application",
   153  		GCMetric:            "",
   154  		ViolationCloseTimer: 0,
   155  	}
   156  
   157  	actual, err := alerts.GetCondition(333, 123)
   158  
   159  	assert.NoError(t, err)
   160  	assert.NotNil(t, actual)
   161  	assert.Equal(t, expected, actual)
   162  }
   163  
   164  func TestCreateCondition(t *testing.T) {
   165  	t.Parallel()
   166  	alerts := newMockResponse(t, testConditionJSON, http.StatusCreated)
   167  	policyID := 333
   168  
   169  	condition := Condition{
   170  		Type:       ConditionTypes.APMApplicationMetric,
   171  		Name:       "Adpex (High)",
   172  		Enabled:    true,
   173  		Entities:   []string{"321"},
   174  		Metric:     MetricTypes.Apdex,
   175  		RunbookURL: "",
   176  		Terms: []ConditionTerm{
   177  			{
   178  				Duration:     5,
   179  				Operator:     "above",
   180  				Priority:     "critical",
   181  				Threshold:    0.9,
   182  				TimeFunction: TimeFunctionTypes.All,
   183  			},
   184  		},
   185  		UserDefined: ConditionUserDefined{
   186  			Metric:        "",
   187  			ValueFunction: "",
   188  		},
   189  		Scope:               "application",
   190  		GCMetric:            "",
   191  		ViolationCloseTimer: 0,
   192  	}
   193  
   194  	expected := &Condition{
   195  		ID:         123,
   196  		Type:       ConditionTypes.APMApplicationMetric,
   197  		Name:       "Apdex (High)",
   198  		Enabled:    true,
   199  		Entities:   []string{"321"},
   200  		Metric:     MetricTypes.Apdex,
   201  		RunbookURL: "",
   202  		Terms: []ConditionTerm{
   203  			{
   204  				Duration:     5,
   205  				Operator:     "above",
   206  				Priority:     "critical",
   207  				Threshold:    0.9,
   208  				TimeFunction: TimeFunctionTypes.All,
   209  			},
   210  		},
   211  		UserDefined: ConditionUserDefined{
   212  			Metric:        "",
   213  			ValueFunction: "",
   214  		},
   215  		Scope:               "application",
   216  		GCMetric:            "",
   217  		ViolationCloseTimer: 0,
   218  	}
   219  
   220  	actual, err := alerts.CreateCondition(policyID, condition)
   221  
   222  	assert.NoError(t, err)
   223  	assert.NotNil(t, actual)
   224  	assert.Equal(t, expected, actual)
   225  }
   226  
   227  func TestUpdateCondition(t *testing.T) {
   228  	t.Parallel()
   229  	alerts := newMockResponse(t, testConditionUpdateJSON, http.StatusCreated)
   230  
   231  	condition := Condition{
   232  		Type:       ConditionTypes.APMApplicationMetric,
   233  		Name:       "Adpex (High)",
   234  		Enabled:    true,
   235  		Entities:   []string{"321"},
   236  		Metric:     MetricTypes.Apdex,
   237  		RunbookURL: "",
   238  		Terms: []ConditionTerm{
   239  			{
   240  				Duration:     5,
   241  				Operator:     "above",
   242  				Priority:     "critical",
   243  				Threshold:    0.9,
   244  				TimeFunction: TimeFunctionTypes.All,
   245  			},
   246  		},
   247  		UserDefined: ConditionUserDefined{
   248  			Metric:        "",
   249  			ValueFunction: "",
   250  		},
   251  		Scope:               "application",
   252  		GCMetric:            "",
   253  		ViolationCloseTimer: 0,
   254  	}
   255  
   256  	expected := &Condition{
   257  		ID:         123,
   258  		Type:       ConditionTypes.APMApplicationMetric,
   259  		Name:       "Apdex (High)",
   260  		Enabled:    true,
   261  		Entities:   []string{"321"},
   262  		Metric:     MetricTypes.Apdex,
   263  		RunbookURL: "",
   264  		Terms: []ConditionTerm{
   265  			{
   266  				Duration:     10,
   267  				Operator:     "below",
   268  				Priority:     "warning",
   269  				Threshold:    0.5,
   270  				TimeFunction: TimeFunctionTypes.All,
   271  			},
   272  		},
   273  		UserDefined: ConditionUserDefined{
   274  			Metric:        "",
   275  			ValueFunction: "",
   276  		},
   277  		Scope:               "application",
   278  		GCMetric:            "",
   279  		ViolationCloseTimer: 0,
   280  	}
   281  
   282  	actual, err := alerts.UpdateCondition(condition)
   283  
   284  	assert.NoError(t, err)
   285  	assert.NotNil(t, actual)
   286  	assert.Equal(t, expected, actual)
   287  }
   288  
   289  func TestDeleteCondition(t *testing.T) {
   290  	t.Parallel()
   291  	alerts := newMockResponse(t, testConditionJSON, http.StatusOK)
   292  
   293  	expected := &Condition{
   294  		ID:         123,
   295  		Type:       ConditionTypes.APMApplicationMetric,
   296  		Name:       "Apdex (High)",
   297  		Enabled:    true,
   298  		Entities:   []string{"321"},
   299  		Metric:     MetricTypes.Apdex,
   300  		RunbookURL: "",
   301  		Terms: []ConditionTerm{
   302  			{
   303  				Duration:     5,
   304  				Operator:     "above",
   305  				Priority:     "critical",
   306  				Threshold:    0.9,
   307  				TimeFunction: TimeFunctionTypes.All,
   308  			},
   309  		},
   310  		UserDefined: ConditionUserDefined{
   311  			Metric:        "",
   312  			ValueFunction: "",
   313  		},
   314  		Scope:               "application",
   315  		GCMetric:            "",
   316  		ViolationCloseTimer: 0,
   317  	}
   318  
   319  	actual, err := alerts.DeleteCondition(123)
   320  
   321  	assert.NoError(t, err)
   322  	assert.NotNil(t, actual)
   323  	assert.Equal(t, expected, actual)
   324  }