github.com/mvdan/u-root-coreutils@v0.0.0-20230122170626-c2eef2898555/pkg/namespace/parser_test.go (about)

     1  // Copyright 2020-2021 the u-root Authors. All rights reserved
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package namespace
     6  
     7  import (
     8  	"io"
     9  	"os"
    10  	"reflect"
    11  	"testing"
    12  )
    13  
    14  func TestParse(t *testing.T) {
    15  	type args struct {
    16  		r io.Reader
    17  	}
    18  	_open := func(name string) func(t *testing.T) args {
    19  		return func(t *testing.T) args {
    20  			r, _ := os.Open(name)
    21  			return args{r}
    22  		}
    23  	}
    24  
    25  	tests := []struct {
    26  		name string
    27  		args func(t *testing.T) args
    28  
    29  		want1      File
    30  		wantErr    bool
    31  		inspectErr func(err error, t *testing.T)
    32  	}{
    33  		{
    34  			name: "namespace",
    35  			args: _open("testdata/namespace"),
    36  			want1: File{
    37  				cmd{
    38  					syscall: MOUNT,
    39  					flag:    REPL | AFTER | CACHE,
    40  					args:    []string{"#s/boot", "/root", "$rootspec"},
    41  				},
    42  				cmd{
    43  					syscall: BIND,
    44  					flag:    REPL | AFTER,
    45  					args:    []string{"$rootdir", "/"},
    46  				},
    47  				cmd{
    48  					syscall: BIND,
    49  					flag:    REPL | CREATE,
    50  					args:    []string{"$rootdir/mnt", "/mnt"},
    51  				},
    52  				// kernel devices
    53  				cmd{
    54  					syscall: BIND,
    55  					args:    []string{"#c", "/dev"},
    56  				},
    57  				cmd{
    58  					syscall: BIND,
    59  					args:    []string{"#d", "/fd"},
    60  				},
    61  				cmd{
    62  					syscall: BIND,
    63  					flag:    REPL | CREATE,
    64  					args:    []string{"#e", "/env"},
    65  				},
    66  				cmd{
    67  					syscall: BIND,
    68  					args:    []string{"#p", "/proc"},
    69  				},
    70  				cmd{
    71  					syscall: BIND,
    72  					flag:    REPL | CREATE,
    73  					args:    []string{"#s", "/srv"},
    74  				},
    75  				cmd{
    76  					syscall: BIND,
    77  					flag:    REPL | AFTER,
    78  					args:    []string{"#¤", "/dev"},
    79  				},
    80  				cmd{
    81  					syscall: BIND,
    82  					flag:    REPL | AFTER,
    83  					args:    []string{"#S", "/dev"},
    84  				},
    85  				cmd{
    86  					syscall: BIND,
    87  					flag:    REPL | BEFORE,
    88  					args:    []string{"#k", "/dev"},
    89  				},
    90  				cmd{
    91  					syscall: BIND,
    92  					flag:    REPL | AFTER,
    93  					args:    []string{"#κ", "/dev"},
    94  				},
    95  				cmd{
    96  					syscall: BIND,
    97  					flag:    REPL | AFTER,
    98  					args:    []string{"#u", "/dev"},
    99  				},
   100  				cmd{
   101  					syscall: BIND,
   102  					flag:    REPL | BEFORE,
   103  					args:    []string{"#P", "/dev"},
   104  				},
   105  				// mount points
   106  				cmd{
   107  					syscall: MOUNT,
   108  					flag:    REPL | AFTER,
   109  					args:    []string{"/srv/slashn", "/n"},
   110  				},
   111  				// authentication
   112  				cmd{
   113  					syscall: MOUNT,
   114  					flag:    REPL | AFTER,
   115  					args:    []string{"/srv/factotum", "/mnt"},
   116  				},
   117  				// standard bin
   118  				cmd{
   119  					syscall: BIND,
   120  					flag:    REPL,
   121  					args:    []string{"/$cputype/bin", "/bin"},
   122  				},
   123  				cmd{
   124  					syscall: BIND,
   125  					flag:    REPL | AFTER,
   126  					args:    []string{"/rc/bin", "/bin"},
   127  				},
   128  				// internal networks
   129  				cmd{
   130  					syscall: BIND,
   131  					flag:    REPL | AFTER,
   132  					args:    []string{"#l", "/net"},
   133  				},
   134  				cmd{
   135  					syscall: BIND,
   136  					flag:    REPL | AFTER,
   137  					args:    []string{"#I", "/net"},
   138  				},
   139  				cmd{
   140  					syscall: MOUNT,
   141  					flag:    REPL | AFTER,
   142  					args:    []string{"/srv/cs", "/net"},
   143  				},
   144  				cmd{
   145  					syscall: MOUNT,
   146  					flag:    REPL | AFTER,
   147  					args:    []string{"/srv/dns", "/net"},
   148  				},
   149  				cmd{
   150  					syscall: MOUNT,
   151  					flag:    REPL | AFTER,
   152  					args:    []string{"/srv/net", "/net"},
   153  				},
   154  				cmd{
   155  					syscall: MOUNT,
   156  					flag:    REPL | BEFORE,
   157  					args:    []string{"/srv/ssh", "/net"},
   158  				},
   159  				// usbd, mainly disks
   160  				cmd{
   161  					syscall: MOUNT,
   162  					args:    []string{"/srv/usb", "/n/usb"},
   163  				},
   164  				cmd{
   165  					syscall: MOUNT,
   166  					flag:    REPL | AFTER,
   167  					args:    []string{"/srv/usb", "/dev"},
   168  				},
   169  				cmd{
   170  					syscall: BIND,
   171  					flag:    REPL | CREATE,
   172  					args:    []string{"/usr/$user/tmp", "/tmp"},
   173  				},
   174  				cmd{
   175  					syscall: CHDIR,
   176  					args:    []string{"/usr/$user"},
   177  				},
   178  				cmd{
   179  					syscall: INCLUDE,
   180  					args:    []string{"/lib/namespace.local"},
   181  				},
   182  				cmd{
   183  					syscall: INCLUDE,
   184  					args:    []string{"/lib/namespace.$sysname"},
   185  				},
   186  				cmd{
   187  					syscall: INCLUDE,
   188  					args:    []string{"/cfg/$sysname/namespace"},
   189  				},
   190  			},
   191  		},
   192  	}
   193  
   194  	for _, tt := range tests {
   195  		t.Run(tt.name, func(t *testing.T) {
   196  			tArgs := tt.args(t)
   197  
   198  			got1, err := Parse(tArgs.r)
   199  
   200  			// assert.Equal(t, tt.want1, got1)
   201  			if !reflect.DeepEqual(tt.want1, got1) {
   202  				t.Errorf(`Parse(%v) = %v, _ , want %v`, tArgs.r, got1, tt.want1)
   203  			}
   204  
   205  			if tt.wantErr {
   206  				if err == nil {
   207  					t.Errorf(`Parse(%v) = _, %v, want not nil`, tArgs.r, err)
   208  
   209  				}
   210  				if tt.inspectErr != nil {
   211  					tt.inspectErr(err, t)
   212  				}
   213  			}
   214  		})
   215  	}
   216  }
   217  
   218  func print(err error, t *testing.T) { t.Log(err) }
   219  
   220  func Test_parseLine(t *testing.T) {
   221  	type args struct {
   222  		line string
   223  	}
   224  	tests := []struct {
   225  		name string
   226  		args func(t *testing.T) args
   227  
   228  		want1      cmd
   229  		wantErr    bool
   230  		inspectErr func(err error, t *testing.T)
   231  	}{
   232  		{
   233  			name: "mount",
   234  			args: func(*testing.T) args { return args{"mount -aC #s/boot /root $rootspec"} },
   235  			want1: cmd{
   236  				syscall: MOUNT,
   237  				flag:    REPL | AFTER | CACHE,
   238  				args:    []string{"#s/boot", "/root", "$rootspec"},
   239  			},
   240  			wantErr:    false,
   241  			inspectErr: print,
   242  		},
   243  		{
   244  			name: "mount",
   245  			args: func(*testing.T) args { return args{"mount -aC #s/boot /root"} },
   246  			want1: cmd{
   247  				syscall: MOUNT,
   248  				flag:    REPL | AFTER | CACHE,
   249  				args:    []string{"#s/boot", "/root"},
   250  			},
   251  			wantErr:    false,
   252  			inspectErr: print,
   253  		},
   254  		{
   255  			name: "bind",
   256  			args: func(*testing.T) args { return args{"bind -a '#r' /dev"} },
   257  			want1: cmd{
   258  				syscall: BIND,
   259  				args:    []string{"'#r'", "/dev"},
   260  				flag:    REPL | AFTER,
   261  			},
   262  			wantErr: false,
   263  		},
   264  		{
   265  			name: "include",
   266  			args: func(*testing.T) args { return args{". /cfg/$sysname/namespace"} },
   267  			want1: cmd{
   268  				syscall: INCLUDE,
   269  				args:    []string{"/cfg/$sysname/namespace"},
   270  				flag:    REPL,
   271  			},
   272  			wantErr: false,
   273  		},
   274  		{
   275  			name: "clear",
   276  			args: func(*testing.T) args { return args{"clear"} },
   277  			want1: cmd{
   278  				syscall: RFORK,
   279  				args:    []string{},
   280  				flag:    REPL,
   281  			},
   282  			wantErr: false,
   283  		},
   284  		{
   285  			name: "umount",
   286  			args: func(*testing.T) args { return args{"unmount /dev"} },
   287  			want1: cmd{
   288  				syscall: UNMOUNT,
   289  				args:    []string{"/dev"},
   290  				flag:    REPL,
   291  			},
   292  			wantErr: false,
   293  		},
   294  		{
   295  			name: "cd",
   296  			args: func(*testing.T) args { return args{"cd /cfg"} },
   297  			want1: cmd{
   298  				syscall: CHDIR,
   299  				args:    []string{"/cfg"},
   300  				flag:    REPL,
   301  			},
   302  			wantErr: false,
   303  		},
   304  		{
   305  			name: "import",
   306  			args: func(*testing.T) args { return args{"import -a $host /srv /srv"} },
   307  			want1: cmd{
   308  				syscall: IMPORT,
   309  				args:    []string{"$host", "/srv", "/srv"},
   310  				flag:    AFTER,
   311  			},
   312  			wantErr: false,
   313  		},
   314  	}
   315  
   316  	for _, tt := range tests {
   317  		t.Run(tt.name, func(t *testing.T) {
   318  			tArgs := tt.args(t)
   319  
   320  			got1, err := ParseLine(tArgs.line)
   321  
   322  			if !reflect.DeepEqual(tt.want1, got1) {
   323  				t.Errorf(`ParseLine(%v) = %v, _ , want %v`, tArgs.line, got1, tt.want1)
   324  			}
   325  
   326  			if tt.wantErr {
   327  				if err == nil {
   328  					t.Errorf(`ParseLine(%v) = _, %v, want not nil`, tArgs.line, err)
   329  				}
   330  				if tt.inspectErr != nil {
   331  					tt.inspectErr(err, t)
   332  				}
   333  			}
   334  		})
   335  	}
   336  }