advertise_test.go

Documentation: github.com/prometheus/alertmanager/cluster

     1  // Copyright 2018 Prometheus Team
     2  // Licensed under the Apache License, Version 2.0 (the "License");
     3  // you may not use this file except in compliance with the License.
     4  // You may obtain a copy of the License at
     5  //
     6  // http://www.apache.org/licenses/LICENSE-2.0
     7  //
     8  // Unless required by applicable law or agreed to in writing, software
     9  // distributed under the License is distributed on an "AS IS" BASIS,
    10  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    11  // See the License for the specific language governing permissions and
    12  // limitations under the License.
    13  
    14  package cluster
    15  
    16  import (
    17  	"errors"
    18  	"net"
    19  	"testing"
    20  
    21  	"github.com/stretchr/testify/require"
    22  )
    23  
    24  func TestCalculateAdvertiseAddress(t *testing.T) {
    25  	old := getPrivateAddress
    26  	defer func() {
    27  		getPrivateAddress = old
    28  	}()
    29  
    30  	cases := []struct {
    31  		name                   string
    32  		privateIPFn            getIPFunc
    33  		publicIPFn             getIPFunc
    34  		bind, advertise        string
    35  		allowInsecureAdvertise bool
    36  
    37  		expectedIP net.IP
    38  		err        bool
    39  	}{
    40  		{
    41  			name:      "use provided bind address",
    42  			bind:      "192.0.2.1",
    43  			advertise: "",
    44  
    45  			expectedIP: net.ParseIP("192.0.2.1"),
    46  			err:        false,
    47  		},
    48  		{
    49  			name:      "use provided advertise address",
    50  			bind:      "192.0.2.1",
    51  			advertise: "192.0.2.2",
    52  
    53  			expectedIP: net.ParseIP("192.0.2.2"),
    54  			err:        false,
    55  		},
    56  		{
    57  			name:        "discover private ip address",
    58  			privateIPFn: func() (string, error) { return "192.0.2.1", nil },
    59  			bind:        "0.0.0.0",
    60  			advertise:   "",
    61  
    62  			expectedIP: net.ParseIP("192.0.2.1"),
    63  			err:        false,
    64  		},
    65  		{
    66  			name:        "error if getPrivateAddress errors",
    67  			privateIPFn: func() (string, error) { return "", errors.New("some error") },
    68  			bind:        "0.0.0.0",
    69  			advertise:   "",
    70  
    71  			err: true,
    72  		},
    73  		{
    74  			name:        "error if getPrivateAddress returns an invalid address",
    75  			privateIPFn: func() (string, error) { return "invalid", nil },
    76  			bind:        "0.0.0.0",
    77  			advertise:   "",
    78  
    79  			err: true,
    80  		},
    81  		{
    82  			name:        "error if getPrivateAddress returns an empty address",
    83  			privateIPFn: func() (string, error) { return "", nil },
    84  			bind:        "0.0.0.0",
    85  			advertise:   "",
    86  
    87  			err: true,
    88  		},
    89  
    90  		{
    91  			name:                   "discover public advertise address",
    92  			privateIPFn:            func() (string, error) { return "", nil },
    93  			publicIPFn:             func() (string, error) { return "192.0.2.1", nil },
    94  			bind:                   "0.0.0.0",
    95  			advertise:              "",
    96  			allowInsecureAdvertise: true,
    97  
    98  			expectedIP: net.ParseIP("192.0.2.1"),
    99  			err:        false,
   100  		},
   101  		{
   102  			name:                   "error if getPublicAddress errors",
   103  			privateIPFn:            func() (string, error) { return "", nil },
   104  			publicIPFn:             func() (string, error) { return "", errors.New("some error") },
   105  			bind:                   "0.0.0.0",
   106  			advertise:              "",
   107  			allowInsecureAdvertise: true,
   108  
   109  			err: true,
   110  		},
   111  		{
   112  			name:                   "error if getPublicAddress returns an invalid address",
   113  			privateIPFn:            func() (string, error) { return "", nil },
   114  			publicIPFn:             func() (string, error) { return "invalid", nil },
   115  			bind:                   "0.0.0.0",
   116  			advertise:              "",
   117  			allowInsecureAdvertise: true,
   118  
   119  			err: true,
   120  		},
   121  		{
   122  			name:                   "error if getPublicAddress returns an empty address",
   123  			privateIPFn:            func() (string, error) { return "", nil },
   124  			publicIPFn:             func() (string, error) { return "", nil },
   125  			bind:                   "0.0.0.0",
   126  			advertise:              "",
   127  			allowInsecureAdvertise: true,
   128  
   129  			err: true,
   130  		},
   131  	}
   132  
   133  	for _, c := range cases {
   134  		t.Run(c.name, func(t *testing.T) {
   135  			getPrivateAddress = c.privateIPFn
   136  			getPublicAddress = c.publicIPFn
   137  			got, err := calculateAdvertiseAddress(c.bind, c.advertise, c.allowInsecureAdvertise)
   138  			if c.err {
   139  				require.Error(t, err)
   140  				return
   141  			}
   142  			require.NoError(t, err)
   143  			require.Equal(t, c.expectedIP.String(), got.String())
   144  		})
   145  	}
   146  }
   147
View as plain text