github.com/anchore/syft@v1.4.2-0.20240516191711-1bec1fc5d397/internal/task/set_test.go (about)

     1  package task
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/anchore/syft/internal/sbomsync"
    10  	"github.com/anchore/syft/syft/file"
    11  )
    12  
    13  var _ Task = (*mockTask)(nil)
    14  
    15  type mockTask struct {
    16  	name string
    17  }
    18  
    19  func (m mockTask) Execute(_ context.Context, _ file.Resolver, _ sbomsync.Builder) error {
    20  	panic("implement me")
    21  }
    22  
    23  func (m mockTask) Name() string {
    24  	return m.name
    25  }
    26  
    27  func Test_set_Add(t *testing.T) {
    28  	tests := []struct {
    29  		name         string
    30  		initialTasks []Task
    31  		newTasks     []Task
    32  		expected     []string
    33  	}{
    34  		{
    35  			name:         "add unique tasks",
    36  			initialTasks: []Task{mockTask{"task2"}, mockTask{"task1"}},
    37  			newTasks:     []Task{mockTask{"task3"}},
    38  			expected: []string{
    39  				"task2", // note order is honored
    40  				"task1",
    41  				"task3",
    42  			},
    43  		},
    44  		{
    45  			name:         "add duplicate tasks",
    46  			initialTasks: []Task{mockTask{"task1"}, mockTask{"task2"}},
    47  			newTasks:     []Task{mockTask{"task1"}},
    48  			expected: []string{
    49  				"task1",
    50  				"task2",
    51  			},
    52  		},
    53  	}
    54  
    55  	for _, tt := range tests {
    56  		t.Run(tt.name, func(t *testing.T) {
    57  			s := newSet(tt.initialTasks...)
    58  			s.Add(tt.newTasks...)
    59  			got := s.Tasks()
    60  			var gotNames []string
    61  			for _, tsk := range got {
    62  				gotNames = append(gotNames, tsk.Name())
    63  			}
    64  			assert.Equal(t, tt.expected, gotNames)
    65  		})
    66  	}
    67  }
    68  
    69  func Test_set_Remove(t *testing.T) {
    70  	tests := []struct {
    71  		name          string
    72  		initialTasks  []Task
    73  		tasksToRemove []Task
    74  		expectedOrder []string
    75  	}{
    76  		{
    77  			name:          "remove existing tasks",
    78  			initialTasks:  []Task{mockTask{"task1"}, mockTask{"task2"}, mockTask{"task3"}},
    79  			tasksToRemove: []Task{mockTask{"task2"}},
    80  			expectedOrder: []string{"task1", "task3"},
    81  		},
    82  		{
    83  			name:          "remove non-existing tasks",
    84  			initialTasks:  []Task{mockTask{"task1"}, mockTask{"task2"}},
    85  			tasksToRemove: []Task{mockTask{"task3"}},
    86  			expectedOrder: []string{"task1", "task2"},
    87  		},
    88  	}
    89  
    90  	for _, tt := range tests {
    91  		t.Run(tt.name, func(t *testing.T) {
    92  			s := newSet(tt.initialTasks...)
    93  			s.Remove(tt.tasksToRemove...)
    94  			assert.Equal(t, tt.expectedOrder, s.order)
    95  		})
    96  	}
    97  }
    98  
    99  func Test_set_Intersect(t *testing.T) {
   100  	tests := []struct {
   101  		name           string
   102  		initialTasks   []Task
   103  		intersectTasks []Task
   104  		expectedOrder  []string
   105  	}{
   106  		{
   107  			name:           "intersect with overlapping tasks",
   108  			initialTasks:   []Task{mockTask{"task1"}, mockTask{"task2"}},
   109  			intersectTasks: []Task{mockTask{"task2"}, mockTask{"task3"}},
   110  			expectedOrder:  []string{"task2"},
   111  		},
   112  		{
   113  			name:           "intersect with non-overlapping tasks",
   114  			initialTasks:   []Task{mockTask{"task1"}, mockTask{"task4"}},
   115  			intersectTasks: []Task{mockTask{"task2"}, mockTask{"task3"}},
   116  			expectedOrder:  []string{},
   117  		},
   118  	}
   119  
   120  	for _, tt := range tests {
   121  		t.Run(tt.name, func(t *testing.T) {
   122  			s := newSet(tt.initialTasks...)
   123  			s.Intersect(tt.intersectTasks...)
   124  			assert.Equal(t, tt.expectedOrder, s.order)
   125  		})
   126  	}
   127  }
   128  
   129  func Test_set_Tasks(t *testing.T) {
   130  	tests := []struct {
   131  		name          string
   132  		initialTasks  []Task
   133  		expectedTasks tasks
   134  	}{
   135  		{
   136  			name:          "empty set",
   137  			initialTasks:  []Task{},
   138  			expectedTasks: nil,
   139  		},
   140  		{
   141  			name:          "get tasks from set",
   142  			initialTasks:  []Task{mockTask{"task1"}, mockTask{"task2"}},
   143  			expectedTasks: []Task{mockTask{"task1"}, mockTask{"task2"}},
   144  		},
   145  	}
   146  
   147  	for _, tt := range tests {
   148  		t.Run(tt.name, func(t *testing.T) {
   149  			s := newSet(tt.initialTasks...)
   150  			resultTasks := s.Tasks()
   151  			assert.Equal(t, tt.expectedTasks, resultTasks)
   152  		})
   153  	}
   154  }