github.com/grafana/synthetic-monitoring-agent@v0.64.2/internal/prober/grpc/grpc_test.go (about)

     1  package grpc
     2  
     3  import (
     4  	"context"
     5  	"io"
     6  	"testing"
     7  
     8  	"github.com/grafana/synthetic-monitoring-agent/internal/model"
     9  	sm "github.com/grafana/synthetic-monitoring-agent/pkg/pb/synthetic_monitoring"
    10  	"github.com/prometheus/blackbox_exporter/config"
    11  	promcfg "github.com/prometheus/common/config"
    12  	"github.com/rs/zerolog"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestName(t *testing.T) {
    17  	name := Prober.Name(Prober{})
    18  	require.Equal(t, name, "grpc")
    19  }
    20  
    21  func TestNewProber(t *testing.T) {
    22  	testcases := map[string]struct {
    23  		input       model.Check
    24  		expected    Prober
    25  		ExpectError bool
    26  	}{
    27  		"default": {
    28  			input: model.Check{
    29  				Check: sm.Check{
    30  					Target: "www.grafana.com",
    31  					Settings: sm.CheckSettings{
    32  						Grpc: &sm.GrpcSettings{},
    33  					},
    34  				},
    35  			},
    36  			expected: Prober{
    37  				config.Module{
    38  					Prober:  "grpc",
    39  					Timeout: 0,
    40  					GRPC: config.GRPCProbe{
    41  						PreferredIPProtocol: "ip6",
    42  						IPProtocolFallback:  true,
    43  					},
    44  				},
    45  			},
    46  		},
    47  		"no-settings": {
    48  			input: model.Check{
    49  				Check: sm.Check{
    50  					Target: "www.grafana.com",
    51  					Settings: sm.CheckSettings{
    52  						Grpc: nil,
    53  					},
    54  				},
    55  			},
    56  			ExpectError: true,
    57  		},
    58  	}
    59  
    60  	ctx := context.Background()
    61  	logger := zerolog.New(io.Discard)
    62  
    63  	for name, tc := range testcases {
    64  		t.Run(name, func(t *testing.T) {
    65  			actual, err := NewProber(ctx, tc.input, logger)
    66  
    67  			require.Equal(t, &tc.expected, &actual)
    68  
    69  			if tc.ExpectError {
    70  				require.Error(t, err, "unsupported check")
    71  			} else {
    72  				require.NoError(t, err)
    73  			}
    74  		})
    75  	}
    76  }
    77  
    78  func TestSettingsToModule(t *testing.T) {
    79  	testcases := map[string]struct {
    80  		input    sm.GrpcSettings
    81  		expected config.Module
    82  	}{
    83  		"default": {
    84  			input: sm.GrpcSettings{},
    85  			expected: config.Module{
    86  				Prober:  "grpc",
    87  				Timeout: 0,
    88  				GRPC: config.GRPCProbe{
    89  					PreferredIPProtocol: "ip6",
    90  					IPProtocolFallback:  true,
    91  				},
    92  			},
    93  		},
    94  		"custom svc": {
    95  			input: sm.GrpcSettings{
    96  				Service: "customSvc",
    97  			},
    98  			expected: config.Module{
    99  				Prober:  "grpc",
   100  				Timeout: 0,
   101  				GRPC: config.GRPCProbe{
   102  					Service:             "customSvc",
   103  					PreferredIPProtocol: "ip6",
   104  					IPProtocolFallback:  true,
   105  				},
   106  			},
   107  		},
   108  		"ipv4": {
   109  			input: sm.GrpcSettings{
   110  				IpVersion: sm.IpVersion_V4,
   111  			},
   112  			expected: config.Module{
   113  				Prober:  "grpc",
   114  				Timeout: 0,
   115  				GRPC: config.GRPCProbe{
   116  					PreferredIPProtocol: "ip4",
   117  					IPProtocolFallback:  false,
   118  				},
   119  			},
   120  		},
   121  		"tls": {
   122  			input: sm.GrpcSettings{
   123  				Tls: true,
   124  				TlsConfig: &sm.TLSConfig{
   125  					InsecureSkipVerify: true,
   126  					ServerName:         "grafana.com",
   127  				},
   128  			},
   129  			expected: config.Module{
   130  				Prober:  "grpc",
   131  				Timeout: 0,
   132  				GRPC: config.GRPCProbe{
   133  					PreferredIPProtocol: "ip6",
   134  					IPProtocolFallback:  true,
   135  					TLS:                 true,
   136  					TLSConfig: promcfg.TLSConfig{
   137  						InsecureSkipVerify: true,
   138  						ServerName:         "grafana.com",
   139  					},
   140  				},
   141  			},
   142  		},
   143  	}
   144  
   145  	ctx := context.Background()
   146  	logger := zerolog.New(io.Discard)
   147  
   148  	for name, tc := range testcases {
   149  		t.Run(name, func(t *testing.T) {
   150  			actual, err := settingsToModule(ctx, &tc.input, logger)
   151  			require.NoError(t, err)
   152  			require.Equal(t, &tc.expected, &actual)
   153  		})
   154  	}
   155  }