github.com/influxdata/telegraf@v1.30.3/internal/snmp/table_test.go (about)

     1  package snmp
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  )
     8  
     9  func TestTableJoin_walk(t *testing.T) {
    10  	tbl := Table{
    11  		Name:       "mytable",
    12  		IndexAsTag: true,
    13  		Fields: []Field{
    14  			{
    15  				Name:  "myfield1",
    16  				Oid:   ".1.0.0.3.1.1",
    17  				IsTag: true,
    18  			},
    19  			{
    20  				Name: "myfield2",
    21  				Oid:  ".1.0.0.3.1.2",
    22  			},
    23  			{
    24  				Name:                "myfield3",
    25  				Oid:                 ".1.0.0.3.1.3",
    26  				SecondaryIndexTable: true,
    27  			},
    28  			{
    29  				Name:              "myfield4",
    30  				Oid:               ".1.0.0.0.1.1",
    31  				SecondaryIndexUse: true,
    32  				IsTag:             true,
    33  			},
    34  			{
    35  				Name:              "myfield5",
    36  				Oid:               ".1.0.0.0.1.2",
    37  				SecondaryIndexUse: true,
    38  			},
    39  		},
    40  	}
    41  
    42  	tb, err := tbl.Build(tsc, true)
    43  	require.NoError(t, err)
    44  
    45  	require.Equal(t, "mytable", tb.Name)
    46  	rtr1 := RTableRow{
    47  		Tags: map[string]string{
    48  			"myfield1": "instance",
    49  			"myfield4": "bar",
    50  			"index":    "10",
    51  		},
    52  		Fields: map[string]interface{}{
    53  			"myfield2": 10,
    54  			"myfield3": 1,
    55  			"myfield5": 2,
    56  		},
    57  	}
    58  	rtr2 := RTableRow{
    59  		Tags: map[string]string{
    60  			"myfield1": "instance2",
    61  			"index":    "11",
    62  		},
    63  		Fields: map[string]interface{}{
    64  			"myfield2": 20,
    65  			"myfield3": 2,
    66  			"myfield5": 0,
    67  		},
    68  	}
    69  	rtr3 := RTableRow{
    70  		Tags: map[string]string{
    71  			"myfield1": "instance3",
    72  			"index":    "12",
    73  		},
    74  		Fields: map[string]interface{}{
    75  			"myfield2": 20,
    76  			"myfield3": 3,
    77  		},
    78  	}
    79  	require.Len(t, tb.Rows, 3)
    80  	require.Contains(t, tb.Rows, rtr1)
    81  	require.Contains(t, tb.Rows, rtr2)
    82  	require.Contains(t, tb.Rows, rtr3)
    83  }
    84  
    85  func TestTableOuterJoin_walk(t *testing.T) {
    86  	tbl := Table{
    87  		Name:       "mytable",
    88  		IndexAsTag: true,
    89  		Fields: []Field{
    90  			{
    91  				Name:  "myfield1",
    92  				Oid:   ".1.0.0.3.1.1",
    93  				IsTag: true,
    94  			},
    95  			{
    96  				Name: "myfield2",
    97  				Oid:  ".1.0.0.3.1.2",
    98  			},
    99  			{
   100  				Name:                "myfield3",
   101  				Oid:                 ".1.0.0.3.1.3",
   102  				SecondaryIndexTable: true,
   103  				SecondaryOuterJoin:  true,
   104  			},
   105  			{
   106  				Name:              "myfield4",
   107  				Oid:               ".1.0.0.0.1.1",
   108  				SecondaryIndexUse: true,
   109  				IsTag:             true,
   110  			},
   111  			{
   112  				Name:              "myfield5",
   113  				Oid:               ".1.0.0.0.1.2",
   114  				SecondaryIndexUse: true,
   115  			},
   116  		},
   117  	}
   118  
   119  	tb, err := tbl.Build(tsc, true)
   120  	require.NoError(t, err)
   121  
   122  	require.Equal(t, "mytable", tb.Name)
   123  	rtr1 := RTableRow{
   124  		Tags: map[string]string{
   125  			"myfield1": "instance",
   126  			"myfield4": "bar",
   127  			"index":    "10",
   128  		},
   129  		Fields: map[string]interface{}{
   130  			"myfield2": 10,
   131  			"myfield3": 1,
   132  			"myfield5": 2,
   133  		},
   134  	}
   135  	rtr2 := RTableRow{
   136  		Tags: map[string]string{
   137  			"myfield1": "instance2",
   138  			"index":    "11",
   139  		},
   140  		Fields: map[string]interface{}{
   141  			"myfield2": 20,
   142  			"myfield3": 2,
   143  			"myfield5": 0,
   144  		},
   145  	}
   146  	rtr3 := RTableRow{
   147  		Tags: map[string]string{
   148  			"myfield1": "instance3",
   149  			"index":    "12",
   150  		},
   151  		Fields: map[string]interface{}{
   152  			"myfield2": 20,
   153  			"myfield3": 3,
   154  		},
   155  	}
   156  	rtr4 := RTableRow{
   157  		Tags: map[string]string{
   158  			"index":    "Secondary.0",
   159  			"myfield4": "foo",
   160  		},
   161  		Fields: map[string]interface{}{
   162  			"myfield5": 1,
   163  		},
   164  	}
   165  	require.Len(t, tb.Rows, 4)
   166  	require.Contains(t, tb.Rows, rtr1)
   167  	require.Contains(t, tb.Rows, rtr2)
   168  	require.Contains(t, tb.Rows, rtr3)
   169  	require.Contains(t, tb.Rows, rtr4)
   170  }
   171  
   172  func TestTableJoinNoIndexAsTag_walk(t *testing.T) {
   173  	tbl := Table{
   174  		Name:       "mytable",
   175  		IndexAsTag: false,
   176  		Fields: []Field{
   177  			{
   178  				Name:  "myfield1",
   179  				Oid:   ".1.0.0.3.1.1",
   180  				IsTag: true,
   181  			},
   182  			{
   183  				Name: "myfield2",
   184  				Oid:  ".1.0.0.3.1.2",
   185  			},
   186  			{
   187  				Name:                "myfield3",
   188  				Oid:                 ".1.0.0.3.1.3",
   189  				SecondaryIndexTable: true,
   190  			},
   191  			{
   192  				Name:              "myfield4",
   193  				Oid:               ".1.0.0.0.1.1",
   194  				SecondaryIndexUse: true,
   195  				IsTag:             true,
   196  			},
   197  			{
   198  				Name:              "myfield5",
   199  				Oid:               ".1.0.0.0.1.2",
   200  				SecondaryIndexUse: true,
   201  			},
   202  		},
   203  	}
   204  
   205  	tb, err := tbl.Build(tsc, true)
   206  	require.NoError(t, err)
   207  
   208  	require.Equal(t, "mytable", tb.Name)
   209  	rtr1 := RTableRow{
   210  		Tags: map[string]string{
   211  			"myfield1": "instance",
   212  			"myfield4": "bar",
   213  			//"index":    "10",
   214  		},
   215  		Fields: map[string]interface{}{
   216  			"myfield2": 10,
   217  			"myfield3": 1,
   218  			"myfield5": 2,
   219  		},
   220  	}
   221  	rtr2 := RTableRow{
   222  		Tags: map[string]string{
   223  			"myfield1": "instance2",
   224  			//"index":    "11",
   225  		},
   226  		Fields: map[string]interface{}{
   227  			"myfield2": 20,
   228  			"myfield3": 2,
   229  			"myfield5": 0,
   230  		},
   231  	}
   232  	rtr3 := RTableRow{
   233  		Tags: map[string]string{
   234  			"myfield1": "instance3",
   235  			//"index":    "12",
   236  		},
   237  		Fields: map[string]interface{}{
   238  			"myfield2": 20,
   239  			"myfield3": 3,
   240  		},
   241  	}
   242  	require.Len(t, tb.Rows, 3)
   243  	require.Contains(t, tb.Rows, rtr1)
   244  	require.Contains(t, tb.Rows, rtr2)
   245  	require.Contains(t, tb.Rows, rtr3)
   246  }