github.com/spotahome/redis-operator@v1.2.4/operator/redisfailover/ensurer_test.go (about)

     1  package redisfailover_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/mock"
     8  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
     9  
    10  	redisfailoverv1 "github.com/spotahome/redis-operator/api/redisfailover/v1"
    11  	"github.com/spotahome/redis-operator/log"
    12  	"github.com/spotahome/redis-operator/metrics"
    13  	mRFService "github.com/spotahome/redis-operator/mocks/operator/redisfailover/service"
    14  	mK8SService "github.com/spotahome/redis-operator/mocks/service/k8s"
    15  	rfOperator "github.com/spotahome/redis-operator/operator/redisfailover"
    16  )
    17  
    18  const (
    19  	name      = "test"
    20  	namespace = "testns"
    21  )
    22  
    23  func generateConfig() rfOperator.Config {
    24  	return rfOperator.Config{
    25  		ListenAddress: "1234",
    26  		MetricsPath:   "/awesome",
    27  	}
    28  }
    29  
    30  func generateRF(enableExporter bool, bootstrapping bool) *redisfailoverv1.RedisFailover {
    31  	return &redisfailoverv1.RedisFailover{
    32  		ObjectMeta: metav1.ObjectMeta{
    33  			Name:      name,
    34  			Namespace: namespace,
    35  		},
    36  		Spec: redisfailoverv1.RedisFailoverSpec{
    37  			Redis: redisfailoverv1.RedisSettings{
    38  				Replicas: int32(3),
    39  				Exporter: redisfailoverv1.Exporter{
    40  					Enabled: enableExporter,
    41  				},
    42  			},
    43  			Sentinel: redisfailoverv1.SentinelSettings{
    44  				Replicas: int32(3),
    45  			},
    46  			BootstrapNode: generateRFBootstrappingNode(bootstrapping),
    47  		},
    48  	}
    49  }
    50  
    51  func generateRFBootstrappingNode(bootstrapping bool) *redisfailoverv1.BootstrapSettings {
    52  	if bootstrapping {
    53  		return &redisfailoverv1.BootstrapSettings{
    54  			Host: "127.0.0.1",
    55  			Port: "6379",
    56  		}
    57  	}
    58  	return nil
    59  }
    60  
    61  func TestEnsure(t *testing.T) {
    62  	tests := []struct {
    63  		name                        string
    64  		exporter                    bool
    65  		bootstrapping               bool
    66  		bootstrappingAllowSentinels bool
    67  	}{
    68  		{
    69  			name:                        "Call everything, use exporter",
    70  			exporter:                    true,
    71  			bootstrapping:               false,
    72  			bootstrappingAllowSentinels: false,
    73  		},
    74  		{
    75  			name:                        "Call everything, don't use exporter",
    76  			exporter:                    false,
    77  			bootstrapping:               false,
    78  			bootstrappingAllowSentinels: false,
    79  		},
    80  		{
    81  			name:                        "Only ensure Redis when bootstrapping",
    82  			exporter:                    false,
    83  			bootstrapping:               true,
    84  			bootstrappingAllowSentinels: false,
    85  		},
    86  		{
    87  			name:                        "call everything when bootstrapping allows sentinels",
    88  			exporter:                    false,
    89  			bootstrapping:               true,
    90  			bootstrappingAllowSentinels: true,
    91  		},
    92  	}
    93  
    94  	for _, test := range tests {
    95  		t.Run(test.name, func(t *testing.T) {
    96  			assert := assert.New(t)
    97  
    98  			rf := generateRF(test.exporter, test.bootstrapping)
    99  			if test.bootstrapping {
   100  				rf.Spec.BootstrapNode.AllowSentinels = test.bootstrappingAllowSentinels
   101  			}
   102  
   103  			config := generateConfig()
   104  			mk := &mK8SService.Services{}
   105  			mrfc := &mRFService.RedisFailoverCheck{}
   106  			mrfh := &mRFService.RedisFailoverHeal{}
   107  			mrfs := &mRFService.RedisFailoverClient{}
   108  			if test.exporter {
   109  				mrfs.On("EnsureRedisService", rf, mock.Anything, mock.Anything).Once().Return(nil)
   110  			} else {
   111  				mrfs.On("EnsureNotPresentRedisService", rf).Once().Return(nil)
   112  			}
   113  
   114  			if !test.bootstrapping || test.bootstrappingAllowSentinels {
   115  				mrfs.On("EnsureSentinelService", rf, mock.Anything, mock.Anything).Once().Return(nil)
   116  				mrfs.On("EnsureSentinelConfigMap", rf, mock.Anything, mock.Anything).Once().Return(nil)
   117  				mrfs.On("EnsureSentinelDeployment", rf, mock.Anything, mock.Anything).Once().Return(nil)
   118  			}
   119  
   120  			mrfs.On("EnsureRedisConfigMap", rf, mock.Anything, mock.Anything).Once().Return(nil)
   121  			mrfs.On("EnsureRedisShutdownConfigMap", rf, mock.Anything, mock.Anything).Once().Return(nil)
   122  			mrfs.On("EnsureRedisReadinessConfigMap", rf, mock.Anything, mock.Anything).Once().Return(nil)
   123  			mrfs.On("EnsureRedisStatefulset", rf, mock.Anything, mock.Anything).Once().Return(nil)
   124  
   125  			// Create the Kops client and call the valid logic.
   126  			handler := rfOperator.NewRedisFailoverHandler(config, mrfs, mrfc, mrfh, mk, metrics.Dummy, log.Dummy)
   127  			err := handler.Ensure(rf, map[string]string{}, []metav1.OwnerReference{}, metrics.Dummy)
   128  
   129  			assert.NoError(err)
   130  			mrfs.AssertExpectations(t)
   131  		})
   132  	}
   133  }