github.com/crowdsecurity/crowdsec@v1.6.1/pkg/types/event_test.go (about)

     1  package types
     2  
     3  import (
     4  	"net"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/crowdsecurity/crowdsec/pkg/models"
    10  )
    11  
    12  func TestSetParsed(t *testing.T) {
    13  	tests := []struct {
    14  		name     string
    15  		evt      *Event
    16  		key      string
    17  		value    string
    18  		expected bool
    19  	}{
    20  		{
    21  			name:     "SetParsed: Valid",
    22  			evt:      &Event{},
    23  			key:      "test",
    24  			value:    "test",
    25  			expected: true,
    26  		},
    27  		{
    28  			name:     "SetParsed: Existing map",
    29  			evt:      &Event{Parsed: map[string]string{}},
    30  			key:      "test",
    31  			value:    "test",
    32  			expected: true,
    33  		},
    34  		{
    35  			name:     "SetParsed: Existing map+key",
    36  			evt:      &Event{Parsed: map[string]string{"test": "foobar"}},
    37  			key:      "test",
    38  			value:    "test",
    39  			expected: true,
    40  		},
    41  	}
    42  
    43  	for _, tt := range tests {
    44  		tt := tt
    45  		t.Run(tt.name, func(t *testing.T) {
    46  			tt.evt.SetParsed(tt.key, tt.value)
    47  			assert.Equal(t, tt.value, tt.evt.Parsed[tt.key])
    48  		})
    49  	}
    50  
    51  }
    52  
    53  func TestSetMeta(t *testing.T) {
    54  	tests := []struct {
    55  		name     string
    56  		evt      *Event
    57  		key      string
    58  		value    string
    59  		expected bool
    60  	}{
    61  		{
    62  			name:     "SetMeta: Valid",
    63  			evt:      &Event{},
    64  			key:      "test",
    65  			value:    "test",
    66  			expected: true,
    67  		},
    68  		{
    69  			name:     "SetMeta: Existing map",
    70  			evt:      &Event{Meta: map[string]string{}},
    71  			key:      "test",
    72  			value:    "test",
    73  			expected: true,
    74  		},
    75  		{
    76  			name:     "SetMeta: Existing map+key",
    77  			evt:      &Event{Meta: map[string]string{"test": "foobar"}},
    78  			key:      "test",
    79  			value:    "test",
    80  			expected: true,
    81  		},
    82  	}
    83  
    84  	for _, tt := range tests {
    85  		tt := tt
    86  		t.Run(tt.name, func(t *testing.T) {
    87  			tt.evt.SetMeta(tt.key, tt.value)
    88  			assert.Equal(t, tt.value, tt.evt.GetMeta(tt.key))
    89  		})
    90  	}
    91  
    92  }
    93  
    94  func TestParseIPSources(t *testing.T) {
    95  	tests := []struct {
    96  		name     string
    97  		evt      Event
    98  		expected []net.IP
    99  	}{
   100  		{
   101  			name: "ParseIPSources: Valid Log Sources",
   102  			evt: Event{
   103  				Type: LOG,
   104  				Meta: map[string]string{
   105  					"source_ip": "127.0.0.1",
   106  				},
   107  			},
   108  			expected: []net.IP{
   109  				net.ParseIP("127.0.0.1"),
   110  			},
   111  		},
   112  		{
   113  			name: "ParseIPSources: Valid Overflow Sources",
   114  			evt: Event{
   115  				Type: OVFLW,
   116  				Overflow: RuntimeAlert{
   117  					Sources: map[string]models.Source{
   118  						"127.0.0.1": {},
   119  					},
   120  				},
   121  			},
   122  			expected: []net.IP{
   123  				net.ParseIP("127.0.0.1"),
   124  			},
   125  		},
   126  		{
   127  			name: "ParseIPSources: Invalid Log Sources",
   128  			evt: Event{
   129  				Type: LOG,
   130  				Meta: map[string]string{
   131  					"source_ip": "IAMNOTANIP",
   132  				},
   133  			},
   134  			expected: []net.IP{
   135  				nil,
   136  			},
   137  		},
   138  		{
   139  			name: "ParseIPSources: Invalid Overflow Sources",
   140  			evt: Event{
   141  				Type: OVFLW,
   142  				Overflow: RuntimeAlert{
   143  					Sources: map[string]models.Source{
   144  						"IAMNOTANIP": {},
   145  					},
   146  				},
   147  			},
   148  			expected: []net.IP{
   149  				nil,
   150  			},
   151  		},
   152  	}
   153  
   154  	for _, tt := range tests {
   155  		tt := tt
   156  		t.Run(tt.name, func(t *testing.T) {
   157  			ips := tt.evt.ParseIPSources()
   158  			assert.Equal(t, tt.expected, ips)
   159  		})
   160  	}
   161  }