github.com/containers/podman/v4@v4.9.4/pkg/env/env_test.go (about)

     1  package env
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  func TestSlice(t *testing.T) {
    10  	goodMap := make(map[string]string, 0)
    11  	goodMap["apple"] = "red"
    12  	goodMap["banana"] = "yellow"
    13  	goodMap["pear"] = ""
    14  	goodResult := []string{"apple=red", "banana=yellow", "pear"}
    15  	type args struct {
    16  		m map[string]string
    17  	}
    18  	tests := []struct {
    19  		name string
    20  		args args
    21  		want []string
    22  	}{
    23  		{
    24  			name: "Good",
    25  			args: args{
    26  				m: goodMap,
    27  			},
    28  			want: goodResult,
    29  		},
    30  	}
    31  	for _, tt := range tests {
    32  		t.Run(tt.name, func(t *testing.T) {
    33  			assert.ElementsMatchf(t, Slice(tt.args.m), tt.want, "Slice() = %v, want %v", Slice(tt.args.m), tt.want)
    34  		})
    35  	}
    36  }
    37  
    38  func TestJoin(t *testing.T) {
    39  	firstMap := make(map[string]string, 0)
    40  	firstMap["apple"] = "red"
    41  	secondMap := make(map[string]string, 0)
    42  	secondMap["banana"] = "yellow"
    43  	goodResult := make(map[string]string, 0)
    44  	goodResult["apple"] = "red"
    45  	goodResult["banana"] = "yellow"
    46  	overrideResult := make(map[string]string, 0)
    47  	overrideResult["apple"] = "green"
    48  	overrideResult["banana"] = "yellow"
    49  	overrideMap := make(map[string]string, 0)
    50  	overrideMap["banana"] = "yellow"
    51  	overrideMap["apple"] = "green"
    52  	type args struct {
    53  		base     map[string]string
    54  		override map[string]string
    55  	}
    56  	tests := []struct {
    57  		name string
    58  		args args
    59  		want map[string]string
    60  	}{
    61  		{
    62  			name: "GoodJoin",
    63  			args: args{
    64  				base:     firstMap,
    65  				override: secondMap,
    66  			},
    67  			want: goodResult,
    68  		},
    69  		{
    70  			name: "GoodOverride",
    71  			args: args{
    72  				base:     firstMap,
    73  				override: overrideMap,
    74  			},
    75  			want: overrideResult,
    76  		},
    77  		{
    78  			name: "EmptyOverride",
    79  			args: args{
    80  				base:     firstMap,
    81  				override: nil,
    82  			},
    83  			want: firstMap,
    84  		},
    85  		{
    86  			name: "EmptyBase",
    87  			args: args{
    88  				base:     nil,
    89  				override: firstMap,
    90  			},
    91  			want: firstMap,
    92  		},
    93  	}
    94  	for _, tt := range tests {
    95  		t.Run(tt.name, func(t *testing.T) {
    96  			got := Join(tt.args.base, tt.args.override)
    97  			assert.EqualValuesf(t, got, tt.want, "Join() = %v, want %v", got, tt.want)
    98  		})
    99  	}
   100  }
   101  
   102  func Test_parseEnv(t *testing.T) {
   103  	good := make(map[string]string)
   104  
   105  	type args struct {
   106  		env  map[string]string
   107  		line string
   108  	}
   109  	tests := []struct {
   110  		name    string
   111  		args    args
   112  		wantErr bool
   113  	}{
   114  		{
   115  			name: "Good",
   116  			args: args{
   117  				env:  good,
   118  				line: "apple=red",
   119  			},
   120  			wantErr: false,
   121  		},
   122  		{
   123  			name: "GoodNoValue",
   124  			args: args{
   125  				env:  good,
   126  				line: "apple=",
   127  			},
   128  			wantErr: false,
   129  		},
   130  		{
   131  			name: "GoodNoKeyNoValue",
   132  			args: args{
   133  				env:  good,
   134  				line: "=",
   135  			},
   136  			wantErr: true,
   137  		},
   138  		{
   139  			name: "BadNoKey",
   140  			args: args{
   141  				env:  good,
   142  				line: "=foobar",
   143  			},
   144  			wantErr: true,
   145  		},
   146  		{
   147  			name: "BadOnlyDelim",
   148  			args: args{
   149  				env:  good,
   150  				line: "=",
   151  			},
   152  			wantErr: true,
   153  		},
   154  	}
   155  	for _, tt := range tests {
   156  		t.Run(tt.name, func(t *testing.T) {
   157  			if err := parseEnv(tt.args.env, tt.args.line); (err != nil) != tt.wantErr {
   158  				t.Errorf("parseEnv() error = %v, wantErr %v", err, tt.wantErr)
   159  			}
   160  		})
   161  	}
   162  }