github.com/treeverse/lakefs@v1.24.1-0.20240520134607-95648127bfb0/pkg/config/struct_fields_test.go (about)

     1  package config_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/treeverse/lakefs/pkg/config"
     8  	"github.com/treeverse/lakefs/pkg/logging"
     9  )
    10  
    11  func TestMapLoggingFields(t *testing.T) {
    12  	f := 64.0
    13  	value := struct {
    14  		A  int
    15  		B  string
    16  		C  *float64
    17  		D  []rune
    18  		E  bool
    19  		AA struct {
    20  			A int
    21  			B string
    22  			C *float64
    23  			D []rune
    24  			E bool
    25  		}
    26  		BB *struct {
    27  			A int
    28  			B string
    29  			C *float64
    30  			D []rune
    31  			E bool
    32  		}
    33  		CC struct {
    34  			A int      `mapstructure:"a1"`
    35  			B string   `mapstructure:"b1"`
    36  			C *float64 `mapstructure:"c1"`
    37  			D []rune   `mapstructure:"d1"`
    38  			E bool     `mapstructure:"e1"`
    39  		} `mapstructure:"c_c"`
    40  		DD struct {
    41  			Squash struct {
    42  				A int
    43  				B string
    44  				C *float64
    45  				D []rune
    46  				E bool
    47  			} `mapstructure:"squash"`
    48  		}
    49  		EE1 config.SecureString
    50  		EE2 config.SecureString
    51  	}{
    52  		A: 1,
    53  		B: "2",
    54  		C: &f,
    55  		D: []rune{1, 2, 3},
    56  		E: true,
    57  		AA: struct {
    58  			A int
    59  			B string
    60  			C *float64
    61  			D []rune
    62  			E bool
    63  		}{
    64  			A: 1,
    65  			B: "2",
    66  			C: &f,
    67  			D: []rune{1, 2, 3},
    68  			E: true,
    69  		},
    70  		BB: nil,
    71  		CC: struct {
    72  			A int      `mapstructure:"a1"`
    73  			B string   `mapstructure:"b1"`
    74  			C *float64 `mapstructure:"c1"`
    75  			D []rune   `mapstructure:"d1"`
    76  			E bool     `mapstructure:"e1"`
    77  		}{
    78  			A: 1,
    79  			B: "2",
    80  			C: &f,
    81  			D: []rune{1, 2, 3, 4},
    82  			E: true,
    83  		},
    84  		DD: struct {
    85  			Squash struct {
    86  				A int
    87  				B string
    88  				C *float64
    89  				D []rune
    90  				E bool
    91  			} `mapstructure:"squash"`
    92  		}{
    93  			Squash: struct {
    94  				A int
    95  				B string
    96  				C *float64
    97  				D []rune
    98  				E bool
    99  			}{
   100  				A: 1,
   101  				B: "2",
   102  				C: &f,
   103  				D: []rune{1, 2, 3},
   104  				E: true,
   105  			},
   106  		},
   107  		EE1: "ee1ee1ee1",
   108  		EE2: "",
   109  	}
   110  	expected := logging.Fields{
   111  		"a":           "1",
   112  		"aa.a":        "1",
   113  		"aa.b":        "2",
   114  		"aa.c":        "64",
   115  		"aa.d":        "[1 2 3]",
   116  		"aa.e":        "true",
   117  		"b":           "2",
   118  		"c":           "64",
   119  		"c_c.a1":      "1",
   120  		"c_c.b1":      "2",
   121  		"c_c.c1":      "64",
   122  		"c_c.d1":      "[1 2 3 4]",
   123  		"c_c.e1":      "true",
   124  		"d":           "[1 2 3]",
   125  		"dd.squash.a": "1",
   126  		"dd.squash.b": "2",
   127  		"dd.squash.c": "64",
   128  		"dd.squash.d": "[1 2 3]",
   129  		"dd.squash.e": "true",
   130  		"e":           "true",
   131  		"ee1":         config.FieldMaskedValue,
   132  		"ee2":         config.FieldMaskedNoValue,
   133  	}
   134  
   135  	fields := config.MapLoggingFields(value)
   136  	if len(expected) != len(fields) {
   137  		t.Fatalf("Expected %d fields, got %d", len(expected), len(fields))
   138  	}
   139  	for k, v := range fields {
   140  		expectedString := expected[k]
   141  		vString := fmt.Sprint(v)
   142  		if vString != expectedString {
   143  			t.Errorf("Value for '%s' is '%s', expected '%s'", k, vString, expectedString)
   144  		}
   145  	}
   146  }