github.com/go-email-validator/go-email-validator@v0.0.0-20230409163946-b8b9e6a0552e/pkg/ev/validator_dep_builder_test.go (about)

     1  package ev
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  )
     7  
     8  func TestDepBuilder_Build(t *testing.T) {
     9  	type fields struct {
    10  		validators ValidatorMap
    11  	}
    12  	tests := []struct {
    13  		name   string
    14  		fields fields
    15  		want   Validator
    16  	}{
    17  		{
    18  			name: "nil",
    19  			fields: fields{
    20  				validators: nil,
    21  			},
    22  			want: NewDepValidator(GetDefaultFactories()),
    23  		},
    24  		{
    25  			name: "empty map",
    26  			fields: fields{
    27  				validators: ValidatorMap{},
    28  			},
    29  			want: NewDepValidator(ValidatorMap{}),
    30  		},
    31  		{
    32  			name: "map",
    33  			fields: fields{
    34  				validators: ValidatorMap{
    35  					mockValidatorName: newMockValidator(true),
    36  				},
    37  			},
    38  			want: NewDepValidator(ValidatorMap{
    39  				mockValidatorName: newMockValidator(true),
    40  			}),
    41  		},
    42  	}
    43  	for _, tt := range tests {
    44  		t.Run(tt.name, func(t *testing.T) {
    45  			d := NewDepBuilder(tt.fields.validators)
    46  			if got := d.Build(); !reflect.DeepEqual(got, tt.want) {
    47  				/*
    48  					TODO find right way to compare struct with function.
    49  					1. Use pointer for function
    50  					2. Use InterfaceData()
    51  				*/
    52  				if tt.name != "nil" || len(got.(depValidator).deps) != len(tt.want.(depValidator).deps) {
    53  					t.Errorf("Build() = %v, want %v", got, tt.want)
    54  				}
    55  			}
    56  		})
    57  	}
    58  }
    59  
    60  func TestDepBuilder_Delete(t *testing.T) {
    61  	type fields struct {
    62  		validators ValidatorMap
    63  	}
    64  	type args struct {
    65  		names []ValidatorName
    66  	}
    67  	tests := []struct {
    68  		name   string
    69  		fields fields
    70  		args   args
    71  		want   *DepBuilder
    72  	}{
    73  		{
    74  			name: "delete not exist element",
    75  			fields: fields{
    76  				validators: ValidatorMap{},
    77  			},
    78  			args: args{
    79  				names: []ValidatorName{mockValidatorName, SyntaxValidatorName},
    80  			},
    81  			want: &DepBuilder{
    82  				validators: ValidatorMap{},
    83  			},
    84  		},
    85  		{
    86  			name: "delete exist element",
    87  			fields: fields{
    88  				validators: ValidatorMap{
    89  					mockValidatorName: newMockValidator(false),
    90  					MXValidatorName:   newMockValidator(false)},
    91  			},
    92  			args: args{
    93  				names: []ValidatorName{mockValidatorName, SyntaxValidatorName},
    94  			},
    95  			want: &DepBuilder{
    96  				validators: ValidatorMap{MXValidatorName: newMockValidator(false)},
    97  			},
    98  		},
    99  	}
   100  	for _, tt := range tests {
   101  		t.Run(tt.name, func(t *testing.T) {
   102  			d := NewDepBuilder(tt.fields.validators)
   103  			if got := d.Delete(tt.args.names...); !reflect.DeepEqual(got, tt.want) {
   104  				t.Errorf("Delete() = %v, want %v", got, tt.want)
   105  			}
   106  		})
   107  	}
   108  }
   109  
   110  func TestDepBuilder_Set(t *testing.T) {
   111  	type fields struct {
   112  		validators ValidatorMap
   113  	}
   114  	type args struct {
   115  		name      ValidatorName
   116  		validator Validator
   117  	}
   118  	tests := []struct {
   119  		name   string
   120  		fields fields
   121  		args   args
   122  		want   *DepBuilder
   123  	}{
   124  		{
   125  			name: "set",
   126  			fields: fields{
   127  				validators: ValidatorMap{},
   128  			},
   129  			args: args{
   130  				name:      mockValidatorName,
   131  				validator: newMockValidator(false),
   132  			},
   133  			want: &DepBuilder{
   134  				validators: ValidatorMap{mockValidatorName: newMockValidator(false)},
   135  			},
   136  		},
   137  	}
   138  	for _, tt := range tests {
   139  		t.Run(tt.name, func(t *testing.T) {
   140  			d := &DepBuilder{
   141  				validators: tt.fields.validators,
   142  			}
   143  			if got := d.Set(tt.args.name, tt.args.validator); !reflect.DeepEqual(got, tt.want) {
   144  				t.Errorf("Set() = %v, want %v", got, tt.want)
   145  			}
   146  		})
   147  	}
   148  }
   149  
   150  func TestDepBuilder_Get(t *testing.T) {
   151  	type fields struct {
   152  		validators ValidatorMap
   153  	}
   154  	type args struct {
   155  		name ValidatorName
   156  	}
   157  	tests := []struct {
   158  		name   string
   159  		fields fields
   160  		args   args
   161  		want   Validator
   162  	}{
   163  		{
   164  			name: "has",
   165  			fields: fields{
   166  				validators: ValidatorMap{mockValidatorName: newMockValidator(false)},
   167  			},
   168  			args: args{
   169  				name: mockValidatorName,
   170  			},
   171  			want: newMockValidator(false),
   172  		},
   173  		{
   174  			name: "has not",
   175  			fields: fields{
   176  				validators: ValidatorMap{},
   177  			},
   178  			args: args{
   179  				name: mockValidatorName,
   180  			},
   181  			want: nil,
   182  		},
   183  	}
   184  	for _, tt := range tests {
   185  		t.Run(tt.name, func(t *testing.T) {
   186  			d := &DepBuilder{
   187  				validators: tt.fields.validators,
   188  			}
   189  			if got := d.Get(tt.args.name); !reflect.DeepEqual(got, tt.want) {
   190  				t.Errorf("Get() = %v, want %v", got, tt.want)
   191  			}
   192  		})
   193  	}
   194  }