net_unix_test.go

Documentation: github.com/prometheus/procfs

     1  // Copyright 2018 The Prometheus Authors
     2  // Licensed under the Apache License, Version 2.0 (the "License");
     3  // you may not use this file except in compliance with the License.
     4  // You may obtain a copy of the License at
     5  //
     6  // http://www.apache.org/licenses/LICENSE-2.0
     7  //
     8  // Unless required by applicable law or agreed to in writing, software
     9  // distributed under the License is distributed on an "AS IS" BASIS,
    10  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    11  // See the License for the specific language governing permissions and
    12  // limitations under the License.
    13  
    14  package procfs
    15  
    16  import (
    17  	"testing"
    18  
    19  	"github.com/google/go-cmp/cmp"
    20  )
    21  
    22  // Whether or not to run tests with inode fixtures.
    23  const (
    24  	checkInode   = true
    25  	noCheckInode = false
    26  )
    27  
    28  func TestNetUnix(t *testing.T) {
    29  	fs, err := NewFS(procTestFixtures)
    30  	if err != nil {
    31  		t.Fatalf("failed to open procfs: %v", err)
    32  	}
    33  
    34  	got, err := fs.NetUNIX()
    35  	if err != nil {
    36  		t.Fatalf("failed to get UNIX socket data: %v", err)
    37  	}
    38  
    39  	testNetUNIX(t, checkInode, got)
    40  }
    41  
    42  func TestNetUnixNoInode(t *testing.T) {
    43  	fs, err := NewFS(procTestFixtures)
    44  	if err != nil {
    45  		t.Fatalf("failed to open procfs: %v", err)
    46  	}
    47  
    48  	got, err := readNetUNIX(fs.proc.Path("net/unix_without_inode"))
    49  	if err != nil {
    50  		t.Fatalf("failed to read UNIX socket data: %v", err)
    51  	}
    52  
    53  	testNetUNIX(t, noCheckInode, got)
    54  }
    55  
    56  func testNetUNIX(t *testing.T, testInode bool, got *NetUNIX) {
    57  	t.Helper()
    58  
    59  	// First verify that the input data matches a prepopulated structure.
    60  
    61  	want := []*NetUNIXLine{
    62  		{
    63  			KernelPtr: "0000000000000000",
    64  			RefCount:  2,
    65  			Flags:     1 << 16,
    66  			Type:      1,
    67  			State:     1,
    68  			Inode:     3442596,
    69  			Path:      "/var/run/postgresql/.s.PGSQL.5432",
    70  		},
    71  		{
    72  			KernelPtr: "0000000000000000",
    73  			RefCount:  10,
    74  			Flags:     1 << 16,
    75  			Type:      5,
    76  			State:     1,
    77  			Inode:     10061,
    78  			Path:      "/run/udev/control",
    79  		},
    80  		{
    81  			KernelPtr: "0000000000000000",
    82  			RefCount:  7,
    83  			Flags:     0,
    84  			Type:      2,
    85  			State:     1,
    86  			Inode:     12392,
    87  			Path:      "/dev/log",
    88  		},
    89  		{
    90  			KernelPtr: "0000000000000000",
    91  			RefCount:  3,
    92  			Flags:     0,
    93  			Type:      1,
    94  			State:     3,
    95  			Inode:     4787297,
    96  			Path:      "/var/run/postgresql/.s.PGSQL.5432",
    97  		},
    98  		{
    99  			KernelPtr: "0000000000000000",
   100  			RefCount:  3,
   101  			Flags:     0,
   102  			Type:      1,
   103  			State:     3,
   104  			Inode:     5091797,
   105  		},
   106  	}
   107  
   108  	// Enable the fixtures to be used for multiple tests by clearing the inode
   109  	// field when appropriate.
   110  	if !testInode {
   111  		for i := 0; i < len(want); i++ {
   112  			want[i].Inode = 0
   113  		}
   114  	}
   115  
   116  	if diff := cmp.Diff(want, got.Rows); diff != "" {
   117  		t.Fatalf("unexpected /proc/net/unix data (-want +got):\n%s", diff)
   118  	}
   119  
   120  	// Now test the field enumerations and ensure they match up correctly
   121  	// with the constants used to generate readable strings.
   122  
   123  	wantFlags := []NetUNIXFlags{
   124  		netUnixFlagListen,
   125  		netUnixFlagListen,
   126  		netUnixFlagDefault,
   127  		netUnixFlagDefault,
   128  		netUnixFlagDefault,
   129  	}
   130  
   131  	wantType := []NetUNIXType{
   132  		netUnixTypeStream,
   133  		netUnixTypeSeqpacket,
   134  		netUnixTypeDgram,
   135  		netUnixTypeStream,
   136  		netUnixTypeStream,
   137  	}
   138  
   139  	wantState := []NetUNIXState{
   140  		netUnixStateUnconnected,
   141  		netUnixStateUnconnected,
   142  		netUnixStateUnconnected,
   143  		netUnixStateConnected,
   144  		netUnixStateConnected,
   145  	}
   146  
   147  	var (
   148  		gotFlags []NetUNIXFlags
   149  		gotType  []NetUNIXType
   150  		gotState []NetUNIXState
   151  	)
   152  
   153  	for _, r := range got.Rows {
   154  		gotFlags = append(gotFlags, r.Flags)
   155  		gotType = append(gotType, r.Type)
   156  		gotState = append(gotState, r.State)
   157  	}
   158  
   159  	if diff := cmp.Diff(wantFlags, gotFlags); diff != "" {
   160  		t.Fatalf("unexpected /proc/net/unix flags (-want +got):\n%s", diff)
   161  	}
   162  
   163  	if diff := cmp.Diff(wantType, gotType); diff != "" {
   164  		t.Fatalf("unexpected /proc/net/unix types (-want +got):\n%s", diff)
   165  	}
   166  
   167  	if diff := cmp.Diff(wantState, gotState); diff != "" {
   168  		t.Fatalf("unexpected /proc/net/unix states (-want +got):\n%s", diff)
   169  	}
   170  }
   171
View as plain text