github.com/operator-framework/operator-lifecycle-manager@v0.30.0/test/e2e/split/main_test.go (about)

     1  package main
     2  
     3  import (
     4  	"os"
     5  	"os/exec"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func TestMain(t *testing.T) {
    12  	// This test makes sure that every spec gets run.
    13  
    14  	cmd := exec.Command("./test/e2e/split/integration_test.sh")
    15  	cmd.Dir = "../../../"
    16  	cmd.Stdout = os.Stdout
    17  	cmd.Stderr = os.Stderr
    18  	err := cmd.Run()
    19  	require.NoError(t, err)
    20  }
    21  
    22  func TestCreateChunkRegexp(t *testing.T) {
    23  	type spec struct {
    24  		name       string
    25  		numChunks  int
    26  		printChunk int
    27  		specs      []string
    28  		expRE      string
    29  		expError   string
    30  	}
    31  
    32  	cases := []spec{
    33  		{
    34  			name:      "singlePrefix1",
    35  			numChunks: 1, printChunk: 0,
    36  			specs: []string{"foo"},
    37  			expRE: "foo .*",
    38  		},
    39  		{
    40  			name:      "multiplePrefixes1",
    41  			numChunks: 1, printChunk: 0,
    42  			specs: []string{"bar foo", "baz", "foo"},
    43  			expRE: "(bar foo|baz|foo) .*",
    44  		},
    45  		{
    46  			name:      "multiplePrefixes2",
    47  			numChunks: 3, printChunk: 0,
    48  			specs: []string{"bar foo", "baz", "foo"},
    49  			expRE: "bar foo .*",
    50  		},
    51  		{
    52  			name:      "multiplePrefixes3",
    53  			numChunks: 3, printChunk: 2,
    54  			specs: []string{"bar foo", "baz", "foo"},
    55  			expRE: "foo .*",
    56  		},
    57  		{
    58  			name:      "empty",
    59  			numChunks: 1, printChunk: 0,
    60  			specs:    nil,
    61  			expError: "have more desired chunks (1) than specs (0)",
    62  		},
    63  		{
    64  			name:      "singleSpecTooManyChunks",
    65  			numChunks: 2, printChunk: 1,
    66  			specs:    []string{"foo"},
    67  			expError: "have more desired chunks (2) than specs (1)",
    68  		},
    69  		{
    70  			name:      "multipleSpecTooManyChunks",
    71  			numChunks: 3, printChunk: 1,
    72  			specs:    []string{"foo", "bar"},
    73  			expError: "have more desired chunks (3) than specs (2)",
    74  		},
    75  	}
    76  
    77  	for _, c := range cases {
    78  		t.Run(c.name, func(t *testing.T) {
    79  			re, err := createChunkRegexp(c.numChunks, c.printChunk, c.specs)
    80  			if c.expError != "" {
    81  				require.EqualError(t, err, c.expError)
    82  			} else {
    83  				require.NoError(t, err)
    84  				require.Equal(t, c.expRE, re)
    85  			}
    86  		})
    87  	}
    88  }
    89  
    90  func TestFindMinimalWordPrefixes(t *testing.T) {
    91  	type spec struct {
    92  		name        string
    93  		specs       []string
    94  		expPrefixes []string
    95  	}
    96  
    97  	cases := []spec{
    98  		{
    99  			name:        "empty",
   100  			specs:       nil,
   101  			expPrefixes: nil,
   102  		},
   103  		{
   104  			name:        "singleSpec",
   105  			specs:       []string{"foo"},
   106  			expPrefixes: []string{"foo"},
   107  		},
   108  		{
   109  			name:        "twoSpecsSingleWordPrefix",
   110  			specs:       []string{"foo", "foo bar"},
   111  			expPrefixes: []string{"foo"},
   112  		},
   113  		{
   114  			name:        "twoMultiWordSpecsSingleWordPrefix",
   115  			specs:       []string{"foo bar", "foo baz"},
   116  			expPrefixes: []string{"foo"},
   117  		},
   118  		{
   119  			name:        "twoMultiWordSpecsLongPrefix",
   120  			specs:       []string{"foo bar", "foo bar baz"},
   121  			expPrefixes: []string{"foo bar"},
   122  		},
   123  		{
   124  			name:        "threeSpecsSingleWordPrefix",
   125  			specs:       []string{"foo", "foo bar", "foo baz"},
   126  			expPrefixes: []string{"foo"},
   127  		},
   128  		{
   129  			name:        "multiplePrefixes",
   130  			specs:       []string{"foo", "foo bar", "foo bar baz", "bar foo", "baz buf", "baz bar foo"},
   131  			expPrefixes: []string{"foo", "bar foo", "baz"},
   132  		},
   133  	}
   134  
   135  	for _, c := range cases {
   136  		t.Run(c.name, func(t *testing.T) {
   137  			prefixes := findMinimalWordPrefixes(c.specs)
   138  			require.ElementsMatch(t, c.expPrefixes, prefixes)
   139  		})
   140  	}
   141  }